WIP: DelayedConnection<>

rtgui/adjuster.cc

@@ -55,11 +55,12 @@ Adjuster::Adjuster (
     imageIcon1(imgIcon1),
     automatic(nullptr),
     adjusterListener(nullptr),
+    spinChange(options.adjusterMinDelay, options.adjusterMaxDelay),
+    sliderChange(options.adjusterMinDelay, options.adjusterMaxDelay),
     editedCheckBox(nullptr),
     afterReset(false),
     blocked(false),
     addMode(false),
-    eventPending(false),
     vMin(vmin),
     vMax(vmax),
     vStep(vstep),
@@ -155,8 +156,27 @@ Adjuster::Adjuster (
     defaultVal = ctorDefaultVal = shapeValue(vdefault);
     editedState = defEditedState = Irrelevant;
 
-    sliderChange = slider->signal_value_changed().connect( sigc::mem_fun(*this, &Adjuster::sliderChanged) );
+    spinChange.connect(
-    spinChange = spin->signal_value_changed().connect( sigc::mem_fun(*this, &Adjuster::spinChanged), true);
+        spin->signal_value_changed(),
+        sigc::mem_fun(*this, &Adjuster::spinChanged),
+        [this]()
+        {
+            sliderChange.block(true);
+            setSliderValue(addMode ? spin->get_value() : this->value2slider(spin->get_value()));
+            sliderChange.block(false);
+        }
+    );
+    sliderChange.connect(
+        slider->signal_value_changed(),
+        sigc::mem_fun(*this, &Adjuster::sliderChanged),
+        [this]()
+        {
+            spinChange.block();
+            const double v = shapeValue(getSliderValue());
+            spin->set_value(addMode ? v : this->slider2value(v));
+            spinChange.unblock();
+        }
+    );
     reset->signal_button_release_event().connect_notify( sigc::mem_fun(*this, &Adjuster::resetPressed) );
 
     show_all();
@@ -165,9 +185,8 @@ Adjuster::Adjuster (
 Adjuster::~Adjuster ()
 {
 
-    sliderChange.block(true);
+    sliderChange.block();
-    spinChange.block(true);
+    spinChange.block();
-    delayConnection.block(true);
     adjusterListener = nullptr;
 
 }
@@ -211,8 +230,6 @@ void Adjuster::throwOnButtonRelease(bool throwOnBRelease)
             buttonReleaseSpin.disconnect();
         }
     }
-
-    eventPending = false;
 }
 
 void Adjuster::setDefault (double def)
@@ -239,9 +256,7 @@ void Adjuster::sliderReleased (GdkEventButton* event)
 {
 
     if ((event != nullptr) && (event->button == 1)) {
-        if (delayConnection.connected()) {
+        sliderChange.cancel();
-            delayConnection.disconnect();
-        }
 
         notifyListener();
     }
@@ -251,9 +266,7 @@ void Adjuster::spinReleased (GdkEventButton* event)
 {
 
     if ((event != nullptr) && delay == 0) {
-        if (delayConnection.connected()) {
+        spinChange.cancel();
-            delayConnection.disconnect();
-        }
 
         notifyListener();
     }
@@ -308,7 +321,7 @@ double Adjuster::shapeValue (double a) const
 void Adjuster::setLimits (double vmin, double vmax, double vstep, double vdefault)
 {
     sliderChange.block(true);
-    spinChange.block(true);
+    spinChange.block();
 
     double pow10 = vstep;
     for (digits = 0; std::fabs(pow10 - floor(pow10)) > 0.000000000001; digits++, pow10 *= 10.0);
@@ -326,7 +339,7 @@ void Adjuster::setLimits (double vmin, double vmax, double vstep, double vdefaul
     setSliderValue(addMode ? shapeVal : value2slider(shapeVal));
 
     sliderChange.block(false);
-    spinChange.block(false);
+    spinChange.unblock();
 }
 
 void Adjuster::setAddMode(bool addM)
@@ -353,29 +366,13 @@ void Adjuster::setAddMode(bool addM)
 
 void Adjuster::spinChanged ()
 {
-    if (delayConnection.connected()) {
+    if (adjusterListener && !blocked) {
-        delayConnection.disconnect();
+        if (!buttonReleaseSlider.connected() || afterReset) {
-    }
+            if (automatic) {
-
+                setAutoValue(false);
-    sliderChange.block(true);
-    setSliderValue(addMode ? spin->get_value() : value2slider(spin->get_value()));
-    sliderChange.block(false);
-
-    if (delay == 0) {
-        if (adjusterListener && !blocked) {
-            if (!buttonReleaseSlider.connected() || afterReset) {
-                eventPending = false;
-                if (automatic) {
-                    setAutoValue(false);
-                }
-                adjusterListener->adjusterChanged(this, spin->get_value());
-            } else {
-                eventPending = true;
             }
+            adjusterListener->adjusterChanged(this, spin->get_value());
         }
-    } else {
-        eventPending = true;
-        delayConnection = Glib::signal_timeout().connect(sigc::mem_fun(*this, &Adjuster::notifyListener), delay);
     }
 
     if (editedState == UnEdited) {
@@ -393,31 +390,13 @@ void Adjuster::spinChanged ()
 
 void Adjuster::sliderChanged ()
 {
-
+    if (adjusterListener && !blocked) {
-    if (delayConnection.connected()) {
+        if (!buttonReleaseSlider.connected() || afterReset) {
-        delayConnection.disconnect();
+            if (automatic) {
-    }
+                setAutoValue(false);
-
-    spinChange.block(true);
-    const double v = shapeValue(getSliderValue());
-    spin->set_value(addMode ? v : slider2value(v));
-    spinChange.block(false);
-
-    if (delay == 0 || afterReset) {
-        if (adjusterListener && !blocked) {
-            if (!buttonReleaseSlider.connected() || afterReset) {
-                eventPending = false;
-                if (automatic) {
-                    setAutoValue(false);
-                }
-                adjusterListener->adjusterChanged(this, spin->get_value());
-            } else {
-                eventPending = true;
             }
+            adjusterListener->adjusterChanged(this, spin->get_value());
         }
-    } else {
-        eventPending = true;
-        delayConnection = Glib::signal_timeout().connect(sigc::mem_fun(*this, &Adjuster::notifyListener), delay);
     }
 
     if (!afterReset && editedState == UnEdited) {
@@ -435,12 +414,12 @@ void Adjuster::sliderChanged ()
 
 void Adjuster::setValue (double a)
 {
-    spinChange.block(true);
+    spinChange.block();
     sliderChange.block(true);
     spin->set_value(shapeValue(a));
     setSliderValue(addMode ? shapeValue(a) : value2slider(shapeValue(a)));
     sliderChange.block(false);
-    spinChange.block(false);
+    spinChange.unblock();
     afterReset = false;
 }
 
@@ -455,16 +434,13 @@ void Adjuster::setAutoValue (bool a)
 
 bool Adjuster::notifyListener ()
 {
-
+    if (adjusterListener != nullptr && !blocked) {
-    if (eventPending && adjusterListener != nullptr && !blocked) {
         if (automatic) {
             setAutoValue(false);
         }
         adjusterListener->adjusterChanged(this, spin->get_value());
     }
 
-    eventPending = false;
-
     return false;
 }
 
@@ -555,8 +531,6 @@ void Adjuster::editedToggled ()
         }
         adjusterListener->adjusterChanged(this, spin->get_value());
     }
-
-    eventPending = false;
 }
 
 void Adjuster::trimValue (double &val) const
@@ -636,7 +610,7 @@ void Adjuster::setSliderValue(double val)
 
 void Adjuster::setLogScale(double base, double pivot, bool anchorMiddle)
 {
-    spinChange.block(true);
+    spinChange.block();
     sliderChange.block(true);
 
     const double cur = getSliderValue();
@@ -646,7 +620,7 @@ void Adjuster::setLogScale(double base, double pivot, bool anchorMiddle)
     setSliderValue(cur);
     
     sliderChange.block(false);
-    spinChange.block(false);
+    spinChange.unblock();
 }
 
 bool Adjuster::getAutoValue() const

rtgui/adjuster.h

@@ -19,6 +19,7 @@
 #pragma once
 
 #include "editedstate.h"
+#include "delayedconnection.h"
 #include "guiutils.h"
 
 class Adjuster;
@@ -46,9 +47,8 @@ protected:
     Gtk::Button* reset;
     Gtk::CheckButton* automatic;
     AdjusterListener* adjusterListener;
-    sigc::connection delayConnection;
+    DelayedConnection<> spinChange;
-    sigc::connection spinChange;
+    DelayedConnection<> sliderChange;
-    sigc::connection sliderChange;
     sigc::connection editedChange;
     sigc::connection autoChange;
     sigc::connection buttonReleaseSlider;
@@ -62,7 +62,6 @@ protected:
     bool afterReset;
     bool blocked;
     bool addMode;
-    bool eventPending;
     double vMin;
     double vMax;
     double vStep;

rtgui/delayedconnection.h

@@ -0,0 +1,147 @@
+/*
+ *  This file is part of RawTherapee.
+ *
+ *  Copyright (C) 2020 Flössie <floessie.mail@gmail.com>
+ *
+ *  RawTherapee is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  RawTherapee is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with RawTherapee.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <tuple>
+
+#include <glibmm/main.h>
+#include <glibmm/signalproxy.h>
+
+template<typename... Ts>
+class DelayedConnection final
+{
+public:
+    DelayedConnection(unsigned int _min_delay_ms, unsigned int _max_delay_ms = 0) :
+        min_delay_ms(_min_delay_ms),
+        max_delay_ms(_max_delay_ms)
+    {
+    }
+
+    void connect(Glib::SignalProxy<void, Ts...> signal, const sigc::slot<void, Ts...>& slot, const sigc::slot<void, Ts...>& immediate_slot = {})
+    {
+        this->slot = slot;
+        this->immediate_slot = immediate_slot;
+        this->signal = signal.connect(sigc::mem_fun(*this, &DelayedConnection::onSignal));
+    }
+
+    void block(bool value = true)
+    {
+        signal.block(value);
+        min_timeout.block(value);
+        max_timeout.block(value);
+    }
+
+    void unblock()
+    {
+        signal.unblock();
+        min_timeout.unblock();
+        max_timeout.unblock();
+    }
+
+    void cancel()
+    {
+        min_timeout.disconnect();
+        max_timeout.disconnect();
+    }
+
+private:
+    void onSignal(Ts... ts)
+    {
+        if (immediate_slot) {
+            immediate_slot(ts...);
+        }
+
+        if (!min_delay_ms) {
+            slot(ts...);
+            return;
+        }
+
+        params = std::make_tuple(ts...);
+
+        min_timeout.disconnect();
+        min_timeout = Glib::signal_timeout().connect(sigc::mem_fun(*this, &DelayedConnection::onMinTimeout), min_delay_ms);
+
+        if (max_delay_ms && !max_timeout.connected()) {
+            max_timeout = Glib::signal_timeout().connect(sigc::mem_fun(*this, &DelayedConnection::onMaxTimeout), max_delay_ms);
+        }
+    }
+
+    bool onMinTimeout()
+    {
+        max_timeout.disconnect();
+        apply(params, slot);
+        return false;
+    }
+
+    bool onMaxTimeout()
+    {
+        min_timeout.disconnect();
+        apply(params, slot);
+        return false;
+    }
+
+    // C++14
+
+    // See https://gist.github.com/ntessore/dc17769676fb3c6daa1f
+    template<std::size_t... Is>
+    struct index_sequence
+    {
+    };
+
+    template<std::size_t N, std::size_t... Is>
+    struct make_index_sequence :
+        make_index_sequence<N-1, N-1, Is...>
+    {
+    };
+
+    template<std::size_t... Is>
+    struct make_index_sequence<0, Is...> :
+        index_sequence<Is...>
+    {
+    };
+
+    // C++17
+
+    // See https://aherrmann.github.io/programming/2016/02/28/unpacking-tuples-in-cpp14/
+    template<typename T, class F, size_t... Is>
+    constexpr void apply_impl(T t, F f, index_sequence<Is...>)
+    {
+        f(std::get<Is>(t)...);
+    }
+
+    template <class T, class F>
+    constexpr void apply(T t, F f)
+    {
+        apply_impl(t, f, make_index_sequence<std::tuple_size<T>{}>{});
+    }
+
+    const unsigned int min_delay_ms;
+    const unsigned int max_delay_ms;
+
+    sigc::connection signal;
+    sigc::connection min_timeout;
+    sigc::connection max_timeout;
+
+    sigc::slot<void, Ts...> slot;
+    sigc::slot<void, Ts...> immediate_slot;
+
+    std::tuple<Ts...> params;
+};