Kwidget.cpp

Go to the documentation of this file.

namespace krotos
{
    const String Kwidget::Constants::ChildDelimiter = ":";
    const String Kwidget::Constants::Parent = "parent";
    const String Kwidget::Constants::Bounds = "bounds";
    const String Kwidget::Constants::Renderstyle = "renderstyle";
 
    Kwidget::Kwidget(const String& kwidgetType, const String& kwidgetID)
        : m_kwidgetType(kwidgetType), m_kwidgetID(kwidgetID), m_kwidgetTree(XmlType::Tag::kwidget),
          m_paramTree(XmlType::Tag::params), m_customParamTree(XmlType::Tag::customParams),
          m_childTree(XmlType::Tag::kwidgets)
    {
        m_kwidgetTree.setProperty(XmlType::Property::type, kwidgetType, nullptr);
        m_kwidgetTree.setProperty(XmlType::Property::id, kwidgetID, nullptr);
        m_kwidgetTree.setProperty(XmlType::Property::version, "1.0", nullptr);
        m_kwidgetTree.appendChild(m_paramTree, nullptr);
        m_kwidgetTree.appendChild(m_customParamTree, nullptr);
        m_kwidgetTree.appendChild(m_childTree, nullptr);
 
        createAndAddCustomParameter(Kwidget::Constants::Parent, -1);
        createAndAddCustomParameter(Kwidget::Constants::Bounds, -1);
        createAndAddCustomParameter(Kwidget::Constants::Renderstyle, -1);
 
        setAccessible(true);
    }
 
    void Kwidget::init()
    {
        auto paramInfo = createParameters();
        for (auto& p : paramInfo)
            createAndAddParameter(p);
 
        m_initialVoice = createProcessor();
        m_processors.add(m_initialVoice.get());
        m_activeVoice = m_initialVoice.get();
    }
 
    KwidgetProcessor* Kwidget::getVoice(int idx) const
    {
        jassert(isPositiveAndBelow(idx, getNumVoices()));
        return m_processors.getUnchecked(idx);
    }
 
    std::unique_ptr<KwidgetProcessor> Kwidget::createVoice()
    {
        if (m_initialVoice != nullptr)
        {
            return std::move(m_initialVoice);
        }
        else
        {
            auto p = createProcessor();
            m_processors.add(p.get());
            return p;
        }
    }
 
    std::unique_ptr<KwidgetGUI> Kwidget::createControls()
    {
        std::unique_ptr<KwidgetGUI> gui = createGUI();
        addChildGuis(gui);
        return gui;
    }
 
    int Kwidget::getNumVoices() const { return m_processors.size(); }
 
    void Kwidget::noteOn(int voiceIdx, int midiNoteNumber, float velocity)
    {
        auto v = getVoice(voiceIdx);
 
        v->updateAttachments();
        v->noteOn(midiNoteNumber, velocity, voiceIdx);
        m_activeVoice = v;
    }
 
    void Kwidget::noteOff(int voiceIdx, float velocity) { getVoice(voiceIdx)->noteOff(velocity); }
 
    void Kwidget::noteCleared(int voiceIdx) { getVoice(voiceIdx)->noteCleared(); }
 
    bool Kwidget::isActive(int voiceIdx) { return getVoice(voiceIdx)->isActive(); }
 
    void Kwidget::addModulator(const String& paramID, Kwidget* modulator, int modulatorIdx, float depth,
                               KAttachment::Polarity polarity)
    {
        if (modulator->getNumVoices() == getNumVoices())
        {
            for (int i = 0; i < getNumVoices(); i++)
            {
                auto modulatorPtr = modulator->getVoice(i)->getModulator(modulatorIdx);
                getVoice(i)->getAttachment(paramID)->addModulator(modulatorPtr, depth, polarity);
            }
        }
        else if (modulator->getNumVoices() == 1)
        {
            auto modulatorPtr = modulator->getVoice(0)->getModulator(modulatorIdx);
 
            for (auto p : m_processors)
                p->getAttachment(paramID)->addModulator(modulatorPtr, depth, polarity);
        }
        else
        {
            // Modulator Kwidget must have the same number of voices as this Kwidget, or be monophonic.
            jassertfalse;
            return;
        }
    }
 
    void Kwidget::removeModulator(const String& paramID, Kwidget* modulator, int modulatorIdx)
    {
        if (modulator->getNumVoices() == getNumVoices())
        {
            for (int i = 0; i < getNumVoices(); i++)
            {
                auto modulatorPtr = modulator->getVoice(i)->getModulator(modulatorIdx);
                getVoice(i)->getAttachment(paramID)->removeModulator(modulatorPtr);
            }
        }
        else
        {
            auto modulatorPtr = modulator->getVoice(0)->getModulator(modulatorIdx);
 
            for (auto p : m_processors)
                p->getAttachment(paramID)->removeModulator(modulatorPtr);
        }
    }
 
    void Kwidget::setModulatorDepth(const String& paramID, Kwidget* modulator, int modulatorIdx, float depth)
    {
        if (modulator->getNumVoices() == getNumVoices())
        {
            for (int i = 0; i < getNumVoices(); i++)
            {
                auto modulatorPtr = modulator->getVoice(i)->getModulator(modulatorIdx);
                getVoice(i)->getAttachment(paramID)->setModulatorDepth(modulatorPtr, depth);
            }
        }
        else
        {
            auto modulatorPtr = modulator->getVoice(0)->getModulator(modulatorIdx);
 
            for (auto p : m_processors)
                p->getAttachment(paramID)->setModulatorDepth(modulatorPtr, depth);
        }
    }
 
    void Kwidget::setModulatorPolarity(const String& paramID, Kwidget* modulator, int modulatorIdx,
                                       KAttachment::Polarity polarity)
    {
        if (modulator->getNumVoices() == getNumVoices())
        {
            for (int i = 0; i < getNumVoices(); i++)
            {
                auto modulatorPtr = modulator->getVoice(i)->getModulator(modulatorIdx);
                getVoice(i)->getAttachment(paramID)->setModulatorPolarity(modulatorPtr, polarity);
            }
        }
        else
        {
            auto modulatorPtr = modulator->getVoice(0)->getModulator(modulatorIdx);
 
            for (auto p : m_processors)
                p->getAttachment(paramID)->setModulatorPolarity(modulatorPtr, polarity);
        }
    }
 
    const std::vector<std::shared_ptr<KParameter>>& Kwidget::getParameters() const { return m_parameters; }
 
    KParameter* Kwidget::getParameter(const String& parameterID) const noexcept
    {
        if (m_parameterIDs.find(parameterID) == m_parameterIDs.end())
        {
            jassertfalse; // parameter not found
            return nullptr;
        }
        return m_parameters[m_parameterIDs.at(parameterID)].get();
    }
 
    std::shared_ptr<KParameter> Kwidget::getParameterToAttach(const String& parameterID) const noexcept
    {
        if (m_parameterIDs.find(parameterID) == m_parameterIDs.end())
        {
            jassertfalse; // parameter not found
            return nullptr;
        }
        return m_parameters[m_parameterIDs.at(parameterID)];
    }
 
    CustomParameter* Kwidget::getCustomParameter(const String& parameterID)
    {
        if (m_customParameterIDs.count(parameterID) == 1)
        {
            return m_customParameters[m_customParameterIDs.at(parameterID)];
        }
        else
        {
            // Parameter ID not found.
            jassertfalse;
            return nullptr;
        }
    }
 
    CustomParameterTree* Kwidget::getCustomParameterTree(const Identifier& type)
    {
        if (m_customParameterTreeTypes.find(type) != m_customParameterTreeTypes.end())
        {
            return m_customParameterTrees[m_customParameterTreeTypes.at(type)];
        }
        else
        {
            // Parameter Tree not found
            jassertfalse;
            return nullptr;
        }
    }
 
    template <typename T> T* Kwidget::getCustomParameter(const Identifier& type)
    {
        static_assert(std::is_base_of<CustomParameterTree, T>::value, "T must be a subclass of CustomParameterTree");
 
        if (m_customParameterTreeTypes.find(type) != m_customParameterTreeTypes.end())
        {
            auto index = m_customParameterTreeTypes.at(type);
            return static_cast<T*>(m_customParameterTrees.getUnchecked(index));
        }
        else
        {
            // Parameter Tree not found
            jassertfalse;
            return nullptr;
        }
    }
 
    void Kwidget::notifyAllParametersListeners()
    {
        auto& kParams = getParameters();
        for (auto& kParam : kParams) // For very parameter in the kwidget ...
        {
            kParam->notifyListeners(); // ... send out a value changed message
        }
    }
 
    const ValueTree& Kwidget::getState()
    {
        flushState();
        return m_kwidgetTree;
    }
 
    bool Kwidget::isAChildKwidget() { return m_kwidgetID.contains(Kwidget::Constants::ChildDelimiter); }
 
    String Kwidget::getParentID(String childKwidgetID)
    {
        if (childKwidgetID.contains(Kwidget::Constants::ChildDelimiter))
        {
            return childKwidgetID.upToLastOccurrenceOf(Kwidget::Constants::ChildDelimiter,
                                                       /*includeSubstring*/ false,
                                                       /*ignoreCase*/ true);
        }
        return ""; // is not a child kwidget
    };
 
    int Kwidget::getTemplateID()
    {
        return getCustomParameter(Kwidget::Constants::Parent) != nullptr
                       ? (int)getCustomParameter(Kwidget::Constants::Parent)->getValue()
                       : -1;
    }
 
    void Kwidget::setState(const ValueTree& newState, KwidgetAudioProcessor& processor)
    {
        m_stateChanging = true;
        const auto& id = XmlType::Property::id;
        const auto& value = XmlType::Property::value;
 
        auto kwidgetTree = newState.createCopy();
        auto paramTree = kwidgetTree.getChildWithName(XmlType::Tag::params);
        auto customParamTree = kwidgetTree.getChildWithName(XmlType::Tag::customParams);
        auto childParamTree = kwidgetTree.getChildWithName(XmlType::Tag::kwidgets);
 
        m_kwidgetStateVersion =
                kwidgetTree[XmlType::Property::version] ? kwidgetTree[XmlType::Property::version] : "1.0";
 
        for (const auto& param : paramTree)
        {
            auto paramID = param[id].toString();
            auto tree = m_paramTree.getChildWithProperty(id, paramID);
            if (tree.isValid())
            {
                tree.copyPropertiesAndChildrenFrom(param, nullptr);
                getParameter(paramID)->set(tree[value]);
            }
        }
 
        for (const auto& param : customParamTree)
        {
            auto tree = m_customParamTree.getChildWithProperty(id, param[id]);
            if (tree.isValid())
                tree.copyPropertiesAndChildrenFrom(param, nullptr);
        }
 
        for (auto childTree : childParamTree)
        {
            // TODO: investigate what this is here for
            // m_childKwidgets.push_back(processor.addKwidget("", "", "", true, &childTree));
            m_childKwidgets.push_back(processor.addKwidgetFromState(childTree));
 
            m_childTree.addChild(m_childKwidgets.back()->getState(), -1, nullptr);
        }
 
        m_stateChanging = false;
    }
 
    void Kwidget::flushState()
    {
        for (auto param : m_paramTree)
        {
            auto paramID = param[XmlType::Property::id].toString();
            param.setProperty(XmlType::Property::value, getParameter(paramID)->get(), nullptr);
        }
        for (auto child : m_childKwidgets)
        {
            child->flushState();
        }
    }
 
    void Kwidget::addChildKwidget(Kwidget* child)
    {
        for (int i = 0; i < m_childKwidgets.size(); i++)
        {
            if (m_childKwidgets.at(i)->getKwidgetID() == child->getKwidgetID())
            {
                // if the child is already there, remove it
                m_childTree.removeChild(m_childKwidgets.at(i)->getState(), nullptr);
                m_childKwidgets.erase(m_childKwidgets.begin() + i);
 
                // need to break out from here as the structure of the array has just changed.
                break;
            }
        }
 
        m_childKwidgets.push_back(child);
        m_childTree.appendChild(child->getState(), nullptr);
    }
 
    void Kwidget::removeChildKwidgetFromTree(String kwidgetID)
    {
        Kwidget* child = findChildKwidget(kwidgetID);
 
        if (child != nullptr)
        {
            // found the kwidget so we can remove the kwidget from the value tree
            m_childTree.removeChild(child->getState(), nullptr);
        }
    }
 
    bool Kwidget::isModulator() const { return getNumModulators() > 0; }
 
    int Kwidget::getNumModulators() const
    {
        // You must call init() in your child class before calling this function.
        jassert(!m_processors.isEmpty());
 
        return m_processors.getUnchecked(0)->getNumModulators();
    }
 
    const String& Kwidget::getKwidgetType() const { return m_kwidgetType; }
 
    const String& Kwidget::getKwidgetID() const { return m_kwidgetID; }
 
    const String& Kwidget::getKwidgetVersionFromCurrentState() const { return m_kwidgetStateVersion; }
 
    void Kwidget::setKwidgetVersion(const String& kwidgetVersionString)
    {
        m_kwidgetTree.setProperty(XmlType::Property::version, kwidgetVersionString, /*undoMan*/ nullptr);
    }
 
    String Kwidget::getKwidgetVersion() const { return m_kwidgetTree.getProperty(XmlType::Property::version); }
 
    const String& Kwidget::getKwidgetLabel()
    {
        return getKwidgetType();
        /* Deterministic label generation from ID
        String id = m_kwidgetID;
        int separator = id.indexOf(":");
        id = id.substring(separator + 1);
        int index = id.indexOfAnyOf("0123456789");
        int number = std::stoi(id.substring(index).toStdString());
        number+=1;
        id = id.replaceSection(index, id.substring(index).length(), String(number));
        id = id.replaceCharacters("_", " ");
        return id;
        */
    }
 
    StringArray Kwidget::getDragID(const String& parameterID)
    {
        StringArray identifier;
        identifier.insert(DragID_Index::KwidgetID, m_kwidgetID);
        identifier.insert(DragID_Index::ParameterID, parameterID);
        return identifier;
    }
 
    KParameter* Kwidget::createAndAddParameter(const ParameterInfo& info)
    {
        m_parameters.push_back(
                std::make_shared<KParameter>(info.id, m_kwidgetID + " " + info.name, info.range, info.defaultValue));
        auto param = m_parameters.back();
        m_parameterIDs[info.id] = m_parameters.size() - 1;
 
        ValueTree paramTree{XmlType::Tag::param,
                            {{XmlType::Property::id, param->paramID},
                             {XmlType::Property::value, param->get()},
                             {XmlType::Property::linkIndex, -1}}};
 
        m_paramTree.appendChild(paramTree, nullptr);
 
        return param.get();
    }
 
    CustomParameter* Kwidget::createAndAddCustomParameter(const String& paramID, const var& value)
    {
        ValueTree customParamTree{XmlType::Tag::customParam,
                                  {{XmlType::Property::id, paramID}, {XmlType::Property::value, value}}};
 
        m_customParamTree.appendChild(customParamTree, nullptr);
        m_customParameters.add(new CustomParameter(customParamTree, XmlType::Property::value));
 
        auto idx = m_customParameters.size() - 1;
        m_customParameterIDs[paramID] = idx;
 
        return m_customParameters.getUnchecked(idx);
    }
 
    template <typename T> T* Kwidget::createAndAddCustomParameter(const Identifier& type)
    {
        static_assert(std::is_base_of<CustomParameterTree, T>::value, "T must be a subclass of CustomParameterTree");
 
        if (m_customParameterTreeTypes.find(type) != m_customParameterTreeTypes.end())
        {
            // Tree type already used! CustomParameterTrees should have unique types.
            // If you need multiple of the same child, create a CustomParameterTree
            // and add them as children.
            jassertfalse;
            return nullptr;
        }
 
        std::unique_ptr<T> treeToCreate = std::make_unique<T>();
        jassert(type == treeToCreate->getType()); // The type given must be the same as the tree type!
 
        m_customParamTree.appendChild(treeToCreate->getParameterTree(), nullptr);
        m_customParameterTrees.add(std::move(treeToCreate));
 
        auto index = m_customParameterTrees.size() - 1;
        m_customParameterTreeTypes[type] = index;
 
        return static_cast<T*>(m_customParameterTrees.getUnchecked(index));
    }
 
    void Kwidget::addParameterCallback(const String& paramID, std::function<void(float)> callback)
    {
        m_parameterCallbacks.add(
                new KParameter::AudioListenerObject(getParameterToAttach(paramID), std::move(callback)));
    }
 
    void Kwidget::addVersionedParameterCallback(StringRef parameterVersion, const String& paramID,
                                                std::function<void(float)> callback)
    {
        auto versionCheckCallback = [this, callback, parameterVersion](float newValue) {
            if (utils::getVersionAsHexInteger(getKwidgetVersionFromCurrentState()) <
                utils::getVersionAsHexInteger(parameterVersion))
            {
                callback(newValue);
            }
        };
 
        addParameterCallback(paramID, versionCheckCallback);
    }
 
    Kwidget* Kwidget::findChildKwidget(String kwidgetID)
    {
        // search through the child kwidgets looking for the matching ID.
        for (auto k : m_childKwidgets)
        {
            if (k != nullptr)
            {
                if (k->getKwidgetID() == kwidgetID)
                {
                    return k;
                }
            }
        }
 
        // if we have any more that a 2 level hierarchy then we will need to split the kwidget ID into child and parent
        //  IDs so that we can search these children.
 
        return nullptr;
    }
 
    void Kwidget::addChildGuis(std::unique_ptr<KwidgetGUI>& parentGui)
    {
        if (m_childKwidgets.size() > 0)
        {
            for (auto k : m_childKwidgets)
            {
                auto gui = k->createControls();
 
                gui->setComponentID(k->getKwidgetID());
                parentGui->addAndMakeVisible(gui.get());
            }
        }
    }
} // namespace krotos