Use namespace for control button mode

mixxxdj · Aug 18, 2024 · abc798a · abc798a
1 parent 6c49909
commit abc798a
Show file tree

Hide file tree

Showing 33 changed files with 152 additions and 136 deletions.
diff --git a/src/broadcast/broadcastmanager.cpp b/src/broadcast/broadcastmanager.cpp
@@ -22,7 +22,7 @@ BroadcastManager::BroadcastManager(SettingsManager* pSettingsManager,
     const bool persist = true;
     m_pBroadcastEnabled = new ControlPushButton(
             ConfigKey(BROADCAST_PREF_KEY,"enabled"), persist);
-    m_pBroadcastEnabled->setButtonMode(ControlButtonMode::Toggle);
+    m_pBroadcastEnabled->setButtonMode(mixxx::control::ButtonMode::Toggle);
     connect(m_pBroadcastEnabled,
             &ControlPushButton::valueChanged,
             this,

diff --git a/src/control/controlbehavior.cpp b/src/control/controlbehavior.cpp
@@ -342,7 +342,7 @@ double ControlLinSteppedIntPotBehavior::parameterToValue(double dParam) {
 const int ControlPushButtonBehavior::kPowerWindowTimeMillis = 300;
 const int ControlPushButtonBehavior::kLongPressLatchingTimeMillis = 300;
 
-ControlPushButtonBehavior::ControlPushButtonBehavior(ControlButtonMode buttonMode,
+ControlPushButtonBehavior::ControlPushButtonBehavior(mixxx::control::ButtonMode buttonMode,
         int iNumStates)
         : m_buttonMode(buttonMode),
           m_iNumStates(iNumStates) {
@@ -364,7 +364,7 @@ void ControlPushButtonBehavior::setValueFromMidi(
     }
 
     // This block makes push-buttons act as power window buttons.
-    if (m_buttonMode == ControlButtonMode::PowerWindow && m_iNumStates == 2) {
+    if (m_buttonMode == mixxx::control::ButtonMode::PowerWindow && m_iNumStates == 2) {
         auto* timer = getTimer();
         if (pressed) {
             // Toggle on press
@@ -376,8 +376,8 @@ void ControlPushButtonBehavior::setValueFromMidi(
             // Disable after releasing a long press
             pControl->set(0., nullptr);
         }
-    } else if (m_buttonMode == ControlButtonMode::Toggle ||
-            m_buttonMode == ControlButtonMode::LongPressLatching) {
+    } else if (m_buttonMode == mixxx::control::ButtonMode::Toggle ||
+            m_buttonMode == mixxx::control::ButtonMode::LongPressLatching) {
         // This block makes push-buttons act as toggle buttons.
         if (m_iNumStates > 1) { // multistate button
             if (pressed) {
@@ -388,14 +388,14 @@ void ControlPushButtonBehavior::setValueFromMidi(
                 double value = pControl->get();
                 value = (int)(value + 1.) % m_iNumStates;
                 pControl->set(value, nullptr);
-                if (m_buttonMode == ControlButtonMode::LongPressLatching) {
+                if (m_buttonMode == mixxx::control::ButtonMode::LongPressLatching) {
                     auto* timer = getTimer();
                     timer->setSingleShot(true);
                     timer->start(kLongPressLatchingTimeMillis);
                 }
             } else {
                 double value = pControl->get();
-                if (m_buttonMode == ControlButtonMode::LongPressLatching &&
+                if (m_buttonMode == mixxx::control::ButtonMode::LongPressLatching &&
                         getTimer()->isActive() && value >= 1.) {
                     // revert toggle if button is released too early
                     value = (int)(value - 1.) % m_iNumStates;

diff --git a/src/control/controlbehavior.h b/src/control/controlbehavior.h
@@ -131,7 +131,7 @@ class ControlPushButtonBehavior : public ControlNumericBehavior {
     static const int kPowerWindowTimeMillis;
     static const int kLongPressLatchingTimeMillis;
 
-    ControlPushButtonBehavior(ControlButtonMode buttonMode, int iNumStates);
+    ControlPushButtonBehavior(mixxx::control::ButtonMode buttonMode, int iNumStates);
     void setValueFromMidi(
             MidiOpCode o, double dParam, ControlDoublePrivate* pControl)
                 override;
@@ -145,7 +145,7 @@ class ControlPushButtonBehavior : public ControlNumericBehavior {
         }
         return m_pushTimer.data();
     }
-    ControlButtonMode m_buttonMode;
+    mixxx::control::ButtonMode m_buttonMode;
     int m_iNumStates;
     QScopedPointer<QTimer> m_pushTimer;
 };

diff --git a/src/control/controlbuttonmode.h b/src/control/controlbuttonmode.h
@@ -1,9 +1,23 @@
 #pragma once
 
-enum class ControlButtonMode {
+// required for Qt-Macros
+#include <qobjectdefs.h>
+
+namespace mixxx {
+
+namespace control {
+
+Q_NAMESPACE
+
+enum class ButtonMode {
     Push,
     Toggle,
     PowerWindow,
     LongPressLatching,
     Trigger
 };
+
+Q_ENUM_NS(ButtonMode);
+
+} // namespace control
+} // namespace mixxx
diff --git a/src/control/controlpushbutton.cpp b/src/control/controlpushbutton.cpp
@@ -8,14 +8,14 @@
    -------- ------------------------------------------------------ */
 ControlPushButton::ControlPushButton(const ConfigKey& key, bool bPersist, double defaultValue)
         : ControlObject(key, false, false, bPersist, defaultValue),
-          m_buttonMode(ControlButtonMode::Push),
+          m_buttonMode(mixxx::control::ButtonMode::Push),
           m_iNoStates(2) {
     updateBehavior();
 }
 
 ControlPushButton::~ControlPushButton() = default;
 
-void ControlPushButton::setButtonMode(ControlButtonMode mode) {
+void ControlPushButton::setButtonMode(mixxx::control::ButtonMode mode) {
     if (m_buttonMode != mode) {
         m_buttonMode = mode;
         updateBehavior();
@@ -29,7 +29,7 @@ void ControlPushButton::setStates(int num_states) {
     }
 }
 
-void ControlPushButton::setBehavior(ControlButtonMode mode, int num_states) {
+void ControlPushButton::setBehavior(mixxx::control::ButtonMode mode, int num_states) {
     bool shouldUpdate = false;
     if (m_buttonMode != mode) {
         m_buttonMode = mode;

diff --git a/src/control/controlpushbutton.h b/src/control/controlpushbutton.h
@@ -6,17 +6,17 @@
 class ControlPushButton : public ControlObject {
     Q_OBJECT
   public:
-    static QString buttonModeToString(ControlButtonMode mode) {
-        switch(mode) {
-        case ControlButtonMode::Push:
+    static QString buttonModeToString(mixxx::control::ButtonMode buttonMode) {
+        switch (buttonMode) {
+        case mixxx::control::ButtonMode::Push:
             return QStringLiteral("Push");
-        case ControlButtonMode::Toggle:
+        case mixxx::control::ButtonMode::Toggle:
             return QStringLiteral("Toggle");
-        case ControlButtonMode::PowerWindow:
+        case mixxx::control::ButtonMode::PowerWindow:
             return QStringLiteral("PowerWindow");
-        case ControlButtonMode::LongPressLatching:
+        case mixxx::control::ButtonMode::LongPressLatching:
             return QStringLiteral("LongPressLatching");
-        case ControlButtonMode::Trigger:
+        case mixxx::control::ButtonMode::Trigger:
             return QStringLiteral("Trigger");
         }
         DEBUG_ASSERT(false);
@@ -26,15 +26,15 @@ class ControlPushButton : public ControlObject {
     ControlPushButton(const ConfigKey& key, bool bPersist = false, double defaultValue = 0.0);
     virtual ~ControlPushButton();
 
-    inline ControlButtonMode getButtonMode() const {
+    inline mixxx::control::ButtonMode getButtonMode() const {
         return m_buttonMode;
     }
-    void setButtonMode(ControlButtonMode mode);
+    void setButtonMode(mixxx::control::ButtonMode mode);
     void setStates(int num_states);
-    void setBehavior(ControlButtonMode mode, int num_states);
+    void setBehavior(mixxx::control::ButtonMode mode, int num_states);
 
   private:
     void updateBehavior();
-    enum ControlButtonMode m_buttonMode;
+    enum mixxx::control::ButtonMode m_buttonMode;
     int m_iNoStates;
 };
diff --git a/src/effects/effectbuttonparameterslot.cpp b/src/effects/effectbuttonparameterslot.cpp
@@ -13,7 +13,7 @@ EffectButtonParameterSlot::EffectButtonParameterSlot(const QString& group,
             ConfigKey(m_group, itemPrefix + QString("_loaded")));
     m_pControlValue = std::make_unique<ControlPushButton>(
             ConfigKey(m_group, itemPrefix));
-    m_pControlValue->setButtonMode(ControlButtonMode::PowerWindow);
+    m_pControlValue->setButtonMode(mixxx::control::ButtonMode::PowerWindow);
     m_pControlType = std::make_unique<ControlObject>(
             ConfigKey(m_group, itemPrefix + QString("_type")));
 

diff --git a/src/effects/effectchain.cpp b/src/effects/effectchain.cpp
@@ -52,7 +52,7 @@ EffectChain::EffectChain(const QString& group,
 
     m_pControlChainEnabled =
             std::make_unique<ControlPushButton>(ConfigKey(m_group, "enabled"));
-    m_pControlChainEnabled->setButtonMode(ControlButtonMode::PowerWindow);
+    m_pControlChainEnabled->setButtonMode(mixxx::control::ButtonMode::PowerWindow);
     // Default to enabled. The skin might not show these buttons.
     m_pControlChainEnabled->setDefaultValue(true);
     m_pControlChainEnabled->set(true);
@@ -82,7 +82,8 @@ EffectChain::EffectChain(const QString& group,
 
     m_pControlChainMixMode =
             std::make_unique<ControlPushButton>(ConfigKey(m_group, "mix_mode"));
-    m_pControlChainMixMode->setBehavior(ControlButtonMode::Toggle, EffectChainMixMode::kNumModes);
+    m_pControlChainMixMode->setBehavior(
+            mixxx::control::ButtonMode::Toggle, EffectChainMixMode::kNumModes);
     double mixModeCODefault = static_cast<double>(EffectChainMixMode::DrySlashWet);
     m_pControlChainMixMode->setDefaultValue(mixModeCODefault);
     m_pControlChainMixMode->set(mixModeCODefault);
@@ -126,21 +127,21 @@ EffectChain::EffectChain(const QString& group,
     // Refer to comment in header for full explanation.
     m_pControlChainShowFocus = std::make_unique<ControlPushButton>(
             ConfigKey(m_group, "show_focus"));
-    m_pControlChainShowFocus->setButtonMode(ControlButtonMode::Toggle);
+    m_pControlChainShowFocus->setButtonMode(mixxx::control::ButtonMode::Toggle);
 
     m_pControlChainHasControllerFocus = std::make_unique<ControlPushButton>(
             ConfigKey(m_group, "controller_input_active"));
-    m_pControlChainHasControllerFocus->setButtonMode(ControlButtonMode::Toggle);
+    m_pControlChainHasControllerFocus->setButtonMode(mixxx::control::ButtonMode::Toggle);
 
     m_pControlChainShowParameters = std::make_unique<ControlPushButton>(
             ConfigKey(m_group, "show_parameters"),
             true);
-    m_pControlChainShowParameters->setButtonMode(ControlButtonMode::Toggle);
+    m_pControlChainShowParameters->setButtonMode(mixxx::control::ButtonMode::Toggle);
 
     m_pControlChainFocusedEffect = std::make_unique<ControlPushButton>(
             ConfigKey(m_group, "focused_effect"),
             true);
-    m_pControlChainFocusedEffect->setButtonMode(ControlButtonMode::Toggle);
+    m_pControlChainFocusedEffect->setButtonMode(mixxx::control::ButtonMode::Toggle);
 
     addToEngine();
 }
@@ -305,7 +306,7 @@ void EffectChain::registerInputChannel(const ChannelHandleAndGroup& handleGroup,
             true,
             initialValue);
     m_channelEnableButtons.insert(handleGroup, pEnableControl);
-    pEnableControl->setButtonMode(ControlButtonMode::PowerWindow);
+    pEnableControl->setButtonMode(mixxx::control::ButtonMode::PowerWindow);
     if (pEnableControl->toBool()) {
         enableForInputChannel(handleGroup);
     }

diff --git a/src/effects/effectknobparameterslot.cpp b/src/effects/effectknobparameterslot.cpp
@@ -30,14 +30,14 @@ EffectKnobParameterSlot::EffectKnobParameterSlot(
 
     m_pControlLinkType = std::make_unique<ControlPushButton>(
             ConfigKey(m_group, itemPrefix + QString("_link_type")));
-    m_pControlLinkType->setBehavior(ControlButtonMode::Toggle,
+    m_pControlLinkType->setBehavior(mixxx::control::ButtonMode::Toggle,
             static_cast<int>(EffectManifestParameter::LinkType::NumLinkTypes));
     m_pControlLinkType->connectValueChangeRequest(
             this, &EffectKnobParameterSlot::slotLinkTypeChanging);
 
     m_pControlLinkInverse = std::make_unique<ControlPushButton>(
             ConfigKey(m_group, itemPrefix + QString("_link_inverse")));
-    m_pControlLinkInverse->setButtonMode(ControlButtonMode::Toggle);
+    m_pControlLinkInverse->setButtonMode(mixxx::control::ButtonMode::Toggle);
     connect(m_pControlLinkInverse.get(),
             &ControlObject::valueChanged,
             this,

diff --git a/src/effects/effectslot.cpp b/src/effects/effectslot.cpp
@@ -68,7 +68,7 @@ EffectSlot::EffectSlot(const QString& group,
     // Default to disabled to prevent accidental activation of effects
     // at the beginning of a set.
     m_pControlEnabled = std::make_unique<ControlPushButton>(ConfigKey(m_group, "enabled"));
-    m_pControlEnabled->setButtonMode(ControlButtonMode::PowerWindow);
+    m_pControlEnabled->setButtonMode(mixxx::control::ButtonMode::PowerWindow);
     connect(m_pControlEnabled.get(),
             &ControlObject::valueChanged,
             this,

diff --git a/src/engine/channels/enginechannel.cpp b/src/engine/channels/enginechannel.cpp
@@ -20,14 +20,14 @@ EngineChannel::EngineChannel(const ChannelHandleAndGroup& handleGroup,
           m_bIsTalkoverChannel(isTalkoverChannel),
           m_channelIndex(-1) {
     m_pPFL = new ControlPushButton(ConfigKey(getGroup(), "pfl"));
-    m_pPFL->setButtonMode(ControlButtonMode::Toggle);
+    m_pPFL->setButtonMode(mixxx::control::ButtonMode::Toggle);
     m_pMainMix = new ControlPushButton(ConfigKey(getGroup(), "main_mix"));
-    m_pMainMix->setButtonMode(ControlButtonMode::PowerWindow);
+    m_pMainMix->setButtonMode(mixxx::control::ButtonMode::PowerWindow);
     m_pMainMix->addAlias(ConfigKey(getGroup(), QStringLiteral("master")));
     // crossfader assignment is persistent
     m_pOrientation = new ControlPushButton(
             ConfigKey(getGroup(), "orientation"), true, defaultOrientation);
-    m_pOrientation->setBehavior(ControlButtonMode::Toggle, 3);
+    m_pOrientation->setBehavior(mixxx::control::ButtonMode::Toggle, 3);
     m_pOrientationLeft = new ControlPushButton(ConfigKey(getGroup(), "orientation_left"));
     connect(m_pOrientationLeft, &ControlObject::valueChanged,
             this, &EngineChannel::slotOrientationLeft, Qt::DirectConnection);
@@ -38,7 +38,7 @@ EngineChannel::EngineChannel(const ChannelHandleAndGroup& handleGroup,
     connect(m_pOrientationCenter, &ControlObject::valueChanged,
             this, &EngineChannel::slotOrientationCenter, Qt::DirectConnection);
     m_pTalkover = new ControlPushButton(ConfigKey(getGroup(), "talkover"));
-    m_pTalkover->setButtonMode(ControlButtonMode::PowerWindow);
+    m_pTalkover->setButtonMode(mixxx::control::ButtonMode::PowerWindow);
 
     if (m_pEffectsManager != nullptr) {
         m_pEffectsManager->registerInputChannel(handleGroup);

diff --git a/src/engine/channels/enginedeck.cpp b/src/engine/channels/enginedeck.cpp
@@ -38,7 +38,7 @@ EngineDeck::EngineDeck(
           m_pPassing(new ControlPushButton(ConfigKey(getGroup(), "passthrough"))) {
     m_pInputConfigured->setReadOnly();
     // Set up passthrough utilities and fields
-    m_pPassing->setButtonMode(ControlButtonMode::PowerWindow);
+    m_pPassing->setButtonMode(mixxx::control::ButtonMode::PowerWindow);
     m_bPassthroughIsActive = false;
     m_bPassthroughWasActive = false;
 

diff --git a/src/engine/controls/bpmcontrol.cpp b/src/engine/controls/bpmcontrol.cpp
@@ -241,7 +241,7 @@ BpmControl::BpmControl(const QString& group,
 
     m_pBpmLock = std::make_unique<ControlPushButton>(
             ConfigKey(group, "bpmlock"), false);
-    m_pBpmLock->setButtonMode(ControlButtonMode::Toggle);
+    m_pBpmLock->setButtonMode(mixxx::control::ButtonMode::Toggle);
     m_pBpmLock->connectValueChangeRequest(
             this,
             &BpmControl::slotToggleBpmLock,

diff --git a/src/engine/controls/cuecontrol.cpp b/src/engine/controls/cuecontrol.cpp
@@ -138,9 +138,9 @@ CueControl::~CueControl() {
 
 void CueControl::createControls() {
     m_pCueSet = std::make_unique<ControlPushButton>(ConfigKey(m_group, "cue_set"));
-    m_pCueSet->setButtonMode(ControlButtonMode::Trigger);
+    m_pCueSet->setButtonMode(mixxx::control::ButtonMode::Trigger);
     m_pCueClear = std::make_unique<ControlPushButton>(ConfigKey(m_group, "cue_clear"));
-    m_pCueClear->setButtonMode(ControlButtonMode::Trigger);
+    m_pCueClear->setButtonMode(mixxx::control::ButtonMode::Trigger);
     m_pCueGoto = std::make_unique<ControlPushButton>(ConfigKey(m_group, "cue_goto"));
     m_pCueGotoAndPlay = std::make_unique<ControlPushButton>(ConfigKey(m_group, "cue_gotoandplay"));
     m_pCuePlay = std::make_unique<ControlPushButton>(ConfigKey(m_group, "cue_play"));

diff --git a/src/engine/controls/keycontrol.cpp b/src/engine/controls/keycontrol.cpp
@@ -53,9 +53,9 @@ KeyControl::KeyControl(const QString& group,
     // Fine adjust with semitone / 10 = 10 ct;.
     m_pPitchAdjust->setSmallStepCount(60);
 
-    m_keylockMode->setButtonMode(ControlButtonMode::Toggle);
+    m_keylockMode->setButtonMode(mixxx::control::ButtonMode::Toggle);
 
-    m_keyunlockMode->setButtonMode(ControlButtonMode::Toggle);
+    m_keyunlockMode->setButtonMode(mixxx::control::ButtonMode::Toggle);
 
     connect(m_pPitch.get(),
             &ControlObject::valueChanged,

diff --git a/src/engine/controls/loopingcontrol.cpp b/src/engine/controls/loopingcontrol.cpp
@@ -137,7 +137,7 @@ LoopingControl::LoopingControl(const QString& group,
     m_pCOLoopAnchor = new ControlPushButton(ConfigKey(group, "loop_anchor"),
             true,
             static_cast<double>(LoopAnchorPoint::Start));
-    m_pCOLoopAnchor->setButtonMode(ControlButtonMode::Toggle);
+    m_pCOLoopAnchor->setButtonMode(mixxx::control::ButtonMode::Toggle);
 
     m_pCOBeatLoopSize = new ControlObject(ConfigKey(group, "beatloop_size"),
                                           true, false, false, 4.0);
@@ -237,7 +237,7 @@ LoopingControl::LoopingControl(const QString& group,
             this, &LoopingControl::slotLoopDouble);
 
     m_pLoopRemoveButton = new ControlPushButton(ConfigKey(group, "loop_remove"));
-    m_pLoopRemoveButton->setButtonMode(ControlButtonMode::Trigger);
+    m_pLoopRemoveButton->setButtonMode(mixxx::control::ButtonMode::Trigger);
     connect(m_pLoopRemoveButton,
             &ControlObject::valueChanged,
             this,
@@ -2013,7 +2013,7 @@ BeatLoopingControl::BeatLoopingControl(const QString& group, double size)
     // is the state of the beatloop control (1 for enabled, 0 for disabled).
     m_pLegacy = std::make_unique<ControlPushButton>(
             keyForControl(group, "beatloop_%1", size));
-    m_pLegacy->setButtonMode(ControlButtonMode::Toggle);
+    m_pLegacy->setButtonMode(mixxx::control::ButtonMode::Toggle);
     connect(m_pLegacy.get(),
             &ControlObject::valueChanged,
             this,

diff --git a/src/engine/controls/quantizecontrol.cpp b/src/engine/controls/quantizecontrol.cpp
@@ -12,7 +12,7 @@ QuantizeControl::QuantizeControl(const QString& group,
         : EngineControl(group, pConfig) {
     // Turn quantize OFF by default. See Bug #898213
     m_pCOQuantizeEnabled = new ControlPushButton(ConfigKey(group, "quantize"), true);
-    m_pCOQuantizeEnabled->setButtonMode(ControlButtonMode::Toggle);
+    m_pCOQuantizeEnabled->setButtonMode(mixxx::control::ButtonMode::Toggle);
     m_pCONextBeat = new ControlObject(ConfigKey(group, "beat_next"));
     m_pCONextBeat->setKbdRepeatable(true);
     m_pCONextBeat->set(mixxx::audio::kInvalidFramePos.toEngineSamplePosMaybeInvalid());

diff --git a/src/engine/controls/vinylcontrolcontrol.cpp b/src/engine/controls/vinylcontrolcontrol.cpp
@@ -31,20 +31,20 @@ VinylControlControl::VinylControlControl(const QString& group, UserSettingsPoint
     m_pControlVinylRate = new ControlObject(ConfigKey(group, "vinylcontrol_rate"));
     m_pControlVinylScratching = new ControlPushButton(ConfigKey(group, "vinylcontrol_scratching"));
     m_pControlVinylScratching->set(0);
-    m_pControlVinylScratching->setButtonMode(ControlButtonMode::Toggle);
+    m_pControlVinylScratching->setButtonMode(mixxx::control::ButtonMode::Toggle);
     m_pControlVinylEnabled = new ControlPushButton(ConfigKey(group, "vinylcontrol_enabled"));
     m_pControlVinylEnabled->set(0);
-    m_pControlVinylEnabled->setButtonMode(ControlButtonMode::Toggle);
+    m_pControlVinylEnabled->setButtonMode(mixxx::control::ButtonMode::Toggle);
     m_pControlVinylWantEnabled = new ControlPushButton(ConfigKey(group, "vinylcontrol_wantenabled"));
     m_pControlVinylWantEnabled->set(0);
-    m_pControlVinylWantEnabled->setButtonMode(ControlButtonMode::Toggle);
+    m_pControlVinylWantEnabled->setButtonMode(mixxx::control::ButtonMode::Toggle);
     m_pControlVinylMode = new ControlPushButton(ConfigKey(group, "vinylcontrol_mode"));
-    m_pControlVinylMode->setBehavior(ControlButtonMode::Toggle, 3);
+    m_pControlVinylMode->setBehavior(mixxx::control::ButtonMode::Toggle, 3);
     m_pControlVinylCueing = new ControlPushButton(ConfigKey(group, "vinylcontrol_cueing"));
-    m_pControlVinylCueing->setBehavior(ControlButtonMode::Toggle, 3);
+    m_pControlVinylCueing->setBehavior(mixxx::control::ButtonMode::Toggle, 3);
     m_pControlVinylSignalEnabled = new ControlPushButton(ConfigKey(group, "vinylcontrol_signal_enabled"));
     m_pControlVinylSignalEnabled->set(1);
-    m_pControlVinylSignalEnabled->setButtonMode(ControlButtonMode::Toggle);
+    m_pControlVinylSignalEnabled->setButtonMode(mixxx::control::ButtonMode::Toggle);
 
     m_pPlayEnabled = new ControlProxy(group, "play", this);
 }