fixed various caching issues when rapidly changing values

app/widget/nodeparamview/nodeparamviewwidgetbridge.cpp

@@ -64,9 +64,20 @@ void NodeParamViewWidgetBridge::CreateWidgets()
   case NodeParam::kFloat:
   {
     FloatSlider* slider = new FloatSlider();
+
     slider->SetValue(base_input->get_value(0).toDouble());
-    widgets_.append(slider);
+
+    if (base_input->has_minimum()) {
+      slider->SetMinimum(base_input->minimum().toDouble());
+    }
+
+    if (base_input->has_maximum()) {
+      slider->SetMaximum(base_input->maximum().toDouble());
+    }
+
     connect(slider, SIGNAL(ValueChanged(double)), this, SLOT(WidgetCallback()));
+
+    widgets_.append(slider);
     break;
   }
   case NodeParam::kVec2:

app/widget/slider/floatslider.cpp

@@ -36,6 +36,16 @@ void FloatSlider::SetValue(const double &d)
   SliderBase::SetValue(d);
 }
 
+void FloatSlider::SetMinimum(const double &d)
+{
+  SetMinimumInternal(d);
+}
+
+void FloatSlider::SetMaximum(const double &d)
+{
+  SetMaximumInternal(d);
+}
+
 void FloatSlider::SetDecimalPlaces(int i)
 {
   decimal_places_ = i;

app/widget/slider/floatslider.h

@@ -33,6 +33,10 @@ public:
 
   void SetValue(const double& d);
 
+  void SetMinimum(const double& d);
+
+  void SetMaximum(const double& d);
+
   void SetDecimalPlaces(int i);
 
 signals:

app/widget/slider/integerslider.cpp

@@ -36,6 +36,16 @@ void IntegerSlider::SetValue(const int &v)
   SliderBase::SetValue(v);
 }
 
+void IntegerSlider::SetMinimum(const int &d)
+{
+  SetMinimumInternal(d);
+}
+
+void IntegerSlider::SetMaximum(const int &d)
+{
+  SetMaximumInternal(d);
+}
+
 void IntegerSlider::ConvertValue(QVariant v)
 {
   emit ValueChanged(v.toInt());

app/widget/slider/integerslider.h

@@ -33,6 +33,10 @@ public:
 
   void SetValue(const int& v);
 
+  void SetMinimum(const int& d);
+
+  void SetMaximum(const int& d);
+
 signals:
   void ValueChanged(int);
 

app/widget/slider/sliderbase.cpp

@@ -28,6 +28,8 @@ SliderBase::SliderBase(Mode mode, QWidget *parent) :
   QStackedWidget(parent),
   decimal_places_(1),
   drag_multiplier_(1.0),
+  has_min_(false),
+  has_max_(false),
   mode_(mode),
   dragged_(false)
 {
@@ -49,16 +51,14 @@ SliderBase::SliderBase(Mode mode, QWidget *parent) :
   switch (mode_) {
   case kString:
     setCursor(Qt::PointingHandCursor);
-    value_ = "";
+    SetValue("");
     break;
   case kInteger:
   case kFloat:
     setCursor(Qt::SizeHorCursor);
-    value_ = 0;
+    SetValue(0);
     break;
   }
-
-  UpdateLabel(value_);
 }
 
 void SliderBase::SetDragMultiplier(const double &d)
@@ -77,11 +77,33 @@ const QVariant &SliderBase::Value()
 
 void SliderBase::SetValue(const QVariant &v)
 {
-  value_ = v;
+  value_ = ClampValue(v);
 
   UpdateLabel(value_);
 }
 
+void SliderBase::SetMinimumInternal(const QVariant &v)
+{
+  min_value_ = v;
+  has_min_ = true;
+
+  // Limit value by this new minimum value
+  if (value_ < min_value_) {
+    SetValue(min_value_);
+  }
+}
+
+void SliderBase::SetMaximumInternal(const QVariant &v)
+{
+  max_value_ = v;
+  has_max_ = true;
+
+  // Limit value by this new maximum value
+  if (value_ > max_value_) {
+    SetValue(max_value_);
+  }
+}
+
 void SliderBase::changeEvent(QEvent *e)
 {
   if (e->type() == QEvent::LanguageChange) {
@@ -90,6 +112,19 @@ void SliderBase::changeEvent(QEvent *e)
   QStackedWidget::changeEvent(e);
 }
 
+const QVariant &SliderBase::ClampValue(const QVariant &v)
+{
+  if (has_min_ && v < min_value_) {
+    return min_value_;
+  }
+
+  if (has_max_ && v > max_value_) {
+    return max_value_;
+  }
+
+  return v;
+}
+
 void SliderBase::UpdateLabel(const QVariant &v)
 {
   switch (mode_) {
@@ -132,14 +167,12 @@ void SliderBase::LabelClicked()
       // No-op
       break;
     case kInteger:
-      value_ = qRound(dragged_diff_);
+      SetValue(qRound(dragged_diff_));
       break;
     case kFloat:
-      value_ = dragged_diff_;
+      SetValue(dragged_diff_);
       break;
     }
-
-    UpdateLabel(value_);
   } else {
     // This was a simple click
 
@@ -177,6 +210,8 @@ void SliderBase::LabelDragged(int i)
       temp_dragged_value_ = dragged_diff_;
     }
 
+    temp_dragged_value_ = ClampValue(temp_dragged_value_);
+
     UpdateLabel(temp_dragged_value_);
     emit ValueChanged(temp_dragged_value_);
     break;
@@ -210,9 +245,7 @@ void SliderBase::LineEditConfirmed()
   }
 
   if (is_valid) {
-    value_ = test_val;
-
-    UpdateLabel(value_);
+    SetValue(test_val);
 
     emit ValueChanged(value_);
 

app/widget/slider/sliderbase.h

@@ -48,6 +48,10 @@ protected:
 
   void SetValue(const QVariant& v);
 
+  void SetMinimumInternal(const QVariant& v);
+
+  void SetMaximumInternal(const QVariant& v);
+
   void UpdateLabel(const QVariant& v);
 
   virtual void changeEvent(QEvent* e) override;
@@ -57,12 +61,20 @@ protected:
   double drag_multiplier_;
 
 private:
+  const QVariant& ClampValue(const QVariant& v);
+
   SliderLabel* label_;
 
   SliderLineEdit* editor_;
 
   QVariant value_;
 
+  bool has_min_;
+  QVariant min_value_;
+
+  bool has_max_;
+  QVariant max_value_;
+
   Mode mode_;
 
   bool dragged_;

app/widget/timeruler/timeruler.cpp

@@ -92,7 +92,7 @@ void TimeRuler::SetTimebase(const rational &r)
   update();
 }
 
-const int64_t &TimeRuler::Time()
+const int64_t &TimeRuler::GetTime()
 {
   return time_;
 }

app/widget/timeruler/timeruler.h

@@ -42,7 +42,7 @@ public:
 
   void SetCenteredText(bool c);
 
-  const int64_t& Time();
+  const int64_t& GetTime();
 
 public slots:
   void SetTime(const int64_t &r);

app/widget/viewer/viewer.cpp

@@ -91,6 +91,11 @@ const double &ViewerWidget::scale()
   return ruler_->scale();
 }
 
+rational ViewerWidget::GetTime()
+{
+  return rational(ruler_->GetTime()) * time_base_;
+}
+
 void ViewerWidget::SetScale(const double &scale_)
 {
   ruler_->SetScale(scale_);
@@ -145,7 +150,7 @@ void ViewerWidget::Play()
   }
 
   start_msec_ = QDateTime::currentMSecsSinceEpoch();
-  start_timestamp_ = ruler_->Time();
+  start_timestamp_ = ruler_->GetTime();
 
   playback_timer_.start();
 
@@ -170,14 +175,14 @@ void ViewerWidget::PrevFrame()
 {
   Pause();
 
-  SetTime(ruler_->Time() - 1);
+  SetTime(qMax(static_cast<int64_t>(0), ruler_->GetTime() - 1));
 }
 
 void ViewerWidget::NextFrame()
 {
   Pause();
 
-  SetTime(ruler_->Time() + 1);
+  SetTime(ruler_->GetTime() + 1);
 }
 
 void ViewerWidget::GoToEnd()

app/widget/viewer/viewer.h

@@ -49,6 +49,8 @@ public:
 
   const double& scale();
 
+  rational GetTime();
+
   void SetScale(const double& scale_);
 
   void SetTime(const int64_t& time);