Kwidget.h

Go to the documentation of this file.

namespace krotos
{
    class KwidgetProcessor;
    class KwidgetAudioProcessor;
    class KwidgetGUI;
 
    class Kwidget : public ResourceLock
    {
      public:
        struct ParameterInfo
        {
            String id;
            String name;
            NormalisableRange<float> range;
            float defaultValue;
        };
 
        struct Constants
        {
            static const String ChildDelimiter;
            static const String Parent;
            static const String Bounds;
            static const String Renderstyle;
        };
 
        Kwidget(const String& kwidgetType, const String& kwidgetID);
 
        virtual ~Kwidget() = default;
 
        void init();
 
        std::unique_ptr<KwidgetProcessor> createVoice();
 
        std::unique_ptr<KwidgetGUI> createControls();
 
        KwidgetProcessor* getVoice(int idx) const;
 
        int getNumVoices() const;
 
        KwidgetProcessor* getActiveVoice() const { return m_activeVoice; }
 
        virtual void noteOn(int voiceIdx, int midiNote, float velocity);
 
        virtual void noteOff(int voiceIdx, float velocity);
 
        virtual void noteCleared(int voiceIdx);
 
        virtual bool isActive(int voiceIdx);
 
        void addModulator(const String& paramID, Kwidget* modulator, int modulatorIdx, float depth = 0.99f,
                          KAttachment::Polarity = KAttachment::Polarity::Bipolar);
 
        void removeModulator(const String& paramID, Kwidget* modulator, int modulatorIdx);
 
        /* Set the depth of a given modulator with range [-1, 1] */
        void setModulatorDepth(const String& paramID, Kwidget* modulator, int modulatorIdx, float depth);
 
        /* Set the polarity of a given modulator, either Bipolar [-1, 1] or Unipolar [0, 1] */
        void setModulatorPolarity(const String& paramID, Kwidget* modulator, int modulatorIdx,
                                  KAttachment::Polarity polarity);
 
        const std::vector<std::shared_ptr<KParameter>>& getParameters() const;
 
        KParameter* getParameter(const String& parameterID) const noexcept;
 
        std::shared_ptr<KParameter> getParameterToAttach(const String& parameterID) const noexcept;
 
        CustomParameter* getCustomParameter(const String& parameterID);
 
        CustomParameterTree* getCustomParameterTree(const Identifier& type);
 
        template <typename T> T* getCustomParameter(const Identifier& type);
 
        void notifyAllParametersListeners();
 
        const ValueTree& getState();
 
        virtual void setState(const ValueTree& newState, KwidgetAudioProcessor& processor);
 
        void flushState();
 
        bool isModulator() const;
 
        int getNumModulators() const;
 
        const String& getKwidgetType() const;
 
        const String& getKwidgetID() const;
 
        const String& getKwidgetVersionFromCurrentState() const;
 
        /* Get the latest version number of the kwidget
         * By default this will be 1.0, an updated kwidget can use setKwidgetVersion to update this
         * @return string of the two digit kwidget version number e.g. "1.1"
         * @see setKwidgetVersion */
        String getKwidgetVersion() const;
 
        virtual const String& getKwidgetLabel();
 
        StringArray getDragID(const String& parameterID);
 
        /* Index for drag and drop description parameter identifiers*/
        enum DragID_Index
        {
            KwidgetID = 0,
            ParameterID = 1
        };
 
        /* override if the kwidget needs more than one Gui representation*/
        virtual size_t numGUIImplementations() { return 1; }
 
        virtual String getGuiName(int /*i*/) { return "None"; }
 
        virtual void createNestedKwidgets(KwidgetAudioProcessor&) {}
 
        bool isAChildKwidget();
 
        std::vector<Kwidget*>& getChildKwidgets() { return m_childKwidgets; }
 
        static String getParentID(String childKwidgetID);
 
        // KwidgetGUI* getGui() { return m_gui; }
 
        bool isStateChanging() { return m_stateChanging; }
 
        /* Add a child kwidget to the kwidget*/
        void addChildKwidget(Kwidget* child);
 
        /* remove a child kwidget from the Kwidget*/
        void removeChildKwidgetFromTree(String kwidgetID);
 
        /* find the child kwidget with the ID*/
        Kwidget* findChildKwidget(String kiwdgetID);
 
        void addParameterCallback(const String& paramID, std::function<void(float)> callback);
 
        void addVersionedParameterCallback(StringRef kwidgetVersionTheParameterChangedIn, const String& paramID,
                                           std::function<void(float)> callback);
 
        int getTemplateID();
 
      protected:
        virtual std::vector<ParameterInfo> createParameters() = 0;
 
        virtual std::unique_ptr<KwidgetProcessor> createProcessor() = 0;
 
        virtual std::unique_ptr<KwidgetGUI> createGUI() = 0;
 
        /*add the child Guis to the kwidgetGUI */
        void addChildGuis(std::unique_ptr<KwidgetGUI>& parentGui);
 
        CustomParameter* createAndAddCustomParameter(const String& paramID, const var& value);
 
        template <typename T> T* createAndAddCustomParameter(const Identifier& type);
 
        void setKwidgetVersion(const String& kwidgetVersionString);
 
        std::vector<Kwidget*> m_childKwidgets;
 
      private:
        KParameter* createAndAddParameter(const ParameterInfo& info);
 
        const String m_kwidgetType;
        const String m_kwidgetID;
        // kwidget version number from preset data
        String m_kwidgetStateVersion;
 
        ValueTree m_kwidgetTree;
        ValueTree m_paramTree;
        ValueTree m_customParamTree;
        ValueTree m_childTree;
        ValueTree m_customDataTree;
 
        std::vector<std::shared_ptr<KParameter>> m_parameters;
        std::map<String, int> m_parameterIDs;
 
        Array<KwidgetProcessor*> m_processors;
        KwidgetProcessor* m_activeVoice{nullptr};
        std::unique_ptr<KwidgetProcessor> m_initialVoice;
 
        OwnedArray<CustomParameter> m_customParameters;
        std::map<String, int> m_customParameterIDs;
 
        OwnedArray<CustomParameterTree> m_customParameterTrees;
        std::map<Identifier, int> m_customParameterTreeTypes;
 
        OwnedArray<KParameter::AudioListenerObject> m_parameterCallbacks;
 
        bool m_stateChanging{false};
    };
} // namespace krotos