CustomLayout.cpp

Go to the documentation of this file.

#include "CustomLayout.h"
 
namespace krotos
{
    const Identifier CustomLayout::Tag::layout = "LAYOUT";
    const Identifier CustomLayout::Tag::slot = "SLOT";
 
    const Identifier CustomLayout::Property::name = "name";
    const Identifier CustomLayout::Property::index = "index";
    const Identifier CustomLayout::Property::bounds = "bounds";
 
    const String CustomLayout::FileExtension = "clf";
    const Rectangle<int> CustomLayout::DefaultSize = Rectangle<int>{50, 50, 100, 100};
 
    CustomLayout::CustomLayout() : m_layoutTree(CustomLayout::Tag::layout)
    {
        // Add Listener for layout tree. This is required for creating & destroying slots.
        m_layoutTree.addListener(this);
    }
 
    CustomLayout::~CustomLayout() { m_layoutTree.removeListener(this); }
 
    void CustomLayout::resized()
    {
        if (m_autoLayout)
        {
 
            auto bounds = getLocalBounds();
 
            FlexBox fb = m_flexSettings;
            FlexItem::Margin margin = m_flexMargin;
 
            for (auto& c : m_components)
            {
                auto componentBounds =
                        Rectangle<int>::fromString(m_layoutTree.getChildWithProperty(Property::name, c->getName())
                                                           .getProperty(CustomLayout::Property::bounds)
                                                           .toString());
 
                if (getAutoLayoutBoundsFromType)
                    componentBounds = getAutoLayoutBoundsFromType(c->getName(), componentBounds);
 
                auto flex = FlexItem(*c)
                                    .withMargin(margin)
                                    .withHeight((float)componentBounds.getHeight())
                                    .withWidth((float)componentBounds.getWidth())
                                    .withOrder(static_cast<int>(componentBounds.getHeight() / 10) * -1);
 
                fb.items.add(flex);
            }
 
            fb.performLayout(bounds);
        }
        else
        {
            for (auto c : m_components)
            {
                auto componentBounds =
                        Rectangle<int>::fromString(m_layoutTree.getChildWithProperty(Property::name, c->getName())
                                                           .getProperty(CustomLayout::Property::bounds)
                                                           .toString());
 
                c->setBounds(componentBounds);
            }
        }
    }
 
    ValueTree& CustomLayout::getLayoutTree()
    {
        saveLayout();
 
        return m_layoutTree;
    }
 
    void CustomLayout::resetLayoutTree(const ValueTree& layoutTree)
    {
        m_layoutTree.removeAllChildren(nullptr);
        m_layoutTree.copyPropertiesAndChildrenFrom(layoutTree, nullptr);
        setLayoutTree(layoutTree);
    }
 
    void CustomLayout::addSlot(const String& name, const Rectangle<int>& bounds)
    {
        ValueTree slotTree{CustomLayout::Tag::slot,
                           {
                                   {CustomLayout::Property::name, name},
                                   {CustomLayout::Property::index, m_components.size()},
                                   {CustomLayout::Property::bounds, bounds.toString()},
                           }};
 
        m_layoutTree.appendChild(slotTree, nullptr);
    }
 
    void CustomLayout::addComponent(Component& component, Rectangle<int> bounds)
    {
        addSlot(component.getComponentID(), bounds);
 
        m_components.getLast()->addAndMakeVisible(component);
        m_components.getLast()->resized();
    }
 
    void CustomLayout::addComponent(Component& component, ValueTree slot)
    {
        jassert(slot.hasType(Tag::slot));
 
        if (slot.hasType(Tag::slot))
        {
            auto name = slot[Property::name].toString();
            auto index = slot[Property::index];
            auto bounds = Rectangle<int>::fromString(slot[Property::bounds].toString());
 
            // Try to find existing slot.
            for (auto c : m_components)
            {
                if (c->getName() == name)
                {
                    c->addAndMakeVisible(component);
                    c->resized();
 
                    // Success, return.
                    return;
                }
            }
 
            // No existing slot found, add a new one.
            addComponent(component, bounds);
        }
    }
 
    void CustomLayout::removeComponent(int index)
    {
        // Remove the component from the tree.
        // The component is then removed in the valueTreeChildRemoved callback.
        m_layoutTree.removeChild(index, nullptr);
    }
 
    void CustomLayout::setEditModeActive(bool isEditModeActive)
    {
        m_editable = isEditModeActive;
 
        for (auto c : m_components)
        {
            dynamic_cast<ResizableComponent*>(c)->setResizable(m_editable);
        }
    }
 
    void CustomLayout::saveLayout()
    {
        if (!m_autoLayout)
        {
            for (int i = 0; i < m_components.size(); ++i)
            {
                auto bounds = m_components[i]->getBounds();
 
                m_layoutTree.getChildWithProperty(Property::name, m_components[i]->getName())
                        .setProperty(CustomLayout::Property::bounds, bounds.toString(), nullptr);
            }
        }
    }
 
    Component* CustomLayout::createAndAddResizableComponent(String name, Rectangle<int> bounds)
    {
        auto comp = new ResizableComponent(name);
        m_components.add(comp);
 
        comp->setResizable(isEditModeActive());
 
        comp->setBounds(bounds);
 
        addAndMakeVisible(comp);
 
        resized();
 
        // Add listener to save bounds to tree when component is resized.
        // See componentMovedOrResized()
        comp->addComponentListener(this);
 
        return comp;
    }
 
    void CustomLayout::valueTreeChildAdded(ValueTree& /*parentTree*/, ValueTree& childWhichHasBeenAdded)
    {
        String name = childWhichHasBeenAdded.getProperty(CustomLayout::Property::name);
        String bounds = childWhichHasBeenAdded.getProperty(CustomLayout::Property::bounds);
 
        createAndAddResizableComponent(name, Rectangle<int>::fromString(bounds));
    }
 
    void CustomLayout::valueTreeChildRemoved(ValueTree& /*parentTree*/, ValueTree& childWhichHasBeenRemoved,
                                             int /*indexFromWhichChildWasRemoved*/)
    {
        String name = childWhichHasBeenRemoved.getProperty(CustomLayout::Property::name);
 
        for (auto c : m_components)
            if (c->getName() == name)
                m_components.remove(m_components.indexOf(c));
    }
 
    void CustomLayout::valueTreePropertyChanged(ValueTree& /*treeWhosePropertyHasChanged*/,
                                                const Identifier& /*property*/)
    {
    }
 
    void CustomLayout::valueTreeRedirected(ValueTree& treeWhichHasBeenChanged)
    {
        if (treeRedirected)
        {
            treeRedirected();
        }
    }
 
    void CustomLayout::componentMovedOrResized(Component& component, bool /*wasMoved*/, bool /*wasResized*/)
    {
        if (!m_autoLayout)
        {
            auto idx = m_components.indexOf(&component);
            auto newBounds = m_components[idx]->getBounds();
 
            // Save bounds as proportions relative to local bounds
            auto bounds = newBounds;
 
            auto nodeToUpdate = m_layoutTree.getChildWithProperty(Property::name, component.getName());
            nodeToUpdate.setProperty(Property::bounds, bounds.toString(), nullptr);
        }
    }
 
    void CustomLayout::configureAutoLayout(FlexBox flexboxSettings, FlexItem::Margin flexMargin)
    {
        m_flexSettings = flexboxSettings;
        m_flexMargin = flexMargin;
    }
 
} // namespace krotos