Add validation to control objects

mixxx/src/control/control.cpp

@@ -2,6 +2,7 @@
 #include <QMutexLocker>
 
 #include "control/control.h"
+#include "controlobject.h"
 
 #include "util/stat.h"
 #include "util/timer.h"
@@ -11,7 +12,9 @@ QHash<ConfigKey, ControlDoublePrivate*> ControlDoublePrivate::m_sqCOHash;
 QMutex ControlDoublePrivate::m_sqCOHashMutex;
 
 ControlDoublePrivate::ControlDoublePrivate()
-        : m_bIgnoreNops(true),
+        : m_Enabled(true),
+          m_pValidator(NULL),
+          m_bIgnoreNops(true),
           m_bTrack(false) {
     m_defaultValue.setValue(0);
     m_value.setValue(0);
@@ -20,6 +23,8 @@ ControlDoublePrivate::ControlDoublePrivate()
 ControlDoublePrivate::ControlDoublePrivate(ConfigKey key,
                                            bool bIgnoreNops, bool bTrack)
         : m_key(key),
+          m_Enabled(true),
+          m_pValidator(NULL),
           m_bIgnoreNops(bIgnoreNops),
           m_bTrack(bTrack),
           m_trackKey("control " + m_key.group + "," + m_key.item),
@@ -45,6 +50,9 @@ ControlDoublePrivate::~ControlDoublePrivate() {
     m_sqCOHashMutex.lock();
     m_sqCOHash.remove(m_key);
     m_sqCOHashMutex.unlock();
+    if (m_pValidator) {
+        delete m_pValidator;
+    }
 }
 
 // static
@@ -82,16 +90,26 @@ void ControlDoublePrivate::reset(QObject* pSender) {
     set(defaultValue, pSender);
 }
 
-void ControlDoublePrivate::set(const double& value, QObject* pSender) {
+bool ControlDoublePrivate::set(const double& value, QObject* pSender) {
+    if (!m_Enabled.getValue()) {
+        return false;
+    }
+
     if (m_bIgnoreNops && get() == value) {
-        return;
+        return true;
     }
 
     double dValue = value;
     // If the behavior says to ignore the set, ignore it.
     ControlNumericBehavior* pBehavior = m_pBehavior;
     if (pBehavior && !pBehavior->setFilter(&dValue)) {
-        return;
+        return false;
+    }
+
+    // Copy to a local to prevent race conditions
+    ControlValidator* validator = m_pValidator;
+    if (validator && validator->validateChange(dValue)) {
+        return false;
     }
     m_value.setValue(dValue);
     emit(valueChanged(dValue, pSender));
@@ -100,6 +118,7 @@ void ControlDoublePrivate::set(const double& value, QObject* pSender) {
         Stat::track(m_trackKey, static_cast<Stat::StatType>(m_trackType),
                     static_cast<Stat::ComputeFlags>(m_trackFlags), dValue);
     }
+    return true;
 }
 
 ControlNumericBehavior* ControlDoublePrivate::setBehavior(ControlNumericBehavior* pBehavior) {
@@ -129,4 +148,3 @@ double ControlDoublePrivate::getMidiParameter() const {
     ControlNumericBehavior* pBehavior = m_pBehavior;
     return pBehavior ? pBehavior->valueToMidiParameter(get()) : get();
 }
-

mixxx/src/control/control.h

@@ -8,6 +8,7 @@
 #include <QAtomicPointer>
 
 #include "control/controlbehavior.h"
+#include "control/controlvalidator.h"
 #include "control/controlvalue.h"
 #include "configobject.h"
 
@@ -31,8 +32,19 @@ class ControlDoublePrivate : public QObject {
         return getControl(key, bCreate, bIgnoreNops, bTrack);
     }
 
-    // Sets the control value.
-    void set(const double& value, QObject* pSetter);
+    inline bool getEnabled() const { return m_Enabled.getValue(); }
+
+    inline void setEnabled(bool e) { m_Enabled.setValue(e); }
+
+    void setValidator(ControlValidator* validator) {
+        if (m_pValidator) {
+            delete m_pValidator;
+        }
+        m_pValidator = validator;
+    }
+
+    // Sets the control value.  Returns true if the set was successful.1
+    bool set(const double& value, QObject* pSetter);
     // Gets the control value.
     double get() const;
     // Resets the control value to its default.
@@ -69,6 +81,11 @@ class ControlDoublePrivate : public QObject {
 
   private:
     ConfigKey m_key;
+
+    // Enabled/Disabled state overrides any validation that may exist.
+    ControlValueAtomic<bool> m_Enabled;
+    // Optional custom validation object to decide if the set command should be allowed.
+    ControlValidator* m_pValidator;
     // Whether to ignore sets which would have no effect.
     bool m_bIgnoreNops;
 

mixxx/src/control/controlvalidator.h

@@ -0,0 +1,13 @@
+#ifndef CONTROLVALIDATOR_H
+#define CONTROLVALIDATOR_H
+
+class ControlValidator {
+  public:
+    virtual ~ControlValidator() {};
+
+    // Subclasses override this function to provide a way to reject invalid settings.
+    // Returns true if the change is valid.
+    virtual bool validateChange(double value) const = 0;
+};
+
+#endif // CONTROLVALIDATOR_H

mixxx/src/control/controlvalue.h

@@ -160,6 +160,11 @@ class ControlValueAtomic
     ControlValueAtomic()
         : ControlValueAtomicBase<T, sizeof(T) <= sizeof(void*)>() {
     }
+
+    ControlValueAtomic(T val)
+        : ControlValueAtomicBase<T, sizeof(T) <= sizeof(void*)>() {
+        this->setValue(val);
+    }
 };
 
 #endif /* CONTROLVALUE_H */

mixxx/src/controlobject.cpp

@@ -23,6 +23,7 @@
 #include "controlobject.h"
 #include "controlevent.h"
 #include "control/control.h"
+#include "control/controlvalidator.h"
 #include "util/stat.h"
 #include "util/timer.h"
 

mixxx/src/controlobject.h

@@ -25,6 +25,7 @@
 #include "configobject.h"
 #include "controllers/midi/midimessage.h"
 #include "control/control.h"
+#include "control/controlvalidator.h"
 
 class ControlObject : public QObject {
     Q_OBJECT
@@ -36,6 +37,12 @@ class ControlObject : public QObject {
                   bool bIgnoreNops=true, bool bTrack=false);
     virtual ~ControlObject();
 
+    void setValidator(ControlValidator* validator) {
+        if (m_pControl) {
+            m_pControl->setValidator(validator);
+        }
+    }
+
     /** Returns a pointer to the ControlObject matching the given ConfigKey */
     static ControlObject* getControl(const ConfigKey& key);
     static inline ControlObject* getControl(const QString& group, const QString& item) {
@@ -64,6 +71,20 @@ class ControlObject : public QObject {
         return m_pControl ? m_pControl->defaultValue() : 0.0;
     }
 
+    inline bool getEnabled() const {
+        if (m_pControl) {
+            return m_pControl->getEnabled();
+        } else {
+            return false;
+        }
+    }
+
+    inline void setEnabled(bool e) {
+        if (m_pControl) {
+            m_pControl->setEnabled(e);
+        }
+    }
+
   signals:
     void valueChanged(double);
     void valueChangedFromEngine(double);

mixxx/src/controlobjectthread.h

@@ -25,8 +25,8 @@
 #include <QQueue>
 
 #include "configobject.h"
+#include "control/control.h"
 
-class ControlDoublePrivate;
 class ControlObject;
 
 class ControlObjectThread : public QObject {
@@ -45,6 +45,20 @@ class ControlObjectThread : public QObject {
         return m_key;
     }
 
+    inline bool getEnabled() const {
+        if (m_pControl) {
+            return m_pControl->getEnabled();
+        } else {
+            return false;
+        }
+    }
+
+    inline void setEnabled(bool e) {
+        if (m_pControl) {
+            m_pControl->setEnabled(e);
+        }
+    }
+
     // Returns the value of the object. Thread safe, non-blocking.
     virtual double get();
 

mixxx/src/engine/enginebuffer.cpp

@@ -108,9 +108,6 @@ EngineBuffer::EngineBuffer(const char * _group, ConfigObject<ConfigValue> * _con
     // Play button
     m_playButton = new ControlPushButton(ConfigKey(m_group, "play"));
     m_playButton->setButtonMode(ControlPushButton::TOGGLE);
-    connect(m_playButton, SIGNAL(valueChanged(double)),
-            this, SLOT(slotControlPlay(double)),
-            Qt::DirectConnection);
 
     //Play from Start Button (for sampler)
     m_playStartButton = new ControlPushButton(ConfigKey(m_group, "start_play"));
@@ -383,6 +380,7 @@ void EngineBuffer::slotTrackLoading() {
     m_iTrackLoading = 1;
     m_pause.unlock();
 
+    m_playButton->setEnabled(true);
     m_playButton->set(0.0); //Stop playback
     m_pTrackSamples->set(0); // Stop renderer
 }
@@ -398,6 +396,7 @@ void EngineBuffer::slotTrackLoaded(TrackPointer pTrack,
     m_file_length_old = iTrackNumSamples;
     m_pTrackSamples->set(iTrackNumSamples);
     m_pTrackSampleRate->set(iTrackSampleRate);
+    m_playButton->setEnabled(true);
     m_pause.unlock();
 
     // All EngingeControls are connected directly
@@ -441,6 +440,7 @@ void EngineBuffer::ejectTrack() {
     m_playButton->set(0.0);
     m_visualBpm->set(0.0);
     slotControlSeek(0.);
+    m_playButton->setEnabled(false);
     m_pause.unlock();
 
     emit(trackUnloaded(pTrack));
@@ -475,16 +475,6 @@ void EngineBuffer::slotControlSeekAbs(double abs)
     slotControlSeek(abs / m_file_length_old);
 }
 
-void EngineBuffer::slotControlPlay(double v)
-{
-    // If no track is currently loaded, turn play off. If a track is loading
-    // allow the set since it might apply to a track we are loading due to the
-    // asynchrony.
-    if (v > 0.0 && !m_pCurrentTrack && m_iTrackLoading == 0) {
-        m_playButton->set(0.0f);
-    }
-}
-
 void EngineBuffer::slotControlStart(double v)
 {
     if (v > 0.0) {
@@ -895,13 +885,6 @@ void EngineBuffer::bindWorkers(EngineWorkerScheduler* pWorkerScheduler) {
     pWorkerScheduler->bindWorker(m_pReader);
 }
 
-bool EngineBuffer::isTrackLoaded() {
-    if (m_pCurrentTrack) {
-        return true;
-    }
-    return false;
-}
-
 void EngineBuffer::slotEjectTrack(double v) {
     if (v > 0) {
         ejectTrack();

mixxx/src/engine/enginebuffer.h

@@ -23,6 +23,7 @@
 #include <QAtomicInt>
 
 #include "defs.h"
+#include "controlobject.h"
 #include "engine/engineobject.h"
 #include "trackinfoobject.h"
 #include "configobject.h"
@@ -39,11 +40,11 @@ class RateControl;
 class LoopingControl;
 class ReadAheadManager;
 class ControlObject;
-class ControlPushButton;
 class ControlObjectThreadMain;
 class ControlBeat;
 class ControlTTRotary;
 class ControlPotmeter;
+class ControlPushButton;
 class CachingReader;
 class EngineBufferScale;
 class EngineBufferScaleDummy;
@@ -81,6 +82,8 @@ const int ENGINE_RAMP_UP = 1;
 
 //const int kiRampLength = 3;
 
+class EngineBuffer;
+
 class EngineBuffer : public EngineObject
 {
      Q_OBJECT
@@ -112,14 +115,14 @@ class EngineBuffer : public EngineObject
     void process(const CSAMPLE *pIn, const CSAMPLE *pOut, const int iBufferSize);
 
     const char* getGroup();
-    bool isTrackLoaded();
+    bool isTrackLoaded() const { return m_pCurrentTrack != NULL; }
+
     TrackPointer getLoadedTrack() const;
 
     // For dependency injection of readers.
     void setReader(CachingReader* pReader);
 
   public slots:
-    void slotControlPlay(double);
     void slotControlPlayFromStart(double);
     void slotControlJumpToStartAndStop(double);
     void slotControlStop(double);
@@ -275,6 +278,7 @@ class EngineBuffer : public EngineObject
     //int m_iRampIter;
 
     TrackPointer m_pCurrentTrack;
+
 #ifdef __SCALER_DEBUG__
     QFile df;
     QTextStream writer;