PerformanceArea.cpp

Go to the documentation of this file.

namespace krotos
{
#include "PerformanceArea.h"
 
    using LAFProperty = Krotos_LookAndFeel::Properties;
 
    const String PerformanceArea::TemplateFileExtension = "kst";
    const Identifier PerformanceArea::Tag::Template = "TEMPLATE";
    const String PerformanceArea::ComponentIds::PerformanceAreaLayoutComponentId = "performArea";
    const String PerformanceArea::ComponentIds::ComboboxTemplateId = "performTemplateDropdown";
 
    const std::string PerformanceArea::analyticsEventTemplateSelected{"analyticsEventTemplateSelected:"};
 
    PerformanceArea::PerformanceArea(ValueTree& customDataTree, KwidgetAudioProcessor& processor, int id,
                                     const StringArray& kTypes)
        : m_customDataTree(customDataTree), m_processor(processor), m_layoutSelector("layout selector"),
          m_editorSelector("editor selector"), m_layoutBuilderTree(XmlType::Tag::kwidgets), m_id(id),
          m_optionKTypes(kTypes)
    {
        initialiseListeners();
 
        addAndMakeVisible(m_layoutEditor);
        addAndMakeVisible(m_layoutSelector);
        addChildComponent(m_editorSelector);
 
        initialiseEditorControls();
        m_layoutEditor.setComponentID(ComponentIds::PerformanceAreaLayoutComponentId);
 
        // Reset the layout editor selection after a state change
        m_layoutEditor.treeRedirected = [this]() { m_layoutSelector.setSelectedId(0); };
 
        m_layoutSelector.setComponentID(ComponentIds::ComboboxTemplateId);
 
        m_layoutSelector.getProperties().set(LAFProperty::ComboBox::DisableHover, true);
        m_layoutSelector.getProperties().set(LAFProperty::ComboBox::RoundedCornerID,
                                             LAFProperty::ComboBox::RoundedCorner::Top);
        m_layoutSelector.getProperties().set(LAFProperty::ComboBox::IconPositionID,
                                             LAFProperty::ComboBox::IconPosition::Left);
        m_layoutSelector.getProperties().set(LAFProperty::ComboBox::UseCustomIcon, true);
        m_layoutSelector.getProperties().set(LAFProperty::ComboBox::FontSize, 18.0f);
 
        m_layoutSelector.setColour(ComboBox::backgroundColourId, findColour(TabbedComponent::backgroundColourId));
        m_layoutSelector.setColour(ComboBox::textColourId, Colours::white);
        m_layoutSelector.setTextWhenNothingSelected("Select a Performing Template");
 
        // Custom icon for dropdown
        m_dropdownIcon = Drawable::createFromImageData(KrotosBinaryData::SampleBrowser_Dropdown_Icon_svg,
                                                       KrotosBinaryData::SampleBrowser_Dropdown_Icon_svgSize);
        addAndMakeVisible(*m_dropdownIcon);
 
        m_editorSelector.getProperties().set(LAFProperty::ComboBox::DisableHover, true);
        m_editorSelector.setColour(ComboBox::backgroundColourId, findColour(TabbedComponent::backgroundColourId));
 
        m_lastSelectedTemplate = m_layoutSelector.getSelectedId();
        m_layoutSelector.onChange = [this] {
            // Template hasn't changed; Don't do anything
            auto selectedId = m_layoutSelector.getSelectedId();
            if (selectedId == m_lastSelectedTemplate || selectedId == 0)
            {
                m_lastSelectedTemplate = selectedId;
                return;
            }
 
            std::function<void(int)> changeCallback = [this, selectedId,
                                                       target = WeakReference<Component>{this}](int option) {
                // Parent has been destroyed; Abort
                if (!target)
                {
                    return;
                }
 
                if (option == 0)
                {
                    if (selectedId > 0 && selectedId <= m_templateFiles.size())
                    {
                        File file = m_templateFiles[selectedId - 1];
                        if (file.hasFileExtension(PerformanceArea::TemplateFileExtension))
                        {
                            XmlDocument doc(file);
                            loadTemplateXml(*doc.getDocumentElement());
                            m_lastSelectedTemplate = selectedId;
 
                            // Mixpanel analytics event for template selected
                            sendActionMessage(analyticsEventTemplateSelected +
                                              m_layoutSelector.getItemText(selectedId).toStdString());
                        }
                    }
                }
                else
                {
                    m_layoutSelector.setSelectedId(m_lastSelectedTemplate);
                }
            };
            getProperties().set(Krotos_LookAndFeel::Properties::AlertWindow::AlertWidthID, 440);
            getProperties().set(Krotos_LookAndFeel::Properties::AlertWindow::AlertHeightID, 226);
            AlertWindow::showAsync(
                    MessageBoxOptions()
                            .withIconType(MessageBoxIconType::WarningIcon)
                            .withTitle("Template Switch")
                            .withMessage("Please note that switching to another\ntemplate will lead to a "
                                         "destructive change,\nresulting in the loss of all prior "
                                         "components,\nparameter settings, and modulation\nassignments")
                            .withButton("Cancel")
                            .withButton("Switch")
                            .withAssociatedComponent(this),
                    changeCallback);
        };
 
        refreshTemplates();
 
        // pass on the callback from customlayout to fetch autolayout bounds from the editor
        m_layoutEditor.getAutoLayoutBoundsFromType = [this](String type, Rectangle<int> currentBounds) {
            if (getAutoLayoutBoundsFromType)
            {
                return getAutoLayoutBoundsFromType(type, currentBounds);
            }
            else
            {
                jassertfalse;
                return Rectangle<int>();
            }
        };
 
        // load background image
        m_backgroundImage = Drawable::createFromImageData(KrotosBinaryData::Perform_Area_Background_png,
                                                          KrotosBinaryData::Perform_Area_Background_pngSize);
 
        m_dropdownIcon->toFront(false);
    }
 
    // Initialise listeners and assign the layout tree to the custom data tree, in order to save
    // and recall layout from the main plugin state.
    void PerformanceArea::initialiseListeners()
    {
        // If you hit these, the custom data tree is invalid.
        // This should have been passed in the ctor. Does it exist in the state?
        jassert(m_customDataTree.isValid());
        jassert(m_customDataTree.hasType(XmlType::Tag::customData));
 
        // Set up attachment to listen to the custom data tree, so if the layout tree
        // is added or removed from it as, we know about it and can update the layout accordingly.
        m_customTreeAttachment.reset(new ValueTreeAttachment(m_customDataTree));
 
        // First, find a layout tree in the main state
        auto layoutTree = m_customDataTree.getChildWithName(CustomLayout::Tag::layout);
 
        // Initialise tree to save / recall from state
 
        // If a layout tree already exists in the state, we want to use that.
        if (layoutTree.isValid())
        {
            // Must be a "Layout" tree!
            jassert(layoutTree.hasType(CustomLayout::Tag::layout));
 
            // Replace local layout tree with the one in the main state.
            resetLayoutTree(layoutTree);
        }
        else
        {
            // Layout tree wasn't valid or didn't exist, so we'll add our local one to the state instead.
            m_customDataTree.appendChild(getLayoutTree(), nullptr);
            // Fetch the reference to it and replace local tree reference with the state reference.
            layoutTree = m_customDataTree.getChildWithName(CustomLayout::Tag::layout);
 
            jassert(layoutTree.isValid());
            jassert(layoutTree.hasType(CustomLayout::Tag::layout));
 
            setLayoutTree(layoutTree);
        }
 
        // Set up listeners...
 
        m_customTreeAttachment->onChildAdded = [this](ValueTree& /*parent*/, ValueTree& child) {
            // If a new layout tree was added to the main state. e.g. When a preset is loaded
            // Replace current layout with the new one!
            if (child.getType() == CustomLayout::Tag::layout)
            {
                resetLayoutTree(child);
            }
        };
 
        m_customTreeAttachment->onChildRemoved = [this](ValueTree& /*parent*/, ValueTree& child) {
            // Layout tree was removed from state for whateve reason, so clear layout.
            if (child.getType() == CustomLayout::Tag::layout)
                m_layoutBuilderTree.removeAllChildren(nullptr);
        };
    }
 
    void PerformanceArea::resized()
    {
        const auto barHeight = 30;
 
        auto bounds = getLocalBounds();
        // Condition to prevent a visible offset if no editor controls are visible
        auto selectorBar = m_layoutSelector.isVisible() || m_showEditorControls ? bounds.removeFromTop(barHeight)
                                                                                : Rectangle<int>();
 
        if (m_showEditorControls)
        {
            setTemplateSelectorVisible(true);
            m_editorSelector.setBounds(selectorBar.removeFromLeft((int)((float)selectorBar.getWidth() * 0.5f)));
        }
        auto layoutBounds = bounds;
        layoutBounds.setHeight(bounds.getHeight());
        m_layoutEditor.setBounds(layoutBounds);
 
        selectorBar.removeFromRight(Layout::selectorBar);
        m_layoutSelector.setBounds(selectorBar);
 
        auto layoutBoxBounds = m_layoutSelector.getBounds();
 
        auto iconBounds = layoutBoxBounds.removeFromLeft(28).withSizeKeepingCentre(12, 12);
        m_dropdownIcon->setBounds(iconBounds);
    }
 
    void PerformanceArea::paint(Graphics& g)
    {
        if (m_drawBackground)
        {
            m_backgroundImage->drawWithin(g, getLocalBounds().toFloat(), RectanglePlacement::stretchToFit, 1.0f);
        }
    }
 
    void PerformanceArea::addToLayoutBuilder(const ValueTree& tree)
    {
        m_layoutBuilderTree.appendChild(tree.createCopy(), nullptr);
        // DBG(m_layoutBuilderTree.toXmlString());
    }
 
    void PerformanceArea::addKwidgetGUI(KwidgetGUI* gui, Rectangle<int> bounds)
    {
        jassert(gui != nullptr);
 
        auto id = gui->getKwidgetID();
 
        auto slotTree = getLayoutTree().getChildWithProperty(CustomLayout::Property::name, id);
 
        // If this kwidget already has a slot in the performance area (i.e. has bounds already) pass it on
        if (slotTree.isValid())
            addComponent(*gui, slotTree);
        // else add it with default sizes.
        else
            addComponent(*gui, bounds);
 
        addToLayoutBuilder(m_processor.getKwidget(id)->getState());
    }
 
    std::unique_ptr<XmlElement> PerformanceArea::saveTemplateXml()
    {
        ValueTree outputTree(Tag::Template);
        outputTree.appendChild(m_layoutBuilderTree.createCopy(), nullptr);
        outputTree.appendChild(getLayoutTree().createCopy(), nullptr);
        // DBG("OUTPUT TEMPLATE TREE");
        // DBG(outputTree.toXmlString());
        return outputTree.createXml();
    }
 
    void PerformanceArea::loadTemplateXml(const XmlElement& templateXml)
    {
        auto newTree = ValueTree::fromXml(templateXml);
        if (newTree.hasType(Tag::Template))
        {
            auto kwidgetsTree = newTree.getChildWithName(XmlType::Tag::kwidgets);
            auto layoutTree = newTree.getChildWithName(CustomLayout::Tag::layout);
 
            // Do some validation
            jassert(kwidgetsTree.isValid());
            jassert(layoutTree.isValid());
 
            auto numberOfLayoutSlots = newTree.getChildWithName(CustomLayout::Tag::layout).getNumChildren();
            auto numberOfKwidgets = kwidgetsTree.getNumChildren();
 
            // Validate there's a slot for every kwidget
            // (If you hit this, check the template preset for any oddities)
            if (numberOfKwidgets != numberOfLayoutSlots)
            {
                AlertWindow::showMessageBoxAsync(MessageBoxIconType::WarningIcon, "Could not load template",
                                                 "Error: Invalid template.");
 
                return;
            }
 
            // Validate the layout and kwidget trees contain the same kwidgets ids...
            StringArray slotNames, kwidgetNames;
 
            for (auto s : layoutTree)
                slotNames.add(s[CustomLayout::Property::name]);
 
            for (auto k : kwidgetsTree)
                kwidgetNames.add(k[XmlType::Property::id]);
 
            // Merge the two arrays.
            // Merge array doesn't add a string if it already exists...
            slotNames.mergeArray(kwidgetNames);
 
            // ... so we can validate by checking the size hasn't changed
            if (slotNames.size() != numberOfKwidgets)
            {
                AlertWindow::showMessageBoxAsync(MessageBoxIconType::WarningIcon, "Could not load template",
                                                 "Error: Invalid template.");
 
                return;
            }
            // Validation complete!
 
            // Begin loading the preset...
 
            // Update layout tree first, as this is needed for the new kwidgets
            if (layoutTree.isValid())
            {
                clearLayout();
 
                getLayoutTree().copyPropertiesAndChildrenFrom(layoutTree, nullptr);
            }
 
            // Todo - pass in the whole tree
            if (kwidgetsTree.isValid())
            {
                for (auto kwidget : kwidgetsTree)
                {
                    // use random kwidget ID for now...
                    // todo: set id to -1 to inform param manager that it needs an id generated
                    Random r;
                    String kType = kwidget[XmlType::Property::type];
                    String ID = kwidget[XmlType::Property::id];
                    auto k = KwidgetFactory::createKwidget(kType, ID); // kType + String(r.nextInt()));
                    if (k->getCustomParameter(Kwidget::Constants::Parent) != nullptr)
                        k->getCustomParameter(Kwidget::Constants::Parent)->setValue(1);
                    auto vt = k->getState().createCopy();
                    m_processor.addKwidgetFromState(*std::move(&vt));
                }
            }
        }
    }
 
    void PerformanceArea::clearLayout()
    {
        m_layoutBuilderTree.removeAllChildren(nullptr);
 
        // Remove kwidgets from current layout
        for (auto slot : getLayoutTree())
        {
            auto kwidgetToRemove = slot[CustomLayout::Property::name];
            m_processor.removeKwidget(kwidgetToRemove);
        }
        getLayoutTree().removeAllChildren(nullptr);
    }
 
    void PerformanceArea::refreshTemplates()
    {
        m_layoutSelector.clear();
 
        File templateDir = PresetManager::getFactoryTemplateDirectory().getFullPathName();
 
        m_templateFiles = templateDir.findChildFiles(File::TypesOfFileToFind::findFiles, true,
                                                     "*." + PerformanceArea::TemplateFileExtension);
        // Sort alphabetically
        std::sort(m_templateFiles.begin(), m_templateFiles.end());
 
        // Show the editor controls if the secret edit file exists in the directory...
        showEditorControls(
                !templateDir.findChildFiles(File::TypesOfFileToFind::findFiles, true, "*." + edit_mode_file_ext)
                         .isEmpty());
 
        int i = 1;
        for (auto file : m_templateFiles)
        {
            m_layoutSelector.addItem(file.getFileNameWithoutExtension(), i++);
        }
    }
 
    void PerformanceArea::initialiseEditorControls()
    {
        m_editorSelector.clear();
 
        // Save layout window
        m_saveWindow.reset(new juce::FileChooser("Save template",
                                                 PresetManager::getFactoryTemplateDirectory().getFullPathName(),
                                                 "*." + PerformanceArea::TemplateFileExtension));
 
        // Additional options
        const StringArray optionSettings{"edit", "save", "clear"};
 
        const String pAdd = "add ";
        const String pSmall = pAdd + "small ";
 
        // Add to dropdown
        StringArray itemList;
 
        for (int i = 0; i < m_optionKTypes.size(); ++i)
        {
            itemList.add(pAdd + m_optionKTypes[i]);
 
            // Add "add small" options
            if (m_optionKTypes[i] != KType::TriggerButton)
                itemList.add(pSmall + m_optionKTypes[i]);
        }
        itemList.addArray(optionSettings);
 
        m_editorSelector.addItemList(itemList, 1);
 
        // Set up callback for adding kwidgets
        m_editorSelector.onChange = [=] {
            auto id = m_editorSelector.getSelectedId() - 1;
            auto option = itemList[id];
 
            // if function ptr exists and id is within bounds of kwidgets
            if (addKwidget && id >= 0 && id < (itemList.size() - optionSettings.size()))
            {
                String kwidget;
                // extract ktype from the dropdow options name
                if (option.contains(pSmall))
                {
                    kwidget = option.substring(pSmall.length());
                    smallify = true;
                }
                else if (option.contains(pAdd))
                {
                    kwidget = option.substring(pAdd.length());
                }
 
                addKwidget(kwidget);
            }
 
            if (option == "edit")
            {
                setEditModeActive(!isEditModeActive());
            }
            else if (option == "save")
            {
                auto flags = juce::FileBrowserComponent::saveMode;
                m_saveWindow->launchAsync(flags, [this](const juce::FileChooser& fc) {
                    auto file = fc.getResult();
                    if (file != juce::File())
                    {
                        saveTemplateXml()->writeTo(file);
 
                        refreshTemplates();
                    }
                });
            }
            else if (option == "clear")
            {
                clearLayout();
            }
            // add your options here...
            // make sure it's name is in optionSettings
 
            m_editorSelector.setSelectedId(0);
        };
    }
 
    void PerformanceArea::showEditorControls(bool isEnabled)
    {
        m_showEditorControls = isEnabled;
        m_editorSelector.setVisible(isEnabled);
        resized();
    }
} // namespace krotos