/*=========================================================================
                                                                                
  Program:   bbtk
  Module:    $RCSfile: bbtkWxBlackBox.cxx,v $
  Language:  C++
  Date:      $Date: 2008/01/22 15:02:00 $
  Version:   $Revision: 1.1 $
                                                                                
  Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
  l'Image). All rights reserved. See Doc/License.txt or
  http://www.creatis.insa-lyon.fr/Public/bbtk/License.html for details.
                                                                                
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.
                                                                                
=========================================================================*/

#ifdef _USE_WXWIDGETS_



/**
 *  \file 
 *  \brief 
 */
 
#include "bbtkWxBlackBox.h"
//#include "bbtkWxContainerBlackBox.h"
#include <wx/dialog.h>

//#include "bbtkData.h"
//#include "bbtkFactory.h"



namespace bbtk
{

  //=========================================================================
  wxWindow* WxBlackBox::bbGlobalGetTopWindow() 
  {
    return bbmgTopWindow;
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBox::bbGlobalSetTopWindow(wxWindow* w) 
  {
    if ( bbmgTopWindow ) 
      {
	bbtkGlobalError("WxBlackBox::bbGlobalSetTopWindow : top window already set !");
      } 
    bbmgTopWindow = w;
  }
  //=========================================================================
   

  //=========================================================================
  void WxBlackBox::bbGlobalDecNbWindowsAlive()
  { 
    bbmgNbWindowsAlive--; 
    /*
    if ( (bbmgNbWindowsAlive==0) && 
	 bbmgTopWindow && (!bbmgTopWindow->IsShown()))
      {
	bbmgTopWindow->Close();
      }
    */
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBox::bbGlobalDecNbWindowsShown()
  { 
    bbmgNbWindowsShown--; 
    if ( (bbmgNbWindowsShown==0) && 
	 bbmgTopWindow && (!bbmgTopWindow->IsShown()))
      {
	bbmgTopWindow->Close();
      }
  }
  //=========================================================================

  //=========================================================================
  // Static members 
  wxWindow* WxBlackBox::bbmgTopWindow =0;
  int WxBlackBox::bbmgNbWindowsAlive = 0;
  int WxBlackBox::bbmgNbWindowsShown = 0;
  //=========================================================================





  //=========================================================================
  // WxBlackBoxWindow
  //=========================================================================



  //=========================================================================
  WxBlackBoxWindow::WxBlackBoxWindow(WxBlackBox* box)
    : mBox(box), mShown(false)
  {
    bbtkDebugMessage("Wx",9,"WxBlackBoxWindow::WxBlackBoxWindow("<<
		     mBox->bbGetFullName()<<")"<<std::endl);
    mBox->bbSetWindow(this);
    WxBlackBox::bbGlobalIncNbWindowsAlive();
    bbtkDebugMessage("Wx",9," -> Number of windows alive = "
		     <<WxBlackBox::bbGlobalGetNbWindowsAlive()<<std::endl);
  }
  //=========================================================================

  //=========================================================================
  WxBlackBoxWindow::~WxBlackBoxWindow()
  {
    bbtkDebugMessage("Wx",9,"WxBlackBoxWindow::~WxBlackBoxWindow() ["<<
		     mBox->bbGetFullName()<<"]"<<std::endl);
    bbHide();
    mBox->bbSetWindow(0);
    WxBlackBox::bbGlobalDecNbWindowsAlive();
    bbtkDebugMessage("Wx",9," -> Number of windows alive = "
		     <<WxBlackBox::bbGlobalGetNbWindowsAlive()<<std::endl);
     

  }
  //========================================================================= 

  //=========================================================================
  void WxBlackBoxWindow::bbShow()
  {
    if (bbIsShown()) return;
    bbtkDebugMessage("Wx",9,"WxBlackBoxWindow::bbShow() ["<<
		     mBox->bbGetFullName()<<"]"<<std::endl);
    WxBlackBox::bbGlobalIncNbWindowsShown();
    mShown = true;
    bbtkDebugMessage("Wx",9," -> Number of windows shown = "
		     <<WxBlackBox::bbGlobalGetNbWindowsShown()<<std::endl);
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxWindow::bbHide()
  {
    if (!bbIsShown()) return;
    bbtkDebugMessage("Wx",9,"WxBlackBoxWindow::bbHide() ["<<
		     mBox->bbGetFullName()<<"]"<<std::endl);
    WxBlackBox::bbGlobalDecNbWindowsShown();
    mShown = false;
    bbtkDebugMessage("Wx",9," -> Number of windows shown = "
		     <<WxBlackBox::bbGlobalGetNbWindowsShown()<<std::endl);
  }
  //=========================================================================



  //=========================================================================
  // WxBlackBoxDialog
  //=========================================================================

  //=========================================================================
  WxBlackBoxDialog::WxBlackBoxDialog(WxBlackBox* box,
				     wxWindow *parent,
				     wxString title,
				     wxSize size)
    :
    WxBlackBoxWindow(box),
    wxDialog( parent, 
		-1, 
		title,
		wxDefaultPosition,
		size,
		wxRESIZE_BORDER | 
		wxSYSTEM_MENU  |
		wxCLOSE_BOX |
		wxMAXIMIZE_BOX | 
		wxMINIMIZE_BOX | 
		wxCAPTION  
		)
  {
    bbtkDebugMessage("Wx",9,"WxBlackBoxDialog::WxBlackBoxDialog("<<
		     bbGetBlackBox()->bbGetFullName()<<","<<parent<<","
		     <<title<<",size)"<<std::endl);
    // Insert the widget into the window
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
    wxWindow* widget = bbGetBlackBox()->bbGetOutputWidget();
    widget->Reparent(this);
    sizer->Add( widget, 1, wxALL|wxEXPAND, 2);
    //SetAutoLayout(true);
    SetSizer(sizer);
    Layout();
  }
  //=========================================================================
  
  //=========================================================================
  void WxBlackBoxDialog::bbShow()
  { 
    bbtkDebugMessage("Wx",5,"WxBlackBoxDialog::bbShow() ["
		     <<bbGetBlackBox()->bbGetFullName()<<"]"<<std::endl);
    WxBlackBoxWindow::bbShow();
    SetReturnCode( wxDialog::ShowModal() ); 
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxDialog::bbHide()
  {
    bbtkDebugMessage("Wx",9,"WxBlackBoxDialog::bbHide() ["<<
		     bbGetBlackBox()->bbGetFullName()<<"]"<<std::endl);
    WxBlackBoxWindow::bbHide();
    Hide();
  }
  //=========================================================================

  //=========================================================================
  WxBlackBoxDialog::~WxBlackBoxDialog()
  {
  }
  //=========================================================================





  //=========================================================================
  // WxBlackBoxFrame
  //=========================================================================

  //=========================================================================
  WxBlackBoxFrame::WxBlackBoxFrame(WxBlackBox* box,
				   wxWindow *parent,
				   wxString title,
				   wxSize size)
    : WxBlackBoxWindow(box),
      wxFrame( parent, 
	       -1, 
	       title,
	       wxDefaultPosition,
	       size,
	       wxRESIZE_BORDER | 
	       wxSYSTEM_MENU  |
	       wxCLOSE_BOX |
	       wxMAXIMIZE_BOX | 
	       wxMINIMIZE_BOX | 
	       wxCAPTION  
	       )
  {
    bbtkDebugMessage("Wx",9,"WxBlackBoxFrame::WxBlackBoxFrame("<<
		     bbGetBlackBox()->bbGetFullName()<<","<<parent<<","
		     <<title<<",size)"<<std::endl);
    // Insert the widget into the window
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
    wxWindow* widget = bbGetBlackBox()->bbGetOutputWidget();
    wxFrame* frame = (wxFrame*)this;
    widget->Reparent(frame);
    sizer->Add( widget, 1, wxALL|wxGROW, 2);
    //  frame->SetAutoLayout(true);
    frame->SetSizer(sizer);
    //frame->Fit();
    frame->Layout();
  }
  //=========================================================================
  
  //=========================================================================
  WxBlackBoxFrame::~WxBlackBoxFrame()
  {
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxFrame::bbShow() 
  { 
    bbtkDebugMessage("Wx",5,"WxBlackBoxFrame::bbShow("
		     <<bbGetBlackBox()->bbGetFullName()<<")"<<std::endl);
    WxBlackBoxWindow::bbShow();
    wxFrame::Show(); 
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxFrame::bbHide()
  {
    bbtkDebugMessage("Wx",9,"WxBlackBoxFrame::bbHide() ["<<
		     bbGetBlackBox()->bbGetFullName()<<"]"<<std::endl);
    WxBlackBoxWindow::bbHide();
    Hide();
  }
  //=========================================================================



  //=========================================================================
  // WxBlackBoxDialogWrapper
  //=========================================================================
  /*
  //=========================================================================
  WxBlackBoxDialogWrapper::WxBlackBoxDialogWrapper(WxBlackBox* box,
						   wxDialog *wrapped) 
    : WxBlackBoxWindow(box),
      mWrapped(wrapped) 
  {
    bbtkDebugMessage("Wx",9,
		     "WxBlackBoxDialogWrapper::WxBlackBoxDialogWrapper("
		     <<bbGetBlackBox()->bbGetFullName()<<","<<wrapped
		     <<")"<<std::endl);
  }
  //=========================================================================

  //=========================================================================
  WxBlackBoxDialogWrapper::~WxBlackBoxDialogWrapper()
  {
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxDialogWrapper::bbShow() 
  {  
    bbtkDebugMessage("Wx",5,"WxBlackBoxDialogWrapper::bbShow("
		     <<bbGetBlackBox()->bbGetFullName()<<")"<<std::endl);
    WxBlackBoxWindow::bbShow();
    int i = mWrapped->ShowModal();
    // For Windows :
    mWrapped->SetReturnCode( i ); 
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxDialogWrapper::bbHide()
  {
    bbtkDebugMessage("Wx",9,"WxBlackBoxDialogWrapper::bbHide() ["<<
		     bbGetBlackBox()->bbGetFullName()<<"]"<<std::endl);
    WxBlackBoxWindow::bbHide();
    mWrapped->Hide();
  }
  //=========================================================================

  */

  /*	 
  //=========================================================================
  // WxBlackBoxWidget
  //=========================================================================

  //=========================================================================
  WxBlackBoxWidget::WxBlackBoxWidget( WxBlackBox* box)
  : mBox(box)
  {
    bbtkDebugMessage("Wx",9,"WxBlackBoxWidget::WxBlackBoxWidget("<<box->bbGetFullName()<<")"<<std::endl);
    mBox->bbSetWidget(this);
  }
  //=========================================================================

  //=========================================================================
  WxBlackBoxWidget::~WxBlackBoxWidget()
  {
    bbtkDebugMessage("Wx",9,"WxBlackBoxWidget::~WxBlackBoxWidget("<<mBox->bbGetFullName()<<")"<<std::endl);
    mBox->bbSetWidget(0);
    //bbtkDebugMessage("Wx",9,"EO WxBlackBoxWidget::~WxBlackBoxWidget("<<mBox->bbGetFullName()<<")"<<std::endl);
  }
  //=========================================================================
  */



  //=========================================================================
  // WxBlackBoxWidgetEventHandler
  //=========================================================================

  //=========================================================================
  WxBlackBoxWidgetEventHandler::WxBlackBoxWidgetEventHandler( WxBlackBox* box, 
							      wxWindow *widget )
    :
    mBox(box),
    mWindow(widget)
							    //    mDead(false)
  { 
    bbtkDebugMessage("Wx",9,"WxBlackBoxWidgetEventHandler::WxBlackBoxWidgetEventHandler("<<mBox->bbGetFullName()<<")"<<std::endl);

    mBox->bbSetWidgetEventHandler(this);

    Connect (  mWindow->GetId(),
	       wxEVT_DESTROY,
	       (wxObjectEventFunction) 
	       (void (wxEvtHandler::*)(wxWindowDestroyEvent& c))
		&WxBlackBoxWidgetEventHandler::OnWindowDestroy );
    
    mWindow->PushEventHandler(this);
    
  }
  //=========================================================================

  //=========================================================================
  WxBlackBoxWidgetEventHandler::~WxBlackBoxWidgetEventHandler()
  {
    bbtkDebugMessage("Wx",9,
		     "WxBlackBoxWidgetEventHandler::~WxBlackBoxWidgetEventHandler("
		     <<mBox->bbGetFullName()<<")"<<std::endl);
     mBox->bbSetWidgetEventHandler(0);   
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxWidgetEventHandler::OnWindowDestroy(wxWindowDestroyEvent&)
  {
    bbtkDebugMessage("Wx",9,"WxBlackBoxWidgetEventHandler::OnWindowDestroy() ["
		     <<mBox->bbGetFullName()<<"]"<<std::endl);
    mBox->bbSetOutputWidget(0);
    mBox->bbSetModifiedStatus();
    //mDead = true;
    //delete this;
  }
  //=========================================================================







  /*
  //=========================================================================
  wxWindow* WxParentToChildData::GetWindowInWhichToInsert( const BlackBox* b)
    const
  {
    bbtkDebugMessageInc("Core",9,"WxParentToChildData::GetWindowInWhichToInsert("<<b->bbGetFullName()<<")"<<std::endl);
    
    BlackBox::InputConnectorMapType::const_iterator i = b->bbGetInputConnectorMap().find("WinParent");
    if (i==b->bbGetInputConnectorMap().end())
      {
	bbtkError("WxParentToChildData::GetWindowInWhichToInsert : the box "
		  <<b->bbGetFullName()
		  <<" does not have any 'Parent' input ?!?");
      }
    Connection* c = i->second->GetConnection();
    if (!c) 
      {
	bbtkDebugMessage("Core",9,
			 "-> The input 'Parent' of the box "
			 <<b->bbGetFullName()
			 <<" is not connected."<<std::endl);
	return 0;
      }
    
    std::map< Connection*, wxWindow *>::const_iterator j 
      = mConnectionToWindowMap.find(c);

    if (j==mConnectionToWindowMap.end())
      {
	bbtkError("WxParentToChildData::GetWindowInWhichToInsert("
		  <<b->bbGetFullName()
		  <<") no window provided by parent ?!?");
      }

    bbtkDebugDecTab("Core",9);
    return j->second;
  }
  //=========================================================================
  */
  
  //=========================================================================
  // WxBlackBox
  //=========================================================================

  //=========================================================================
  //=========================================================================
  //=========================================================================
  //=========================================================================
  BBTK_USER_BLACK_BOX_IMPLEMENTATION(WxBlackBox,UserBlackBox);
  //=========================================================================
  
  //=========================================================================
  void WxBlackBox::bbUserConstructor()
  {
    bbtkDebugMessage("Core",9,"WxBlackBox::bbUserConstructor()"<<std::endl);
    bbInitAttributes();
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBox::bbUserCopyConstructor()
  {
    bbtkDebugMessage("Core",9,"WxBlackBox::bbUserCopyConstructor()"
		     <<std::endl);
    bbInitAttributes();
  }
  //=========================================================================


  //=========================================================================
  void WxBlackBox::bbUserDestructor()
  {
    bbtkDebugMessage("Core",9,"WxBlackBox::bbUserDestructor()"<<std::endl);
    if (bbGetWindow()) {
      delete bbGetWindow();
      //      bbSetWindow(0);
    }
    bbtkDebugMessage("Core",9,"EO WxBlackBox::bbUserDestructor()"<<std::endl);
  }
  //=========================================================================
  

  /*
  //=========================================================================
  WxBlackBox::Widget*  WxBlackBox::bbGetWidget()
  { 
    if (bbGetOutputWidget() && bbGetOutputWidget()->IsDead()) 
      {
	bbtkDebugMessage("Wx",9,"WxBlackBox::bbGetWidget() ["<<
			 bbGetFullName()<<"] : Widget is dead : deleting it"
			 <<std::endl);
	delete bbGetOutputWidget();
	bbSetOutputWidget(0);
      }
    return bbGetOutputWidget();
  }
  //=========================================================================
  */


  //=========================================================================
  /**
   * \brief Initialize the attributes of the class
   *
   */
  void WxBlackBox::bbInitAttributes()
  {
    bbmWindow = 0;
    //    bbmWidget = 0;
    //    bbSetInputWinParent(0);
    bbSetInputWinTitle("...");
    bbSetInputWinWidth(800);
    bbSetInputWinHeight(800);
    bbSetInputWinDialog(false);
    bbSetOutputWidget(0);

    bbSetWidgetEventHandler(0);
  }
  //=========================================================================



  //==================================================================
  /// Specific methods for window creation during pipeline execution
  /// Shows the window associated to the box 
  /// (called after bbProcess during bbExecute)
  void WxBlackBox::bbShowWindow(Connection* caller)
  {
    bbtkDebugMessageInc("Process",1,"=> WxBlackBox::bbShowWindow() ["
			<<bbGetFullName()<<"]"<<std::endl);
 
    // If Event Handler for the widget does not exist or is obsolete : create it 
    if (bbGetOutputWidget()!=0)
      {
	if (bbGetWidgetEventHandler()==0)
	  {
	    bbtkDebugMessage("Process",3,
			     "-> No widget event handler : creating one"
			     <<std::endl);
	    new WxBlackBoxWidgetEventHandler(this,bbGetOutputWidget());
	  }
	else if ( ! bbGetWidgetEventHandler()->IsHandlerOf 
		  ( bbGetOutputWidget() ) )
	  {
	    bbtkDebugMessage("Process",3,
			     "-> Obsolete widget event handler : re-creating one"
			     <<std::endl);
	    delete bbGetWidgetEventHandler();
	    new WxBlackBoxWidgetEventHandler(this,bbGetOutputWidget());
	  }
      }

    // If the output 'Widget' is connected then it's gonna 
    // be captured by its parent window : nothing to do 
    if ( (*bbGetOutputConnectorMap().find("Widget")).second
	 ->GetConnectionVector().size() != 0 ) 
      {
	
	bbtkDebugMessage("Process",2,
			 "-> Output 'Widget' connected : nothing to do"
			 <<std::endl);
	bbtkDebugDecTab("Process",1);
	return;
      }


    Window* show = 0;
    // If the window already exists : no need creating it
    if (bbGetWindow()!=0)
      {
	bbtkDebugMessage("Process",2,
			 "-> Window already exists"
			 <<std::endl);
	show = bbGetWindow();
      }
    // Else if the widget exists : create window 
    else if (bbGetOutputWidget()!=0) 
      {
	bbtkDebugMessage("Process",2,
			 "-> Widget exists : creating the window"
			 <<std::endl);


	// Input WinDialog set to true : creating a Dialog
	if (bbGetInputWinDialog()) 
	  {
	    bbtkDebugMessage("Process",2,
			     "   Input WinDialog set to true : creating a Dialog"
			     <<std::endl);
	    show = (Window*) new WxBlackBoxDialog( this,
						   bbGlobalGetTopWindow(), 
						   std2wx( bbGetInputWinTitle() + " - bbtk (c) CREATIS LRMN"),
						   wxSize( bbGetInputWinWidth() , bbGetInputWinHeight() ) );
	  }
	// Input WinDialog set to false : creating a Frame
	else 
	  {
	    bbtkDebugMessage("Process",2,
			     "   Input WinDialog set to false : creating a Frame"
			     <<std::endl);
	    show = (Window*) new WxBlackBoxFrame( this,
						  bbGlobalGetTopWindow(), 
						  std2wx( bbGetInputWinTitle()  + " - bbtk (c) CREATIS LRMN"),
						  wxSize( bbGetInputWinWidth() , bbGetInputWinHeight() ) );
	  }

      }
    // No window nor widget : error
    else
      {
	bbtkError("WxBlackBox::bbShowWindow() ["
		  <<bbGetFullName()
		  <<"] : No widget. Did you set the box output 'Widget' in the processing method of the box ?");
      }
 
    
    // Show the window
    if (true) //!show->IsShown())
      {
	show->bbShow(); 
      }
    else 
      {
	bbtkDebugMessage("Process",2,"-> Already shown : nothing to do"<<std::endl);
      }
  

    bbtkDebugMessage("Process",1,"<= WxBlackBox::bbShowWindow() ["
			<<bbGetFullName()<<"]"<<std::endl);
    bbtkDebugDecTab("Process",1);
  }
  //==================================================================




  //==================================================================
   void WxBlackBox::bbHideWindow()
  {
    bbtkDebugMessageInc("Process",1,"=> WxBlackBox::bbHideWindow() ["
			<<bbGetFullName()<<"]"<<std::endl);

    if (bbGetWindow()!=0) bbGetWindow()->bbHide();

    bbtkDebugMessageDec("Process",1,"<= WxBlackBox::bbHideWindow() ["
			<<bbGetFullName()<<"]"<<std::endl);
  }
  //==================================================================




}//namespace bbtk


#endif