ModulationAssignerTable.cpp

Go to the documentation of this file.

#include "ModulationAssignerTable.h"
 
namespace krotos
{
    const String ModulationAssignerTable::ComponentIds::TextButtonBackId("ModulationBackLevelButton");
    const String ModulationAssignerTable::ComponentIds::TextButtonDeleteId("ParamDeleteButton");
    const String ModulationAssignerTable::ComponentIds::SliderDepthId("ParamDepthSlider");
 
    ModulationAssignerTable::ModulationAssignerTable(ModulationAssigner& owner, String name, String id)
        : Component(name), m_id(id), m_assigner(owner), m_backButton("Back"), m_titleLabel(name, name), m_numRows(0)
    {
        addAndMakeVisible(m_backButton);
        m_backButton.setComponentID(ComponentIds::TextButtonBackId);
        m_backButton.onClick = [this]() {
            auto tabs = dynamic_cast<TabbedComponent*>(this->getParentComponent());
            tabs->setCurrentTabIndex(k_dropTabIndex);
        };
 
        // Title Label
        addAndMakeVisible(m_titleLabel);
        m_titleLabel.setJustificationType(juce::Justification::centredRight);
        m_titleLabel.setFont(Font(18.0f));
 
        // Begin setting up the TableListBox
        m_table.setModel(this);
        m_table.setHeaderHeight(19);
        m_table.setRowHeight(30);
        m_table.getViewport()->setScrollBarThickness(6);
        m_table.getHeader().addColumn("Source", col_Source, /*width*/ 50);
        m_table.getHeader().addColumn("Destination", col_Destination, /*width*/ 228, /*minWidth*/ 110);
        m_table.getHeader().addColumn("Depth", col_Depth, /*width*/ 110, /*minWidth*/ 60);
        m_table.getHeader().addColumn("", col_Delete, /*width*/ 25, /*minWidth*/ 25, /*maxWidth*/ 25);
 
        // sort forwards by the ID column
        m_table.getHeader().setSortColumnId(col_Destination, true);
        m_table.getHeader().setColumnVisible(col_Source, false);
 
        // Stretch-to-fit mode
        m_table.getHeader().setStretchToFitActive(true);
 
        addAndMakeVisible(m_table);
    }
 
    int ModulationAssignerTable::getNumRows() { return m_numRows; }
 
    void ModulationAssignerTable::paintRowBackground(Graphics& g, int rowNumber, int /*width*/, int /*height*/,
                                                     bool /*rowIsSelected*/)
    {
        g.fillAll(getLookAndFeel().findColour(ListBox::backgroundColourId));
        if (rowNumber % 2)
        {
            g.fillAll(Colours::white.withAlpha(0.04f));
        }
    }
 
    void ModulationAssignerTable::paintCell(Graphics& g, int rowNumber, int columnId, int width, int height,
                                            bool /*rowIsSelected*/)
    {
        g.setColour(getLookAndFeel().findColour(juce::ListBox::textColourId));
        g.setFont(m_font.withExtraKerningFactor(0.1f));
 
        String text;
 
        switch (columnId)
        {
        case col_Source:
            text = m_sources[rowNumber];
            break;
        case col_Destination:
            text = m_destinations[rowNumber];
            break;
        }
 
        g.drawText(text, /*x*/ 8, /*y*/ 0, width - 4, height, juce::Justification::centredLeft, /*useEllipses*/ true);
    }
 
    Component* ModulationAssignerTable::refreshComponentForCell(int rowNumber, int columnId, bool /*isRowSelected*/,
                                                                Component* existingComponentToUpdate)
    {
        switch (columnId)
        {
        case col_Depth: {
            auto* depthSlider = static_cast<ModDepthSlider*>(existingComponentToUpdate);
 
            if (depthSlider == nullptr)
            {
                depthSlider = new ModDepthSlider(*this);
            }
 
            depthSlider->setAttachment(rowNumber, columnId, m_modulationTrees[rowNumber],
                                       m_depthIdentifier); // more thought needed here to handle removal of rows
            depthSlider->setValue(m_modulationTrees[rowNumber].getProperty(XmlType::Property::depth));
 
            return depthSlider;
        }
        case col_Delete: {
            auto* deleteButton = static_cast<DrawableButton*>(existingComponentToUpdate);
 
            if (deleteButton == nullptr)
            {
                deleteButton = new DrawableButton("", DrawableButton::ButtonStyle::ImageFitted);
                std::unique_ptr<Drawable> defaultCross(
                        Drawable::createFromImageData(KrotosBinaryData::table_close_button_faded_svg,
                                                      KrotosBinaryData::table_close_button_faded_svgSize));
                std::unique_ptr<Drawable> crossHover(
                        Drawable::createFromImageData(KrotosBinaryData::table_close_button_very_faded_svg,
                                                      KrotosBinaryData::table_close_button_very_faded_svgSize));
                std::unique_ptr<Drawable> crossClicked(
                        Drawable::createFromImageData(KrotosBinaryData::table_close_button_solid_svg,
                                                      KrotosBinaryData::table_close_button_solid_svgSize));
                deleteButton->setImages(defaultCross.get(), crossHover.get(), crossClicked.get());
                deleteButton->onClick = [this, rowNumber]() { deleteRow(rowNumber, true); };
 
                deleteButton->setComponentID(ComponentIds::TextButtonDeleteId);
            }
 
            return deleteButton;
        }
        }
 
        jassert(existingComponentToUpdate == nullptr);
        return nullptr;
    }
 
    void ModulationAssignerTable::paint(Graphics& g)
    {
        g.setColour(getLookAndFeel().findColour(ListBox::outlineColourId));
        g.fillRoundedRectangle(getLocalBounds().toFloat(), /*cornerSize*/ 4.0f);
        // draw line above header row
        const Colour horizontalLineColour(0x33FFFFFF); // white, 0.2 opacity
        g.setColour(horizontalLineColour);
        g.fillRect(/*x*/ 0, /*y*/ 20, /*w*/ getWidth(), /*h*/ 1);
    }
 
    void ModulationAssignerTable::resized()
    {
        auto bounds = getLocalBounds();
        auto topBar = bounds.removeFromTop(21);
        topBar.removeFromLeft(8);
        m_backButton.setBounds(topBar.removeFromLeft(60));
        m_titleLabel.setBounds(topBar);
        m_table.setBounds(bounds.withX(0).withWidth(getWidth()));
    }
 
    void ModulationAssignerTable::addRow(const ValueTree& modulationInstanceTree)
    {
        String source = modulationInstanceTree.getProperty(XmlType::Property::source);
        String index = modulationInstanceTree.getProperty(XmlType::Property::modulatorIndex);
        String destination = modulationInstanceTree.getProperty(XmlType::Property::destination);
        String param = modulationInstanceTree.getProperty(XmlType::Property::param);
 
        // Construct strings for row labels.
        source.append(index, k_maxAppendLength);
        destination.append(param, k_maxAppendLength);
 
        if (m_sources.contains(source) && m_destinations.contains(destination))
        {
            // Mod routing already exists in the table.
            // This may be because there's multiple instances of
            // the same modulation in the ValueTree, or because
            // the user is trying to route modulation that already exists.
            jassertfalse;
        }
        else
        {
            m_sources.add(source);
            m_destinations.add(destination);
 
            m_modulationTrees.push_back(modulationInstanceTree);
 
            m_numRows++;
            m_table.updateContent();
        }
    }
 
    void ModulationAssignerTable::deleteRow(const ValueTree& modulationInstanceTree, int row, bool notifyAssigner)
    {
        String source = modulationInstanceTree.getProperty(XmlType::Property::source).toString();
        String index = modulationInstanceTree.getProperty(XmlType::Property::modulatorIndex).toString();
        String destination = modulationInstanceTree.getProperty(XmlType::Property::destination).toString();
        String param = modulationInstanceTree.getProperty(XmlType::Property::param).toString();
 
        // Construct strings for row labels.
        source.append(index, k_maxAppendLength);
        destination.append(param, k_maxAppendLength);
 
        if (m_sources[row] == source && m_destinations[row] == destination)
        {
            m_sources.remove(row);
            m_destinations.remove(row);
 
            // If we are deleting because of a ValueTree state change, we don't need to notify the assigner
            // to delete it again.
            if (notifyAssigner)
                m_assigner.modulationDeleted(modulationInstanceTree);
 
            m_modulationTrees.erase(m_modulationTrees.begin() + row);
 
            m_numRows--;
            m_table.updateContent();
        }
    }
 
    void ModulationAssignerTable::deleteRow(int row, bool notifyAssigner)
    {
        deleteRow(m_modulationTrees[row], row, notifyAssigner);
    }
 
    void ModulationAssignerTable::deleteRow(const ValueTree& modInstanceTree, bool notifyAssigner)
    {
        int tableIndex = -1;
        for (int i = 0; i < m_modulationTrees.size(); i++)
        {
            if (m_modulationTrees[i].isEquivalentTo(modInstanceTree))
                tableIndex = i;
        }
        if (tableIndex >= 0)
            deleteRow(tableIndex, notifyAssigner);
    }
 
    // ========================== Mod Depth Slider ==========================
 
    ModulationAssignerTable::ModDepthSlider::ModDepthSlider(ModulationAssignerTable& modList)
        : m_owner(modList), Slider(Slider::SliderStyle::LinearHorizontal, Slider::TextEntryBoxPosition::NoTextBox)
    {
        m_laf.setDrawMirrored(true);
        setLookAndFeel(&m_laf);
        setRange(-1.0, 1.0, 0.01);
        setValue(0.0, dontSendNotification);
        setDoubleClickReturnValue(true, 0.0);
        setComponentID(ComponentIds::SliderDepthId);
    }
 
    ModulationAssignerTable::ModDepthSlider::~ModDepthSlider() { setLookAndFeel(nullptr); }
 
    void ModulationAssignerTable::ModDepthSlider::setAttachment(int row, int column, const ValueTree& tree,
                                                                const Identifier& property)
    {
        m_row = row;
        m_column = column;
        m_tree = tree;
        m_property = property;
 
        m_tree.addListener(this);
    }
 
    void ModulationAssignerTable::ModDepthSlider::valueChanged()
    {
        m_tree.setPropertyExcludingListener(this, m_property, getValue(), nullptr);
    }
 
    void ModulationAssignerTable::ModDepthSlider::valueTreePropertyChanged(ValueTree& tree, const Identifier& property)
    {
        if (property == m_property)
            setValue(tree[property]);
    }
 
    void ModulationAssignerTable::ModDepthSlider::lookAndFeelChanged()
    {
        setPopupDisplayEnabled(true, true, findParentComponentOfClass<AudioProcessorEditor>());
    }
 
} // namespace krotos