/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbtkKWBlackBox.h,v $
  Language:  C++
  Date:      $Date: 2008/11/29 21:41:34 $
  Version:   $Revision: 1.1 $
========================================================================*/


/* ---------------------------------------------------------------------

* Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
* Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
*
*  This software is governed by the CeCILL-B license under French law and 
*  abiding by the rules of distribution of free software. You can  use, 
*  modify and/ or redistribute the software under the terms of the CeCILL-B 
*  license as circulated by CEA, CNRS and INRIA at the following URL 
*  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
*  or in the file LICENSE.txt.
*
*  As a counterpart to the access to the source code and  rights to copy,
*  modify and redistribute granted by the license, users are provided only
*  with a limited warranty  and the software's author,  the holder of the
*  economic rights,  and the successive licensors  have only  limited
*  liability. 
*
*  The fact that you are presently reading this means that you have had
*  knowledge of the CeCILL-B license and that you accept its terms.
* ------------------------------------------------------------------------ */                                                                         
/**
 * \brief Short description in one line
 * 
 * Long description which 
 * can span multiple lines
 */
/**
 * \file 
 * \brief 
 */
/**
 * \class bbtk::
 * \brief 
 */
#ifndef __bbtkKWBlackBox_h_INCLUDED__
#define __bbtkKWBlackBox_h_INCLUDED__


#ifdef USE_KWWIDGETS

#include "bbtkAtomicBlackBox.h"


#include "bbtkKW.h"
#include "vtkKWWidget.h"
#include "vtkKWWindowBase.h"
#include "vtkKWFrame.h"
#include "vtkKWDialog.h"

namespace bbtk
{




  //==================================================================
  // Forward declaration of the class of window associated to a KWBlackBox
  class vtkKWBlackBoxWindow;
  //==================================================================

  //==================================================================
  // Forward declaration of the widget event handler class
  //  class KWBlackBoxWidgetEventHandler;
  //==================================================================


  //==================================================================
  /// Widget black boxes
  class BBTK_EXPORT KWBlackBox : public bbtk::AtomicBlackBox  
  { 
    BBTK_BLACK_BOX_INTERFACE(KWBlackBox,bbtk::AtomicBlackBox);
    BBTK_DECLARE_INPUT(WinTitle,std::string);
    BBTK_DECLARE_INPUT(WinWidth,int);
    BBTK_DECLARE_INPUT(WinHeight,int);
    BBTK_DECLARE_INPUT(WinDialog,bool);
    BBTK_DECLARE_INPUT(WinHide,Void);
    BBTK_DECLARE_INPUT(WinClose,Void);
    BBTK_DECLARE_OUTPUT(Widget, vtkKWWidget*);

  public:
    /// Main processing method of the box. Overloaded to handle windows inclusion : if the output Widget is connected then the execution is transfered to the box to which it is connected (as the container window must be created and displayed - this box will be executed by the normal pipeline recursion mechanism)
    virtual void bbExecute(bool force = false);


    typedef vtkKWBlackBoxWindow Window;
    
    /// Returns the **OWN** window associated to the box
    /// If 0 returned = no window
    Window* bbGetWindow() { return bbmWindow; }

    /// Returns the window containing the widget associated to the box
    /// Which can be the own window of **ANOTHER** box in case of 
    /// a hierarchy of widgets.
    /// More precisely :
    /// If bbGetWindow() != 0 then returns bbGetWindow()
    /// Else if the output 'Widget' is connected 
    ///  then returns bbGetContainingWindow() of the box connected to 'Widget'
    /// Else returns 0;
    Window* bbGetContainingWindow();

    /// Returns the parent wxWindow that must be used to create the widget 
	  //
	  // LG 24/11/08 : New widget pipeline
	  //    wxWindow* bbGetKWParent();

    /// Returns true iff the 'containing window' exists and is shown 
    /// (see bbGetContainingWindow).
    bool bbIsShown();

    //==================================================================    
    /// User callback invoked when the containing window is shown
    virtual void bbUserOnShow() {}
    //==================================================================    
 
    //==================================================================    
    /// User callback invoked when the containing window is hidden
    virtual void bbUserOnHide() {}
    //==================================================================    

    // LG 24/11/08 : New widget pipeline
    //    void bbCreateWidgetAndEventHandler(vtkKWWidget* parent); 

	  
  protected:
    
  
    //==================================================================
    /// User callback called in the box contructor
    virtual void bbUserConstructor();
    /// User callback called in the box copy constructor
    virtual void bbUserCopyConstructor(bbtk::BlackBox::Pointer);
    /// User callback called in the box destructor
    virtual void bbUserDestructor();
    //==================================================================    

    //==================================================================    
    /// User callback for creating the widget associated to the box
    /// ** Must be defined **
    // LG 24/11/08 : New widget pipeline
    virtual void bbUserCreateWidget(vtkKWWidget* parent) 
    {
      bbtkError(bbGetTypeName()<<" is a KWBlackBox whose bbUserCreateWidget methods is not overloaded : is it a feature or a bug ?!?");
    }
    //==================================================================    


    vtkKWWidget* bbCreateWidgetOfInput(const std::string& in, 
				       vtkKWWidget* parent);


    //==================================================================
    /// Main processing method of the box.
    virtual IOStatus bbBackwardUpdate( Connection::Pointer caller );
    //==================================================================



    //==================================================================
    /// Overloaded processing method for KWBlackBoxes
    virtual void bbProcess();
    //==================================================================

    //==================================================================
    /// If necessary creates the KWBlackBoxWindow associated to the box
    /// and shows it 
    /// (does nothing if the box output 'Widget' is connected which 
    /// means that the box does not have its own window but is contained 
    /// into another window)
    void bbShowWindow();
    /// Hides the KWBlackBoxWindow associated to the box (if exists)
    void bbHideWindow();
    /// Closes (destroys) the KWBlackBoxWindow associated to the box (if exists)
    void bbCloseWindow();
    //==================================================================

  private:
    /// friendship
    friend class vtkKWBlackBoxWindow;
    //    friend class KWBlackBoxWidgetEventHandler;

    /// Sets the window
    inline void bbSetWindow(Window* w) { bbmWindow=w; }

    /*
    /// Sets the Widget Event Handler
    inline void bbSetWidgetEventHandler(KWBlackBoxWidgetEventHandler* w) 
    { bbmWidgetEventHandler = w; }
    /// Gets the Widget Event Handler
    inline KWBlackBoxWidgetEventHandler* bbGetWidgetEventHandler()
    { return bbmWidgetEventHandler; }
    */

    /// The KWBlackBoxWindow associated to the box
    Window* bbmWindow;
    /// The KWBlackBoxWidgetEventHandler associated to the box
    //    KWBlackBoxWidgetEventHandler* bbmWidgetEventHandler;


    void bbInitAttributes();

  protected :


    /// For Forward update mechanism when execution is called 
    /// on a contained window
    /// Is set to true before transfering update to parent 
    /// in order to not re-transfer a second time...
    bool bbmUpdateTransferedToParent;

    bool bbGetUpdateTransferedToParent() const { return bbmUpdateTransferedToParent; }
    void bbSetUpdateTransferedToParent(bool b) 
    { bbmUpdateTransferedToParent = b; }

  };
  //=================================================================
 

  //======================================================================
  /// Defines the bbUserCreateWidget method
#define BBTK_CREATE_KWWIDGET(CALLBACK)					\
  public:								\
  inline void bbUserCreateWidget(vtkKWWidget* parent)			\
  {									\
    bbtkDebugMessageInc("kw",1,"**> Creating widget for ["		\
			<<bbGetFullName()<<"]"<<std::endl);		\
    CALLBACK(parent);							\
    bbtkDebugMessageInc("kw",1,"<** Creating widget for ["		\
			<<bbGetFullName()<<"]"<<std::endl);		\
  }
  
  //======================================================================

  //======================================================================
  /// Defines the bbUserOnShow method
#define BBTK_ON_SHOW_WIDGET(CALLBACK)					\
  public:								\
  inline void bbUserOnShow()					\
  {									\
    bbtkDebugMessageInc("wx",1,"**> Showing ["		\
			<<bbGetFullName()<<"]"<<std::endl);		\
    CALLBACK();								\
    bbtkDebugMessageInc("wx",1,"<** Showing ["		\
			<<bbGetFullName()<<"]"<<std::endl);		\
  }
  
  //======================================================================

  //=================================================================
  // KWBlackBoxDescriptor declaration
  BBTK_BEGIN_DESCRIBE_BLACK_BOX(KWBlackBox,bbtk::AtomicBlackBox);
  BBTK_NAME("KWBlackBox");
  // BBTK_DESCRIPTION("Widget box. The inputs marked with (*) are only used if the widget is not inserted in another widget.\n");
  BBTK_CATEGORY("widget");
  BBTK_INPUT(KWBlackBox,WinTitle,
	     "Title of the window (*)",
	     std::string,"");
  BBTK_INPUT(KWBlackBox,WinWidth,
	     "Width of the window (* : only used if the widget is not connected to a Layout box)",int,"");
  BBTK_INPUT(KWBlackBox,WinHeight,
	     "Height of the window (*)",int,"");
  BBTK_INPUT(KWBlackBox,WinDialog,
	     "Set to 'true' to create a dialog window, i.e. which blocks the pipeline until it is closed (modal) (*)",bool,"");
  BBTK_INPUT(KWBlackBox,WinHide,
	     "Any signal received hides the window (*)",Void,"signal");
  BBTK_INPUT(KWBlackBox,WinClose,
	     "Any signal received closes the window (*)",Void,"signal");
  BBTK_OUTPUT(KWBlackBox,Widget,"Output widget",vtkKWWidget*,"");
  BBTK_END_DESCRIBE_BLACK_BOX(KWBlackBox);
  //=================================================================









  //==================================================================
  // The base of the hierarchy of windows associated to a KWBlackBox
  class BBTK_EXPORT vtkKWBlackBoxWindow 
  {
  public:
    vtkKWBlackBoxWindow();
    virtual ~vtkKWBlackBoxWindow();
    virtual void bbShow();
    virtual void bbHide();
    virtual void bbClose();
    bool bbIsShown() { return mShown; }
    void bbSetBlackBox(KWBlackBox::Pointer box) 
    { 
      mBox = box; 
      mBox.lock()->bbSetWindow(this);
    }
    virtual KWBlackBox::Pointer bbGetBlackBox() { return mBox.lock(); }
  private:
    KWBlackBox::WeakPointer mBox;
    bool mShown;
  };
  //==================================================================


  //==================================================================
  // Dialog window which is modal
  // Name of window must not begin with uppercase letter 
  class BBTK_EXPORT  vtkKWBlackBoxDialog : public vtkKWDialog, 
					public vtkKWBlackBoxWindow
  {
  public:
    static vtkKWBlackBoxDialog* New();
    vtkTypeRevisionMacro(vtkKWBlackBoxDialog,vtkKWDialog);
    void bbShow();  
    void bbHide();
    void bbClose();
    void Cancel();
  protected:
    vtkKWBlackBoxDialog();
    ~vtkKWBlackBoxDialog();
  private:
    vtkKWBlackBoxDialog(const vtkKWBlackBoxDialog&);   // Not implemented.
    void operator=(const vtkKWBlackBoxDialog&);  // Not implemented.
  };
  //==================================================================

  //==================================================================
  // Frame window which is not modal
  class BBTK_EXPORT  vtkKWBlackBoxFrame : public vtkKWWindowBase,
				       public vtkKWBlackBoxWindow
  {
  public:
    static vtkKWBlackBoxFrame* New();
    vtkTypeRevisionMacro(vtkKWBlackBoxFrame,vtkKWWindowBase);
    void bbShow();  
    void bbHide();
    void bbClose();
  protected:
    vtkKWBlackBoxFrame();
    ~vtkKWBlackBoxFrame();
  private:
    vtkKWBlackBoxFrame(const vtkKWBlackBoxFrame&);   // Not implemented.
    void operator=(const vtkKWBlackBoxFrame&);  // Not implemented.
  };
  //==================================================================


  /*
  //=================================================================
  // Handles the destroy events of a widget associated to a KWBlackBox 
  // in order to signal the widget death to its associated box
  class BBTK_EXPORT KWBlackBoxWidgetEventHandler : public wxEvtHandler
  {
  public:
    /// Ctor with the box and widget 
    KWBlackBoxWidgetEventHandler( KWBlackBox::Pointer box, wxWindow *widget );
    /// Dtor
    ~KWBlackBoxWidgetEventHandler();
    /// Returns true iff is the handler for that window  
    bool IsHandlerOf( wxWindow* w ) { return mWindow == w; }
    // wxWindow* GetKWWindow() { return mWindow; }
    /// Method processing the destroy event of the widget
    void OnWindowDestroy(wxWindowDestroyEvent&);
    //
    //bool IsDead() { return mDead; }

  private:
    KWBlackBox::WeakPointer mBox;
    wxWindow* mWindow;
    //bool mDead;
  };  
  //=================================================================
  */


} //namespace bbtk



#endif  // USE_KWWIDGETS
#endif  //__bbtkKWBlackBox_h__