packages/qt/src/bbqtQSlider.cxx~

   1 /*=========================================================================
   2   Program:   bbtk
   3   Module:    $RCSfile: bbqtQSlider.cxx~,v $
   4   Language:  C++
   5   Date:      $Date: 2009/04/08 07:56:33 $
   6   Version:   $Revision: 1.1 $
   7 =========================================================================*/
   8
   9 /* ---------------------------------------------------------------------
  10
  11 * Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
  12 * Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
  13 *
  14 *  This software is governed by the CeCILL-B license under French law and
  15 *  abiding by the rules of distribution of free software. You can  use,
  16 *  modify and/ or redistribute the software under the terms of the CeCILL-B
  17 *  license as circulated by CEA, CNRS and INRIA at the following URL
  18 *  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  19 *  or in the file LICENSE.txt.
  20 *
  21 *  As a counterpart to the access to the source code and  rights to copy,
  22 *  modify and redistribute granted by the license, users are provided only
  23 *  with a limited warranty  and the software's author,  the holder of the
  24 *  economic rights,  and the successive licensors  have only  limited
  25 *  liability.
  26 *
  27 *  The fact that you are presently reading this means that you have had
  28 *  knowledge of the CeCILL-B license and that you accept its terms.
  29 * ------------------------------------------------------------------------ */
  30
  31 /**
  32  * \file
  33  * \brief Short description in one line
  34  *
  35  * Long
  36  * description
  37  *
  38  */
  39
  40 #ifdef USE_QT
  41
  42 #include "bbqtQSlider.h"
  43 #include "bbqtPackage.h"
  44 #include "bbtkUtilities.h"
  45
  46 namespace bbqt
  47 {
  48
  49   /*
  50   //--------------------------------------------------------------------------
  51   // The widget created by the box
  52   class SliderWidget : public qtPanel
  53   {
  54   public:
  55     /// Ctor with the two first params the parent window and the creator box
  56     /// which must be passed to the QtBlackBoxWidget constructor.
  57     /// The other params initialize the widget
  58     SliderWidget(Slider* box, qtWindow *parent,
  59                  int orientation,
  60                  bool changeresolution,
  61                  bool label,
  62                  qtString title,
  63                  int vmin,
  64                  int vmax,
  65                  int value,
  66                  bool track);
  67     /// Dtor
  68     ~SliderWidget();
  69     /// Events callbacks
  70     /// Called when the slider is moved
  71     void OnSliderTrack(qtScrollEvent& event);
  72     /// Called when the slider is released
  73     void OnSliderRelease(qtScrollEvent& event);
  74     /// Called when the little slider which controls the resolution
  75     /// of the main slider is moved (if activated)
  76     void OnResolutionOfSlider(qtScrollEvent& event);
  77
  78     // Accessors
  79     void SetValue(int v) { mqtSlider->SetValue(v); }
  80     int  GetValue() { return mqtSlider->GetValue(); }
  81     void SetRange(int min, int max);
  82     // Update the texts which display the min/max/current values of the slider
  83     void RefreshLabels();
  84
  85   private:
  86     Slider*    mBox;
  87     qtSlider   *mqtSlider;
  88     qtSlider   *mResolutionOfSlider;
  89     int        min;
  90     int        max;
  91     bool       reactiveOnTrack;
  92     qtStaticText        *label_vertical;
  93     qtStaticText        *label_min;
  94     qtStaticText        *label_max;
  95   };
  96   //------------------------------------------------------------------------
  97   //------------------------------------------------------------------------
  98   //------------------------------------------------------------------------
  99
 100
 101
 102   //-------------------------------------------------------------------------
 103   SliderWidget::SliderWidget(Slider* box, qtWindow *parent,
 104                              int orientation,
 105                              bool changeresolution,
 106                              bool labels,
 107                              qtString title,
 108                              int vmin,
 109                              int vmax,
 110                              int value,
 111                              bool reactiveontrack)
 112     :
 113     qtPanel( parent, -1, qtDefaultPosition, qtDefaultSize, qtTAB_TRAVERSAL),
 114     mBox(box),
 115     min(vmin),
 116     max(vmax),
 117     reactiveOnTrack(reactiveontrack)
 118   {
 119     qtPanel * panel = this;
 120
 121     label_min           = NULL;
 122     label_max           = NULL;
 123     label_vertical      = NULL;
 124     mResolutionOfSlider = NULL;
 125
 126     int sizeX,sizeY;
 127     long qtlabels=0;
 128     long qtorientation=0;
 129     if (orientation==0)
 130       {
 131         sizeX                   = 2;
 132         sizeY                   = 40;
 133         qtorientation           = qtSL_HORIZONTAL;
 134         if (labels==true)
 135           {
 136             qtlabels = qtSL_LABELS;
 137           }
 138       }
 139     else
 140       {
 141         sizeX           = 20;
 142         sizeY           = 2;
 143         qtorientation   = qtSL_VERTICAL;
 144       }
 145
 146     //---------------------------------------------------------------------
 147     // 1) Creation of the components of the widget
 148     // Any top level sub-widget must have the panel returned by panel
 149     // for parent
 150     mqtSlider = new qtSlider( panel,
 151                               -1, 0 , 0, 500 ,
 152                               qtDefaultPosition,
 153                               qtSize(sizeX,sizeY),
 154                               qtorientation  | qtlabels );
 155
 156     //    mqtSlider->SetInitialSize(qtSize(sizeX,sizeY));
 157
 158     //  mqtSlider->SetTickFreq(100,0);
 159     mqtSlider->SetRange(min,max);
 160     mqtSlider->SetValue(value);
 161
 162     //    RefreshLabels();
 163
 164     // Connecting events to callbacks
 165     Connect( mqtSlider->GetId(),
 166              qtEVT_SCROLL_THUMBRELEASE,
 167              (qtObjectEventFunction)
 168              (void (qtPanel::*)(qtScrollEvent&))
 169              &SliderWidget::OnSliderRelease );
 170
 171     Connect( mqtSlider->GetId(),
 172              qtEVT_SCROLL_THUMBTRACK,
 173              (qtObjectEventFunction)
 174              (void (qtPanel::*)(qtScrollEvent&))
 175               &SliderWidget::OnSliderTrack );
 176
 177     Connect( mqtSlider->GetId(),
 178              qtEVT_SCROLL_CHANGED,
 179              (qtObjectEventFunction)
 180              (void (qtPanel::*)(qtScrollEvent&))
 181               &SliderWidget::OnSliderTrack );
 182
 183     // If asked : creation of the other little slider which allows to change
 184     // the resolution of the main slider
 185     if (changeresolution==true){
 186       // has panel for parent too
 187       mResolutionOfSlider = new qtSlider(panel,
 188                                          -1,5,1,10,
 189                                          qtDefaultPosition,
 190                                          qtSize(25,45),
 191                                          qtSL_VERTICAL |
 192                                          qtSL_AUTOTICKS |
 193                                          qtSL_LEFT  );
 194
 195
 196       mResolutionOfSlider->SetRange(1,8);
 197       mResolutionOfSlider->SetValue(5);
 198       // Is qtEVT_COMMAND_SLIDER_UPDATED event
 199       // is connected to the method OnResolutionOfSlider
 200       Connect(mResolutionOfSlider->GetId(),
 201               qtEVT_COMMAND_SLIDER_UPDATED,
 202               (qtObjectEventFunction)
 203               (void (qtPanel::*)(qtScrollEvent&))
 204               &SliderWidget::OnResolutionOfSlider );
 205     }
 206     //---------------------------------------------------------------------
 207
 208     //---------------------------------------------------------------------
 209     // 2) Insertion of the components in the window
 210
 211     // We use a FlexGridSizer
 212     qtFlexGridSizer *sizer;
 213
 214
 215     if (orientation==0)
 216       {
 217         // HORIZONTAL
 218         if (mResolutionOfSlider!=NULL)
 219           {
 220             sizer       = new qtFlexGridSizer(2);
 221             if (title!=_T(""))
 222               {
 223                 sizer   -> Add( new qtStaticText(panel,-1, title ) );
 224                 sizer   -> Add( new qtStaticText(panel,-1, _T("") ) );
 225               }
 226           }
 227         else
 228           {
 229             sizer       = new qtFlexGridSizer(1);
 230             if (title!=_T(""))
 231               {
 232                 sizer   -> Add( new qtStaticText(panel,-1, title ) );
 233               }
 234           }
 235         sizer   -> Add( mqtSlider,1,qtGROW );
 236         sizer   -> AddGrowableCol(0);
 237         if (mResolutionOfSlider!=NULL)
 238           {
 239             sizer       -> Add( mResolutionOfSlider );
 240           }
 241       }
 242     else
 243       {
 244         // VERTICAL
 245         sizer   = new qtFlexGridSizer(1);
 246         if (labels==true)  // with lable
 247           {
 248             label_vertical = new qtStaticText(panel,-1,_T(""));
 249             label_min = new qtStaticText(panel,-1,_T(""));
 250             label_max = new qtStaticText(panel,-1,_T(""));
 251             if (title!=_T(""))
 252               {
 253                 sizer   -> Add( new qtStaticText(panel,-1, title ) );
 254                 sizer   -> AddGrowableRow(3);
 255               }
 256             else
 257               {
 258                 sizer   -> AddGrowableRow(2);
 259               }
 260             sizer       -> Add( label_vertical );
 261             sizer       -> Add( label_min );
 262             sizer       -> Add( mqtSlider,1,qtGROW );
 263             sizer       -> Add( label_max );
 264             if (mResolutionOfSlider!=NULL)
 265               {
 266                 sizer   -> Add( mResolutionOfSlider );
 267               }
 268           }
 269         else
 270           {
 271             if (title!=_T(""))
 272               {
 273                 sizer   -> Add( new qtStaticText(panel,-1, title ) );
 274                 sizer   -> AddGrowableRow(1);
 275               }
 276             else
 277               {
 278                 sizer   -> AddGrowableRow(0);
 279               }
 280             sizer       -> Add( mqtSlider,1,qtGROW );
 281             if (mResolutionOfSlider!=NULL)
 282               {
 283                 sizer   -> Add( mResolutionOfSlider );
 284               }
 285           }
 286       }
 287     // Initialize the labels
 288     RefreshLabels();
 289     // Insert the sizer in the main panel and refresh the layout
 290     panel->SetSizer(sizer);
 291   }
 292   //-------------------------------------------------------------------------
 293
 294
 295   //-------------------------------------------------------------------------
 296   SliderWidget::~SliderWidget()
 297   {
 298   }
 299   //-------------------------------------------------------------------------
 300
 301
 302   //-------------------------------------------------------------------------
 303   void SliderWidget::OnResolutionOfSlider(qtScrollEvent& event)
 304   {
 305     int value = mqtSlider->GetValue();
 306     int delta = (int) (pow( 4 , mResolutionOfSlider->GetValue() ));
 307     int minTmp   = value - delta/2;
 308     int maxTmp   = value + delta/2;
 309     if (minTmp<min)
 310       {
 311         minTmp = min;
 312         //              maxTmp = delta;
 313       }
 314     if (maxTmp>max)
 315       {
 316         maxTmp = max;
 317       }
 318     mqtSlider->SetRange(minTmp,maxTmp);
 319     RefreshLabels();
 320   }
 321   //-------------------------------------------------------------------------
 322
 323
 324
 325   //-------------------------------------------------------------------------
 326   void SliderWidget::OnSliderTrack(qtScrollEvent& event)
 327   {
 328     if(reactiveOnTrack)
 329     {
 330     // When user releases the slider
 331     // we update the output of the box
 332
 333     mBox->bbSetOutputOut( mqtSlider->GetValue() );
 334     mBox->bbSetInputIn( mqtSlider->GetValue() );
 335     // and signal that the output has changed
 336         mBox->bbSignalOutputModification(std::string("Out"));
 337     }
 338     RefreshLabels();
 339   }
 340   //-------------------------------------------------------------------------
 341
 342
 343   //-------------------------------------------------------------------------
 344   void SliderWidget::OnSliderRelease(qtScrollEvent& event)
 345   {
 346     // When user releases the slider
 347     // we update the output of the box
 348     mBox->bbSetOutputOut( mqtSlider->GetValue() );
 349     mBox->bbSetInputIn( mqtSlider->GetValue() );
 350     // and signal that the output has changed
 351         mBox->bbSignalOutputModification(std::string("Out"));
 352   }
 353   //-------------------------------------------------------------------------
 354
 355
 356   //-------------------------------------------------------------------------
 357   void SliderWidget::RefreshLabels()
 358   {
 359     qtString strValue;
 360     if (label_vertical!=NULL)
 361       {
 362         strValue.Printf( _T("%d"), mqtSlider->GetValue() );
 363         label_vertical->SetLabel(strValue);
 364       }
 365     if (label_min!=NULL)
 366       {
 367         strValue.Printf( _T("%d"), mqtSlider->GetMin() );
 368         label_min->SetLabel(strValue);
 369       }
 370     if (label_max!=NULL)
 371       {
 372         strValue.Printf( _T("%d"), mqtSlider->GetMax() );
 373         label_max->SetLabel(strValue);
 374       }
 375   }
 376   //-------------------------------------------------------------------------
 377
 378
 379   //-------------------------------------------------------------------------
 380   void SliderWidget::SetRange(int min, int max)
 381   {
 382     this->min = min;
 383     this->max = max;
 384     mqtSlider->SetRange(min,max);
 385     RefreshLabels();
 386   }
 387   //-------------------------------------------------------------------------
 388
 389   */
 390
 391
 392   //--------------------------------------------------------------------------
 393   //-------------------------------------------------------------------------
 394   // QtBlackBox implementation
 395   //--------------------------------------------------------------------------
 396   //--------------------------------------------------------------------------
 397
 398   //--------------------------------------------------------------------------
 399   BBTK_BLACK_BOX_IMPLEMENTATION(Slider,bbtk::QtBlackBox);
 400   BBTK_ADD_BLACK_BOX_TO_PACKAGE(qt,Slider);
 401
 402   //--------------------------------------------------------------------------
 403   void Slider::bbUserConstructor()
 404   {
 405     bbSetInputIn(0);
 406     bbSetInputMin(0);
 407     bbSetInputMax(500);
 408     bbSetOutputOut(0);
 409     bbSetInputOrientation("HORIZONTAL");
 410     bbSetInputChangeResolution(false);
 411     bbSetInputLabel(true);
 412     bbSetInputReactiveOnTrack(false);
 413   }
 414   //--------------------------------------------------------------------------
 415
 416   //--------------------------------------------------------------------------
 417   void Slider::Process()
 418   {
 419     bbtkDebugMessage("process",3,
 420                      "Slider "<<bbGetName()<<" input="
 421                      <<bbGetInputIn()<<std::endl);
 422
 423     bbSetOutputOut( bbGetInputIn() );
 424     if (bbGetOutputWidget()!=0)
 425       {
 426         ((QSlider*)bbGetOutputWidget())->setValue(bbGetInputIn());
 427       }
 428   }
 429   //--------------------------------------------------------------------------
 430
 431   //--------------------------------------------------------------------------
 432   void Slider::CreateWidget(QWidget* parent)
 433   {
 434
 435      Qt::Orientation orientation;
 436     if (bbtk::Utilities::loosematch(bbGetInputOrientation(),"0|H|HORIZONTAL")
 437         ==true)
 438       { orientation = Qt::Horizontal; }
 439     if (bbtk::Utilities::loosematch(bbGetInputOrientation(),"1|V|VERTICAL")
 440         ==true)
 441       { orientation = Qt::Vertical ; }
 442
 443
 444     //    std::cout << "bbGetQtParent = "<<bbGetQtParent()<<std::endl;
 445     QSlider *w =  new QSlider(parent);
 446     w->setOrientation(orientation);
 447     w->setMinimum( bbGetInputMin() );
 448     w->setMaximum( bbGetInputMax() );
 449     w->setSliderPosition ( bbGetInputIn() );
 450
 451     if (bbGetInputReactiveOnTrack())
 452       w->setTracking(true);
 453     else
 454       w->setTracking(false);
 455
 456     connect(w,SIGNAL(valueChanged(int)),this,SLOT(OnValueChanged(int)));
 457
 458     w->setSizePolicy( QSizePolicy(QSizePolicy::Expanding,
 459                                   QSizePolicy::Expanding) );
 460
 461     bbSetOutputWidget( w );
 462   }
 463   //--------------------------------------------------------------------------
 464
 465   //--------------------------------------------------------------------------
 466   void Slider::OnValueChanged(int v)
 467   {
 468     std::cout << "OnValueChanged "<<v<<std::endl;
 469     bbSetOutputOut( v );
 470     bbSetInputIn( v );
 471     // and signal that the output has changed
 472     bbSignalOutputModification(std::string("Out"));
 473
 474   }
 475   //--------------------------------------------------------------------------
 476
 477
 478 } //namespace bbqt
 479
 480 #endif // USE_QT
 481
 482