Effect Blacklisting

src/effects/effectmanifest.h

@@ -23,8 +23,7 @@
 class EffectManifest final {
   public:
     EffectManifest()
-        : m_isVisible(true),
-          m_isMixingEQ(false),
+        : m_isMixingEQ(false),
           m_isMasterEQ(false),
           m_effectRampsFromDry(false),
           m_metaknobDefault(0.5) {
@@ -59,6 +58,13 @@ class EffectManifest final {
         }
     }
 
+    const QString& backendName() const {
+        return m_backendName;
+    }
+    void setBackendName(const QString& name) {
+        m_backendName = name;
+    }
+
     const QString& author() const {
         return m_author;
     }
@@ -77,14 +83,6 @@ class EffectManifest final {
         return m_description;
     }
 
-    const bool& isVisible() const {
-        return m_isVisible;
-    }
-
-    void setVisibility(const bool value) {
-        m_isVisible = value;
-    }
-
     const bool& isMixingEQ() const {
         return m_isMixingEQ;
     }
@@ -142,10 +140,10 @@ class EffectManifest final {
     QString m_id;
     QString m_name;
     QString m_shortName;
+    QString m_backendName;
     QString m_author;
     QString m_version;
     QString m_description;
-    bool m_isVisible;
     // This helps us at DlgPrefEQ's basic selection of Equalizers
     bool m_isMixingEQ;
     bool m_isMasterEQ;

src/effects/effectsbackend.cpp

@@ -13,6 +13,7 @@ EffectsBackend::EffectsBackend(UserSettingsPointer pConfig,
 
 EffectsBackend::~EffectsBackend() {
     m_registeredEffects.clear();
+    m_visibleEffectIds.clear();
     m_effectIds.clear();
 }
 
@@ -30,9 +31,12 @@ void EffectsBackend::registerEffect(const QString& id,
 
     const bool visible = m_pConfig->getValue<bool>(ConfigKey("[Visible Effects]", 
                                                    pManifest->id()), true);
-    pManifest->setVisibility(visible);
+    pManifest->setBackendName(m_name);
 
     m_registeredEffects[id] = RegisteredEffect(pManifest, pInstantiator);
+    if (visible) {
+        addVisibleEffect(id);
+    }
     m_effectIds.append(id);
     emit(effectRegistered(pManifest));
 }
@@ -49,6 +53,14 @@ EffectManifestPointer EffectsBackend::getManifest(const QString& effectId) const
     return m_registeredEffects[effectId].manifest();
 }
 
+bool EffectsBackend::getVisibility(const QString& effectId) const {
+    return m_visibleEffectIds.contains(effectId);
+}
+
+void EffectsBackend::addVisibleEffect(const QString& effectId) {
+    m_visibleEffectIds.append(effectId);
+}
+
 bool EffectsBackend::canInstantiateEffect(const QString& effectId) const {
     return m_registeredEffects.contains(effectId);
 }

src/effects/effectsbackend.h

@@ -28,6 +28,8 @@ class EffectsBackend : public QObject {
     // returns a list sorted like it should be displayed in the GUI 
     virtual const QList<QString> getEffectIds() const;
     virtual EffectManifestPointer getManifest(const QString& effectId) const;
+    virtual bool getVisibility(const QString& effectId) const;
+    virtual void addVisibleEffect(const QString& effectId);
     virtual bool canInstantiateEffect(const QString& effectId) const;
     virtual EffectPointer instantiateEffect(
             EffectsManager* pEffectsManager, const QString& effectId);
@@ -64,7 +66,6 @@ class EffectsBackend : public QObject {
 
         EffectManifestPointer manifest() const { return m_pManifest; };
         EffectInstantiatorPointer initiator() const { return m_pInitator; };
-
       private:
         EffectManifestPointer m_pManifest;
         EffectInstantiatorPointer m_pInitator;
@@ -73,6 +74,7 @@ class EffectsBackend : public QObject {
     QString m_name;
     QMap<QString, RegisteredEffect> m_registeredEffects;
     QList<QString> m_effectIds;
+    QList<QString> m_visibleEffectIds;
 };
 
 #endif /* EFFECTSBACKEND_H */

src/effects/effectsmanager.cpp

@@ -68,7 +68,11 @@ EffectsManager::~EffectsManager() {
 
 bool alphabetizeEffectManifests(EffectManifestPointer pManifest1,
                                 EffectManifestPointer pManifest2) {
-    return QString::localeAwareCompare(pManifest1->displayName(), pManifest2->displayName()) < 0;
+
+    int dNameComp = QString::localeAwareCompare(pManifest1->displayName(), pManifest2->displayName());
+    int bNameComp = QString::localeAwareCompare(pManifest1->backendName(), pManifest2->backendName());
+    // Add an exception for "Native" backends, to keep the Native effects in the beginning
+    return (bNameComp ? (bNameComp > 0) : (dNameComp < 0));
 }
 
 void EffectsManager::addEffectsBackend(EffectsBackend* pBackend) {
@@ -81,6 +85,9 @@ void EffectsManager::addEffectsBackend(EffectsBackend* pBackend) {
     for (const QString& effectId : backendEffects) {
         const EffectManifestPointer pManifest = pBackend->getManifest(effectId);
         m_availableEffectManifests.append(pManifest);
+        if (pBackend->getVisibility(effectId)) {
+            setEffectVisibility(pManifest, true);
+        }
     }
 
     m_pNumEffectsAvailable->forceSet(m_availableEffectManifests.size());
@@ -96,9 +103,9 @@ void EffectsManager::addEffectsBackend(EffectsBackend* pBackend) {
 }
 
 void EffectsManager::slotBackendRegisteredEffect(EffectManifestPointer pManifest) {
-    auto insertion_point = qLowerBound(m_availableEffectManifests.begin(),
-                                       m_availableEffectManifests.end(),
-                                       pManifest, alphabetizeEffectManifests);
+    auto insertion_point = std::lower_bound(m_availableEffectManifests.begin(),
+                                            m_availableEffectManifests.end(),
+                                            pManifest, alphabetizeEffectManifests);
     m_availableEffectManifests.insert(insertion_point, pManifest);
     m_pNumEffectsAvailable->forceSet(m_availableEffectManifests.size());
 }
@@ -311,6 +318,22 @@ EffectButtonParameterSlotPointer EffectsManager::getEffectButtonParameterSlot(
     return pParameterSlot;
 }
 
+void EffectsManager::setEffectVisibility(EffectManifestPointer pManifest, bool visible) {
+    if (visible && !m_visibleEffectManifests.contains(pManifest)) {
+        auto insertion_point = std::lower_bound(m_visibleEffectManifests.begin(),
+                                                m_visibleEffectManifests.end(),
+                                                pManifest, alphabetizeEffectManifests);
+        m_visibleEffectManifests.insert(insertion_point, pManifest);
+        emit visibleEffectsUpdated();
+    } else if (!visible) {
+        m_visibleEffectManifests.removeOne(pManifest);
+        emit visibleEffectsUpdated();
+    }
+}
+
+bool EffectsManager::getEffectVisibility(EffectManifestPointer pManifest) {
+    return m_visibleEffectManifests.contains(pManifest);
+}
 
 void EffectsManager::setup() {
     // These controls are used inside EQ Effects

src/effects/effectsmanager.h

@@ -8,6 +8,8 @@
 #include <QScopedPointer>
 #include <QPair>
 
+#include <algorithm>
+
 #include "preferences/usersettings.h"
 #include "control/controlpotmeter.h"
 #include "control/controlpushbutton.h"
@@ -79,6 +81,9 @@ class EffectsManager : public QObject {
     inline const QList<EffectManifestPointer>& getAvailableEffectManifests() const {
         return m_availableEffectManifests;
     };
+    inline const QList<EffectManifestPointer>& getVisibleEffectManifests() const {
+        return m_visibleEffectManifests;
+    };
     const QList<EffectManifestPointer> getAvailableEffectManifestsFiltered(
         EffectManifestFilterFnc filter) const;
     bool isEQ(const QString& effectId) const;
@@ -88,6 +93,9 @@ class EffectsManager : public QObject {
     EffectManifestPointer getEffectManifest(const QString& effectId) const;
     EffectPointer instantiateEffect(const QString& effectId);
 
+    void setEffectVisibility(EffectManifestPointer pManifest, bool visibility);
+    bool getEffectVisibility(EffectManifestPointer pManifest); 
+
     // Temporary, but for setting up all the default EffectChains and EffectRacks
     void setup();
 
@@ -101,6 +109,7 @@ class EffectsManager : public QObject {
   signals:
     // TODO() Not connected. Can be used when we implement effect PlugIn loading at runtime
     void availableEffectsUpdated(EffectManifestPointer);
+    void visibleEffectsUpdated();
 
   private slots:
     void slotBackendRegisteredEffect(EffectManifestPointer pManifest);
@@ -118,6 +127,7 @@ class EffectsManager : public QObject {
     EffectChainManager* m_pEffectChainManager;
     QList<EffectsBackend*> m_effectsBackends;
     QList<EffectManifestPointer> m_availableEffectManifests;
+    QList<EffectManifestPointer> m_visibleEffectManifests;
 
     EngineEffectsManager* m_pEngineEffectsManager;
 

src/effects/lv2/lv2backend.cpp

@@ -31,7 +31,10 @@ void LV2Backend::enumeratePlugins() {
 
         const bool visible = m_pConfig->getValue<bool>(ConfigKey("[Visible Effects]", 
                                                        lv2Manifest->getEffectManifest()->id()), false);
-        lv2Manifest->getEffectManifest()->setVisibility(visible);
+        lv2Manifest->getEffectManifest()->setBackendName(this->getName());
+        if (visible) {
+            addVisibleEffect(lv2Manifest->getEffectManifest()->id());
+        }
 
         m_registeredEffects.insert(lv2Manifest->getEffectManifest()->id(),
                                    lv2Manifest);

src/preferences/dialog/dlgprefeffects.cpp

@@ -26,7 +26,7 @@ DlgPrefEffects::DlgPrefEffects(QWidget* pParent,
     // Highlight first row
     availableEffectsList->selectRow(0);
 
-    availableEffectsList->setColumnWidth(0, 50);
+    availableEffectsList->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
 }
 
 DlgPrefEffects::~DlgPrefEffects() {
@@ -44,8 +44,8 @@ void DlgPrefEffects::slotUpdate() {
 
 void DlgPrefEffects::slotApply() {
     for (EffectProfilePtr profile : m_pAvailableEffectsModel->profiles()) {
-        EffectManifest* pManifest = profile->getManifest();
-        pManifest->setVisibility(profile->isVisible());
+        EffectManifestPointer pManifest = profile->getManifest();
+        m_pEffectsManager->setEffectVisibility(pManifest, profile->isVisible());
         m_pConfig->set(ConfigKey("[Visible Effects]", pManifest->id()), ConfigValue(profile->isVisible()));
     }
 }

src/preferences/effectprofile.cpp

@@ -1,34 +1,11 @@
-#include <QEventLoop>
-#include <QFile>
-#include <QFileInfo>
-#include <QTextStream>
-#include <QRegExp>
-#include <QString>
-#include <QStringList>
-
-#ifdef __QTKEYCHAIN__
-#include <qtkeychain/keychain.h>
-using namespace QKeychain;
-#endif
-
-// #include "broadcast/defs_broadcast.h"
-#include "defs_urls.h"
-#include "util/xml.h"
-#include "util/memory.h"
-#include "util/logger.h"
-
 #include "preferences/effectprofile.h"
 
-namespace {
-const mixxx::Logger kLogger("EffectProfile");
-} // anonymous namespace
-
-EffectProfile::EffectProfile(EffectManifest &pManifest,
-                                   QObject* parent)
-    : QObject(parent) {
-
-    m_isVisible = pManifest.isVisible();
-    m_pManifest = &pManifest;
+EffectProfile::EffectProfile(EffectManifestPointer pManifest,
+                             bool visibility,
+                             QObject* parent)
+    : QObject(parent),
+      m_pManifest(pManifest),
+      m_isVisible(visibility) {
 }
 
 QString EffectProfile::getEffectId() const {
@@ -47,6 +24,6 @@ void EffectProfile::setVisibility(bool value) {
     m_isVisible = value;
 }
 
-EffectManifest* EffectProfile::getManifest() const {
+EffectManifestPointer EffectProfile::getManifest() const {
     return m_pManifest;
 }

src/preferences/effectprofile.h

@@ -5,8 +5,9 @@
 #include <QObject>
 #include <QString>
 
-#include "preferences/usersettings.h"
+#include "effects/defs.h"
 #include "effects/effectmanifest.h"
+#include "preferences/usersettings.h"
 
 class EffectProfile;
 typedef QSharedPointer<EffectProfile> EffectProfilePtr;
@@ -16,18 +17,19 @@ class EffectProfile : public QObject {
   Q_OBJECT
 
   public:
-    EffectProfile(EffectManifest &pManifest,
-                                 QObject* parent = NULL);
+    EffectProfile(EffectManifestPointer pManifest,
+                  bool visibility,
+                  QObject* parent = NULL);
 
     QString getEffectId() const;
     QString getDisplayName() const;
     bool isVisible() const;
     void setVisibility(bool value);
-    EffectManifest* getManifest() const;
+    EffectManifestPointer getManifest() const;
 
   private:
+    EffectManifestPointer m_pManifest;
     bool m_isVisible;
-    EffectManifest* m_pManifest;
 };
 
 #endif // EFFECTPROFILE_H

src/preferences/effectsettingsmodel.cpp

@@ -1,7 +1,5 @@
 #include <preferences/effectsettingsmodel.h>
 
-// #include <preferences/effectsettings.h>
-#include "effects/effectmanifest.h"
 
 namespace {
 const int kColumnEnabled = 0;
@@ -24,8 +22,8 @@ void EffectSettingsModel::resetFromEffectManager(EffectsManager* pEffectsManager
     m_profiles.clear();
 
     for(EffectManifestPointer pManifest : pEffectsManager->getAvailableEffectManifests()) {
-        // qDebug() << "Manifest: " << pManifest->id();
-        addProfileToModel(EffectProfilePtr(new EffectProfile(*pManifest)));
+        const bool visibility = pEffectsManager->getEffectVisibility(pManifest);
+        addProfileToModel(EffectProfilePtr(new EffectProfile(pManifest, visibility)));
     }
 }
 
@@ -36,7 +34,7 @@ bool EffectSettingsModel::addProfileToModel(EffectProfilePtr profile) {
     int position = m_profiles.size();
     beginInsertRows(QModelIndex(), position, position);
 
-    m_profiles.insert(profile->getEffectId(), EffectProfilePtr(profile));
+    m_profiles.push_back(EffectProfilePtr(profile));
 
     endInsertRows();
     return true;
@@ -46,12 +44,12 @@ void EffectSettingsModel::deleteProfileFromModel(EffectProfilePtr profile) {
     if(!profile)
         return;
 
-    int position = m_profiles.keys().indexOf(profile->getEffectId());
+    int position = m_profiles.indexOf(profile);
     if(position > -1) {
         beginRemoveRows(QModelIndex(), position, position);
         endRemoveRows();
     }
-    m_profiles.remove(profile->getEffectId());
+    m_profiles.removeAll(profile);
 }
 
 int EffectSettingsModel::rowCount(const QModelIndex& parent) const {
@@ -69,7 +67,7 @@ QVariant EffectSettingsModel::data(const QModelIndex& index, int role) const {
     if (!index.isValid() || rowIndex >= m_profiles.size())
         return QVariant();
 
-    EffectProfilePtr profile = m_profiles.values().at(rowIndex);
+    EffectProfilePtr profile = m_profiles.at(rowIndex);
     if (profile) {
         if (role == Qt::UserRole)
             return profile->getEffectId();
@@ -116,7 +114,7 @@ Qt::ItemFlags EffectSettingsModel::flags(const QModelIndex& index) const {
 
 bool EffectSettingsModel::setData(const QModelIndex& index, const QVariant& value, int role) {
     if(index.isValid()) {
-        EffectProfilePtr profile = m_profiles.values().at(index.row());
+        EffectProfilePtr profile = m_profiles.at(index.row());
         if(profile) {
             if(index.column() == kColumnEnabled && role == Qt::CheckStateRole) {
                 profile->setVisibility(value.toBool());