ParameterManager.cpp

Go to the documentation of this file.

namespace krotos
{
    const float ParameterManager::DefaultModDepth = 0.2f;
    const float ParameterManager::OnOffThreshold = 0.5f;
 
    ParameterManager::ParameterManager(AudioProcessor& processor, int numParams, const String& namePrefix)
        : m_processor(processor), m_vts(processor, &m_undoManager), m_parentTree(XmlType::Tag::plugin),
          m_processorTree(XmlType::Tag::params), m_kwidgetTree(XmlType::Tag::kwidgets),
          m_connectionTree(XmlType::Tag::connections), m_modulationTree(XmlType::Tag::modulations),
          m_customDataTree(XmlType::Tag::customData), m_numGenericParameters(numParams),
          m_parameterNamePrefix(namePrefix)
    {
        // The number of digits of the max number of parameters, ex.  512 -> numZeros=3   80 -> numZeros=2   etc.
        // for making the parameter names look nice in the loop.
        m_numDigitsInGenericParamName =
                static_cast<int>(std::floor(std::log10(static_cast<double>(m_numGenericParameters - 1)))) + 1;
 
        m_parentTree.appendChild(m_kwidgetTree, nullptr);
        m_parentTree.appendChild(m_connectionTree, nullptr);
        m_parentTree.appendChild(m_processorTree, nullptr);
        m_parentTree.appendChild(m_modulationTree, nullptr);
 
        // custom data tree test
        m_parentTree.appendChild(m_customDataTree, nullptr);
 
        addGenericParameters();
 
        // When using the 2-parameter constructor for AudioProcessorValueTreeState, you have to add
        // all the parameters and then assign it a valid ValueTree (i.e. one with a name)
        m_vts.state = m_processorTree;
 
        resetUndoManager();
    }
 
    Kwidget* ParameterManager::getKwidget(const String& kwidgetID)
    {
        Kwidget* kwidget = nullptr;
        try
        {
            kwidget = m_activeKwidgets.at(kwidgetID);
        }
        catch (std::out_of_range& e)
        {
            DBG("Error: getKwidget failed to find kwidget with given ID: " << kwidgetID << "\n" << e.what());
            ignoreUnused(e);
        }
 
        return kwidget;
    }
 
    bool ParameterManager::addKwidget(Kwidget* kwidget, bool useEndParams, bool isChildKwidget)
    {
        auto kwidgetID = kwidget->getKwidgetID();
        // do not allow duplicate kwidgetIDs
        if (m_activeKwidgets[kwidgetID] != nullptr)
        {
            // Duplicate kwidgetID
            jassertfalse;
            return false;
        }
 
        auto kwidgetTree = createKwidgetTree(kwidget, useEndParams);
 
        if (!kwidgetTree.isValid())
        {
            jassertfalse;
            return false;
        }
 
        // Append the kwidget tree to the kwidgets tree
        if (!isChildKwidget)
            m_kwidgetTree.appendChild(kwidgetTree, nullptr);
 
        m_kwidgetData[kwidget] = kwidgetTree;
        m_activeKwidgets[kwidget->getKwidgetID()] = kwidget;
 
        attachParameters(kwidget, kwidgetTree);
 
        return true;
    }
 
    void ParameterManager::removeKwidget(const String& kwidgetID)
    {
        removeModulationInvolving(kwidgetID);
        removeConnectionsInvolving(kwidgetID);
 
        auto k = getKwidget(kwidgetID);
 
        k->setAccessible(false);
 
        detachParameters(k, m_kwidgetData[k]);
        m_kwidgetTree.removeChild(m_kwidgetData[k], nullptr);
        m_kwidgetData.erase(k);
        m_activeKwidgets.erase(kwidgetID);
    }
 
    void ParameterManager::clearKwidgets()
    {
        StringArray kwidgetsToRemove;
        for (const auto& kwidget : m_activeKwidgets)
            kwidgetsToRemove.add(kwidget.first);
 
        for (const auto& kwidget : kwidgetsToRemove)
            removeKwidget(kwidget);
    }
 
    void ParameterManager::addConnection(const String& sourceID, const String& destinationID)
    {
        ValueTree newConnection{
                XmlType::Tag::connection,
                {{XmlType::Property::source, sourceID}, {XmlType::Property::destination, destinationID}}};
 
        m_connectionTree.appendChild(newConnection, getUndoManager());
    }
 
    void ParameterManager::removeConnection(const String& sourceID, const String& destID)
    {
        for (const auto& connection : m_connectionTree)
        {
            if (connection[XmlType::Property::source] == sourceID &&
                connection[XmlType::Property::destination] == destID)
            {
                m_connectionTree.removeChild(connection, getUndoManager());
                return;
            }
        }
 
        // If you reach this point, that means you tried to remove a connection that didn't exist.
        jassertfalse;
    }
 
    void ParameterManager::removeConnectionsInvolving(const String& kwidgetID)
    {
        std::vector<ValueTree> connectionsToRemove;
 
        for (const auto& c : m_connectionTree)
            if (c[XmlType::Property::source] == kwidgetID || c[XmlType::Property::destination] == kwidgetID)
                connectionsToRemove.push_back(c);
 
        for (const auto& c : connectionsToRemove)
            m_connectionTree.removeChild(c, getUndoManager());
    }
 
    void ParameterManager::clearConnections() { m_connectionTree.removeAllChildren(getUndoManager()); }
 
    bool ParameterManager::connectionExists(const String& sourceID, const String& destID)
    {
        for (const auto& connection : m_connectionTree)
        {
            if (connection[XmlType::Property::source] == sourceID &&
                connection[XmlType::Property::destination] == destID)
            {
                return true;
            }
        }
        return false;
    }
 
    ValueTree ParameterManager::addModulation(const String& src, int modulatorIdx, const String& dest,
                                              const String& paramID, float depth, KAttachment::Polarity polarity)
    {
        ValueTree vt{Tag::modulation,
                     {{Property::source, src},
                      {Property::modulatorIndex, modulatorIdx},
                      {Property::destination, dest},
                      {Property::param, paramID},
                      {Property::depth, depth},
                      {Property::polarity, polarity}}};
 
        for (int i = 0; i < m_modulationTree.getNumChildren(); i++)
        {
            auto child = m_modulationTree.getChild(i);
            auto destination = child.getPropertyPointer(Property::destination)->toString();
            auto param = child.getPropertyPointer(Property::param)->toString();
            auto source = child.getPropertyPointer(Property::source)->toString();
 
            if (destination == dest && param == paramID)
            {
                // the new kwidget and parameter are the same ones that already exist in the tree.
                if (source == src)
                {
                    // the modulation that you are trying to create already exists
                    // we don't need to add this modulation
                    return child;
                }
            }
        }
 
        m_modulationTree.appendChild(vt, getUndoManager());
 
        return vt;
    }
 
    void ParameterManager::removeModulation(const String& src, int modulatorIdx, const String& dest,
                                            const String& paramID)
    {
        m_modulationTree.removeChild(getModulationTree(src, modulatorIdx, dest, paramID), getUndoManager());
    }
 
    void ParameterManager::removeModulation(ValueTree modulationChildTree)
    {
        if (modulationChildTree.isAChildOf(m_modulationTree))
            m_modulationTree.removeChild(modulationChildTree, getUndoManager());
        else
            // Tree is not a child of the modulation tree. Has it been deleted already?
            jassertfalse;
    }
 
    void ParameterManager::setModulationDepth(const String& src, int modulatorIdx, const String& dest,
                                              const String& paramID, float depth)
    {
        getModulationTree(src, modulatorIdx, dest, paramID).setProperty(Property::depth, depth, getUndoManager());
    }
 
    void ParameterManager::setModulationPolarity(const String& src, int modulatorIdx, const String& dest,
                                                 const String& paramID, KAttachment::Polarity polarity)
    {
        getModulationTree(src, modulatorIdx, dest, paramID).setProperty(Property::polarity, polarity, getUndoManager());
    }
 
    void ParameterManager::removeModulationInvolving(const String& kwidgetID)
    {
        std::vector<ValueTree> modulationToRemove;
 
        for (const auto& m : m_modulationTree)
            if (m[Property::source] == kwidgetID || m[Property::destination] == kwidgetID)
                modulationToRemove.push_back(m);
 
        for (const auto& m : modulationToRemove)
            m_modulationTree.removeChild(m, getUndoManager());
    }
 
    void ParameterManager::clearModulation() { m_modulationTree.removeAllChildren(getUndoManager()); }
 
    void ParameterManager::clearModulationExcept(const String& allowedSource)
    {
        Array<ValueTree> nodesToRemove;
 
        for (auto child : m_modulationTree)
        {
            // Check if the source attribute contains the allowed source
            if (!child[Property::source].toString().contains(allowedSource))
            {
                // Add the modulation node to the array for removal
                nodesToRemove.add(child);
            }
        }
 
        // Remove the nodes after the read iteration
        for (auto& node : nodesToRemove)
        {
            m_modulationTree.removeChild(node, getUndoManager());
        }
    }
 
    ValueTree& ParameterManager::getState() { return m_parentTree; }
 
    const ValueTree& ParameterManager::getModulationTree() { return m_modulationTree; };
 
    const ValueTree& ParameterManager::getKwidgetsTree() { return m_kwidgetTree; };
 
    const StringArray ParameterManager::StaticConnectionDestinations = {"Master", "AudioOut1", "AudioOut2", "AudioOut3",
                                                                        "AudioOut4"};
 
    void ParameterManager::setCurrentState(const ValueTree& newState)
    {
        // Update AudioProcessorValueTreeState params
        m_parentTree.removeChild(m_processorTree, nullptr);
        m_processorTree = newState.getChildWithName(Tag::params).createCopy();
        m_parentTree.appendChild(m_processorTree, nullptr);
        m_vts.replaceState(m_processorTree);
 
        // Add connections - changes to the m_connectionTree will cause callbacks which add/remove connections as
        // necessary
        auto newConnectionTree = newState.getChildWithName(Tag::connections);
        addNonStaticConnections(newConnectionTree);
 
        // Add modulation
        auto newModulationTree = newState.getChildWithName(Tag::modulations);
        copyModulationTree(newModulationTree);
 
        resetUndoManager();
    }
 
    void ParameterManager::addNonStaticConnections(juce::ValueTree& newConnectionTree)
    {
        // Remove all connections to audio out destinations
        // Loop though children from last to first so removing a child won't kill indexing
        for (int i = newConnectionTree.getNumChildren() - 1; i >= 0; i--)
        {
            auto child = newConnectionTree.getChild(i);
            auto destination = child.getPropertyPointer(Property::destination)->toString();
            // Add any non-static connections to the m_connectionTree
            if (!isAStaticConnectionDestination(destination))
            {
                newConnectionTree.removeChild(
                        child, nullptr); // You must remove the child from the parent before adding it elsewhere
                m_connectionTree.addChild(child, -1, nullptr);
            }
        }
    }
 
    AudioProcessor& ParameterManager::getProcessor() { return m_processor; }
 
    AudioProcessorValueTreeState& ParameterManager::getProcessorState() { return m_vts; }
 
    UndoManager* ParameterManager::getUndoManager() { return &m_undoManager; }
 
    void ParameterManager::resetUndoManager()
    {
        struct InitialStateAction : public UndoableAction
        {
            bool perform() override { return true; }
            bool undo() override { return true; }
        };
 
        m_undoManager.clearUndoHistory();
        m_undoManager.beginNewTransaction("Initial State");
        m_undoManager.perform(new InitialStateAction());
    }
 
    void ParameterManager::debugState() const { DBG(m_parentTree.toXmlString()); }
 
    void ParameterManager::addCustomDataNode(const ValueTree& customDataNode)
    {
        m_customDataTree.appendChild(customDataNode, getUndoManager());
    }
 
    ValueTree& ParameterManager::getCustomDataTree() { return m_customDataTree; }
 
    void ParameterManager::addGenericParameters()
    {
        for (int i = 0; i < m_numGenericParameters; i++)
        {
            // For 512 total params, parameterID looks like -> '#000' '#025' '#495' etc.
            auto name = m_parameterNamePrefix + String(i).paddedLeft('0', m_numDigitsInGenericParamName);
 
            std::unique_ptr<GenericParameter> p{new GenericParameter(name, name, i)};
            m_genericParameters.push_back(p.get()); // Save a pointer to the GenericParameter
            m_vts.createAndAddParameter(
                    std::move(p)); // Give ownership of the parameter to AudioProcessorValueTreeState
        }
    }
 
    std::vector<int> ParameterManager::findGenericParameters(int numParametersToLink, bool useEndParams)
    {
        // find a consecutive group of free GenericParameters to link the KParameters to
        int startIdx = -1;
        int freeCount = 0;
        bool success = false;
 
        if (useEndParams == false)
        {
            for (int i = 0; i < m_numGenericParameters; i++)
            {
                bool attached = m_genericParameters[static_cast<size_t>(i)]->isLinked();
 
                if (freeCount == 0)
                {
                    if (!attached)
                    {
                        startIdx = i;
                        freeCount++;
                    }
                }
                else if (freeCount > 0 && freeCount < numParametersToLink)
                {
                    if (!attached)
                        freeCount++;
                    else
                        freeCount = 0;
                }
                else if (freeCount == numParametersToLink)
                {
                    success = true;
                    break;
                }
            }
        }
        else
        {
            // for child kwidgets assign from the end of the generic parameters
            for (int i = m_numGenericParameters - 1; i >= 0; i--)
            {
                bool attached = m_genericParameters[static_cast<size_t>(i)]->isLinked();
 
                if (freeCount == 0)
                {
                    if (!attached)
                    {
                        freeCount++;
                    }
                }
                else if (freeCount > 0 && freeCount < numParametersToLink)
                {
                    if (!attached)
                        freeCount++;
                    else
                        freeCount = 0;
                }
                else if (freeCount == numParametersToLink)
                {
                    startIdx = i + 1;
                    success = true;
                    break;
                }
            }
        }
 
        if (success)
        {
            std::vector<int> paramLocs;
            for (int i = 0; i < numParametersToLink; i++)
            {
                paramLocs.push_back(i + startIdx);
            }
            return paramLocs;
        }
 
        return {};
    }
 
    ValueTree ParameterManager::createKwidgetTree(Kwidget* k, bool useEndParams)
    {
        ValueTree kwidgetTree(k->getState());
        auto paramTree = kwidgetTree.getChildWithName(Tag::params);
 
        // No parameter attachment necessary if the Kwidget has no parameters.
        auto numParams = paramTree.getNumChildren();
        if (numParams == 0)
            return kwidgetTree;
 
        // If a Kwidget is added from a saved state, it will link to the same parameters
        // that it was previously linked to.
        bool needsAttachment = static_cast<int>(paramTree.getChild(0)[Property::linkIndex]) == -1;
        if (!needsAttachment)
            return kwidgetTree;
 
        // If there are no available parameters to link to, this will return an invalid ValueTree.
        auto genericParameterLocs = findGenericParameters(numParams, useEndParams);
        if (genericParameterLocs.empty())
            return {};
 
        // Set the linkIndex property for each parameter using the indices obtained in the previous step.
        auto it = genericParameterLocs.begin();
        for (auto param : paramTree)
            param.setProperty(Property::linkIndex, *it++, nullptr);
 
        return kwidgetTree;
    }
 
    String ParameterManager::generateKwidgetID(const String& kwidgetType, const String& idModifier, int typeLimit)
    {
        jassert(kwidgetType != "");
        jassert(typeLimit >= 0);
 
        auto kwidgetCount = std::distance(m_activeKwidgets.begin(), m_activeKwidgets.end()) + 1;
 
        // Todo: maxSuffixes appears to be redundant / unused. Leaving in to retain limiter on type count.
        if (typeLimit <= 0)
        {
            typeLimit = kwidgetCount;
        }
 
        for (int candidateSuffix = 0; candidateSuffix < typeLimit; candidateSuffix++)
        {
            String candidateID = idModifier + kwidgetType + String(candidateSuffix);
            // Only consider the candidate if it isn't already assigned to a kwidget
            // We loop round incrementing the suffix until we find a vacant ID
            if (m_activeKwidgets[candidateID] == nullptr) // == nullptr if not in the map
            {
                // Success, this candidateID is not in use by any kwidget in the system,
                // we return it for use by the caller
                return candidateID;
            }
            // Otherwise we loop round and generate a new candidate
        }
        DBG("ParameterManager::generateKwidgetID: Failed to generate a kwidgetID based on input parameters");
        return ""; // Returning empty string denotes that the operation was not successful
    }
 
    bool ParameterManager::registerKwidget(juce::ValueTree& kwidget, StringArray& kwidgetIDArray,
                                           bool /*repairEnabled*/)
    {
        bool isValid = true;
        String errorMessage = "";
 
        auto kwidgetID = kwidget[XmlType::Property::id].toString();
 
        if (kwidgetIDArray.contains(kwidgetID, true)) // See if it already registered
        {
            isValid = false; // Return false as currently we are not attempting to rectify duplicate IDs, only flag them
            errorMessage += "Duplicate KwidgetID found: " + kwidgetID + ", not automatically repaired";
        }
        else
        {
            kwidgetIDArray.add(kwidgetID);
        }
 
        if (errorMessage != "")
        {
            DBG(errorMessage);
        }
 
        return isValid;
    }
 
    bool ParameterManager::initialiseKwidgetIDUsageTable(const ValueTree& state, bool repairEnabled)
    {
        StringArray kwidgetIDArray;
        bool isValid = true;
        // Set the entire vector to unallocated
        kwidgetIDArray.clear();
 
        auto kwidgetTree = state.getChildWithName(XmlType::Tag::kwidgets);
        // DBG(kwidgetTree.toXmlString());
        for (auto kwidget : kwidgetTree) // For every kwidget
        {
            isValid &= registerKwidget(kwidget, kwidgetIDArray, repairEnabled);
            // Dealing with child Kwidgets - not recursive - we have no plans for infinitely nested Kwidgets
            auto childKwidgetTree = kwidget.getChildWithName(XmlType::Tag::kwidgets);
            for (auto ckwidget : childKwidgetTree) // For every child kwidget
            {
                isValid &= registerKwidget(ckwidget, kwidgetIDArray, repairEnabled);
            }
        }
        return isValid;
    }
 
    bool ParameterManager::flagUsedIndexes(juce::ValueTree& kwidget, bool repairEnabled)
    {
        bool isValid = true;
        auto paramTree = kwidget.getChildWithName(Tag::params); // Get the tree of parameters
        String errorMessage = "";
        for (auto param : paramTree) // Loop though each parameter
        {
            // For every link index in every Kwidget, keep a note of which indexes are used
            auto idx = static_cast<int>(param[Property::linkIndex]); // Fetch its link index
            if (idx >= 0 && idx < m_numGenericParameters)            // Check within valid range
            {
                if (m_linkIndexAllocation[idx] == true) // If it is already true, we have found a duplicate index
                {
                    isValid = repairEnabled; // This will never become invalid if repair is enabled
                    errorMessage += "Duplicate link index found: " + param[Property::id].toString() +
                                    ", linkIndex = " + String(idx);
 
                    if (repairEnabled)
                    {
                        param.setProperty(Property::linkIndex, "-1",
                                          nullptr); // Start the repair process by flagging as unallocated
                        errorMessage += " : Set to -1, will be repaired by the Parameter check";
                    }
                    errorMessage += "\n";
                }
                else
                {
                    m_linkIndexAllocation[idx] = true; // Flag the index as used
                }
            }
        }
 
        if (errorMessage != "")
        {
            DBG(errorMessage);
        }
 
        return isValid;
    }
 
    bool ParameterManager::initialiseLinkIndexUsageTable(const ValueTree& state, bool repairEnabled)
    {
        bool isValid = true;
        // Set the entire vector to unallocated
        m_linkIndexAllocation.clear();
        for (int i = 0; i < m_numGenericParameters; i++)
        {
            m_linkIndexAllocation.push_back(false);
        }
 
        auto kwidgetTree = state.getChildWithName(XmlType::Tag::kwidgets);
        // DBG(kwidgetTree.toXmlString());
        for (auto kwidget : kwidgetTree) // For every kwidget
        {
            isValid &= flagUsedIndexes(kwidget, repairEnabled);
            // Dealing with child Kwidgets - not recursive - we have no plans for infinitely nested Kwidgets
            auto childKwidgetTree = kwidget.getChildWithName(XmlType::Tag::kwidgets);
            for (auto ckwidget : childKwidgetTree) // For every child kwidget
            {
                isValid &= flagUsedIndexes(ckwidget, repairEnabled);
            }
        }
        return isValid;
    }
 
    int ParameterManager::getUnusedLinkIndex()
    {
        for (int idx = 0; idx < m_numGenericParameters; idx++)
        {
            if (m_linkIndexAllocation[idx] == false)
            {
                m_linkIndexAllocation[idx] = true; // Flag that it is now used
                return idx;
            }
        }
        jassertfalse; // No free indices left
        return -1;    // TODO: deal with no free indexes left situation
    }
 
    void ParameterManager::setGenericParameterValue(ValueTree& paramTreeGeneric, int index, var newValue)
    {
        auto genericParamID =
                m_parameterNamePrefix + String(index).paddedLeft('0', m_numDigitsInGenericParamName); // Create the ID
        auto genericParam =
                paramTreeGeneric.getChildWithProperty(Property::id, genericParamID); // Retreive the generic param
        genericParam.setProperty(Property::value, newValue, nullptr);
    }
 
    bool ParameterManager::validateKwidgetState(ValueTree& kwidgetTree, ValueTree& paramTreeGeneric,
                                                bool repairEnabled = false)
    {
        String errorMessage = "";
        int errorCount = 0;
        bool isValid = true;
 
        String kwidgetType = kwidgetTree[XmlType::Property::type].toString();
        auto kwidgetID = kwidgetTree[XmlType::Property::id].toString();
        auto kwidget = KwidgetFactory::createKwidget(kwidgetType, kwidgetID);
 
        // Check that the Kwidget was created
        if (kwidget != nullptr)
        {
            auto paramTree = kwidgetTree.getChildWithName(Tag::params); // Get the incoming tree of parameters
            for (auto param : paramTree)                                // Loop though each parameter
            {
                auto idx = static_cast<int>(param[Property::linkIndex]); // Fetch its link index
                auto paramID = param[Property::id].toString();           // Fetch its ID
 
                // Check link index to see whether it is within valid range
                if (idx < 0 || idx >= m_numGenericParameters)
                {
                    errorMessage +=
                            String(++errorCount) + ") Index out of range: " + paramID + ", linkIndex = " + String(idx);
                    if (repairEnabled)
                    {
                        int newIndex = getUnusedLinkIndex();
                        param.setProperty(Property::linkIndex, newIndex,
                                          nullptr); // Repair state by setting linkIndex to an unused index
                        auto existingValue = param.getProperty(
                                Property::value); // We will use this to update the newly assigned generic parameter
                        // DBG(existingValue.toString());
                        //  Copy the original value of the parameter into the value of the newly linked generic
                        //  parameter We don't care if the existingValue is out of range, this will be checked for as
                        //  usual further down
                        setGenericParameterValue(paramTreeGeneric, newIndex, existingValue);
 
                        errorMessage += " : Repaired with linkIndex = " + String(newIndex) +
                                        " set to original value (= " + existingValue.toString() + ")";
                    }
                    isValid = repairEnabled;
                    errorMessage += "\n";
                }
 
                // Check that the parameter is recognised ( ID exists within the Kwidget prototype )
                auto p = kwidget->getParameter(paramID);
                if (p == nullptr)
                {
                    errorMessage += String(++errorCount) + ") Parameter not recognised: " + paramID +
                                    ", linkIndex = " + String(idx);
                    /* Temporarily disabled this repair as deleting node here upsets the node iterator and skips
                     * processing the next node leaving unrecognised param in is benign anyway, it will simply be
                     * ignored, cannot exist in kwidget state as param not declared TODO: for completeness remove the
                     * child, and nudge the iterator back 1 somehow*/
                    if (repairEnabled)
                    {
                        // paramTree.removeChild(param, nullptr);  // Repair state by removing unwanted parameter
                        errorMessage += " : Not repaired but benign - see comment in code";
                    }
                    isValid = repairEnabled;
                    errorMessage += "\n";
                }
            }
 
            auto& kwidgetParams = kwidget->getParameters();
            for (auto param : kwidgetParams) // Loop though each parameter in the kwidget - this is the defintition of
                                             // the params we actually need
            {
                auto id = param->getParameterID();     // This is the name of the parameter
                auto defaultValue = param->getValue(); // and the value it defaulted to when it was created
                auto paramChild = paramTree.getChildWithProperty(
                        Property::id, id); // Try to fetch a parameter with the same name from state
                if (paramChild.isValid())  // If it is valid, we know the parameter exists in state - hooray!
                {
                    auto value = paramChild.getProperty(Property::value);
                    auto range = param->getNormalisableRange();
                    if (float(value) < range.start || float(value) > range.end)
                    {
                        errorMessage += String(++errorCount) + ") Parameter value out of range: " + id +
                                        ", range = " + String(range.start) + " to " + String(range.end) +
                                        ", value = " + String(float(value));
                        if (repairEnabled)
                        {
                            paramChild.setProperty(Property::value, defaultValue,
                                                   nullptr); // Repair state by setting to default value
 
                            // Copy the corrected value of the parameter into the value of its linked generic parameter
                            auto linkIndex = static_cast<int>(paramChild[Property::linkIndex]); // Fetch its link index
                            setGenericParameterValue(paramTreeGeneric, linkIndex, defaultValue);
 
                            errorMessage += " : Repaired with default value (= " + String(defaultValue) + ")";
                        }
                        isValid = repairEnabled;
                        errorMessage += "\n";
                    }
                }
                else // The parameter was not found in the state - boohoo !
                {
                    errorMessage += String(++errorCount) + ") Parameter missing: " + id;
                    if (repairEnabled)
                    {
                        // Create the missing parameter with default value and set the linked generic param to that
                        // value as well
                        auto newParameter = kwidgetTree.getChildWithName(Tag::params)
                                                    .getChild(0)
                                                    .createCopy(); // Grab this as a template
                        auto newIndex = getUnusedLinkIndex();
                        newParameter.setProperty(Property::id, param->getParameterID(), nullptr);
                        newParameter.setProperty(Property::linkIndex, newIndex, nullptr);
                        newParameter.setProperty(Property::value, defaultValue, nullptr);
                        paramTree.appendChild(
                                newParameter,
                                nullptr); // Repair state by adding missing parameter with an available link index
 
                        // Set the linked generic parameter with the default value as well
                        setGenericParameterValue(paramTreeGeneric, newIndex, defaultValue);
 
                        errorMessage += " : Repaired with new param and default value = " + String(defaultValue);
                    }
                    isValid = repairEnabled;
                    errorMessage += "\n";
                }
            }
        }
        else // Could not create Kwidget, this is an unrecoverable error at present
        {
            errorMessage +=
                    String(++errorCount) + ") Kwidget type not recognised: " + kwidgetType + " : Not Repaired\n";
            isValid = false;
        }
 
        errorMessage = "Parameter check found " + String(errorCount) + " errors in Kwidget " + kwidgetID + ":\n" +
                       errorMessage;
 
        if (errorCount > 0)
        {
            DBG(errorMessage);
        }
 
        return isValid;
    }
 
    void ParameterManager::attachParameters(Kwidget* kwidget, const ValueTree& kwidgetTree)
    {
        auto paramTree = kwidgetTree.getChildWithName(Tag::params);
        for (const auto& param : paramTree)
        {
            auto paramID = param[Property::id].toString();
            auto idx = static_cast<int>(param[Property::linkIndex]);
            auto p = kwidget->getParameter(paramID);
 
            p->attach(m_genericParameters[static_cast<size_t>(idx)]);
        }
    }
 
    void ParameterManager::detachParameters(Kwidget* kwidget, const ValueTree& kwidgetTree)
    {
        auto paramTree = kwidgetTree.getChildWithName(Tag::params);
        for (const auto& param : paramTree)
        {
            auto paramID = param[Property::id].toString();
            auto p = kwidget->getParameter(paramID);
 
            p->detach();
        }
    }
 
    ValueTree ParameterManager::getModulationTree(const String& sourceID, int modulatorIdx, const String& destinationID,
                                                  const String& paramID)
    {
        for (const auto& m : m_modulationTree)
        {
            if (m[Property::source].toString() == sourceID && int(m[Property::modulatorIndex]) == modulatorIdx &&
                m[Property::destination].toString() == destinationID && m[Property::param].toString() == paramID)
            {
                return m;
            }
        }
 
        // No matching modulation instance.
        jassertfalse;
        return m_modulationTree;
    }
 
    void ParameterManager::copyModulationTree(ValueTree modTree)
    {
        // check through the modulation connections and only copy over modulations that don't exist already in the tree.
        for (int i = 0; i < modTree.getNumChildren(); i++)
        {
            auto child = modTree.getChild(i);
            auto destination = child.getPropertyPointer(Property::destination)->toString();
            auto param = child.getPropertyPointer(Property::param)->toString();
            auto source = child.getPropertyPointer(Property::source)->toString();
 
            bool found = false;
            for (int j = 0; j < m_modulationTree.getNumChildren(); j++)
            {
                auto modulation = m_modulationTree.getChild(j);
 
                if (source == modulation.getProperty(Property::source).toString() &&
                    param == modulation.getProperty(Property::param).toString())
                {
                    // this is the same kwidget and parameter
                    // see if the destination also matches
                    if (destination == modulation.getProperty(Property::destination).toString())
                    {
                        // this modulation is already in the tree, don't add a duplicate
                        // but do update its value if the incoming one is different
                        if (modulation.getProperty(Property::depth) != child.getProperty(Property::depth))
                        {
                            modulation.setProperty(Property::depth, child.getProperty(Property::depth), nullptr);
                        }
                        found = true;
                        break;
                    }
                }
            }
 
            if (found == false)
            {
                // if we haven't found the modulation copy this one over to the tree
                ValueTree newModulation(child.getType());
                newModulation.copyPropertiesAndChildrenFrom(child, nullptr);
                m_modulationTree.addChild(newModulation, -1, nullptr);
            }
        }
    }
} // namespace krotos