ENH: Exposing rangeChanged(...) to the ctkXXXSliderXXX classes

Libs/Widgets/ctkDoubleRangeSlider.cpp

@@ -44,6 +44,8 @@ public:
   ctkRangeSlider* Slider;
   double Minimum;
   double Maximum;
+  bool   SettingRange;
+
   // we should have a MinValueOffset and MinPositionOffset (and MinimumOffset?)
   double MinOffset;
   // we should have a MaxValueOffset and MaxPositionOffset (and MaximumOffset?)
@@ -61,6 +63,7 @@ ctkDoubleRangeSliderPrivate::ctkDoubleRangeSliderPrivate()
   this->Slider = 0;
   this->Minimum = 0.;
   this->Maximum = 99.;
+  this->SettingRange = false;
   this->MinOffset = 0.;
   this->MaxOffset = 0.;
   this->SingleStep = 1.;
@@ -108,6 +111,8 @@ void ctkDoubleRangeSliderPrivate::connectSlider()
              p, SIGNAL(sliderPressed()));
   p->connect(this->Slider, SIGNAL(sliderReleased()),
              p, SIGNAL(sliderReleased()));
+  p->connect(this->Slider, SIGNAL(rangeChanged(int, int)),
+             p, SLOT(onRangeChanged(int, int)));
 }
 
 // --------------------------------------------------------------------------
@@ -173,7 +178,10 @@ void ctkDoubleRangeSlider::setMinimum(double min)
     {// TBD: use same offset
     d->updateMaxOffset(d->Minimum);
     }
+  d->SettingRange = true;
   d->Slider->setMinimum(d->toInt(min));
+  d->SettingRange = false;
+  emit this->rangeChanged(d->Minimum, d->Maximum);
 }
 
 // --------------------------------------------------------------------------
@@ -196,7 +204,10 @@ void ctkDoubleRangeSlider::setMaximum(double max)
     {// TBD: use same offset ?
     d->updateMaxOffset(d->Maximum);
     }
+  d->SettingRange = true;
   d->Slider->setMaximum(d->toInt(max));
+  d->SettingRange = false;
+  emit this->rangeChanged(d->Minimum, d->Maximum);
 }
 
 // --------------------------------------------------------------------------
@@ -228,7 +239,10 @@ void ctkDoubleRangeSlider::setRange(double min, double max)
     {// TBD: use same offset ?
     d->updateMaxOffset(d->Maximum);
     }
+  d->SettingRange = true;
   d->Slider->setRange(d->toInt(min), d->toInt(max));
+  d->SettingRange = false;
+  emit this->rangeChanged(d->Minimum, d->Maximum);
 }
 
 // --------------------------------------------------------------------------
@@ -504,6 +518,16 @@ void ctkDoubleRangeSlider::onPositionsChanged(int min, int max)
 }
 
 // --------------------------------------------------------------------------
+void ctkDoubleRangeSlider::onRangeChanged(int min, int max)
+{
+  CTK_D(const ctkDoubleRangeSlider);
+  if (!d->SettingRange)
+    {
+    this->setRange(d->minFromInt(min), d->maxFromInt(max));
+    }
+}
+
+// --------------------------------------------------------------------------
 ctkRangeSlider* ctkDoubleRangeSlider::slider()const
 {
   CTK_D(const ctkDoubleRangeSlider);

Libs/Widgets/ctkDoubleRangeSlider.h

@@ -193,7 +193,13 @@ signals:
   /// or programmatically when setSliderDown(false) is called. 
   void sliderReleased();
 
-    
+  ///
+  /// This signal is emitted when the slider range has changed, with min being
+  /// the new minimum, and max being the new maximum.
+  /// Warning: don't confound with valuesChanged(double, double);
+  /// \sa QAbstractSlider::rangeChanged()
+  void rangeChanged(double min, double max);
+
 public slots:
   /// 
   /// This property holds the slider's current minimum value.
@@ -221,6 +227,7 @@ protected slots:
   void onMinPosChanged(int value);
   void onMaxPosChanged(int value);
   void onPositionsChanged(int min, int max);
+  void onRangeChanged(int min, int max);
 
 protected:
   ctkRangeSlider* slider()const;

Libs/Widgets/ctkDoubleSlider.cpp

@@ -41,6 +41,7 @@ class ctkDoubleSliderPrivate: public ctkPrivate<ctkDoubleSlider>
   QSlider*    Slider;
   double      Minimum;
   double      Maximum;
+  bool        SettingRange;
   // we should have a Offset and SliderPositionOffset (and MinimumOffset?)
   double      Offset;
   double      SingleStep;
@@ -53,6 +54,7 @@ ctkDoubleSliderPrivate::ctkDoubleSliderPrivate()
   this->Slider = 0;
   this->Minimum = 0.;
   this->Maximum = 100.;
+  this->SettingRange = false;
   this->Offset = 0.;
   this->SingleStep = 1.;
   this->Value = 0.;
@@ -76,6 +78,8 @@ void ctkDoubleSliderPrivate::init()
   p->connect(this->Slider, SIGNAL(sliderMoved(int)), p, SLOT(onSliderMoved(int)));
   p->connect(this->Slider, SIGNAL(sliderPressed()), p, SIGNAL(sliderPressed()));
   p->connect(this->Slider, SIGNAL(sliderReleased()), p, SIGNAL(sliderReleased()));
+  p->connect(this->Slider, SIGNAL(rangeChanged(int, int)),
+             p, SLOT(onRangeChanged(int, int)));
 
   p->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed,
                                QSizePolicy::Slider));
@@ -143,7 +147,10 @@ void ctkDoubleSlider::setMinimum(double min)
     {
     d->updateOffset(d->Minimum);
     }
+  d->SettingRange = true;
   d->Slider->setMinimum(d->toInt(min));
+  d->SettingRange = false;
+  emit this->rangeChanged(d->Minimum, d->Maximum);
 }
 
 // --------------------------------------------------------------------------
@@ -155,7 +162,10 @@ void ctkDoubleSlider::setMaximum(double max)
     {
     d->updateOffset(d->Maximum);
     }
+  d->SettingRange = true;
   d->Slider->setMaximum(d->toInt(max));
+  d->SettingRange = false;
+  emit this->rangeChanged(d->Minimum, d->Maximum);
 }
 
 // --------------------------------------------------------------------------
@@ -173,8 +183,10 @@ void ctkDoubleSlider::setRange(double min, double max)
     {
     d->updateOffset(d->Maximum);
     }
-  
+  d->SettingRange = true;
   d->Slider->setRange(d->toInt(min), d->toInt(max));
+  d->SettingRange = false;
+  emit this->rangeChanged(d->Minimum, d->Maximum);
 }
 
 // --------------------------------------------------------------------------
@@ -334,4 +346,14 @@ void ctkDoubleSlider::onSliderMoved(int newPosition)
   emit this->sliderMoved(d->fromInt(newPosition));
 }
 
+// --------------------------------------------------------------------------
+void ctkDoubleSlider::onRangeChanged(int min, int max)
+{
+  CTK_D(const ctkDoubleSlider);
+  if (!d->SettingRange)
+    {
+    this->setRange(d->fromInt(min), d->fromInt(max));
+    }
+}
+
 

Libs/Widgets/ctkDoubleSlider.h

@@ -146,10 +146,6 @@ public slots:
   /// The orientation must be Qt::Vertical (the default) or Qt::Horizontal.
   void setOrientation(Qt::Orientation orientation);
 
-protected slots:
-  void onValueChanged(int value);
-  void onSliderMoved(int position);
-
 signals:
   ///
   /// This signal is emitted when the slider value has changed, with the new
@@ -172,7 +168,19 @@ signals:
   /// This signal is emitted when the user releases the slider with the mouse, 
   /// or programmatically when setSliderDown(false) is called.
   void sliderReleased();
-  
+
+  ///
+  /// This signal is emitted when the slider range has changed, with min being
+  /// the new minimum, and max being the new maximum.
+  /// Warning: don't confound with valuesChanged(double, double);
+  /// \sa QAbstractSlider::rangeChanged()
+  void rangeChanged(double min, double max);
+
+protected slots:
+  void onValueChanged(int value);
+  void onSliderMoved(int position);
+  void onRangeChanged(int min, int max);
+
 private:
   CTK_DECLARE_PRIVATE(ctkDoubleSlider);
 };

Libs/Widgets/ctkRangeSlider.cpp

@@ -661,6 +661,20 @@ void ctkRangeSlider::mouseReleaseEvent(QMouseEvent* mouseEvent)
 }
 
 // --------------------------------------------------------------------------
+bool ctkRangeSlider::isMinimumSliderDown()const
+{
+  CTK_D(const ctkRangeSlider);
+  return d->m_SelectedHandles & ctkRangeSliderPrivate::MinimumHandle;
+}
+
+// --------------------------------------------------------------------------
+bool ctkRangeSlider::isMaximumSliderDown()const
+{
+  CTK_D(const ctkRangeSlider);
+  return d->m_SelectedHandles & ctkRangeSliderPrivate::MaximumHandle;
+}
+
+// --------------------------------------------------------------------------
 void ctkRangeSlider::initMinimumSliderStyleOption(QStyleOptionSlider* option) const
 {
   this->initStyleOption(option);

Libs/Widgets/ctkRangeSlider.h

@@ -149,6 +149,9 @@ protected:
   virtual void mouseMoveEvent(QMouseEvent* ev);
   virtual void mouseReleaseEvent(QMouseEvent* ev);
 
+  bool isMinimumSliderDown()const;
+  bool isMaximumSliderDown()const;
+
   // Description:
   // Rendering is done here.
   virtual void paintEvent(QPaintEvent* ev);

Libs/Widgets/ctkRangeWidget.cpp

@@ -42,6 +42,7 @@ public:
 
   bool          Tracking;
   bool          Changing;
+  bool          SettingRange;
   double        MinimumValueBeforeChange;
   double        MaximumValueBeforeChange;
   bool          AutoSpinBoxWidth;
@@ -59,6 +60,7 @@ ctkRangeWidgetPrivate::ctkRangeWidgetPrivate()
 {
   this->Tracking = true;
   this->Changing = false;
+  this->SettingRange = false;
   this->MinimumValueBeforeChange = 0.;
   this->MaximumValueBeforeChange = 0.;
   this->AutoSpinBoxWidth = true;
@@ -89,6 +91,8 @@ void ctkRangeWidgetPrivate::connectSlider()
                    p, SLOT(startChanging()));
   QObject::connect(this->Slider, SIGNAL(sliderReleased()),
                    p, SLOT(stopChanging()));
+  QObject::connect(this->Slider, SIGNAL(rangeChanged(double, double)),
+                   p, SLOT(onSliderRangeChanged(double, double)));
 }
 
 // --------------------------------------------------------------------------
@@ -215,7 +219,9 @@ void ctkRangeWidget::setMinimum(double min)
   d->MinimumSpinBox->setMinimum(min);
   // SpinBox can truncate min (depending on decimals).
   // use Spinbox's min to set Slider's min
+  d->SettingRange = true;
   d->Slider->setMinimum(d->MinimumSpinBox->minimum());
+  d->SettingRange = false;
   Q_ASSERT(d->equal(d->MinimumSpinBox->minimum(),d->Slider->minimum()));
   d->updateSpinBoxWidth();
 }
@@ -227,7 +233,9 @@ void ctkRangeWidget::setMaximum(double max)
   d->MaximumSpinBox->setMaximum(max);
   // SpinBox can truncate max (depending on decimals).
   // use Spinbox's max to set Slider's max
+  d->SettingRange = true;
   d->Slider->setMaximum(d->MaximumSpinBox->maximum());
+  d->SettingRange = false;
   Q_ASSERT(d->equal(d->MaximumSpinBox->maximum(), d->Slider->maximum()));
   d->updateSpinBoxWidth();
 }
@@ -241,11 +249,24 @@ void ctkRangeWidget::setRange(double min, double max)
   d->MaximumSpinBox->setMaximum(qMax(min,max));
   // SpinBox can truncate the range (depending on decimals).
   // use Spinbox's range to set Slider's range
+  d->SettingRange = true;
   d->Slider->setRange(d->MinimumSpinBox->minimum(), d->MaximumSpinBox->maximum());
+  d->SettingRange = false;
   Q_ASSERT(d->equal(d->MinimumSpinBox->minimum(), d->Slider->minimum()));
   Q_ASSERT(d->equal(d->MaximumSpinBox->maximum(), d->Slider->maximum()));
   d->updateSpinBoxWidth();
 }
+
+// --------------------------------------------------------------------------
+void ctkRangeWidget::onSliderRangeChanged(double min, double max)
+{
+  CTK_D(ctkRangeWidget);
+  if (!d->SettingRange)
+    {
+    this->setRange(min, max);
+    }
+}
+
 /*
 // --------------------------------------------------------------------------
 double ctkRangeWidget::sliderPosition()const

Libs/Widgets/ctkRangeWidget.h

@@ -196,6 +196,7 @@ protected slots:
   void changeMaximumValue(double value);
   void setMinimumToMaximumSpinBox(double minimum);
   void setMaximumToMinimumSpinBox(double maximum);
+  void onSliderRangeChanged(double min, double max);
 
 protected:
   virtual bool eventFilter(QObject *obj, QEvent *event);