KwidgetGUI.cpp

Go to the documentation of this file.

namespace krotos
{
    KwidgetGUI::KwidgetGUI(Kwidget& k) : m_owner(k), m_topBarComponent(true, k.getKwidgetID())
    {
        setComponentID(getKwidgetID());
        setInterceptsMouseClicks(true, true);
 
        // Add TopBarComponent
        addAndMakeVisible(m_topBarComponent);
 
        // Default to borderless if we are a child kwidget
        if (k.isAChildKwidget())
            setRenderStyle(RenderStyle::borderless);
 
        // assign getTopBarComponent().onDelete to KwidgetGUI::onDelete to avoid duplicate definitions
        getTopBarComponent().onDelete = onDelete;
    }
 
    void KwidgetGUI::moved()
    {
        Rectangle<int> bounds = getBoundsInParent();
        CustomParameter* boundsParameter = m_owner.getCustomParameter(Kwidget::Constants::Bounds);
        boundsParameter->setValue(bounds.toString());
    }
 
    void KwidgetGUI::paint(Graphics& g)
    {
        auto backgroundBounds = getLocalBounds();
 
        if (m_renderStyle == KwidgetGUI::RenderStyle::minimised)
        {
            backgroundBounds = getTopBarComponent().getLocalBounds();
        }
 
        if (m_renderStyle == KwidgetGUI::RenderStyle::normal)
        {
            g.setColour(getLookAndFeel().findColour(ResizableWindow::backgroundColourId));
            g.fillRoundedRectangle(backgroundBounds.reduced(1).toFloat(), 8.0f);
 
            g.setColour(m_borderColour);
            g.drawRoundedRectangle(getLocalBounds().reduced(3).toFloat(), 6.0f, k_borderThickness);
        }
    }
 
    void KwidgetGUI::resized()
    {
        // GUI proportion we want to be on screen when dragged off limits - Bound constrainer not used atm
        // m_constrainer.setMinimumOnscreenAmounts(getHeight(), getWidth(), getHeight(), getWidth());
 
        if (m_ignorePadding)
        {
            m_currentBounds = getLocalBounds();
        }
        else
        {
            m_currentBounds = getLocalBounds().reduced(k_padding);
        }
 
        if (m_renderStyle == RenderStyle::normal || m_renderStyle == RenderStyle::minimised)
        {
            auto dim = k_buttonSize + k_padding;
            auto topBar = m_currentBounds.removeFromTop(dim);
 
            m_topBarComponent.setBounds(topBar);
        }
    }
 
    const String& KwidgetGUI::getKwidgetType() const { return m_owner.getKwidgetType(); }
 
    const String& KwidgetGUI::getKwidgetID() const { return m_owner.getKwidgetID(); }
 
    std::unique_ptr<SliderParameterAttachment> KwidgetGUI::createParameterAttachment(const String& paramID,
                                                                                     Slider& slider)
    {
        return std::make_unique<SliderParameterAttachment>(*m_owner.getParameter(paramID)->getAttachedParameter(),
                                                           slider, m_undoManager);
    }
 
    std::unique_ptr<ButtonParameterAttachment> KwidgetGUI::createParameterAttachment(const String& paramID,
                                                                                     Button& button)
    {
        return std::make_unique<ButtonParameterAttachment>(*m_owner.getParameter(paramID)->getAttachedParameter(),
                                                           button, m_undoManager);
    }
 
    std::unique_ptr<ComboBoxParameterAttachment> KwidgetGUI::createParameterAttachment(const String& paramID,
                                                                                       ComboBox& comboBox)
    {
        return std::make_unique<ComboBoxParameterAttachment>(*m_owner.getParameter(paramID)->getAttachedParameter(),
                                                             comboBox, m_undoManager);
    }
 
    std::unique_ptr<ParameterAttachment> KwidgetGUI::createParameterAttachment(const String& paramID,
                                                                               std::function<void(float)> callback)
    {
        return std::make_unique<ParameterAttachment>(*m_owner.getParameter(paramID)->getAttachedParameter(),
                                                     std::move(callback), m_undoManager);
    }
 
    std::unique_ptr<LabelCustomParameterAttachment> KwidgetGUI::createCustomParameterAttachment(const String& paramID,
                                                                                                Label& label)
    {
        return std::make_unique<LabelCustomParameterAttachment>(*m_owner.getCustomParameter(paramID), label);
    }
 
    Kwidget& KwidgetGUI::getOwner() { return m_owner; }
 
    void KwidgetGUI::addParameterCallback(const String& paramID, std::function<void(float)> callback)
    {
        m_parameterCallbacks.add(
                new KParameter::AsyncListenerObject(m_owner.getParameterToAttach(paramID), std::move(callback)));
    }
 
    void KwidgetGUI::setRenderStyle(RenderStyle newStyle)
    {
        m_renderStyle = newStyle;
 
#if ENABLE_SANDBOX
        CustomParameter* renderStyleParameter = m_owner.getCustomParameter(Kwidget::Constants::Renderstyle);
        renderStyleParameter->setValue(static_cast<int>(m_renderStyle));
 
        m_topBarComponent.setVisible(m_renderStyle != RenderStyle::borderless ||
                                     m_renderStyle != RenderStyle::borderless_with_buttons);
 
        String topBarComponentID = m_topBarComponent.getComponentID();
 
        if (m_renderStyle == RenderStyle::minimised)
        {
            setInterceptsMouseClicks(false, true);
            for (Component* child : getChildren())
            {
                if (child->getComponentID() != topBarComponentID)
                {
                    child->setVisible(false);
                    child->setEnabled(false);
                    child->setAccessible(false);
                }
            }
        }
        else
        {
            setInterceptsMouseClicks(true, true);
            toFront(false);
            for (Component* child : getChildren())
            {
                if (child->getComponentID() != topBarComponentID)
                {
                    child->setVisible(true);
                    child->setEnabled(true);
                    child->setAccessible(true);
                }
            }
        }
#endif
        repaint();
    }
 
    void KwidgetGUI::mouseDown(const MouseEvent& event)
    {
        String topBarComponentID = getTopBarComponent().getComponentID();
 
        if (event.eventComponent->getComponentID() == topBarComponentID)
        {
            m_dragger.startDraggingComponent(this, event);
            m_allowDrag = true;
        }
        else
        {
            m_allowDrag = false;
        }
    }
 
#if ENABLE_SANDBOX
    void KwidgetGUI::mouseDrag(const MouseEvent& event)
    {
        if (m_allowDrag == true)
        {
            m_dragger.dragComponent(this, event, nullptr);
            // Constaint the GUI within the screen - Not used atm
            // m_constrainer.checkComponentBounds(this);
        }
    }
#endif
} // namespace krotos