Error when converting from int to double in ctkDoubleSlider

When converting from int to double, we might reach under and above the
minimum and maximum of the slider. It is not allowed to have values
outside the range, so we bound them.

Libs/Widgets/ctkDoubleRangeSlider.cpp

@@ -39,6 +39,9 @@ public:
   int toInt(double _value)const;
   double minFromInt(int _value)const;
   double maxFromInt(int _value)const;
+  double safeMinFromInt(int _value)const;
+  double safeMaxFromInt(int _value)const;
+  
   void init();
   void connectSlider();
   void updateMinOffset(double value);
@@ -141,6 +144,18 @@ double ctkDoubleRangeSliderPrivate::maxFromInt(int intValue)const
 }
 
 // --------------------------------------------------------------------------
+double ctkDoubleRangeSliderPrivate::safeMinFromInt(int intValue)const
+{
+  return qBound(this->Minimum, this->minFromInt(intValue), this->Maximum);
+}
+
+// --------------------------------------------------------------------------
+double ctkDoubleRangeSliderPrivate::safeMaxFromInt(int intValue)const
+{
+  return qBound(this->Minimum, this->maxFromInt(intValue), this->Maximum);
+}
+
+// --------------------------------------------------------------------------
 void ctkDoubleRangeSliderPrivate::updateMinOffset(double value)
 {
   this->MinOffset = (value / this->SingleStep) - this->toInt(value);
@@ -272,7 +287,7 @@ void ctkDoubleRangeSlider::setRange(double min, double max)
 double ctkDoubleRangeSlider::minimumPosition()const
 {
   Q_D(const ctkDoubleRangeSlider);
-  return d->minFromInt(d->Slider->minimumPosition());
+  return d->safeMinFromInt(d->Slider->minimumPosition());
 }
 
 // --------------------------------------------------------------------------
@@ -286,7 +301,7 @@ void ctkDoubleRangeSlider::setMinimumPosition(double minPos)
 double ctkDoubleRangeSlider::maximumPosition()const
 {
   Q_D(const ctkDoubleRangeSlider);
-  return d->maxFromInt(d->Slider->maximumPosition());
+  return d->safeMaxFromInt(d->Slider->maximumPosition());
 }
 
 // --------------------------------------------------------------------------
@@ -459,7 +474,7 @@ void ctkDoubleRangeSlider::setSingleStep(double newStep)
 double ctkDoubleRangeSlider::tickInterval()const
 {
   Q_D(const ctkDoubleRangeSlider);
-  return d->minFromInt(d->Slider->tickInterval());
+  return d->SingleStep * d->Slider->tickInterval();
 }
 
 // --------------------------------------------------------------------------
@@ -534,8 +549,8 @@ void ctkDoubleRangeSlider::setSymmetricMoves(bool symmetry)
 void ctkDoubleRangeSlider::onValuesChanged(int newMinValue, int newMaxValue)
 {
   Q_D(ctkDoubleRangeSlider);
-  double doubleNewMinValue = d->minFromInt(newMinValue);
-  double doubleNewMaxValue = d->maxFromInt(newMaxValue);
+  double doubleNewMinValue = d->safeMinFromInt(newMinValue);
+  double doubleNewMaxValue = d->safeMaxFromInt(newMaxValue);
 
   bool emitMinValueChanged = (d->MinValue != doubleNewMinValue);
   bool emitMaxValueChanged = (d->MaxValue != doubleNewMaxValue);
@@ -561,21 +576,21 @@ void ctkDoubleRangeSlider::onValuesChanged(int newMinValue, int newMaxValue)
 void ctkDoubleRangeSlider::onMinPosChanged(int newPosition)
 {
   Q_D(const ctkDoubleRangeSlider);
-  emit this->minimumPositionChanged(d->minFromInt(newPosition));
+  emit this->minimumPositionChanged(d->safeMinFromInt(newPosition));
 }
 
 // --------------------------------------------------------------------------
 void ctkDoubleRangeSlider::onMaxPosChanged(int newPosition)
 {
   Q_D(const ctkDoubleRangeSlider);
-  emit this->maximumPositionChanged(d->maxFromInt(newPosition));
+  emit this->maximumPositionChanged(d->safeMaxFromInt(newPosition));
 }
 
 // --------------------------------------------------------------------------
 void ctkDoubleRangeSlider::onPositionsChanged(int min, int max)
 {
   Q_D(const ctkDoubleRangeSlider);
-  emit this->positionsChanged(d->minFromInt(min), d->maxFromInt(max));
+  emit this->positionsChanged(d->safeMinFromInt(min), d->safeMaxFromInt(max));
 }
 
 // --------------------------------------------------------------------------

Libs/Widgets/ctkDoubleSlider.cpp

@@ -36,8 +36,9 @@ protected:
   ctkDoubleSlider* const q_ptr;
 public:
   ctkDoubleSliderPrivate(ctkDoubleSlider& object);
-  int toInt(double _value)const;
-  double fromInt(int _value)const;
+  int toInt(double value)const;
+  double fromInt(int value)const;
+  double safeFromInt(int value)const;
   void init();
   void updateOffset(double value);
 
@@ -120,6 +121,12 @@ double ctkDoubleSliderPrivate::fromInt(int intValue)const
 }
 
 // --------------------------------------------------------------------------
+double ctkDoubleSliderPrivate::safeFromInt(int intValue)const
+{
+  return qBound(this->Minimum, this->fromInt(intValue), this->Maximum);
+}
+
+// --------------------------------------------------------------------------
 void ctkDoubleSliderPrivate::updateOffset(double value)
 {
   this->Offset = (value / this->SingleStep) - this->toInt(value);
@@ -217,7 +224,7 @@ double ctkDoubleSlider::maximum()const
 double ctkDoubleSlider::sliderPosition()const
 {
   Q_D(const ctkDoubleSlider);
-  return d->fromInt(d->Slider->sliderPosition());
+  return d->safeFromInt(d->Slider->sliderPosition());
 }
 
 // --------------------------------------------------------------------------
@@ -302,7 +309,8 @@ void ctkDoubleSlider::setPageStep(double newStep)
 double ctkDoubleSlider::tickInterval()const
 {
   Q_D(const ctkDoubleSlider);
-  return d->fromInt(d->Slider->tickInterval());
+  // No need to apply Offset
+  return d->SingleStep * d->Slider->tickInterval();
 }
 
 // --------------------------------------------------------------------------
@@ -363,7 +371,7 @@ void ctkDoubleSlider::setOrientation(Qt::Orientation newOrientation)
 void ctkDoubleSlider::onValueChanged(int newValue)
 {
   Q_D(ctkDoubleSlider);
-  double doubleNewValue = d->fromInt(newValue);
+  double doubleNewValue = d->safeFromInt(newValue);
 /*
   qDebug() << "onValueChanged: " << newValue << "->"<< d->fromInt(newValue+d->Offset) 
            << " old: " << d->Value << "->" << d->toInt(d->Value) 
@@ -381,7 +389,7 @@ void ctkDoubleSlider::onValueChanged(int newValue)
 void ctkDoubleSlider::onSliderMoved(int newPosition)
 {
   Q_D(const ctkDoubleSlider);
-  emit this->sliderMoved(d->fromInt(newPosition));
+  emit this->sliderMoved(d->safeFromInt(newPosition));
 }
 
 // --------------------------------------------------------------------------

Libs/Widgets/ctkSliderWidget.cpp

@@ -278,6 +278,7 @@ void ctkSliderWidget::changeValue(double newValue)
   bool wasBlocked = d->SpinBox->blockSignals(true);
   d->SpinBox->setValue(newValue);
   d->SpinBox->blockSignals(wasBlocked);
+  Q_ASSERT(d->equal(d->SpinBox->value(), d->Slider->value()));
   
   if (!d->Tracking)
     {