Effect selector widget

build/depends.py

@@ -844,6 +844,7 @@ def sources(self, build):
                    "widget/wstarrating.cpp",
                    "widget/weffectchain.cpp",
                    "widget/weffect.cpp",
+                   "widget/weffectselector.cpp",
                    "widget/weffectparameter.cpp",
                    "widget/weffectbuttonparameter.cpp",
                    "widget/weffectparameterbase.cpp",

src/effects/effectmanifest.h

@@ -48,6 +48,14 @@ class EffectManifest final {
         m_shortName = shortName;
     }
 
+    virtual const QString& displayName() const {
+        if (!m_shortName.isEmpty()) {
+            return m_shortName;
+        } else {
+            return m_name;
+        }
+    }
+
     virtual const QString& author() const {
         return m_author;
     }

src/effects/effectrack.cpp

@@ -133,6 +133,33 @@ void EffectRack::loadPrevChain(const unsigned int iChainSlotNumber,
     m_effectChainSlots[iChainSlotNumber]->loadEffectChain(pPrevChain);
 }
 
+void EffectRack::maybeLoadEffect(const unsigned int iChainSlotNumber,
+                                 const unsigned int iEffectSlotNumber,
+                                 const QString& id) {
+    if (iChainSlotNumber >= static_cast<unsigned int>(m_effectChainSlots.size())) {
+        return;
+    }
+
+    EffectChainSlotPointer pChainSlot = m_effectChainSlots[iChainSlotNumber];
+    if (pChainSlot == nullptr) {
+        return;
+    }
+    EffectSlotPointer pEffectSlot = pChainSlot->getEffectSlot(iEffectSlotNumber);
+
+    bool loadNew = false;
+    if (pEffectSlot == nullptr || pEffectSlot->getEffect() == nullptr) {
+        loadNew = true;
+    } else if (id != pEffectSlot->getEffect()->getManifest().id()) {
+        loadNew = true;
+    }
+
+    if (loadNew) {
+        EffectChainPointer pChain = pChainSlot->getEffectChain();
+        EffectPointer pEffect = m_pEffectsManager->instantiateEffect(id);
+        pChain->replaceEffect(iEffectSlotNumber, pEffect);
+    }
+}
+
 void EffectRack::loadNextEffect(const unsigned int iChainSlotNumber,
                                 const unsigned int iEffectSlotNumber,
                                 EffectPointer pEffect) {

src/effects/effectrack.h

@@ -40,6 +40,10 @@ class EffectRack : public QObject {
     int numEffectChainSlots() const;
     EffectChainSlotPointer getEffectChainSlot(int i);
 
+    void maybeLoadEffect(const unsigned int iChainSlotNumber,
+                         const unsigned int iEffectSlotNumber,
+                         const QString& id);
+
     unsigned int getRackNumber() const {
         return m_iRackNumber;
     }

src/effects/effectsbackend.cpp

@@ -28,7 +28,7 @@ void EffectsBackend::registerEffect(const QString& id,
     m_registeredEffects[id] = QPair<EffectManifest, EffectInstantiatorPointer>(
             manifest, pInstantiator);
     m_effectIds.append(id);
-    emit(effectRegistered());
+    emit(effectRegistered(manifest));
 }
 
 const QList<QString>& EffectsBackend::getEffectIds() const {

src/effects/effectsbackend.h

@@ -32,7 +32,7 @@ class EffectsBackend : public QObject {
             EffectsManager* pEffectsManager, const QString& effectId);
 
   signals:
-    void effectRegistered();
+    void effectRegistered(EffectManifest);
 
   protected:
     void registerEffect(const QString& id,

src/effects/effectslot.h

@@ -30,13 +30,23 @@ class EffectSlot : public QObject {
     // returns a null EffectPointer.
     EffectPointer getEffect() const;
 
+    inline int getEffectSlotNumber() const {
+        return m_iEffectNumber;
+    }
+
     unsigned int numParameterSlots() const;
     EffectParameterSlotPointer addEffectParameterSlot();
     EffectParameterSlotPointer getEffectParameterSlot(unsigned int slotNumber);
+    inline const QList<EffectParameterSlotPointer>& getEffectParameterSlots() const {
+        return m_parameters;
+    };
 
     unsigned int numButtonParameterSlots() const;
     EffectButtonParameterSlotPointer addEffectButtonParameterSlot();
     EffectButtonParameterSlotPointer getEffectButtonParameterSlot(unsigned int slotNumber);
+    inline const QList<EffectButtonParameterSlotPointer>& getEffectButtonParameterSlots() const {
+        return m_buttonParameters;
+    };
 
     double getMetaParameter() const;
 

src/effects/effectsmanager.cpp

@@ -53,13 +53,37 @@ EffectsManager::~EffectsManager() {
     delete m_pEngineEffectsManager;
 }
 
+bool alphabetizeEffectManifests(const EffectManifest& manifest1,
+                                const EffectManifest& manifest2) {
+    return QString::localeAwareCompare(manifest1.displayName(), manifest2.displayName()) < 0;
+}
+
 void EffectsManager::addEffectsBackend(EffectsBackend* pBackend) {
     DEBUG_ASSERT_AND_HANDLE(pBackend) {
         return;
     }
     m_effectsBackends.append(pBackend);
-    connect(pBackend, SIGNAL(effectRegistered()),
-            this, SIGNAL(availableEffectsUpdated()));
+
+    QList<QString> backendEffects = pBackend->getEffectIds();
+    for (const QString& effectId : backendEffects) {
+        m_availableEffectManifests.append(pBackend->getManifest(effectId));
+    }
+
+    qSort(m_availableEffectManifests.begin(), m_availableEffectManifests.end(),
+          alphabetizeEffectManifests);
+
+    connect(pBackend, SIGNAL(effectRegistered(EffectManifest)),
+            this, SLOT(slotBackendRegisteredEffect(EffectManifest)));
+
+    connect(pBackend, SIGNAL(effectRegistered(EffectManifest)),
+            this, SIGNAL(availableEffectsUpdated(EffectManifest)));
+}
+
+void EffectsManager::slotBackendRegisteredEffect(EffectManifest manifest) {
+    auto insertion_point = qLowerBound(m_availableEffectManifests.begin(),
+                                       m_availableEffectManifests.end(),
+                                       manifest, alphabetizeEffectManifests);
+    m_availableEffectManifests.insert(insertion_point, manifest);
 }
 
 void EffectsManager::registerChannel(const ChannelHandleAndGroup& handle_group) {
@@ -70,81 +94,63 @@ const QSet<ChannelHandleAndGroup>& EffectsManager::registeredChannels() const {
     return m_pEffectChainManager->registeredChannels();
 }
 
-const QList<QString> EffectsManager::getAvailableEffects() const {
-    QList<QString> availableEffects;
-
-    foreach (EffectsBackend* pBackend, m_effectsBackends) {
-        const QList<QString>& backendEffects = pBackend->getEffectIds();
-        foreach (QString effectId, backendEffects) {
-            if (availableEffects.contains(effectId)) {
-                qWarning() << "WARNING: Duplicate effect ID" << effectId;
-                continue;
-            }
-            availableEffects.append(effectId);
-        }
+const QList<EffectManifest> EffectsManager::getAvailableEffectManifestsFiltered(
+        EffectManifestFilterFnc filter) const {
+    if (filter == nullptr) {
+        return m_availableEffectManifests;
     }
 
-    return availableEffects;
-}
-
-const QList<QPair<QString, QString> > EffectsManager::getEffectNamesFiltered(
-        EffectManifestFilterFnc filter) const {
-    QList<QPair<QString, QString> > filteredEQEffectNames;
-    QString currentEffectName;
-    foreach (EffectsBackend* pBackend, m_effectsBackends) {
-        QList<QString> backendEffects = pBackend->getEffectIds();
-        foreach (QString effectId, backendEffects) {
-            EffectManifest manifest = pBackend->getManifest(effectId);
-            if (filter && !filter(&manifest)) {
-                continue;
-            }
-            currentEffectName = manifest.name();
-            filteredEQEffectNames.append(qMakePair(effectId, currentEffectName));
+    QList<EffectManifest> list;
+    for (const auto& manifest : m_availableEffectManifests) {
+        if (filter(manifest)) {
+            list.append(manifest);
         }
     }
-
-    return filteredEQEffectNames;
+    return list;
 }
 
 bool EffectsManager::isEQ(const QString& effectId) const {
     return getEffectManifest(effectId).isMixingEQ();
 }
 
 QString EffectsManager::getNextEffectId(const QString& effectId) {
-    const QList<QString> effects = getAvailableEffects();
-
-    if (effects.isEmpty()) {
+    if (m_availableEffectManifests.isEmpty()) {
         return QString();
     }
-
     if (effectId.isNull()) {
-        return effects.first();
+        return m_availableEffectManifests.first().id();
     }
 
-    int index = effects.indexOf(effectId);
-    if (++index >= effects.size()) {
+    int index;
+    for (index = 0; index < m_availableEffectManifests.size(); ++index) {
+        if (effectId == m_availableEffectManifests.at(index).id()) {
+            break;
+        }
+    }
+    if (++index >= m_availableEffectManifests.size()) {
         index = 0;
     }
-    return effects.at(index);
+    return m_availableEffectManifests.at(index).id();
 }
 
 QString EffectsManager::getPrevEffectId(const QString& effectId) {
-    const QList<QString> effects = getAvailableEffects();
-
-    if (effects.isEmpty()) {
+    if (m_availableEffectManifests.isEmpty()) {
         return QString();
     }
-
     if (effectId.isNull()) {
-        return effects.last();
+        return m_availableEffectManifests.last().id();
     }
 
-    int index = effects.indexOf(effectId);
+    int index;
+    for (index = 0; index < m_availableEffectManifests.size(); ++index) {
+        if (effectId == m_availableEffectManifests.at(index).id()) {
+            break;
+        }
+    }
     if (--index < 0) {
-        index = effects.size() - 1;
+        index = m_availableEffectManifests.size() - 1;
     }
-    return effects.at(index);
-
+    return m_availableEffectManifests.at(index).id();
 }
 
 QPair<EffectManifest, EffectsBackend*> EffectsManager::getEffectManifestAndBackend(
@@ -166,6 +172,9 @@ EffectManifest EffectsManager::getEffectManifest(const QString& effectId) const
 }
 
 EffectPointer EffectsManager::instantiateEffect(const QString& effectId) {
+    if (effectId.isEmpty()) {
+        return EffectPointer();
+    }
     foreach (EffectsBackend* pBackend, m_effectsBackends) {
         if (pBackend->canInstantiateEffect(effectId)) {
             return pBackend->instantiateEffect(this, effectId);

src/effects/effectsmanager.h

@@ -27,7 +27,7 @@ class EngineEffectsManager;
 class EffectsManager : public QObject {
     Q_OBJECT
   public:
-    typedef bool (*EffectManifestFilterFnc)(EffectManifest* pManifest);
+    typedef bool (*EffectManifestFilterFnc)(const EffectManifest& pManifest);
 
     EffectsManager(QObject* pParent, UserSettingsPointer pConfig);
     virtual ~EffectsManager();
@@ -61,9 +61,11 @@ class EffectsManager : public QObject {
     QString getNextEffectId(const QString& effectId);
     QString getPrevEffectId(const QString& effectId);
 
-    const QList<QString> getAvailableEffects() const;
-    // Each entry of the set is a pair containing the effect id and its name
-    const QList<QPair<QString, QString> > getEffectNamesFiltered(EffectManifestFilterFnc filter) const;
+    inline const QList<EffectManifest>& getAvailableEffectManifests() const {
+        return m_availableEffectManifests;
+    };
+    const QList<EffectManifest> getAvailableEffectManifestsFiltered(
+        EffectManifestFilterFnc filter) const;
     bool isEQ(const QString& effectId) const;
     QPair<EffectManifest, EffectsBackend*> getEffectManifestAndBackend(
             const QString& effectId) const;
@@ -78,7 +80,10 @@ class EffectsManager : public QObject {
     bool writeRequest(EffectsRequest* request);
 
   signals:
-    void availableEffectsUpdated();
+    void availableEffectsUpdated(EffectManifest);
+
+  private slots:
+    void slotBackendRegisteredEffect(EffectManifest manifest);
 
   private:
     QString debugString() const {
@@ -89,6 +94,7 @@ class EffectsManager : public QObject {
 
     EffectChainManager* m_pEffectChainManager;
     QList<EffectsBackend*> m_effectsBackends;
+    QList<EffectManifest> m_availableEffectManifests;
 
     EngineEffectsManager* m_pEngineEffectsManager;
 

src/preferences/dialog/dlgprefeffects.cpp

@@ -18,27 +18,20 @@ DlgPrefEffects::DlgPrefEffects(QWidget* pParent,
 
 void DlgPrefEffects::slotUpdate() {
     clear();
-    QStringList effectIds = m_pEffectsManager->getAvailableEffects();
+    const QList<EffectManifest> availableEffectManifests = m_pEffectsManager->getAvailableEffectManifests();
 
-    foreach (QString id, effectIds) {
-        addEffectToList(id);
+    for (const auto& manifest : availableEffectManifests) {
+        QListWidgetItem* pItem = new QListWidgetItem();
+        pItem->setData(Qt::UserRole, manifest.id());
+        pItem->setText(manifest.displayName());
+        availableEffectsList->addItem(pItem);
     }
 
-    if (!effectIds.isEmpty()) {
+    if (!availableEffectManifests.isEmpty()) {
         availableEffectsList->setCurrentRow(0);
     }
 }
 
-void DlgPrefEffects::addEffectToList(const QString& effectId) {
-    QPair<EffectManifest, EffectsBackend*> manifestAndBackend =
-            m_pEffectsManager->getEffectManifestAndBackend(effectId);
-
-    QListWidgetItem* pItem = new QListWidgetItem();
-    pItem->setText(manifestAndBackend.first.name());
-    pItem->setData(Qt::UserRole, effectId);
-    availableEffectsList->addItem(pItem);
-}
-
 void DlgPrefEffects::slotApply() {
     // Nothing to apply.
 }

src/preferences/dialog/dlgprefeffects.h

@@ -24,7 +24,6 @@ class DlgPrefEffects : public DlgPreferencePage, public Ui::DlgPrefEffectsDlg {
                             QListWidgetItem* pPrevious);
 
   private:
-    void addEffectToList(const QString& id);
     void clear();
 
     UserSettingsPointer m_pConfig;