Add CustomParameter

Author: jd-13

WECore/CoreJUCEPlugin/CoreAudioProcessor.h

@@ -27,6 +27,7 @@
 #include "../JuceLibraryCode/JuceHeader.h"
 #include "General/ParameterDefinition.h"
 #include "ParameterUpdateHandler.h"
+#include "CustomParameter.h"
 
 namespace WECore::JUCEPlugin {
 
@@ -118,7 +119,6 @@ namespace WECore::JUCEPlugin {
                                       float defaultValue);
         /** @} */
 
-        // These methods allow custom setters if needed
         /**
          * Used to register private parameters that are not visible to the host. Used for parameters
          * that cause other parameter or state changes so make automation impractical, but should
@@ -133,7 +133,10 @@ namespace WECore::JUCEPlugin {
          *
          * Int parameters are created with their real (not normalised) ranges.
          *
+         * Custom parameters don't have a range and can only ever be private.
+         *
          * (Bool parameters don't have a meaningful range.)
+         *
          */
         /** @{ */
         inline void registerPrivateParameter(juce::AudioParameterFloat*& param,
@@ -148,6 +151,9 @@ namespace WECore::JUCEPlugin {
                                              const ParameterDefinition::BaseParameter<int>* range,
                                              int defaultValue,
                                              std::function<void(int)> setter);
+
+        template <typename PARAM_TYPE>
+        inline void registerPrivateParameter(PARAM_TYPE*& param, const juce::String& name);
         /** @} */
 
         /**
@@ -169,6 +175,7 @@ namespace WECore::JUCEPlugin {
         // We need to store pointers to all the private parameters that are registered so that they
         // can be deallocated by the destructor
         std::vector<juce::AudioProcessorParameter*> _privateParameters;
+        std::vector<CustomParameter*> _customParameters;
 
         /**
          * Stores a setter and getter for a parameter. Used when persisting parameter values to XML
@@ -180,6 +187,17 @@ namespace WECore::JUCEPlugin {
             std::function<void(float)> setter;
         };
 
+        /**
+         * Stores a setter and getter for a custom parameter. Used when persisting parameter values
+         * to XML and restoring values from XML. Access to the params XML element is provided since
+         * custom parameters typically need to store complex data.
+         */
+        struct CustomParameterInterface {
+            juce::String name;
+            std::function<void(juce::XmlElement*)> writeToXml;
+            std::function<void(juce::XmlElement*)> restoreFromXml;
+        };
+
         /**
          * Listens for parameter changes and triggers the broadcaster so the changes can be handled
          * by another thread.
@@ -200,9 +218,10 @@ namespace WECore::JUCEPlugin {
         ParameterBroadcaster _parameterBroadcaster;
 
         /**
-         * List of parameters in the order they are registered and stored in XML.
+         * List of parameters which will trigger updates and are stored in XML.
          */
         std::vector<ParameterInterface> _paramsList;
+        std::vector<CustomParameterInterface> _customParamsList;
 
         inline std::vector<float> _stringToFloatVector(const juce::String sFloatCSV) const;
 
@@ -224,6 +243,10 @@ namespace WECore::JUCEPlugin {
         for (juce::AudioProcessorParameter* parameter : _privateParameters) {
             delete parameter;
         }
+
+        for (CustomParameter* parameter : _customParameters) {
+            delete parameter;
+        }
     }
 
     void CoreAudioProcessor::setParameterValueInternal(juce::AudioParameterFloat* param, float value) {
@@ -251,6 +274,11 @@ namespace WECore::JUCEPlugin {
             paramsElement->setAttribute(param.name, param.getter());
         }
 
+        for (const CustomParameterInterface& param : _customParamsList) {
+            juce::XmlElement* thisParameterElement = paramsElement->createNewChildElement(param.name);
+            param.writeToXml(thisParameterElement);
+        }
+
         copyXmlToBinary(rootElement, destData);
     }
 
@@ -273,6 +301,14 @@ namespace WECore::JUCEPlugin {
                         param.setter(paramsElement->getDoubleAttribute(param.name));
                     }
                 }
+
+                for (const CustomParameterInterface& param : _customParamsList) {
+                    juce::XmlElement* thisParameterElement = paramsElement->getChildByName(param.name);
+
+                    if (thisParameterElement != nullptr) {
+                        param.restoreFromXml(thisParameterElement);
+                    }
+                }
             }
         }
     }
@@ -371,6 +407,19 @@ namespace WECore::JUCEPlugin {
         _privateParameters.push_back(param);
     }
 
+    template <typename PARAM_TYPE>
+    void CoreAudioProcessor::registerPrivateParameter(PARAM_TYPE*& param, const juce::String& name) {
+        param = new PARAM_TYPE();
+
+        CustomParameterInterface interface = {name,
+                                              [&param](juce::XmlElement* element) { param->writeToXml(element); },
+                                              [&param](juce::XmlElement* element) { param->restoreFromXml(element); }};
+        _customParamsList.push_back(interface);
+
+        param->setListener(&_parameterBroadcaster);
+        _customParameters.push_back(param);
+    }
+
     std::vector<float> CoreAudioProcessor::_stringToFloatVector(const juce::String sFloatCSV) const {
         juce::StringArray tokenizer;
         tokenizer.addTokens(sFloatCSV, ",","");

WECore/CoreJUCEPlugin/CustomParameter.h

@@ -0,0 +1,76 @@
+/*
+ *	File:		CustomParameter.h
+ *
+ *	Version:	1.0.0
+ *
+ *	Created:	18/08/2021
+ *
+ *	This file is part of WECore.
+ *
+ *  WECore is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  WECore is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with WECore.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+
+#include "../JuceLibraryCode/JuceHeader.h"
+
+/**
+ * Used to store state that shouldn't be exposed to the host, but would benefit from using the
+ * save/restore and update mechanism used by conventional parameters.
+ *
+ * Derive from this class and add your own setter/getter methods as needed, just call
+ * _updateListener() to trigger an update.
+ *
+ * Provide an implementation for restoreFromXml and writeToXml to enable saving and restoring
+ * parameter state.
+ */
+class CustomParameter {
+public:
+    inline CustomParameter();
+    virtual ~CustomParameter() = default;
+
+    inline void setListener(juce::AudioProcessorParameter::Listener* listener);
+    inline void removeListener();
+
+    virtual void restoreFromXml(juce::XmlElement* element) = 0;
+    virtual void writeToXml(juce::XmlElement* element) = 0;
+
+protected:
+    inline void _updateListener();
+
+private:
+    std::mutex _listenerMutex;
+    juce::AudioProcessorParameter::Listener* _listener;
+};
+
+CustomParameter::CustomParameter() : _listener(nullptr) {
+}
+
+void CustomParameter::setListener(juce::AudioProcessorParameter::Listener* listener) {
+    std::scoped_lock lock(_listenerMutex);
+    _listener = listener;
+}
+
+void CustomParameter::removeListener() {
+    std::scoped_lock lock(_listenerMutex);
+    _listener = nullptr;
+}
+
+void CustomParameter::_updateListener() {
+    std::scoped_lock lock(_listenerMutex);
+    if (_listener != nullptr) {
+        _listener->parameterValueChanged(0, 0);
+    }
+}