ModulationAssigner.cpp

Go to the documentation of this file.

#include "ModulationAssigner.h"
 
namespace krotos
{
    ModulationAssigner::ModulationAssigner(KwidgetAudioProcessor& processor, const StringArray& kwidgetWhitelist)
        : m_processor(processor), m_modulationParentTree(processor.parameterManager.getModulationTree()),
          m_kwidgetTree(processor.parameterManager.getKwidgetsTree()), TabbedComponent(TabbedButtonBar::TabsAtTop)
    {
        addToWhitelist(kwidgetWhitelist);
 
        m_processor.addKListener(this);
        m_dropArea = std::make_unique<ModulationAssignerDropArea>();
        m_dropArea->setNumComponentsPerRow(m_rowSize, m_rowSize);
        m_dropArea->drawSingleRowAsColumn(false);
 
        attachKwidgetsTreeListener(m_kwidgetTree);
        attachModTreeListener(m_modulationParentTree);
 
        setTabBarDepth(0);
        setOutline(0);
 
        addTab("Assign", findColour(TabbedComponent::backgroundColourId), m_dropArea.get(), true);
 
        initialiseData();
    }
 
    ModulationAssigner::~ModulationAssigner() { m_processor.removeKListener(this); }
 
    void ModulationAssigner::colourChanged()
    {
        // Update assign tab after a setColour call
        if (getNumTabs() > 0)
        {
            setTabBackgroundColour(0, findColour(TabbedComponent::backgroundColourId));
        }
    }
 
    DropComponent* ModulationAssigner::addDropComponent(const String& labelText, const String& targetModSourceKwidgetID,
                                                        int targetModulatorIdx)
    {
        auto* dropComponent = m_dropArea->addDropComponent(new DropComponent(labelText, targetModSourceKwidgetID));
        auto* modTable =
                addTable(labelText + " Modulation", ModSourceIndexPair(targetModSourceKwidgetID, targetModulatorIdx));
        int tabIndex = getTabNames().indexOf(modTable->getId());
 
        dropComponent->onDropped = [this, targetModSourceKwidgetID, targetModulatorIdx, modTable](var desc) {
            assignModulation(desc, targetModSourceKwidgetID, targetModulatorIdx, modTable);
        };
 
        // Set up Button onClick to switch to Mod List
        dropComponent->onClick = [this, tabIndex] { setCurrentTabIndex(tabIndex); };
 
        return dropComponent;
    }
 
    void ModulationAssigner::kwidgetAdded(Kwidget* kwidget)
    {
#if !ENABLE_QUICKFX_ASSIGNMENT
        // Do not add specific MasterFX types
        if (kwidget->getKwidgetID().contains(KwidgetFactory::KwidgetModifiers::MasterFX))
        {
            return;
        }
#endif
 
        auto type = kwidget->getKwidgetType();
 
#if ENABLE_SANDBOX
        if (kwidget->getKwidgetID().contains(KwidgetFactory::KwidgetModifiers::SandBox))
        {
            auto numModulators = kwidget->getNumModulators();
 
            if (numModulators > 0)
            {
                Array<Value> labelValues = Array<Value>();
                auto customParams = kwidget->getState().getChildWithName(XmlType::Tag::customParams);
 
                for (auto param : customParams)
                {
                    if (param.getProperty(XmlType::Property::id).toString().contains("editableLabel"))
                        labelValues.add(param.getPropertyAsValue(XmlType::Property::value, nullptr));
                }
 
                addMultiDropComponent(kwidget->getKwidgetLabel(), kwidget->getKwidgetID(), numModulators, labelValues);
            }
        }
#endif
 
        if (m_whitelist.isEmpty() || m_whitelist.contains(type))
        {
            auto numModulators = kwidget->getNumModulators();
 
#if !ENABLE_VELOCITY_ASSIGNMENT
            // Do not add Table for final modulator i.e. Velocity
            if (type.contains(KwidgetFactory::KwidgetType::XyPad))
            {
                numModulators -= 1;
            }
#endif
            if (numModulators > 0)
            {
                Array<Value> labelValues = Array<Value>();
                auto customParams = kwidget->getState().getChildWithName(XmlType::Tag::customParams);
 
                for (auto param : customParams)
                {
                    if (param.getProperty(XmlType::Property::id).toString().contains("editableLabel"))
                        labelValues.add(param.getPropertyAsValue(XmlType::Property::value, nullptr));
                }
 
                addMultiDropComponent(kwidget->getKwidgetLabel(), kwidget->getKwidgetID(), numModulators, labelValues);
            }
        }
    }
 
    void ModulationAssigner::kwidgetRemoved(Kwidget* kwidget) { removeDropComponent(kwidget->getKwidgetID()); }
 
    MultiDropComponent* ModulationAssigner::addMultiDropComponent(const String& labelText,
                                                                  const String& targetModSourceKwidgetID,
                                                                  int numModulators, Array<Value> labelValues)
    {
        auto* dc = m_dropArea->addMultiDropComponent(
                new MultiDropComponent(labelText, targetModSourceKwidgetID, numModulators));
 
        for (int i = 0; i < numModulators; ++i)
        {
            auto label = labelText + " " + String(i + 1) + " Modulation";
 
            auto* modTable = addTable(label, ModSourceIndexPair(targetModSourceKwidgetID, i));
            int tabIndex = getTabNames().indexOf(modTable->getId());
            auto* dropComponent = dc->getDropComponent(i);
            dropComponent->onDropped = [this, targetModSourceKwidgetID, i, modTable](var desc) {
                assignModulation(desc, targetModSourceKwidgetID, i, modTable);
            };
            dropComponent->onClick = [this, tabIndex] { setCurrentTabIndex(tabIndex); };
 
            // If provided, set up the label Values
            if (!labelValues.isEmpty())
            {
                // Not enough label values for the number of modulators.
                jassert(i < labelValues.size());
 
                auto value = labelValues[i];
 
                if (i < labelValues.size())
                    dropComponent->setLabelValue(value);
            }
        }
 
        return dc;
    }
 
    void ModulationAssigner::removeDropComponent(const String& kwidgetID) { m_dropArea->removeComponent(kwidgetID); }
 
    void ModulationAssigner::paintOverChildren(Graphics& g)
    {
        if (m_indicatorActive)
        {
            g.setColour(findColour(LassoComponent<TabbedComponent>::lassoOutlineColourId));
            g.drawRoundedRectangle(getLocalBounds().reduced(m_padding - 1).toFloat(), m_cornerSize, (float)m_padding);
        }
    }
 
    void ModulationAssigner::resized()
    {
        TabbedComponent::resized();
        if (m_dropArea != nullptr)
        {
            m_dropArea->resized();
        }
    }
 
    ModulationAssignerTable* ModulationAssigner::getTable(String id)
    {
        for (auto* t : m_modulationTables)
        {
            if (t->getId() == id)
                return t;
        }
 
        return nullptr;
    }
 
    ModulationAssignerTable* ModulationAssigner::addTable(String label, ModSourceIndexPair modSourceIdx)
    {
        auto id = String(modSourceIdx.first) + String(modSourceIdx.second);
        auto colour = findColour(ResizableWindow::backgroundColourId);
        auto* table = m_modulationTables.add(new ModulationAssignerTable(*this, label, id));
 
        m_tableMap.insert(std::pair<ModSourceIndexPair, ModulationAssignerTable*>(modSourceIdx, table));
 
        addTab(table->getId(), colour, table, true);
 
        return table;
    }
 
    void ModulationAssigner::removeTable(ModSourceIndexPair modSourceIdx)
    {
        auto table = m_tableMap[modSourceIdx];
        auto tabID = getTabNames().indexOf(table->getId());
        if (table != nullptr)
        {
            m_tableMap.erase(modSourceIdx);
            m_modulationTables.removeObject(table, true);
            removeTab(tabID);
        }
        else
        {
            m_tableMap.erase(modSourceIdx);
        }
    }
 
    void ModulationAssigner::attachModTreeListener(const ValueTree& tree)
    {
        // We need the "Modulations" tree!
        jassert(tree.hasType(XmlType::Tag::modulations));
 
        m_modulationParentTree = tree;
        m_modulationParentTree.addListener(this);
    }
 
    void ModulationAssigner::attachKwidgetsTreeListener(const ValueTree& tree)
    {
        // We need the "Kwidgets" tree!
        jassert(tree.hasType(XmlType::Tag::kwidgets));
 
        m_kwidgetTree = tree;
        m_kwidgetTree.addListener(this);
    }
 
    void ModulationAssigner::initialiseData()
    {
        // First, initialise drop components by looking for modulator kwidgets
        auto& kwidgets = m_processor.getKwidgets();
        for (auto& k : kwidgets)
        {
            kwidgetAdded(k);
        }
 
        // Then initialise tables with data from the modulation ValueTree.
        // Used if the ValueTree already has data in it before the Table has been created.
        // This is really inefficient and could potentially be really slow if there's
        // lots of modulation entries in the ValueTree.
        if (m_modulationParentTree.isValid())
        {
            for (int i = 0; i < m_modulationParentTree.getNumChildren(); i++)
            {
                addAssignment(m_modulationParentTree.getChild(i));
            }
        }
        else
            jassertfalse;
    }
 
    void ModulationAssigner::valueTreePropertyChanged(ValueTree& treeWhosePropertyHasChanged,
                                                      const Identifier& property)
    {
        (void)treeWhosePropertyHasChanged;
        (void)property;
    }
 
    void ModulationAssigner::valueTreeChildAdded(ValueTree& /*parentTree*/, ValueTree& childWhichHasBeenAdded)
    {
        if (childWhichHasBeenAdded.hasType(XmlType::Tag::modulation))
        {
            addAssignment(childWhichHasBeenAdded);
        }
    }
 
    void ModulationAssigner::valueTreeChildRemoved(ValueTree& /*parentTree*/, ValueTree& childWhichHasBeenRemoved,
                                                   int /*indexFromWhichChildWasRemoved*/)
    {
        if (childWhichHasBeenRemoved.hasType(XmlType::Tag::modulation))
        {
            auto source = childWhichHasBeenRemoved.getProperty(XmlType::Property::source);
            auto index = childWhichHasBeenRemoved.getProperty(XmlType::Property::modulatorIndex);
 
            auto pair = ModSourceIndexPair(source, index);
 
            if (m_tableMap[pair])
            {
                m_tableMap[pair]->deleteRow(childWhichHasBeenRemoved, false);
            }
 
            if (auto* dropComponent = m_dropArea->findDropComponent(source, index))
            {
                dropComponent->setArmed(false);
            }
        }
    }
 
    void ModulationAssigner::addAssignment(ValueTree newAssignment)
    {
        auto source = newAssignment.getProperty(XmlType::Property::source);
        auto index = newAssignment.getProperty(XmlType::Property::modulatorIndex);
 
        auto pair = ModSourceIndexPair(source, index);
 
        if (m_tableMap[pair])
        {
            m_tableMap[pair]->addRow(newAssignment);
        }
 
        if (auto* dropComponent = m_dropArea->findDropComponent(source, index))
        {
            dropComponent->setArmed(true);
        }
    }
 
    void ModulationAssigner::setIndicatorActive(bool isActive)
    {
        m_indicatorActive = isActive;
        repaint();
    }
 
} // namespace krotos