/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbtkWxBlackBox.cxx,v $
  Language:  C++
  Date:      $Date: 2008/12/08 12:54:27 $
  Version:   $Revision: 1.33 $
=========================================================================*/

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

* 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.
* ------------------------------------------------------------------------ */                                                                         


#ifdef _USE_WXWIDGETS_



/**
 *  \file 
 *  \brief 
 */
 
#include "bbtkWxBlackBox.h"
#include "bbtkBlackBoxOutputConnector.h"

//#include "bbtkWxContainerBlackBox.h"
#include <wx/dialog.h>

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




namespace bbtk
{




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



  //=========================================================================
  WxBlackBoxWindow::WxBlackBoxWindow(WxBlackBox::Pointer box)
    : mBox(box), mShown(false)
  {
    bbtkDebugMessage("wx",9,"WxBlackBoxWindow::WxBlackBoxWindow("<<
		     mBox.lock()->bbGetFullName()<<")"<<std::endl);
    mBox.lock()->bbSetWindow(this);
    Wx::IncNbWindowsAlive();
  }
  //=========================================================================

  //=========================================================================
  WxBlackBoxWindow::~WxBlackBoxWindow()
  {
    bbtkDebugMessage("wx",9,"WxBlackBoxWindow::~WxBlackBoxWindow() "
		     <<this<<std::endl);
    bbHide();
    Wx::DecNbWindowsAlive();
    if (!mBox.expired())
      {
	mBox.lock()->bbSetWindow(0);
      }
  }
  //========================================================================= 


  //=========================================================================
  void WxBlackBoxWindow::bbShow()
  {
    if (bbIsShown()) return;
    bbtkDebugMessage("wx",9,"WxBlackBoxWindow::bbShow()"<<std::endl);
    Wx::IncNbWindowsShown();
    mShown = true;
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxWindow::bbHide()
  {
    if (!bbIsShown()) return;
    bbtkDebugMessage("wx",9,"WxBlackBoxWindow::bbHide()"<<std::endl);
    Wx::DecNbWindowsShown();
    mShown = false;
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxWindow::bbClose()
  {
  }
  //=========================================================================


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

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

  //=========================================================================
  void WxBlackBoxDialog::bbHide()
  {
    bbtkDebugMessage("wx",9,"WxBlackBoxDialog::bbHide()"<<std::endl);
    WxBlackBoxWindow::bbHide();
    Hide();
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxDialog::bbClose()
  {
    bbtkDebugMessage("wx",9,"WxBlackBoxDialog::bbClose()"<<std::endl);
    wxDialog::Destroy();
  }
  //=========================================================================

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





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

  //=========================================================================
  WxBlackBoxFrame::WxBlackBoxFrame(WxBlackBox::Pointer box,
				   wxWindow *parent,
				   wxString title,
				   wxSize size)
    :  wxFrame( parent, 
	       -1, 
	       title,
	       wxDefaultPosition,
	       size,
	       wxRESIZE_BORDER | 
	       wxSYSTEM_MENU  |
	       wxCLOSE_BOX |
	       wxMAXIMIZE_BOX | 
	       wxMINIMIZE_BOX | 
	       wxCAPTION  
		),
       WxBlackBoxWindow(box)
  {
    bbtkDebugMessage("wx",9,"WxBlackBoxFrame::WxBlackBoxFrame("<<
		     bbGetBlackBox()->bbGetFullName()<<","<<parent<<","
		     <<title<<",size)"<<std::endl);
    // Insert the widget into the window
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
	  // LG 22/11/08 : new widget pipeline
	  bbGetBlackBox()->bbCreateWidgetAndEventHandler(this);
    wxWindow* widget = bbGetBlackBox()->bbGetOutputWidget();
    wxFrame* frame = (wxFrame*)this;
// old :    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() 
  { 
    if (bbIsShown()) return;
    bbtkDebugMessage("wx",5,"WxBlackBoxFrame::bbShow("
		     <<bbGetBlackBox()->bbGetFullName()<<")"<<std::endl);
    WxBlackBoxWindow::bbShow();
  wxFrame::Show();
    // This Update is ** MANDATORY ** 
    // to synchronize wxvtkRenderWindowInteractor objects
    // (force wx objects creation **NOW**)


#if defined(_WIN32)
      wxFrame::Refresh();
#endif

      wxFrame::Update();
      wxFrame::SetFocus();
    if (bbGetBlackBox()) bbGetBlackBox()->bbUserOnShow();
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxFrame::bbHide()
  {
    bbtkDebugMessage("wx",9,"WxBlackBoxFrame::bbHide()"<<std::endl);
    WxBlackBoxWindow::bbHide();
    wxFrame::Hide();
    if (bbGetBlackBox()) bbGetBlackBox()->bbUserOnHide();
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxFrame::bbClose()
  {
    bbtkDebugMessage("wx",9,"WxBlackBoxFrame::bbClose()"<<std::endl);
    wxFrame::Close();
  }
  //=========================================================================



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

  //=========================================================================
  WxBlackBoxWidgetEventHandler::
  WxBlackBoxWidgetEventHandler( WxBlackBox::Pointer box, 
				wxWindow *widget )
    :
    mBox(box),
    mWindow(widget)
  { 
    bbtkDebugMessage("wx",9,"WxBlackBoxWidgetEventHandler::WxBlackBoxWidgetEventHandler("<<mBox.lock()->bbGetFullName()<<")"<<std::endl);

    mBox.lock()->bbSetWidgetEventHandler(this);

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

  //=========================================================================
  WxBlackBoxWidgetEventHandler::~WxBlackBoxWidgetEventHandler()
  {
    if (mBox.expired()) return;
    bbtkDebugMessage("wx",9,
		     "WxBlackBoxWidgetEventHandler::~WxBlackBoxWidgetEventHandler() ["
		     <<mBox.lock()->bbGetFullName()<<"]"<<std::endl);
     mBox.lock()->bbSetWidgetEventHandler(0);   
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBoxWidgetEventHandler::OnWindowDestroy(wxWindowDestroyEvent&)
  {
    if (mBox.expired()) return;
    bbtkDebugMessage("wx",9,"WxBlackBoxWidgetEventHandler::OnWindowDestroy() ["
		     <<mBox.lock()->bbGetFullName()<<"]"<<std::endl);
    mBox.lock()->bbSetOutputWidget(0);
    // LGSIGNAL
    //    mBox.lock()->bbSetModifiedStatus();
  }
  //=========================================================================







  //=========================================================================
  // WxBlackBox
  //=========================================================================

  //=========================================================================
  //=========================================================================
  //=========================================================================
  //=========================================================================
  BBTK_BLACK_BOX_IMPLEMENTATION(WxBlackBox,AtomicBlackBox);
  //=========================================================================
  
  //=========================================================================
  void WxBlackBox::bbUserConstructor()
  {
    bbtkDebugMessage("Kernel",9,"WxBlackBox::bbUserConstructor()"<<std::endl);
    bbInitAttributes();
  }
  //=========================================================================

  //=========================================================================
  void WxBlackBox::bbUserCopyConstructor(bbtk::BlackBox::Pointer)
  {
    bbtkDebugMessage("Kernel",9,"WxBlackBox::bbUserCopyConstructor()"
		     <<std::endl);
    bbInitAttributes();
  }
  //=========================================================================


  //=========================================================================
  void WxBlackBox::bbUserDestructor()
  {
    bbtkDebugMessage("wx",9,"==> WxBlackBox::bbUserDestructor() ["<<bbGetFullName()<<"]"<<std::endl);
    if (bbGetWindow()) {
      delete bbGetWindow();
      bbSetWindow(0);
    }
    bbtkDebugMessage("wx",9,"<== WxBlackBox::bbUserDestructor() ["<<bbGetFullName()<<"]"<<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(bbGetName());
    bbSetInputWinWidth(800);
    bbSetInputWinHeight(800);
    bbSetInputWinDialog(false);
    bbSetOutputWidget(0);

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

  //=========================================================================
  /// Main processing method of the box.
  void WxBlackBox::bbExecute(bool force)
  {
    
    bbtkDebugMessageInc("process",2,
			"=> WxBlackBox::bbExecute("<<(int)force<<") ["
			<<bbGetFullName()<<"]"<<std::endl);
    
    
    // If the output 'Widget' is connected then 
    // we must execute the parent box
    BlackBox::OutputConnectorMapType::const_iterator i 
      = bbGetOutputConnectorMap().find("Widget");
    
    if ( i->second->GetConnectionVector().size() != 0 ) 
      {
	bbtkWarning("Execution called on '"<<bbGetFullName()
		    <<"' although its Output 'Widget' is connected: "
		    <<"if the widget is not created yet then it will not be! "
		    <<"Execute the top level Layout widget to create and "
		    <<"display the widget.");
      }

    AtomicBlackBox::bbExecute(force);

    bbtkDebugMessageDec("process",2,
			"<= WxBlackBox::bbExecute() ["
			<<bbGetFullName()<<"]"<<std::endl);
  }
  //=========================================================================


  //=========================================================================
  void WxBlackBox::bbProcess()
  { 
/*
	  if (bbGetOutputWidget()==0) this->bbUserCreateWidget();
	  this->bbUserProcess(); 
	  bbShowWindow();
	  //    this->bbUserOnShow();
	  */
    // LG 22/11/08 : new widget pipeline
    // If output widget not connected : 
    if ( (*bbGetOutputConnectorMap().find("Widget")).second
	 ->GetConnectionVector().size() == 0 ) 
      {
	Window* show = 0;
	// If the window already exists : no need creating it
	if (bbGetWindow()!=0)
	  {
	    bbtkDebugMessage("wx",2,
			     "-> Window already exists"
			     <<std::endl);
	    show = bbGetWindow();
	  }
	// Else create window 
	else 
	  {
	    bbtkDebugMessage("wx",2,
			     "-> Creating the window"
			     <<std::endl);
	    
	    
	    // Input WinDialog set to true : creating a Dialog
	    if (bbGetInputWinDialog()) 
	      {
		bbtkDebugMessage("wx",2,
				 "   Input WinDialog set to true : creating a Dialog"
				 <<std::endl);
		show = (Window*) new WxBlackBoxDialog( GetThisPointer<WxBlackBox>(),
						       // bbGetWxParent(), 
						       // LG 24/11/08 : New widget pipeline
						       Wx::GetTopWindow(),
						       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( GetThisPointer<WxBlackBox>(),
						      // bbGetWxParent(), 
						      // LG 24/11/08 : New widget pipeline
						      Wx::GetTopWindow(),
						      std2wx( bbGetInputWinTitle()  + " - bbtk (c) CREATIS LRMN"),
						      wxSize( bbGetInputWinWidth() , bbGetInputWinHeight() ) );
	      }
	    
	  }
	
	// Show the window
	show->bbShow(); 
	
	
      }		  
    this->bbUserProcess(); 
    
  }
  //=========================================================================
 
	
	
  // LG 24/11/08 : New widget pipeline
  void WxBlackBox::bbCreateWidgetAndEventHandler(wxWindow* parent)
  {
    if (bbGetOutputWidget()==0)
      {
	this->bbUserCreateWidget(parent);
      }		
    // If Event Handler for the widget does not exist or is obsolete : create it 
    if (bbGetOutputWidget()!=0)
      {
	if (bbGetWidgetEventHandler()==0)
	  {
	    bbtkDebugMessage("wx",3,
			     "-> No widget event handler : creating one"
			     <<std::endl);
	    new WxBlackBoxWidgetEventHandler(GetThisPointer<WxBlackBox>(),
					     bbGetOutputWidget());
	  }
	else if ( ! bbGetWidgetEventHandler()->IsHandlerOf 
		  ( bbGetOutputWidget() ) )
	  {
	    bbtkDebugMessage("wx",3,
			     "-> Obsolete widget event handler : re-creating one"
			     <<std::endl);
	    delete bbGetWidgetEventHandler();
	    new WxBlackBoxWidgetEventHandler(GetThisPointer<WxBlackBox>(),
					     bbGetOutputWidget());
	  }
	// Sets the name of the wxWindow to the input WinTitle
	bbGetOutputWidget()->SetName(bbtk::std2wx(bbGetInputWinTitle()));
      }
    
    
  }
  
  
  
  wxWindow*  WxBlackBox::bbCreateWidgetOfInput(const std::string& in, wxWindow* parent)
  {
    wxWindow* w = 0;
    // If input is connected 
    BlackBoxInputConnector* c = bbGetInputConnectorMap().find(in)->second ;
    if ( c->IsConnected() )			
      {
	// Get black box from 
	BlackBox::Pointer from = 
	  c->GetConnection()->GetBlackBoxFrom();
	// Cast it into a WxBlackBox
	WxBlackBox::Pointer wfrom = boost::dynamic_pointer_cast<WxBlackBox>(from);
	// Call bbCreateWidgetAndEventHandler
	wfrom->bbCreateWidgetAndEventHandler(parent);
	// Get the widget created
	w = wfrom->bbGetOutputWidget();
      }
    return w;
  }
  
  /*
  //==================================================================
  /// Specific methods for window creation during pipeline execution
  /// Shows the window associated to the box 
  /// (called after bbProcess during bbExecute)
  void WxBlackBox::bbShowWindow()
  {
    bbtkDebugMessageInc("wx",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("wx",3,
			     "-> No widget event handler : creating one"
			     <<std::endl);
	    new WxBlackBoxWidgetEventHandler(GetThisPointer<WxBlackBox>(),
					     bbGetOutputWidget());
	  }
	else if ( ! bbGetWidgetEventHandler()->IsHandlerOf 
		  ( bbGetOutputWidget() ) )
	  {
	    bbtkDebugMessage("wx",3,
			     "-> Obsolete widget event handler : re-creating one"
			     <<std::endl);
	    delete bbGetWidgetEventHandler();
	    new WxBlackBoxWidgetEventHandler(GetThisPointer<WxBlackBox>(),
					     bbGetOutputWidget());
	  }
	// Sets the name of the wxWindow to the input WinTitle
	bbGetOutputWidget()->SetName(bbtk::std2wx(bbGetInputWinTitle()));
      }

    // 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("wx",2,
			 "-> Output 'Widget' connected : nothing to do"
			 <<std::endl);
	return;
      }


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


	// Input WinDialog set to true : creating a Dialog
	if (bbGetInputWinDialog()) 
	  {
	    bbtkDebugMessage("wx",2,
			     "   Input WinDialog set to true : creating a Dialog"
			     <<std::endl);
	    show = (Window*) new WxBlackBoxDialog( GetThisPointer<WxBlackBox>(),
						  // bbGetWxParent(), 
											  // LG 24/11/08 : New widget pipeline
											  Wx::GetTopWindow(),
						   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( GetThisPointer<WxBlackBox>(),
						  // bbGetWxParent(), 
											 // LG 24/11/08 : New widget pipeline
											 Wx::GetTopWindow(),
						  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("wx",2,"-> Already shown : nothing to do"<<std::endl);
      }
  

    bbtkDebugMessage("wx",2,"<= WxBlackBox::bbShowWindow() ["
			<<bbGetFullName()<<"]"<<std::endl);

  }
  //==================================================================
*/



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

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

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


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

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

    bbtkDebugMessageDec("wx",2,"<= WxBlackBox::bbCloseWindow() ["
			<<bbGetFullName()<<"]"<<std::endl);
  }
  //==================================================================

  //==================================================================
  WxBlackBox::Window* WxBlackBox::bbGetContainingWindow()
  {
    if (bbGetWindow()!=0) return bbGetWindow();
    BlackBox::OutputConnectorMapType::const_iterator i 
      = bbGetOutputConnectorMap().find("Widget");
    if ( i->second->GetConnectionVector().size() != 0 ) 
      {
	return boost::static_pointer_cast<WxBlackBox>
	  (i->second->GetConnectionVector().front() //.lock()
	   ->GetBlackBoxTo())->bbGetContainingWindow();
      }
    return 0;
  }
  //==================================================================


  //==================================================================
	// LG 24/11/08 : New widget pipeline
	//  wxWindow* WxBlackBox::bbGetWxParent() { return Wx::GetTopWindow(); }
  //==================================================================
  
  
  //==================================================================
  bool WxBlackBox::bbIsShown()
  {
    if (bbGetContainingWindow()!=0)
      return bbGetContainingWindow()->bbIsShown();
    return false;
  }
  //==================================================================


}//namespace bbtk


#endif