save/load effect parameter state to XML on shutdown/startup

21 files changed, 241 insertions, 76 deletions

diff --git a/src/effects/effect.cpp b/src/effects/effect.cpp
index 2efdedc175..1398e1507e 100644
--- a/src/effects/effect.cpp
+++ b/src/effects/effect.cpp
@@ -172,29 +172,8 @@ 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) {
     // Empty <Effect/> elements are used to preserve chain order
     // when there are empty slots at the beginning of the chain.
@@ -203,6 +182,5 @@ EffectPointer Effect::fromXML(EffectsManager* pEffectsManager,
     }
     QString effectId = XmlParse::selectNodeQString(element, "Id");
     EffectPointer pEffect = pEffectsManager->instantiateEffect(effectId);
-    // TODO(rryan): Load parameter values / etc. from element.
     return pEffect;
 }
diff --git a/src/effects/effect.h b/src/effects/effect.h
index fbfa75a6a1..2d6c57f474 100644
--- a/src/effects/effect.h
+++ b/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:
diff --git a/src/effects/effectbuttonparameterslot.cpp b/src/effects/effectbuttonparameterslot.cpp
index 51a9964230..c00417da06 100644
--- a/src/effects/effectbuttonparameterslot.cpp
+++ b/src/effects/effectbuttonparameterslot.cpp
@@ -5,6 +5,7 @@
 #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)
@@ -107,3 +108,30 @@ void EffectButtonParameterSlot::slotValueChanged(double v) {
         m_pEffectParameter->setValue(v);
     }
 }
+
+QDomElement EffectButtonParameterSlot::toXML(QDomDocument* doc) const {
+    QDomElement buttonParameterElement;
+    if (m_pEffectParameter != nullptr) {
+        buttonParameterElement = doc->createElement("ButtonParameter");
+        XmlParse::addElement(*doc, buttonParameterElement, "Id",
+                             m_pEffectParameter->id());
+        // TODO(rryan): Do smarter QVariant formatting?
+        XmlParse::addElement(*doc, buttonParameterElement, "Value",
+                            QString::number(m_pControlValue->get()));
+    }
+
+    return buttonParameterElement;
+}
+
+void EffectButtonParameterSlot::loadValuesFromXml(const QDomElement&
+                                                  buttonParameterElement) {
+    if (m_pEffectParameter == nullptr) {
+        return;
+    }
+    if (buttonParameterElement.text().isEmpty()) {
+        m_pControlValue->reset();
+    } else {
+        m_pControlValue->set(
+            XmlParse::selectNodeDouble(buttonParameterElement, "Value"));
+    }
+}
diff --git a/src/effects/effectbuttonparameterslot.h b/src/effects/effectbuttonparameterslot.h
index c537034b89..b24f7b4a62 100644
--- a/src/effects/effectbuttonparameterslot.h
+++ b/src/effects/effectbuttonparameterslot.h
@@ -32,6 +32,9 @@ class EffectButtonParameterSlot : public EffectParameterSlotBase {
     // Clear the currently loaded effect
     void clear();
 
+    QDomElement toXML(QDomDocument* doc) const;
+    void loadValuesFromXml(const QDomElement& buttonParameterElement);
+
   private slots:
     // Solely for handling control changes
     void slotParameterValueChanged(double value);
diff --git a/src/effects/effectchain.cpp b/src/effects/effectchain.cpp
index 5a6e35dc0a..ac89e7faa4 100644
--- a/src/effects/effectchain.cpp
+++ b/src/effects/effectchain.cpp
@@ -271,34 +271,8 @@ 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) {
-        QDomElement effectNode;
-        if (pEffect) {
-            effectNode = pEffect->toXML(doc);
-        } else {
-            // Create empty element to ensure effects stay in order
-            // if there are empty slots before loaded slots.
-            effectNode = doc->createElement("Effect");
-        }
-        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");
@@ -322,7 +296,7 @@ EffectChainPointer EffectChain::fromXML(EffectsManager* pEffectsManager,
     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());
             pChain->addEffect(pEffect);
         }
diff --git a/src/effects/effectchain.h b/src/effects/effectchain.h
index 204b7a8012..66a41d4300 100644
--- a/src/effects/effectchain.h
+++ b/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);
 
diff --git a/src/effects/effectchainmanager.cpp b/src/effects/effectchainmanager.cpp
index 315209cf48..524903864a 100644
--- a/src/effects/effectchainmanager.cpp
+++ b/src/effects/effectchainmanager.cpp
@@ -6,7 +6,6 @@
 #include <QDir>
 
 #include "effects/effectsmanager.h"
-#include "util/xml.h"
 
 EffectChainManager::EffectChainManager(UserSettingsPointer pConfig,
                                        EffectsManager* pEffectsManager)
@@ -163,32 +162,37 @@ bool EffectChainManager::saveEffectChains() {
     return true;
 }
 
-QList<EffectChainPointer> EffectChainManager::loadEffectChains() {
-    QList<EffectChainPointer> loadedChains;
+QList<std::pair<EffectChainPointer, QDomElement>> EffectChainManager::loadEffectChains() {
+    // StandardEffectRack::addEffectChainSlot uses both the EffectChainPointer
+    // and the saved state from the XML to initialize the respective
+    // EffectChain/Effect/EffectParameter/EffectButtonParameter Slots
+    QList<std::pair<EffectChainPointer, QDomElement>> loadedChains;
 
     QDir settingsPath(m_pConfig->getSettingsPath());
     QFile file(settingsPath.absoluteFilePath("effects.xml"));
+    QDomDocument doc;
 
     if (!file.open(QIODevice::ReadOnly)) {
         EffectChainPointer pEmptyChain;
+        QDomElement emptyChainElement = doc.createElement("EffectChain");
         for (int i = 0; i < 4; ++i) {
             pEmptyChain = EffectChainPointer(new EffectChain(m_pEffectsManager,
                                                             QString(),
                                                             EffectChainPointer()));
-            loadedChains.append(pEmptyChain);
+            loadedChains.append(std::make_pair(pEmptyChain, emptyChainElement));
         }
         return loadedChains;
     }
 
-    QDomDocument doc;
     if (!doc.setContent(&file)) {
         file.close();
         EffectChainPointer pEmptyChain;
+        QDomElement emptyChainElement = doc.createElement("EffectChain");
         for (int i = 0; i < 4; ++i) {
             pEmptyChain = EffectChainPointer(new EffectChain(m_pEffectsManager,
                                                             QString(),
                                                             EffectChainPointer()));
-            loadedChains.append(pEmptyChain);
+            loadedChains.append(std::make_pair(pEmptyChain, emptyChainElement));
         }
         return loadedChains;
     }
@@ -203,10 +207,11 @@ QList<EffectChainPointer> EffectChainManager::loadEffectChains() {
         QDomNode chainNode = chainsList.at(i);
 
         if (chainNode.isElement()) {
-            EffectChainPointer pChain = EffectChain::fromXML(
-                m_pEffectsManager, chainNode.toElement());
+            QDomElement chainElement = chainNode.toElement();
+            EffectChainPointer pChain = EffectChain::createFromXml(
+                m_pEffectsManager, chainElement);
 
-            loadedChains.append(pChain);
+            loadedChains.append(std::make_pair(pChain, chainElement));
             m_effectChains.append(pChain);
         }
     }
diff --git a/src/effects/effectchainmanager.h b/src/effects/effectchainmanager.h
index 4a266d4957..2292b4b37f 100644
--- a/src/effects/effectchainmanager.h
+++ b/src/effects/effectchainmanager.h
@@ -10,6 +10,7 @@
 #include "effects/effectrack.h"
 #include "engine/channelhandle.h"
 #include "util/class.h"
+#include "util/xml.h"
 
 class EffectsManager;
 
@@ -50,7 +51,7 @@ class EffectChainManager : public QObject {
     EffectChainPointer getPrevEffectChain(EffectChainPointer pEffectChain);
 
     bool saveEffectChains();
-    QList<EffectChainPointer> loadEffectChains();
+    QList<std::pair<EffectChainPointer, QDomElement>> loadEffectChains();
 
   private:
     QString debugString() const {
diff --git a/src/effects/effectchainslot.cpp b/src/effects/effectchainslot.cpp
index 98a9458fbf..4cd8a1b22a 100644
--- a/src/effects/effectchainslot.cpp
+++ b/src/effects/effectchainslot.cpp
@@ -5,6 +5,7 @@
 #include "control/controlpushbutton.h"
 #include "mixer/playermanager.h"
 #include "util/math.h"
+#include "util/xml.h"
 
 EffectChainSlot::EffectChainSlot(EffectRack* pRack, const QString& group,
                                  unsigned int iChainNumber)
@@ -431,3 +432,48 @@ void EffectChainSlot::slotChannelStatusChanged(const QString& group) {
 unsigned int EffectChainSlot::getChainSlotNumber() const {
     return m_iChainSlotNumber;
 }
+
+QDomElement EffectChainSlot::toXML(QDomDocument* doc) const {
+    QDomElement chainElement = doc->createElement("EffectChain");
+
+    XmlParse::addElement(*doc, chainElement, "Name",
+                         m_pEffectChain->name());
+    XmlParse::addElement(*doc, chainElement, "Description",
+                         m_pEffectChain->description());
+    XmlParse::addElement(*doc, chainElement, "InsertionType",
+                         QString::number(m_pControlChainInsertionType->get()));
+
+    QDomElement effectsElement = doc->createElement("Effects");
+    for (EffectSlotPointer pEffectSlot : m_slots) {
+        QDomElement effectNode;
+        if (pEffectSlot->getEffect()) {
+            effectNode = pEffectSlot->toXML(doc);
+        } else {
+            // Create empty element to ensure effects stay in order
+            // if there are empty slots before loaded slots.
+            effectNode = doc->createElement("Effect");
+        }
+        effectsElement.appendChild(effectNode);
+    }
+    chainElement.appendChild(effectsElement);
+
+    return chainElement;
+}
+
+void EffectChainSlot::loadValuesFromXml(const QDomElement& effectChainElement) {
+    if (effectChainElement.text().isEmpty()) {
+        return;
+    }
+
+    QDomElement effectsElement = XmlParse::selectElement(effectChainElement, "Effects");
+    QDomNodeList effectsNodeList = effectsElement.childNodes();
+    for (int i = 0; i < m_slots.size(); ++i) {
+        if (m_slots[i] != nullptr) {
+            QDomNode effectNode = effectsNodeList.at(i);
+            if (effectNode.isElement()) {
+                QDomElement effectElement = effectNode.toElement();
+                m_slots[i]->loadValuesFromXml(effectElement);
+            }
+        }
+    }
+}
diff --git a/src/effects/effectchainslot.h b/src/effects/effectchainslot.h
index bc0ecd642f..0a665f6022 100644
--- a/src/effects/effectchainslot.h
+++ b/src/effects/effectchainslot.h
@@ -51,6 +51,9 @@ class EffectChainSlot : public QObject {
         return m_group;
     }
 
+    QDomElement toXML(QDomDocument* doc) const;
+    void loadValuesFromXml(const QDomElement& effectChainElement);
+
   signals:
     // Indicates that the effect pEffect has been loaded into slotNumber of
     // EffectChainSlot chainNumber. pEffect may be an invalid pointer, which
diff --git a/src/effects/effectparameterslot.cpp b/src/effects/effectparameterslot.cpp
index b988132adf..e9155de3b4 100644
--- a/src/effects/effectparameterslot.cpp
+++ b/src/effects/effectparameterslot.cpp
@@ -5,6 +5,7 @@
 #include "control/controlobject.h"
 #include "control/controlpushbutton.h"
 #include "controllers/softtakeover.h"
+#include "util/xml.h"
 
 EffectParameterSlot::EffectParameterSlot(const QString& group, const unsigned int iParameterSlotNumber)
         : EffectParameterSlotBase(group, iParameterSlotNumber) {
@@ -242,3 +243,41 @@ void EffectParameterSlot::slotValueChanged(double v) {
         m_pEffectParameter->setValue(v);
     }
 }
+
+QDomElement EffectParameterSlot::toXML(QDomDocument* doc) const {
+    QDomElement knobParameterElement;
+    if (m_pEffectParameter != nullptr) {
+        knobParameterElement = doc->createElement("KnobParameter");
+        XmlParse::addElement(*doc, knobParameterElement, "Id",
+                             m_pEffectParameter->id());
+        // TODO(rryan): Do smarter QVariant formatting?
+        XmlParse::addElement(*doc, knobParameterElement, "Value",
+                            QString::number(m_pControlValue->getParameter()));
+        XmlParse::addElement(*doc, knobParameterElement, "LinkType",
+                            QString::number(m_pControlLinkType->get()));
+        XmlParse::addElement(*doc, knobParameterElement, "LinkInversion",
+                            QString::number(m_pControlLinkInverse->get()));
+    }
+
+    return knobParameterElement;
+}
+
+void EffectParameterSlot::loadValuesFromXml(const QDomElement& knobParameterElement) {
+    if (m_pEffectParameter == nullptr) {
+        return;
+    }
+    if (knobParameterElement.text().isEmpty()) {
+        m_pControlValue->reset();
+        m_pControlLinkType->set(
+            static_cast<double>(m_pEffectParameter->getDefaultLinkType()));
+        m_pControlLinkInverse->set(
+            static_cast<double>(m_pEffectParameter->getDefaultLinkInversion()));
+    } else {
+        m_pControlValue->setParameter(
+            XmlParse::selectNodeDouble(knobParameterElement, "Value"));
+        m_pControlLinkType->set(
+            XmlParse::selectNodeDouble(knobParameterElement, "LinkType"));
+        m_pControlLinkInverse->set(
+            XmlParse::selectNodeDouble(knobParameterElement, "LinkInversion"));
+    }
+}
diff --git a/src/effects/effectparameterslot.h b/src/effects/effectparameterslot.h
index 25d7474f8f..c237c0b9d3 100644
--- a/src/effects/effectparameterslot.h
+++ b/src/effects/effectparameterslot.h
@@ -43,6 +43,9 @@ class EffectParameterSlot : public EffectParameterSlotBase {
     // Clear the currently loaded effect
     void clear();
 
+    QDomElement toXML(QDomDocument* doc) const;
+    void loadValuesFromXml(const QDomElement& knobParameterElement);
+
   private slots:
     // Solely for handling control changes
     void slotParameterValueChanged(double value);
diff --git a/src/effects/effectrack.cpp b/src/effects/effectrack.cpp
index 93663f988c..bf33898232 100644
--- a/src/effects/effectrack.cpp
+++ b/src/effects/effectrack.cpp
@@ -184,7 +184,8 @@ QDomElement EffectRack::toXML(QDomDocument* doc) const {
 
     QDomElement chainsElement = doc->createElement("Chains");
     foreach (EffectChainSlotPointer pChainSlot, m_effectChainSlots) {
-        QDomElement chain = pChainSlot->getEffectChain()->toXML(doc);
+//         QDomElement chain = pChainSlot->getEffectChain()->toXML(doc);
+        QDomElement chain = pChainSlot->toXML(doc);
         chainsElement.appendChild(chain);
     }
     rackElement.appendChild(chainsElement);
@@ -198,7 +199,8 @@ StandardEffectRack::StandardEffectRack(EffectsManager* pEffectsManager,
                      formatGroupString(iRackNumber)) {
 }
 
-EffectChainSlotPointer StandardEffectRack::addEffectChainSlot(EffectChainPointer pChain) {
+EffectChainSlotPointer StandardEffectRack::addEffectChainSlot(EffectChainPointer pChain,
+                                                              const QDomElement& effectChainElement) {
     int iChainSlotNumber = numEffectChainSlots();
 
     QString group = formatEffectChainSlotGroupString(getRackNumber(),
@@ -228,7 +230,7 @@ EffectChainSlotPointer StandardEffectRack::addEffectChainSlot(EffectChainPointer
     // Register all the existing channels with the new EffectChain.
     const QSet<ChannelHandleAndGroup>& registeredChannels =
             m_pEffectChainManager->registeredChannels();
-    foreach (const ChannelHandleAndGroup& handle_group, registeredChannels) {
+    for (const ChannelHandleAndGroup& handle_group : registeredChannels) {
         pChainSlot->registerChannel(handle_group);
     }
 
@@ -237,6 +239,8 @@ EffectChainSlotPointer StandardEffectRack::addEffectChainSlot(EffectChainPointer
 
     pChainSlotPointer->loadEffectChain(pChain);
 
+    pChainSlot->loadValuesFromXml(effectChainElement);
+
     return pChainSlotPointer;
 }
 
diff --git a/src/effects/effectrack.h b/src/effects/effectrack.h
index a4ee5ea685..cb6a0b39f1 100644
--- a/src/effects/effectrack.h
+++ b/src/effects/effectrack.h
@@ -112,7 +112,8 @@ class StandardEffectRack : public EffectRack {
                 .arg(QString::number(iEffectSlotNumber + 1));
     }
 
-    EffectChainSlotPointer addEffectChainSlot(EffectChainPointer pChain);
+    EffectChainSlotPointer addEffectChainSlot(EffectChainPointer pChain,
+                                              const QDomElement& effectChainElement);
 };
 
 class PerGroupRack : public EffectRack {
diff --git a/src/effects/effectslot.cpp b/src/effects/effectslot.cpp
index de03ce3b3b..1d97b1e26e 100644
--- a/src/effects/effectslot.cpp
+++ b/src/effects/effectslot.cpp
@@ -4,6 +4,7 @@
 
 #include "control/controlpushbutton.h"
 #include "control/controlproxy.h"
+#include "util/xml.h"
 
 // The maximum number of effect parameters we're going to support.
 const unsigned int kDefaultMaxParameters = 16;
@@ -268,3 +269,68 @@ void EffectSlot::slotEffectMetaParameter(double v, bool force) {
         pParameterSlot->onEffectMetaParameterChanged(v, force);
     }
 }
+
+QDomElement EffectSlot::toXML(QDomDocument* doc) const {
+    QDomElement effectElement = doc->createElement("Effect");
+    EffectManifest manifest = m_pEffect->getManifest();
+    XmlParse::addElement(*doc, effectElement, "Id", manifest.id());
+    XmlParse::addElement(*doc, effectElement, "Version", manifest.version());
+
+    QDomElement parametersElement = doc->createElement("Parameters");
+
+    QDomElement knobParametersElement = doc->createElement("KnobParameters");
+    for (EffectParameterSlotPointer pParameterSlot : m_parameters) {
+        knobParametersElement.appendChild(pParameterSlot->toXML(doc));
+    }
+    parametersElement.appendChild(knobParametersElement);
+
+    QDomElement buttonParametersElement = doc->createElement("ButtonParameters");
+    for (EffectButtonParameterSlotPointer pButtonParameterSlot : m_buttonParameters) {
+        buttonParametersElement.appendChild(pButtonParameterSlot->toXML(doc));
+    }
+    parametersElement.appendChild(buttonParametersElement);
+
+    effectElement.appendChild(parametersElement);
+    return effectElement;
+}
+
+void EffectSlot::loadValuesFromXml(const QDomElement& effectElement) {
+    if (effectElement.text().isEmpty()) {
+        return;
+    }
+
+    QDomElement parametersElement = XmlParse::selectElement(effectElement,
+                                                            "Parameters");
+    if (parametersElement.text().isEmpty()) {
+        return;
+    }
+
+    QDomElement knobParametersElement = XmlParse::selectElement(parametersElement,
+                                                                "KnobParameters");
+    QDomNodeList knobParametersNodeList = knobParametersElement.childNodes();
+    for (int i = 0; i < m_parameters.size(); ++i) {
+        if (m_parameters[i] != nullptr) {
+            QDomNode knobParameterNode = knobParametersNodeList.at(i);
+            if (knobParameterNode.isElement()) {
+                QDomElement knobParameterElement = knobParameterNode.toElement();
+                m_parameters[i]->loadValuesFromXml(knobParameterElement);
+            }
+        }
+    }
+
+    QDomElement buttonParametersElement = XmlParse::selectElement(parametersElement,
+                                                                  "ButtonParameters");
+    QDomNodeList buttonParametersNodeList = buttonParametersElement.childNodes();
+    for (int i = 0; i < m_buttonParameters.size(); ++i) {
+        if (i == m_buttonParameters.size()) {
+            break;
+        }
+        if (m_buttonParameters[i] != nullptr) {
+            QDomNode buttonParameterNode = buttonParametersNodeList.at(i);
+            if (buttonParameterNode.isElement()) {
+                QDomElement buttonParameterElement = buttonParameterNode.toElement();
+                m_buttonParameters[i]->loadValuesFromXml(buttonParameterElement);
+            }
+        }
+    }
+}
diff --git a/src/effects/effectslot.h b/src/effects/effectslot.h
index 04a776fbe3..9cb6cddffb 100644
--- a/src/effects/effectslot.h
+++ b/src/effects/effectslot.h
@@ -51,6 +51,9 @@ class EffectSlot : public QObject {
         return m_group;
     }
 
+    QDomElement toXML(QDomDocument* doc) const;
+    void loadValuesFromXml(const QDomElement& effectElement);
+
   public slots:
     // Request that this EffectSlot load the given Effect
     void loadEffect(EffectPointer pEffect);
diff --git a/src/effects/effectsmanager.cpp b/src/effects/effectsmanager.cpp
index 85781ca2a5..99202061c1 100644
--- a/src/effects/effectsmanager.cpp
+++ b/src/effects/effectsmanager.cpp
@@ -202,12 +202,14 @@ EffectRackPointer EffectsManager::getEffectRack(const QString& group) {
     return m_pEffectChainManager->getEffectRack(group);
 }
 
-void EffectsManager::setupDefaults() {
+void EffectsManager::setup() {
     // Add a general purpose rack
-    QList<EffectChainPointer> savedChains = m_pEffectChainManager->loadEffectChains();
+    QList<std::pair<EffectChainPointer, QDomElement>> savedChains;
+    savedChains = m_pEffectChainManager->loadEffectChains();
+
     StandardEffectRackPointer pStandardRack = addStandardEffectRack();
-    foreach (EffectChainPointer pSavedChain, savedChains) {
-        pStandardRack->addEffectChainSlot(pSavedChain);
+    for (auto chain : savedChains) {
+        pStandardRack->addEffectChainSlot(chain.first, chain.second);
     }
 
     EffectChainPointer pChain = EffectChainPointer(new EffectChain(
diff --git a/src/effects/effectsmanager.h b/src/effects/effectsmanager.h
index 9233025af4..fd1ce022b5 100644
--- a/src/effects/effectsmanager.h
+++ b/src/effects/effectsmanager.h
@@ -71,7 +71,7 @@ class EffectsManager : public QObject {
     EffectPointer instantiateEffect(const QString& effectId);
 
     // Temporary, but for setting up all the default EffectChains and EffectRacks
-    void setupDefaults();
+    void setup();
 
     // Write an EffectsRequest to the EngineEffectsManager. EffectsManager takes
     // ownership of request and deletes it once a response is received.
diff --git a/src/mixxx.cpp b/src/mixxx.cpp
index 54792adf23..ac3a1f6adc 100644
--- a/src/mixxx.cpp
+++ b/src/mixxx.cpp
@@ -184,8 +184,8 @@ void MixxxMainWindow::initialize(QApplication* pApp, const CmdlineArgs& args) {
     NativeBackend* pNativeBackend = new NativeBackend(m_pEffectsManager);
     m_pEffectsManager->addEffectsBackend(pNativeBackend);
 
-    // Sets up the default EffectChains and EffectRacks (long)
-    m_pEffectsManager->setupDefaults();
+    // Sets up the EffectChains and EffectRacks (long)
+    m_pEffectsManager->setup();
 
     launchProgress(8);
 
diff --git a/src/util/xml.cpp b/src/util/xml.cpp
index 32ae840e43..d740286a66 100644
--- a/src/util/xml.cpp
+++ b/src/util/xml.cpp
@@ -13,6 +13,11 @@ float XmlParse::selectNodeFloat(const QDomNode& nodeHeader,
     return selectNode(nodeHeader, sNode).toElement().text().toFloat();
 }
 
+double XmlParse::selectNodeDouble(const QDomNode& nodeHeader,
+                                 const QString& sNode) {
+    return selectNode(nodeHeader, sNode).toElement().text().toDouble();
+}
+
 QDomNode XmlParse::selectNode(const QDomNode& nodeHeader,
                               const QString& sNode) {
     QDomNode node = nodeHeader.firstChild();
diff --git a/src/util/xml.h b/src/util/xml.h
index d9420c3a15..6f5b729323 100644
--- a/src/util/xml.h
+++ b/src/util/xml.h
@@ -30,6 +30,12 @@ class XmlParse {
                                  const QString& sNode);
 
     // Searches for an element named sNode in the children of nodeHeader and
+    // parses the text value of its children as a double. Returns 0.0 if sNode
+    // is not found in nodeHeader's children.
+    static double selectNodeDouble(const QDomNode& nodeHeader,
+                                   const QString& sNode);
+
+    // Searches for an element named sNode in the children of nodeHeader and
     // returns the text value of its children. Returns the empty string if sNode
     // is not found in nodeHeader's children.
     static QString selectNodeQString(const QDomNode& nodeHeader,