persistent effects

src/control/controleffectknob.cpp

@@ -13,10 +13,10 @@ void ControlEffectKnob::setBehaviour(EffectManifestParameter::ControlHint type,
         return;
     }
 
-    if (type == EffectManifestParameter::CONTROL_KNOB_LINEAR) {
+    if (type == EffectManifestParameter::ControlHint::KNOB_LINEAR) {
             m_pControl->setBehavior(new ControlLinPotmeterBehavior(
                     dMinValue, dMaxValue, false));
-    } else if (type == EffectManifestParameter::CONTROL_KNOB_LOGARITHMIC) {
+    } else if (type == EffectManifestParameter::ControlHint::KNOB_LOGARITHMIC) {
         if (dMinValue == 0) {
             if (dMaxValue == 1.0) {
                 // Volume like control

src/control/controlpotmeter.cpp

@@ -23,8 +23,9 @@ ControlPotmeter::ControlPotmeter(ConfigKey key, double dMinValue, double dMaxVal
                                  bool allowOutOfBounds,
                                  bool bIgnoreNops,
                                  bool bTrack,
-                                 bool bPersist)
-        : ControlObject(key, bIgnoreNops, bTrack, bPersist),
+                                 bool bPersist,
+                                 double defaultValue)
+        : ControlObject(key, bIgnoreNops, bTrack, bPersist, defaultValue),
           m_controls(key) {
     setRange(dMinValue, dMaxValue, allowOutOfBounds);
     double default_value = dMinValue + 0.5 * (dMaxValue - dMinValue);

src/control/controlpotmeter.h

@@ -77,7 +77,8 @@ class ControlPotmeter : public ControlObject {
                     bool allowOutOfBounds = false,
                     bool bIgnoreNops = true,
                     bool bTrack = false,
-                    bool bPersist = false);
+                    bool bPersist = false,
+                    double defaultValue = 0.0);
     virtual ~ControlPotmeter();
 
     // Sets the step count of the associated PushButtons.

src/effects/effect.cpp

@@ -3,6 +3,7 @@
 #include "effects/effect.h"
 #include "effects/effectprocessor.h"
 #include "effects/effectsmanager.h"
+#include "effects/effectxmlelements.h"
 #include "engine/effects/engineeffectchain.h"
 #include "engine/effects/engineeffect.h"
 #include "util/xml.h"
@@ -111,7 +112,7 @@ void Effect::sendParameterUpdate() {
 unsigned int Effect::numKnobParameters() const {
     unsigned int num = 0;
     foreach(const EffectParameter* parameter, m_parameters) {
-        if (parameter->manifest().controlHint() != EffectManifestParameter::CONTROL_TOGGLE_STEPPING) {
+        if (parameter->manifest().controlHint() != EffectManifestParameter::ControlHint::TOGGLE_STEPPING) {
             ++num;
         }
     }
@@ -121,7 +122,7 @@ unsigned int Effect::numKnobParameters() const {
 unsigned int Effect::numButtonParameters() const {
     unsigned int num = 0;
     foreach(const EffectParameter* parameter, m_parameters) {
-        if (parameter->manifest().controlHint() == EffectManifestParameter::CONTROL_TOGGLE_STEPPING) {
+        if (parameter->manifest().controlHint() == EffectManifestParameter::ControlHint::TOGGLE_STEPPING) {
             ++num;
         }
     }
@@ -140,7 +141,7 @@ EffectParameter* Effect::getParameterById(const QString& id) const {
 // static
 bool Effect::isButtonParameter(EffectParameter* parameter) {
     return  parameter->manifest().controlHint() ==
-            EffectManifestParameter::CONTROL_TOGGLE_STEPPING;
+            EffectManifestParameter::ControlHint::TOGGLE_STEPPING;
 }
 
 // static
@@ -172,32 +173,15 @@ EffectParameter* Effect::getButtonParameterForSlot(unsigned int slotNumber) {
     return getFilteredParameterForSlot(isButtonParameter, slotNumber);
 }
 
-QDomElement Effect::toXML(QDomDocument* doc) const {
-    QDomElement element = doc->createElement("Effect");
-    XmlParse::addElement(*doc, element, "Id", m_manifest.id());
-    XmlParse::addElement(*doc, element, "Version", m_manifest.version());
-
-    QDomElement parameters = doc->createElement("Parameters");
-    foreach (EffectParameter* pParameter, m_parameters) {
-        const EffectManifestParameter& parameterManifest =
-                pParameter->manifest();
-        QDomElement parameter = doc->createElement("Parameter");
-        XmlParse::addElement(*doc, parameter, "Id", parameterManifest.id());
-        // TODO(rryan): Do smarter QVariant formatting?
-        XmlParse::addElement(*doc, parameter, "Value", QString::number(pParameter->getValue()));
-        // TODO(rryan): Output link state, etc.
-        parameters.appendChild(parameter);
-    }
-    element.appendChild(parameters);
-
-    return element;
-}
-
 // static
-EffectPointer Effect::fromXML(EffectsManager* pEffectsManager,
+EffectPointer Effect::createFromXml(EffectsManager* pEffectsManager,
                               const QDomElement& element) {
-    QString effectId = XmlParse::selectNodeQString(element, "Id");
+    // Empty <Effect/> elements are used to preserve chain order
+    // when there are empty slots at the beginning of the chain.
+    if (!element.hasChildNodes()) {
+        return EffectPointer();
+    }
+    QString effectId = XmlParse::selectNodeQString(element, EffectXml::EffectId);
     EffectPointer pEffect = pEffectsManager->instantiateEffect(effectId);
-    // TODO(rryan): Load parameter values / etc. from element.
     return pEffect;
 }

src/effects/effect.h

@@ -55,8 +55,7 @@ class Effect : public QObject {
     void removeFromEngine(EngineEffectChain* pChain, int iIndex);
     void updateEngineState();
 
-    QDomElement toXML(QDomDocument* doc) const;
-    static EffectPointer fromXML(EffectsManager* pEffectsManager,
+    static EffectPointer createFromXml(EffectsManager* pEffectsManager,
                                  const QDomElement& element);
 
   signals:

src/effects/effectbuttonparameterslot.cpp

@@ -2,9 +2,11 @@
 
 #include "control/controleffectknob.h"
 #include "effects/effectbuttonparameterslot.h"
+#include "effects/effectxmlelements.h"
 #include "control/controlobject.h"
 #include "control/controlpushbutton.h"
 #include "util/math.h"
+#include "util/xml.h"
 
 EffectButtonParameterSlot::EffectButtonParameterSlot(const QString& group,
                                                      const unsigned int iParameterSlotNumber)
@@ -31,6 +33,7 @@ EffectButtonParameterSlot::EffectButtonParameterSlot(const QString& group,
 
 EffectButtonParameterSlot::~EffectButtonParameterSlot() {
     //qDebug() << debugString() << "destroyed";
+    // m_pControlLoaded and m_pControlType are deleted by ~EffectParameterSlotBase
     delete m_pControlValue;
 }
 
@@ -107,3 +110,34 @@ void EffectButtonParameterSlot::slotValueChanged(double v) {
         m_pEffectParameter->setValue(v);
     }
 }
+
+QDomElement EffectButtonParameterSlot::toXml(QDomDocument* doc) const {
+    QDomElement parameterElement;
+    if (m_pEffectParameter != nullptr) {
+        parameterElement = doc->createElement(EffectXml::Parameter);
+        XmlParse::addElement(*doc, parameterElement,
+                             EffectXml::ParameterValue,
+                             QString::number(m_pControlValue->get()));
+    }
+
+    return parameterElement;
+}
+
+void EffectButtonParameterSlot::loadParameterSlotFromXml(const QDomElement&
+                                                  parameterElement) {
+    if (m_pEffectParameter == nullptr) {
+        return;
+    }
+    if (!parameterElement.hasChildNodes()) {
+        m_pControlValue->reset();
+    } else {
+        bool conversionWorked = false;
+        double value = XmlParse::selectNodeDouble(parameterElement,
+                                                  EffectXml::ParameterValue,
+                                                  &conversionWorked);
+        if (conversionWorked) {
+            m_pControlValue->set(value);
+        }
+        // If the conversion failed, the default value is kept.
+    }
+}

src/effects/effectbuttonparameterslot.h

@@ -32,6 +32,9 @@ class EffectButtonParameterSlot : public EffectParameterSlotBase {
     // Clear the currently loaded effect
     void clear();
 
+    QDomElement toXml(QDomDocument* doc) const override;
+    void loadParameterSlotFromXml(const QDomElement& parameterElement) override;
+
   private slots:
     // Solely for handling control changes
     void slotParameterValueChanged(double value);

src/effects/effectchain.cpp

@@ -2,6 +2,7 @@
 
 #include "effects/effectchainmanager.h"
 #include "effects/effectsmanager.h"
+#include "effects/effectxmlelements.h"
 #include "engine/effects/engineeffectchain.h"
 #include "engine/effects/engineeffectrack.h"
 #include "engine/effects/message.h"
@@ -96,8 +97,14 @@ EffectChainPointer EffectChain::clone(EffectChainPointer pChain) {
     // Do not set the state of the chain because that information belongs
     // to the EffectChainSlot. Leave that to EffectChainSlot::loadEffectChain.
     for (const auto& pEffect : pChain->effects()) {
-        EffectPointer pClonedEffect = pChain->m_pEffectsManager
-                ->instantiateEffect(pEffect->getManifest().id());
+        EffectPointer pClonedEffect;
+        if (pEffect == nullptr) {
+            // Insert empty effect to preserve chain order
+            pClonedEffect = EffectPointer();
+        } else {
+            pClonedEffect = pChain->m_pEffectsManager
+                    ->instantiateEffect(pEffect->getManifest().id());
+        }
         pClone->addEffect(pClonedEffect);
     }
     return EffectChainPointer(pClone);
@@ -196,6 +203,9 @@ void EffectChain::setInsertionType(InsertionType insertionType) {
 void EffectChain::addEffect(EffectPointer pEffect) {
     //qDebug() << debugString() << "addEffect";
     if (!pEffect) {
+        // Insert empty effects to preserve chain order
+        // when loading chains with empty effects
+        m_effects.append(pEffect);
         return;
     }
 
@@ -214,15 +224,14 @@ void EffectChain::addEffect(EffectPointer pEffect) {
 
 void EffectChain::replaceEffect(unsigned int effectSlotNumber,
                                 EffectPointer pEffect) {
-    //qDebug() << debugString() << "replaceEffect" << iEffectNumber << pEffect;
+    //qDebug() << debugString() << "replaceEffect" << effectSlotNumber << pEffect;
     while (effectSlotNumber >= static_cast<unsigned int>(m_effects.size())) {
         if (pEffect.isNull()) {
             return;
         }
         m_effects.append(EffectPointer());
     }
 
-
     EffectPointer pOldEffect = m_effects[effectSlotNumber];
     if (!pOldEffect.isNull()) {
         if (m_bAddedToEngine) {
@@ -269,34 +278,17 @@ void EffectChain::sendParameterUpdate() {
     m_pEffectsManager->writeRequest(pRequest);
 }
 
-QDomElement EffectChain::toXML(QDomDocument* doc) const {
-    QDomElement element = doc->createElement("EffectChain");
-
-    XmlParse::addElement(*doc, element, "Id", m_id);
-    XmlParse::addElement(*doc, element, "Name", m_name);
-    XmlParse::addElement(*doc, element, "Description", m_description);
-    XmlParse::addElement(*doc, element, "InsertionType",
-                         insertionTypeToString(m_insertionType));
-
-    QDomElement effectsNode = doc->createElement("Effects");
-    foreach (EffectPointer pEffect, m_effects) {
-        if (pEffect) {
-            QDomElement effectNode = pEffect->toXML(doc);
-            effectsNode.appendChild(effectNode);
-        }
-    }
-    element.appendChild(effectsNode);
-
-    return element;
-}
-
 // static
-EffectChainPointer EffectChain::fromXML(EffectsManager* pEffectsManager,
+EffectChainPointer EffectChain::createFromXml(EffectsManager* pEffectsManager,
                                         const QDomElement& element) {
-    QString id = XmlParse::selectNodeQString(element, "Id");
-    QString name = XmlParse::selectNodeQString(element, "Name");
-    QString description = XmlParse::selectNodeQString(element, "Description");
-    QString insertionTypeStr = XmlParse::selectNodeQString(element, "InsertionType");
+    QString id = XmlParse::selectNodeQString(element,
+                                             EffectXml::ChainId);
+    QString name = XmlParse::selectNodeQString(element,
+                                               EffectXml::ChainName);
+    QString description = XmlParse::selectNodeQString(element,
+                                                      EffectXml::ChainDescription);
+    QString insertionTypeStr = XmlParse::selectNodeQString(element,
+                                                           EffectXml::ChainInsertionType);
 
     EffectChain* pChain = new EffectChain(pEffectsManager, id);
     pChain->setName(name);
@@ -309,17 +301,15 @@ EffectChainPointer EffectChain::fromXML(EffectsManager* pEffectsManager,
     EffectChainPointer pChainWrapped(pChain);
     pEffectsManager->getEffectChainManager()->addEffectChain(pChainWrapped);
 
-    QDomElement effects = XmlParse::selectElement(element, "Effects");
+    QDomElement effects = XmlParse::selectElement(element, EffectXml::EffectsRoot);
     QDomNodeList effectChildren = effects.childNodes();
 
     for (int i = 0; i < effectChildren.count(); ++i) {
         QDomNode effect = effectChildren.at(i);
         if (effect.isElement()) {
-            EffectPointer pEffect = Effect::fromXML(
+            EffectPointer pEffect = Effect::createFromXml(
                 pEffectsManager, effect.toElement());
-            if (pEffect) {
-                pChain->addEffect(pEffect);
-            }
+            pChain->addEffect(pEffect);
         }
     }
 

src/effects/effectchain.h

@@ -93,8 +93,7 @@ class EffectChain : public QObject {
 
     EngineEffectChain* getEngineEffectChain();
 
-    QDomElement toXML(QDomDocument* doc) const;
-    static EffectChainPointer fromXML(EffectsManager* pEffectsManager,
+    static EffectChainPointer createFromXml(EffectsManager* pEffectsManager,
                                       const QDomElement& element);
     static EffectChainPointer clone(EffectChainPointer pChain);