/*=========================================================================
                                                                                
  Program:   bbtk
  Module:    $RCSfile: bbwxSlider.cxx,v $
  Language:  C++
  Date:      $Date: 2008/01/22 15:02:00 $
  Version:   $Revision: 1.1.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.
                                                                                
=========================================================================*/
/**
 * \file 
 * \brief Short description in one line
 *
 * Long 
 * description
 *  
 */


#ifdef _USE_WXWIDGETS_



#include "bbwxSlider.h"
#include "bbwxPackage.h"




namespace bbwx
{
  
  //-------------------------------------------------------------------------
  SliderWidget::SliderWidget(Slider* box, wxWindow *parent,
			     int orientation,
			     bool changeresolution,
			     bool labels,
			     wxString title,
			     int vmin,
			     int vmax,
			     int value,
              int reactiveontrack)
    :  
    wxPanel( parent, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL),
    mBox(box),
    min(vmin),
    max(vmax),
    reactiveOnTrack(reactiveontrack)
  {
    wxPanel * panel = this;

    label_min           = NULL;
    label_max           = NULL;
    label_vertical      = NULL;
    mResolutionOfSlider	= NULL;
    
    int sizeX,sizeY;
    long wxlabels=0;
    long wxorientation=0;
    if (orientation==0) 
      {
	sizeX			= 2;
	sizeY			= 40;
	wxorientation	= wxSL_HORIZONTAL;
	if (labels==true)
	  {
	    wxlabels = wxSL_LABELS;
	  }
      } 
    else 
      {
	sizeX			= 20;
	sizeY			= 2;
	wxorientation	= wxSL_VERTICAL;
      }
    
    //---------------------------------------------------------------------
    // 1) Creation of the components of the widget
    // Any top level sub-widget must have the panel returned by panel
    // for parent
    mwxSlider = new wxSlider( panel, 
			      -1, 0 , 0, 500 , 
			      wxDefaultPosition, 
			      wxSize(sizeX,sizeY), 
			      wxorientation  | wxlabels );

    //    mwxSlider->SetInitialSize(wxSize(sizeX,sizeY));

    //	mwxSlider->SetTickFreq(100,0);
    mwxSlider->SetRange(min,max);
    mwxSlider->SetValue(value);

    //    RefreshLabels();

    // Connecting events to callbacks
    Connect( mwxSlider->GetId(), 
	     wxEVT_SCROLL_THUMBRELEASE, 

	     (wxObjectEventFunction) 
	     (void (wxPanel::*)(wxScrollEvent&))
	     &SliderWidget::OnSliderRelease ); 

    Connect( mwxSlider->GetId(),  
	     wxEVT_SCROLL_THUMBTRACK, 

	     (wxObjectEventFunction) 
	     (void (wxPanel::*)(wxScrollEvent&))
	      &SliderWidget::OnSliderTrack ); 
    

    // If asked : creation of the other little slider which allows to change 
    // the resolution of the main slider
    if (changeresolution==true){
      // has panel for parent too
      mResolutionOfSlider = new wxSlider(panel,
					 -1,5,1,10,
					 wxDefaultPosition,
					 wxSize(25,45),
					 wxSL_VERTICAL | 
					 wxSL_AUTOTICKS |
					 wxSL_LEFT  );
   

      mResolutionOfSlider->SetRange(1,8);
      mResolutionOfSlider->SetValue(5);
      // Is wxEVT_COMMAND_SLIDER_UPDATED event 
      // is connected to the method OnResolutionOfSlider
      Connect(mResolutionOfSlider->GetId(),
	      wxEVT_COMMAND_SLIDER_UPDATED,
	      (wxObjectEventFunction) 
	      (void (wxPanel::*)(wxScrollEvent&))
	      &SliderWidget::OnResolutionOfSlider ); 
    }
    //---------------------------------------------------------------------

    //---------------------------------------------------------------------
    // 2) Insertion of the components in the window
    
    // We use a FlexGridSizer
    wxFlexGridSizer *sizer;


    if (orientation==0) 
      {
	// HORIZONTAL
	if (mResolutionOfSlider!=NULL) 
	  {
	    sizer	= new wxFlexGridSizer(2);
	    if (title!=_T(""))
	      {
		sizer	-> Add( new wxStaticText(panel,-1, title ) ); 
		sizer	-> Add( new wxStaticText(panel,-1, _T("") ) ); 
	      }
	  } 
	else 
	  {
	    sizer	= new wxFlexGridSizer(1);
	    if (title!=_T(""))
	      {
		sizer	-> Add( new wxStaticText(panel,-1, title ) ); 
	      }
	  }
	sizer	-> Add( mwxSlider,1,wxGROW ); 
	sizer	-> AddGrowableCol(0);
	if (mResolutionOfSlider!=NULL) 
	  {
	    sizer	-> Add( mResolutionOfSlider ); 
	  }
      } 
    else 
      {
	// VERTICAL 
	sizer	= new wxFlexGridSizer(1);
	if (labels==true)  // with lable
	  {
	    label_vertical = new wxStaticText(panel,-1,_T(""));
	    label_min = new wxStaticText(panel,-1,_T(""));
	    label_max = new wxStaticText(panel,-1,_T(""));
	    if (title!=_T(""))
	      {
		sizer	-> Add( new wxStaticText(panel,-1, title ) );
		sizer	-> AddGrowableRow(3);
	      } 
	    else 
	      {
		sizer	-> AddGrowableRow(2);
	      }
	    sizer	-> Add( label_vertical );
	    sizer	-> Add( label_min );
	    sizer	-> Add( mwxSlider,1,wxGROW );
	    sizer	-> Add( label_max );
	    if (mResolutionOfSlider!=NULL) 
	      {
		sizer	-> Add( mResolutionOfSlider ); 
	      }
	  } 
	else 
	  {
	    if (title!=_T(""))
	      {
		sizer	-> Add( new wxStaticText(panel,-1, title ) );
		sizer	-> AddGrowableRow(1);
	      } 
	    else 
	      {
		sizer	-> AddGrowableRow(0);
	      }
	    sizer	-> Add( mwxSlider,1,wxGROW );
	    if (mResolutionOfSlider!=NULL) 
	      {
		sizer	-> Add( mResolutionOfSlider ); 
	      }
	  }
      }
    // Initialize the labels 
    RefreshLabels();  
    // Insert the sizer in the main panel and refresh the layout
    panel->SetSizer(sizer);
    //   panel->SetAutoLayout(true);
    //    panel->Layout();
  }
  //-------------------------------------------------------------------------
  

  //-------------------------------------------------------------------------
  SliderWidget::~SliderWidget()
  {
  }
  //-------------------------------------------------------------------------


  //-------------------------------------------------------------------------
  void SliderWidget::OnResolutionOfSlider(wxScrollEvent& event)
  {
    int value = mwxSlider->GetValue();
    int delta = (int) (pow( 4 , mResolutionOfSlider->GetValue() ));
    int minTmp   = value - delta/2;
    int maxTmp   = value + delta/2;
    if (minTmp<min)
      {
	minTmp = min;
	//		maxTmp = delta;
      }
    if (maxTmp>max)
      {
	maxTmp = max;
      }
    mwxSlider->SetRange(minTmp,maxTmp);
    RefreshLabels();
  }
  //-------------------------------------------------------------------------



  //-------------------------------------------------------------------------
  void SliderWidget::OnSliderTrack(wxScrollEvent& event)
  {
    if(reactiveOnTrack)
    {
    // When user releases the slider 
    // we update the output of the box
    mBox->bbSetOutputOut( mwxSlider->GetValue() );
    mBox->bbSetInputIn( mwxSlider->GetValue() );
    // and signal that the output has changed
    mBox->bbSignalOutputModification("Out");    
    }
    RefreshLabels();  
  }
  //-------------------------------------------------------------------------


  //-------------------------------------------------------------------------
  void SliderWidget::OnSliderRelease(wxScrollEvent& event)
  {
    // When user releases the slider 
    // we update the output of the box
    mBox->bbSetOutputOut( mwxSlider->GetValue() );
    mBox->bbSetInputIn( mwxSlider->GetValue() );
    // and signal that the output has changed
    mBox->bbSignalOutputModification("Out");
  }
  //-------------------------------------------------------------------------
  

  //-------------------------------------------------------------------------
  void SliderWidget::RefreshLabels()
  {
    wxString strValue;
    if (label_vertical!=NULL)
      {
	strValue.Printf( _T("%d"), mwxSlider->GetValue() );
	label_vertical->SetLabel(strValue);
      }
    if (label_min!=NULL)
      {
	strValue.Printf( _T("%d"), mwxSlider->GetMin() );
	label_min->SetLabel(strValue);
      }
    if (label_max!=NULL)
      {
	strValue.Printf( _T("%d"), mwxSlider->GetMax() );
	label_max->SetLabel(strValue);
      }  
  }
  //-------------------------------------------------------------------------
  

  //-------------------------------------------------------------------------
  void SliderWidget::SetRange(int min, int max)
  {
    this->min = min;
    this->max = max;
    mwxSlider->SetRange(min,max);
    RefreshLabels();
  }
  //-------------------------------------------------------------------------

 


  //--------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  // WxBlackBox implementation
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  //--------------------------------------------------------------------------
  BBTK_USER_BLACK_BOX_IMPLEMENTATION(Slider,bbtk::WxBlackBox);
  BBTK_ADD_BLACK_BOX_TO_PACKAGE(wx,Slider);
  //--------------------------------------------------------------------------

  //--------------------------------------------------------------------------
  void Slider::bbUserConstructor() 
  { 
    bbSetInputIn(0);
    bbSetInputMin(0);
    bbSetInputMax(500);
    bbSetOutputOut(0);
    bbSetInputOrientation(0);
    bbSetInputChangeResolution(false);
    bbSetInputLabel(true);
    bbSetInputReactiveOnTrack(0);    
  }
  //--------------------------------------------------------------------------

  //--------------------------------------------------------------------------
  void Slider::Process() 
  {
    int val = bbGetInputIn();
    bbSetOutputOut( bbGetInputIn() );

    if (bbGetOutputWidget()==0) 
      {
	bbSetOutputWidget( new SliderWidget(this, 
					    bbGetWxParent(),
					    bbGetInputOrientation() , 
					    bbGetInputChangeResolution(), 
					    bbGetInputLabel(), 
					    bbtk::std2wx( bbGetInputTitle() ),
					    bbGetInputMin(), 
					    bbGetInputMax(),
					    val,
					    bbGetInputReactiveOnTrack()
					    )
			   );
      }
  }
  //--------------------------------------------------------------------------  
  /*
  //--------------------------------------------------------------------------
  bbtk::WxBlackBoxWidget* Slider::bbUserCreateWidget(wxWindow *parent)
  {
   

  }
  //--------------------------------------------------------------------------
  */


} //namespace bbwx

#endif // _USE_WXWIDGETS_