Added Effect Preset classes

- Added EffectChainPreset class
- Added EffectPreset class
- Added EffectsManager::loadEffectChainPresets

build/depends.py

@@ -745,6 +745,8 @@ def sources(self, build):
 
                    "src/effects/effectparameter.cpp",
 
+                   "src/effects/effectchainpreset.cpp",
+                   "src/effects/effectpreset.cpp",
                    "src/effects/effectchainslot.cpp",
                    "src/effects/specialeffectchainslots.cpp",
                    "src/effects/effectslot.cpp",

src/effects/defs.h

@@ -73,6 +73,12 @@ typedef QSharedPointer<EffectParameterSlotBase> EffectParameterSlotBasePointer;
 class EffectChainSlot;
 typedef QSharedPointer<EffectChainSlot> EffectChainSlotPointer;
 
+class EffectChainPreset;
+typedef QSharedPointer<EffectChainPreset> EffectChainPresetPointer;
+
+class EffectPreset;
+typedef QSharedPointer<EffectPreset> EffectPresetPointer;
+
 class StandardEffectChainSlot;
 typedef QSharedPointer<StandardEffectChainSlot> StandardEffectChainSlotPointer;
 

src/effects/effectchainpreset.cpp

@@ -0,0 +1,38 @@
+#include "effects/effectchainpreset.h"
+
+#include "effects/effectxmlelements.h"
+#include "effects/effectchainslot.h"
+#include "util/xml.h"
+
+EffectChainPreset::EffectChainPreset() {
+}
+
+EffectChainPreset::EffectChainPreset(const QDomElement& element) {
+    if (!element.hasChildNodes()) {
+        return;
+    }
+
+    m_id = XmlParse::selectNodeQString(element, EffectXml::ChainId);
+    m_name = XmlParse::selectNodeQString(element, EffectXml::ChainName);
+    m_description = XmlParse::selectNodeQString(element, EffectXml::ChainDescription);
+
+    QString mixModeStr = XmlParse::selectNodeQString(element, EffectXml::ChainMixMode);
+    m_mixMode = EffectChainSlot::mixModeFromString(mixModeStr);
+
+    m_dSuper = XmlParse::selectNodeDouble(element, EffectXml::ChainSuperParameter);
+
+    QDomElement effectsElement = XmlParse::selectElement(element, EffectXml::EffectsRoot);
+    QDomNodeList effectList = effectsElement.childNodes();
+
+    for (int i = 0; i < effectList.count(); ++i) {
+        QDomNode effectNode = effectList.at(i);
+        if (effectNode.isElement()) {
+            QDomElement effectElement = effectNode.toElement();
+            EffectPresetPointer pPreset(new EffectPreset(effectElement));
+            m_effectPresets.append(pPreset);
+        }
+    }
+}
+
+EffectChainPreset::~EffectChainPreset() {
+}

src/effects/effectchainpreset.h

@@ -0,0 +1,29 @@
+#ifndef EFFECTCHAINPRESET_H
+#define EFFECTCHAINPRESET_H
+
+#include <QDomElement>
+
+#include "effects/defs.h"
+#include "effects/effectpreset.h"
+
+
+class EffectChainPreset {
+  public:
+    EffectChainPreset();
+    EffectChainPreset(const QDomElement& element);
+    ~EffectChainPreset();
+
+    QString name() const {
+        return m_name;
+    }
+
+  private:
+    QString m_id;
+    QString m_name;
+    QString m_description;
+    double m_dSuper;
+    EffectChainMixMode m_mixMode;
+    QList <EffectPresetPointer> m_effectPresets;
+};
+
+#endif /* EFFECTCHAINPRESET_H */

src/effects/effectpreset.cpp

@@ -0,0 +1,32 @@
+#include "effects/effectpreset.h"
+
+#include "effects/effectxmlelements.h"
+#include "util/xml.h"
+
+EffectPreset::EffectPreset() {
+}
+
+EffectPreset::EffectPreset(const QDomElement& element) {
+    if (!element.hasChildNodes()) {
+        return;
+    }
+
+    m_id = XmlParse::selectNodeQString(element, EffectXml::EffectId);
+    m_version = XmlParse::selectNodeQString(element, EffectXml::EffectVersion);
+    m_dMetaParameter = XmlParse::selectNodeDouble(element, EffectXml::EffectMetaParameter);
+
+    QDomElement parametersElement = XmlParse::selectElement(element, EffectXml::ParametersRoot);
+    QDomNodeList parametersList = parametersElement.childNodes();
+
+    for (int i = 0; i < parametersList.count(); ++i) {
+        QDomNode parameterNode = parametersList.at(i);
+        if (parameterNode.isElement()) {
+            QDomElement parameterElement = parameterNode.toElement();
+            // EffectParameterPresetPointer pPreset(new EffectParameterPreset(parameterElement));
+            // m_effectParameterPresets.append(pPreset);
+        }
+    }
+}
+
+EffectPreset::~EffectPreset() {
+}

src/effects/effectpreset.h

@@ -0,0 +1,23 @@
+#ifndef EFFECTPRESET_H
+#define EFFECTPRESET_H
+
+#include <QDomElement>
+
+#include "effects/defs.h"
+
+
+class EffectPreset {
+  public:
+    EffectPreset();
+    EffectPreset(const QDomElement& element);
+    ~EffectPreset();
+
+  private:
+    QString m_id;
+    QString m_version;
+    double m_dMetaParameter;
+
+    // QList <EffectParameterPresetPointer> m_effectParameterPresets;
+};
+
+#endif /* EFFECTPRESET_H */

src/effects/effectsmanager.cpp

@@ -1,11 +1,13 @@
 #include "effects/effectsmanager.h"
 
+#include <QDir>
 #include <QMetaType>
 #include <QtAlgorithms>
 
 #include <algorithm>
 
 #include "engine/effects/engineeffectsmanager.h"
+#include "effects/effectchainpreset.h"
 #include "effects/effectsbackend.h"
 #include "effects/effectslot.h"
 #include "effects/effectxmlelements.h"
@@ -328,7 +330,8 @@ void EffectsManager::addQuickEffectChainSlot(const QString& deckGroupName) {
     m_effectChainSlotsByGroup.insert(pChainSlot->group(), pChainSlot);
 }
 
-EffectChainSlotPointer EffectsManager::getEffectChainSlot(const QString& group) const {
+EffectChainSlotPointer EffectsManager::getEffectChainSlot(
+        const QString& group) const {
     return m_effectChainSlotsByGroup.value(group);
 }
 
@@ -384,17 +387,12 @@ bool EffectsManager::getEffectVisibility(EffectManifestPointer pManifest) {
 }
 
 void EffectsManager::setup() {
+    loadEffectChainPresets();
     // Add postfader effect chain slots
     addStandardEffectChainSlots();
     addOutputEffectChainSlot();
 }
 
-// NOTE(Kshitij) : Use new functions for effect loading using Effect Preset
-// void EffectsManager::loadEffectChains() {
-//     // populate rack and restore state from effects.xml
-//     m_pEffectChainManager->loadEffectChains();
-// }
-
 void EffectsManager::setEffectParameterPosition(EffectManifestPointer pManifest,
         const unsigned int parameterId, const unsigned int position) {
     for (auto& pChainSlot : m_standardEffectChainSlots) {
@@ -498,3 +496,32 @@ void EffectsManager::collectGarbage(const EffectsRequest* pRequest) {
                 pRequest->DisableInputChannelForChain.pChannelHandle);
     }
 }
+
+void EffectsManager::loadEffectChainPresets() {
+    QDir settingsPath(m_pConfig->getSettingsPath());
+    QFile file(settingsPath.absoluteFilePath("effects.xml"));
+    QDomDocument doc;
+
+    if (!file.open(QIODevice::ReadOnly)) {
+        return;
+    } else if (!doc.setContent(&file)) {
+        file.close();
+        return;
+    }
+    file.close();
+
+    QDomElement root = doc.documentElement();
+    QDomElement rackElement = XmlParse::selectElement(root, EffectXml::Rack);
+    QDomElement chainsElement = XmlParse::selectElement(rackElement, EffectXml::ChainsRoot);
+    QDomNodeList chainsList = chainsElement.elementsByTagName(EffectXml::Chain);
+
+    for (int i=0; i<chainsList.count(); ++i) {
+        QDomNode chainNode = chainsList.at(i);
+
+        if (chainNode.isElement()) {
+            QDomElement chainElement = chainNode.toElement();
+            EffectChainPresetPointer pPreset(new EffectChainPreset(chainElement));
+            m_effectChainPresets.insert(pPreset->name(), pPreset);
+        }
+    }
+}

src/effects/effectsmanager.h

@@ -53,7 +53,6 @@ class EffectsManager : public QObject {
 
     // NOTE(Kshitij) : New functions for saving and loading
     // bool saveEffectChains();
-    // void loadEffectChains();
 
     static const int kNumStandardEffectChains = 4;
 
@@ -104,8 +103,7 @@ class EffectsManager : public QObject {
     void addEqualizerEffectChainSlot(const QString& deckGroupName);
     void addQuickEffectChainSlot(const QString& deckGroupName);
 
-    // NOTE(Kshitij) : Use new functions
-    // void loadEffectChains();
+    void loadEffectChainPresets();
 
     // TODO: Remove these methods to reduce coupling between GUI and
     // effects system implementation details.
@@ -187,6 +185,8 @@ class EffectsManager : public QObject {
     QHash<QString, EqualizerEffectChainSlotPointer> m_equalizerEffectChainSlots;
     QHash<QString, QuickEffectChainSlotPointer> m_quickEffectChainSlots;
 
+    QHash<QString, EffectChainPresetPointer> m_effectChainPresets;
+
     DISALLOW_COPY_AND_ASSIGN(EffectsManager);
 };