KwidgetGUI_XyPad.cpp

Go to the documentation of this file.

namespace krotos
{
    const String KwidgetGUI_XyPad::ComponentIds::ButtonNoteTriggerId("noteTriggerToggleButton");
 
    KwidgetGUI_XyPad::KwidgetGUI_XyPad(Kwidget& owner)
        : KwidgetGUI(owner), m_grainVisualiser(std::make_unique<GrainVisualiser>())
    {
        setLookAndFeel(&m_lookAndFeelv4);
        setRenderStyle(RenderStyle::borderless);
 
        addAndMakeVisible(m_grainVisualiser.get());
        addMouseListener(this, true);
        auto currentMode = dynamic_cast<Kwidget_XyPad*>(&getOwner())->getCurrentMode();
 
        m_editableLabelX = std::make_unique<AttachedLabel>(owner.getKwidgetLabel());
        m_editableLabelX->getAttachment() =
                createCustomParameterAttachment(Parameters::editableLabelX, m_editableLabelX->getLabel());
        m_editableLabelX->getLabel().setColour(juce::Label::textColourId, juce::Colours::lightgrey);
        m_editableLabelX->getLabel().setJustificationType(Justification::centredRight);
        addAndMakeVisible(m_editableLabelX.get());
 
        m_editableLabelY = std::make_unique<AttachedLabel>(owner.getKwidgetLabel());
        m_editableLabelY->getAttachment() =
                createCustomParameterAttachment(Parameters::editableLabelY, m_editableLabelY->getLabel());
        m_editableLabelY->getLabel().setColour(juce::Label::textColourId, juce::Colours::lightgrey);
        m_editableLabelY->getLabel().setJustificationType(Justification::centredLeft);
        addAndMakeVisible(m_editableLabelY.get());
 
        switch (currentMode)
        {
        case Kwidget_XyPad::Simple: {
            m_xyButton.createMask(KrotosBinaryData::XYPad_2Zone_svg, KrotosBinaryData::XYPad_2Zone_svgSize);
            break;
        }
        case Kwidget_XyPad::Distance: {
            m_xyButton.setMaskNotStreched();
            m_xyButton.createMask(KrotosBinaryData::XYPad_Distance_svg, KrotosBinaryData::XYPad_Distance_svgSize);
            // Change centering of x,y labels
            m_editableLabelX->getLabel().setJustificationType(Justification::centredLeft);
            m_editableLabelY->getLabel().setJustificationType(Justification::centred);
            // FOR NOW COPY WHAT WE HAVE IN 4 ZONE - Reposition after Nikolas Designs
            // Create two additional labels
            m_editableLabelW = std::make_unique<AttachedLabel>(owner.getKwidgetLabel());
            m_editableLabelW->getAttachment() =
                    createCustomParameterAttachment(Parameters::editableLabelW, m_editableLabelW->getLabel());
            m_editableLabelW->getLabel().setColour(juce::Label::textColourId, juce::Colours::lightgrey);
            m_editableLabelW->getLabel().setJustificationType(Justification::centred);
            addAndMakeVisible(m_editableLabelW.get());
 
            m_editableLabelZ = std::make_unique<AttachedLabel>(owner.getKwidgetLabel());
            m_editableLabelZ->getAttachment() =
                    createCustomParameterAttachment(Parameters::editableLabelZ, m_editableLabelZ->getLabel());
            m_editableLabelZ->getLabel().setColour(juce::Label::textColourId, juce::Colours::lightgrey);
            m_editableLabelZ->getLabel().setJustificationType(Justification::centredLeft);
            addAndMakeVisible(m_editableLabelZ.get());
            break;
        }
        case Kwidget_XyPad::Peak: {
            m_xyButton.createMask(KrotosBinaryData::XYPad_Peak_svg, KrotosBinaryData::XYPad_Peak_svgSize);
 
            // Change centering of x,y labels
            m_editableLabelX->getLabel().setJustificationType(Justification::centredLeft);
            m_editableLabelY->getLabel().setJustificationType(Justification::centredRight);
            // FOR NOW COPY WHAT WE HAVE IN 4 ZONE - Reposition after Nikolas Designs
            // Create two additional labels
            m_editableLabelW = std::make_unique<AttachedLabel>(owner.getKwidgetLabel());
            m_editableLabelW->getAttachment() =
                    createCustomParameterAttachment(Parameters::editableLabelW, m_editableLabelW->getLabel());
            m_editableLabelW->getLabel().setColour(juce::Label::textColourId, juce::Colours::lightgrey);
            m_editableLabelW->getLabel().setJustificationType(Justification::centredRight);
            addAndMakeVisible(m_editableLabelW.get());
 
            m_editableLabelZ = std::make_unique<AttachedLabel>(owner.getKwidgetLabel());
            m_editableLabelZ->getAttachment() =
                    createCustomParameterAttachment(Parameters::editableLabelZ, m_editableLabelZ->getLabel());
            m_editableLabelZ->getLabel().setColour(juce::Label::textColourId, juce::Colours::lightgrey);
            m_editableLabelZ->getLabel().setJustificationType(Justification::centredLeft);
            addAndMakeVisible(m_editableLabelZ.get());
            break;
        }
        case Kwidget_XyPad::FourZone: {
            m_xyButton.createMask(KrotosBinaryData::XYPad_4Zone_svg, KrotosBinaryData::XYPad_4Zone_svgSize);
            // Change centering of x,y labels
            m_editableLabelX->getLabel().setJustificationType(Justification::centredLeft);
            m_editableLabelY->getLabel().setJustificationType(Justification::centredRight);
            // FOR NOW COPY WHAT WE HAVE IN 4 ZONE - Reposition after Nikolas Designs
            // Create two additional labels
            m_editableLabelW = std::make_unique<AttachedLabel>(owner.getKwidgetLabel());
            m_editableLabelW->getAttachment() =
                    createCustomParameterAttachment(Parameters::editableLabelW, m_editableLabelW->getLabel());
            m_editableLabelW->getLabel().setColour(juce::Label::textColourId, juce::Colours::lightgrey);
            m_editableLabelW->getLabel().setJustificationType(Justification::centredRight);
            addAndMakeVisible(m_editableLabelW.get());
 
            m_editableLabelZ = std::make_unique<AttachedLabel>(owner.getKwidgetLabel());
            m_editableLabelZ->getAttachment() =
                    createCustomParameterAttachment(Parameters::editableLabelZ, m_editableLabelZ->getLabel());
            m_editableLabelZ->getLabel().setColour(juce::Label::textColourId, juce::Colours::lightgrey);
            m_editableLabelZ->getLabel().setJustificationType(Justification::centredLeft);
            addAndMakeVisible(m_editableLabelZ.get());
            break;
        }
        case Kwidget_XyPad::Polar: { // TODO: If we decide we want this XYPad we need a mask from Nikolas (best
                                     // concentric circles with fading alpha)
            m_xyButton.createMask(KrotosBinaryData::XYPad_2Zone_svg, KrotosBinaryData::XYPad_2Zone_svgSize);
            break;
        }
        }
 
        addAndMakeVisible(m_xyButton);
 
        // Set up toggle label
        addChildComponent(m_toggleLabel);
        m_toggleLabel.setVisible(owner.getParameter(Parameters::toggleOn)->getValue() > 0.0f);
        m_toggleLabel.setJustificationType(Justification::centredBottom);
        m_toggleLabel.setBorderSize(BorderSize<int>(8));
        m_toggleLabel.setColour(Label::textColourId, Colours::white.withAlpha(0.3f));
        m_toggleLabel.setText("Click or drag\nto trigger a performance", dontSendNotification);
        m_toggleLabel.setInterceptsMouseClicks(false, false);
        m_toggleLabelAttachment = createParameterAttachment(
                Parameters::toggleOn, [=](float value) { m_toggleLabel.setVisible(value > 0.0f); });
 
        auto& xParam = *owner.getParameter(Parameters::posX)->getAttachedParameter();
        auto& yParam = *owner.getParameter(Parameters::posY)->getAttachedParameter();
        auto& clickParam = *owner.getParameter(Parameters::onClick)->getAttachedParameter();
        auto& toggleParam = *owner.getParameter(Parameters::toggleOn)->getAttachedParameter();
 
        m_xyButtonAttachment.reset(
                new XYButtonParameterAttachment(xParam, yParam, clickParam, toggleParam, m_xyButton));
        m_contextMenu.setComponentID(ComponentIds::ButtonNoteTriggerId);
 
        addAndMakeVisible(m_contextMenu);
        m_contextMenu.onClick = [&] { showContextMenu(); };
 
#if ENABLE_REFORMER
        // Starts slow because we are only polling for the existence of a suitable
        // kwidget to display
        startTimerSlow(true);
#endif
    }
 
    KwidgetGUI_XyPad::~KwidgetGUI_XyPad() { setLookAndFeel(nullptr); }
 
#if ENABLE_REFORMER
    void KwidgetGUI_XyPad::startTimerSlow(bool goSlow)
    {
        if (goSlow && !m_goSlow)
        {
            m_goSlow = true;
            startTimerHz(PAINT_REFRESH_TIMER_HZ_SLOW);
        }
        else if (!goSlow && m_goSlow)
        {
            m_goSlow = false;
            startTimerHz(PAINT_REFRESH_TIMER_HZ_NORMAL);
        }
    }
 
    void KwidgetGUI_XyPad::timerCallback()
    {
        if (auto toggleParameter = getOwner().getParameter(Parameters::toggleOn); !toggleParameter->isOn())
        {
            // If "Note Trigger" is not on then
            // we are not going to paint in the grain visualiser
            // Switch on the default XY button background
            m_xyButton.setPaintBackground(true);
            m_grainVisualiser->setVisible(false);
            // Do slow polling to save CPU
            startTimerSlow(true);
            return; // Then go home
        }
 
        m_grainVisualiser->setPuckPosition(m_xyButton.getPuckPosition());
 
        // GEt a pointer to the kwidget audio processor
        auto kProcessor = static_cast<Kwidget_XyPad&>(getOwner()).getKwidgetAudioProcessorReference();
        if (kProcessor == nullptr)
        {
            return; // Return if no access to kwidget audio processor
        }
 
        auto& thisXyPadId = getKwidgetID();
 
        // Get a list of all the KwidgetFactory::KwidgetType::Reformer type kwidgets in the system
        auto reformerKwidgets =
                kProcessor->getKwidgetsOfTypeWithAccessPermission(KwidgetFactory::KwidgetType::Reformer, thisXyPadId);
 
        if (m_activeReformerKwidgets != reformerKwidgets.size())
        {
            m_grainVisualiser->requestBackgroundCacheRegeneration();
            m_activeReformerKwidgets = reformerKwidgets.size();
        }
 
        // Are there any Reformer kwidgets to display ?
        if (reformerKwidgets.size() == 0)
        {
            // No reformer kwidget was found - so we are not going to paint in the grain visualiser
            // Instead, we switch on the default XY button background
            m_xyButton.setPaintBackground(true);
            m_grainVisualiser->setVisible(false);
            startTimerSlow(true);
            if (m_frameCooldownCounter < FRAME_COOLDOWN)
            {
                // Draw a few frames after grains stop playing
                m_frameCooldownCounter++;
                m_grainVisualiser->repaint();
            }
        }
        else // At least one reformer kwidget was found
        {
            // move the x and y labels for XYButton when using reformer kwidget
            m_editableLabelX->getLabel().setJustificationType(Justification::centred);
            m_editableLabelY->getLabel().setJustificationType(Justification::centred);
            resized();
 
            m_grainVisualiser->prepareToAddSampleEngines();
            for (int i = 0; i < jmin<int>(GrainVisualiser::ReformerMaxDisplayedInstances, reformerKwidgets.size()); i++)
            {
                // Cast Kwidget pointer into a reformer kwidget
                auto reformerKwidget = dynamic_cast<Kwidget_Reformer*>(reformerKwidgets[i]);
                if (reformerKwidget != nullptr)
                {
                    // Copy the sound data which we want to display
                    m_grainVisualiser->shallowCopy(reformerKwidget->getSound());
                }
                // We no longer need a lock on the kwidget since we have copied the data we need
                reformerKwidgets[i]->finishedAccessing(thisXyPadId);
            }
            // This call allows us to count the active engines, and detect any change
            // in that count. If the number of active engines changes, a re-draw of the
            // background cache is triggered
            m_grainVisualiser->finishedAddingSampleEngines();
 
            // At this point, all the data which the grain visualiser requires to do its job
            // has been copied into the grain visualiser, and we have handed back the locks
            // on the kwidgets which supplied the data using finishedAccessing()
 
            // No further resource locking is required. Grain visualiser paint() has its own copy
            // of the data now and can use it freely. This timer callback is the only place
            // where that data can be modified, added or removed, and this is on the message thread
            // Since paint() calls are also on the message thread, there is no danger that data
            // will change during a paint call
 
            // Switch to full speed display rate
            startTimerSlow(false);
            m_frameCooldownCounter = 0;
            m_xyButton.setPaintBackground(false);
            m_grainVisualiser->setVisible(true);
            m_grainVisualiser->setPerformMode(m_performMode);
            m_grainVisualiser->repaint();
        }
    }
 
#endif
 
    void KwidgetGUI_XyPad::paint(Graphics& g) { KwidgetGUI::paint(g); }
 
    void KwidgetGUI_XyPad::drawDebugGraphics(Graphics& g)
    {
        auto xyButtonBounds = m_xyButton.getBounds();
 
        int maxDimension = jmax(xyButtonBounds.getWidth(), xyButtonBounds.getHeight());
        float radius = 0.7f * maxDimension;
        auto currentMode = dynamic_cast<Kwidget_XyPad*>(&getOwner())->getCurrentMode();
        switch (currentMode)
        {
        case Kwidget_XyPad::xyMode::FourZone: {
            // g.setColour(Colours::aqua);
            // g.drawRect(xyButtonBounds);
 
            // Top left corner Arc
            juce::Path path;
            path.addCentredArc(
                    /*centreX*/ static_cast<float>(xyButtonBounds.getTopLeft().getX()),
                    /*centreY*/ static_cast<float>(xyButtonBounds.getTopLeft().getY()),
                    /*radiusX*/ radius,
                    /*radiusY*/ radius,
                    /*rotationOfEllipse*/ MathConstants<float>::halfPi,
                    /*fromRadians*/ 0.0f,
                    /*toRadians*/ MathConstants<float>::halfPi,
                    /*startAsNewSubPath*/ true);
            g.setColour(Colours::lightgrey);
            g.strokePath(path, PathStrokeType(static_cast<float>(3.0f)));
            // Top right corner Arc
            juce::Path path1;
            path1.addCentredArc(
                    /*centreX*/ static_cast<float>(xyButtonBounds.getTopRight().getX()),
                    /*centreY*/ static_cast<float>(xyButtonBounds.getTopRight().getY()),
                    /*radiusX*/ radius,
                    /*radiusY*/ radius,
                    /*rotationOfEllipse*/ MathConstants<float>::twoPi,
                    /*fromRadians*/ 0.0f,
                    /*toRadians*/ MathConstants<float>::halfPi * 3.0f,
                    /*startAsNewSubPath*/ true);
            g.setColour(Colours::darkgrey);
            g.strokePath(path1, PathStrokeType(static_cast<float>(3.0f)));
            // Bottom left corner Arc
            juce::Path path2;
            path2.addCentredArc(
                    /*centreX*/ static_cast<float>(xyButtonBounds.getBottomLeft().getX()),
                    /*centreY*/ static_cast<float>(xyButtonBounds.getBottomLeft().getY()),
                    /*radiusX*/ radius,
                    /*radiusY*/ radius,
                    /*rotationOfEllipse*/ MathConstants<float>::twoPi,
                    /*fromRadians*/ 0.0f,
                    /*toRadians*/ MathConstants<float>::halfPi,
                    /*startAsNewSubPath*/ true);
            g.setColour(Colours::blanchedalmond);
            g.strokePath(path2, PathStrokeType(static_cast<float>(3.0f)));
            // Bottom right corner Arc
            juce::Path path3;
            path3.addCentredArc(
                    /*centreX*/ static_cast<float>(xyButtonBounds.getBottomRight().getX()),
                    /*centreY*/ static_cast<float>(xyButtonBounds.getBottomRight().getY()),
                    /*radiusX*/ radius,
                    /*radiusY*/ radius,
                    /*rotationOfEllipse*/ MathConstants<float>::twoPi,
                    /*fromRadians*/ MathConstants<float>::halfPi * 3.0f,
                    /*toRadians*/ MathConstants<float>::twoPi,
                    /*startAsNewSubPath*/ true);
            g.setColour(Colours::darkcyan);
            g.strokePath(path3, PathStrokeType(static_cast<float>(3.0f)));
            break;
        }
        case Kwidget_XyPad::xyMode::Peak: {
            // g.setColour(Colours::aqua);
            // g.drawRect(xyButtonBounds);
 
            g.setColour(Colours::lightgrey);
            auto lineHeight = static_cast<float>(xyButtonBounds.getHeight() + xyButtonBounds.getHeight() / 8.0f);
            auto linePoint = xyButtonBounds.getWidth() / 2;
            auto start = static_cast<float>(xyButtonBounds.getTopLeft().getY());
            g.drawVerticalLine(linePoint, start, lineHeight);
        }
        }
    }
 
    void KwidgetGUI_XyPad::resized()
    {
        auto currentMode = dynamic_cast<Kwidget_XyPad*>(&getOwner())->getCurrentMode();
 
        m_ignorePadding = true;
        KwidgetGUI::resized();
        Rectangle<int> mainRect = m_currentBounds;
 
        float masterWidth = (float)mainRect.getWidth();
        float masterHeight = (float)mainRect.getHeight();
 
        if (m_contextMenu.isVisible())
        {
            auto contextMenuRect = mainRect.removeFromRight(constants.contextMenuSize);
            mainRect.removeFromBottom(constants.contextMenuSize);
 
            masterWidth = (float)mainRect.getWidth();
            masterHeight = (float)mainRect.getHeight();
 
            contextMenuRect.removeFromTop(constants.contextMenuMargin);
            m_contextMenu.setBounds(contextMenuRect.removeFromTop(constants.contextMenuSize));
        }
 
        // calculate xyButton dimensions to resize
        auto xyButtonCenter = mainRect.getCentre().toFloat(); // Point<float>(masterWidth * 0.5f, masterHeight * 0.5f);
        auto xyButtonBounds = Rectangle<float>()
                                      .withCentre(xyButtonCenter)
                                      .withSizeKeepingCentre(masterWidth, masterHeight - constants.LabelPadding);
        m_xyButton.setBounds(xyButtonBounds.toNearestInt());
        m_grainVisualiser->setBounds(xyButtonBounds.toNearestInt());
 
        // generic label dimensions
        // TODO These values should come from LaF
        auto labelFont = Font().withPointHeight(static_cast<float>(constants.FontSize));
        labelFont.setExtraKerningFactor(constants.KerningFactor);
        int labelHeight = constants.LabelPadding / 2;
        int labelWidth = mainRect.getWidth() / 2;
 
        // hide toggle label if xy pad is smaller than small width
        auto toggleLabelBounds =
                masterWidth > constants.mediumXYWidth ? xyButtonBounds.toNearestInt() : Rectangle<int>(0, 0);
        m_toggleLabel.setBounds(
                toggleLabelBounds.removeFromBottom(static_cast<int>(toggleLabelBounds.getHeight() * 0.3f)));
        m_toggleLabel.setFont(labelFont);
 
        // toggle button bounds
        Rectangle<int> toggleButtonBounds;
 
        switch (currentMode)
        {
        case Kwidget_XyPad::Simple: {
            Rectangle<int> labelBoundsX;
            Rectangle<int> labelBoundsY;
 
            if (m_xyButton.getPaintBackground())
            {
                // label X
                labelBoundsX = Rectangle<int>(mainRect.getWidth() - labelWidth, mainRect.getHeight() - labelHeight,
                                              labelWidth, labelHeight);
 
                // label Y
                labelBoundsY = Rectangle<int>(mainRect.getX(), mainRect.getY(), labelWidth, labelHeight);
            }
            else // if we're dealing with a reformer attachment
            {
                // Calculate the center position for the labels
                int labelCenterX = mainRect.getX() + mainRect.getWidth() / 2;
 
                // Calculate half width of the label
                int halfLabelWidth = labelWidth / 2;
 
                // Calculate the Y position for the labels, adjusting for labelHeight
                int labelYPosition = mainRect.getY();
 
                // label X (centered underneath the xy button)
                labelBoundsX = Rectangle<int>(labelCenterX - halfLabelWidth, mainRect.getHeight() - labelHeight,
                                              labelWidth, labelHeight);
 
                // label Y (centered above the xy button)
                labelBoundsY = Rectangle<int>(labelCenterX - halfLabelWidth, labelYPosition, labelWidth, labelHeight);
            }
 
            m_editableLabelX->setBounds(labelBoundsX);
            m_editableLabelX->getLabel().setFont(labelFont);
 
            m_editableLabelY->setBounds(labelBoundsY);
            m_editableLabelY->getLabel().setFont(labelFont);
 
            // toggle button bounds
            toggleButtonBounds =
                    Rectangle<int>(mainRect.getX(), mainRect.getHeight() - labelHeight, labelWidth / 3, labelHeight);
            break;
        }
        case Kwidget_XyPad::Distance: {
            // label X
            Rectangle<int> labelBoundsX = Rectangle<int>(mainRect.getX(), mainRect.getY(), labelWidth, labelHeight);
            m_editableLabelX->setBounds(labelBoundsX);
            m_editableLabelX->getLabel().setFont(labelFont);
 
            // label Y
            Rectangle<int> labelBoundsY =
                    Rectangle<int>((mainRect.getWidth() / 2.0f) - 50, mainRect.getY(), labelWidth, labelHeight);
            m_editableLabelY->setBounds(labelBoundsY);
            m_editableLabelY->getLabel().setFont(labelFont);
 
            // label W
            Rectangle<int> labelBoundsW = Rectangle<int>((mainRect.getWidth() / 2.0f) - 50,
                                                         mainRect.getHeight() - labelHeight, labelWidth, labelHeight);
            m_editableLabelW->setBounds(labelBoundsW);
            m_editableLabelW->getLabel().setFont(labelFont);
 
            // label Z
            Rectangle<int> labelBoundsZ = Rectangle<int>(mainRect.getX(), mainRect.getHeight() - labelHeight,
                                                         labelWidth - constants.toggleOffset, labelHeight);
            m_editableLabelZ->setBounds(labelBoundsZ);
            m_editableLabelZ->getLabel().setFont(labelFont);
 
            // put toggle in the middle so it's visible for now
            toggleButtonBounds = Rectangle<int>(0, mainRect.getHeight() - labelHeight, labelWidth / 3, labelHeight);
            break;
        }
        case Kwidget_XyPad::Peak: {
            // FOR NOW COPY WHAT WE HAVE IN 4 ZONE - Reposition after Nikolas Designs
            //  label X
            Rectangle<int> labelBoundsX = Rectangle<int>(mainRect.getX(), mainRect.getY(), labelWidth, labelHeight);
            m_editableLabelX->setBounds(labelBoundsX);
            m_editableLabelX->getLabel().setFont(labelFont);
 
            // label Y
            Rectangle<int> labelBoundsY =
                    Rectangle<int>(mainRect.getWidth() - labelWidth, mainRect.getY(), labelWidth, labelHeight);
            m_editableLabelY->setBounds(labelBoundsY);
            m_editableLabelY->getLabel().setFont(labelFont);
 
            // label W
            Rectangle<int> labelBoundsW = Rectangle<int>(mainRect.getWidth() - labelWidth,
                                                         mainRect.getHeight() - labelHeight, labelWidth, labelHeight);
            m_editableLabelW->setBounds(labelBoundsW);
            m_editableLabelW->getLabel().setFont(labelFont);
 
            // label Z
            Rectangle<int> labelBoundsZ = Rectangle<int>(mainRect.getX(), mainRect.getHeight() - labelHeight,
                                                         labelWidth - constants.toggleOffset, labelHeight);
            m_editableLabelZ->setBounds(labelBoundsZ);
            m_editableLabelZ->getLabel().setFont(labelFont);
 
            // put toggle in the middle so it's visible for now
            toggleButtonBounds = Rectangle<int>((mainRect.getWidth() / 2.0f) - constants.toggleOffset,
                                                mainRect.getHeight() - labelHeight, labelWidth / 3, labelHeight);
            break;
        }
        case Kwidget_XyPad::FourZone: {
            // label X
            Rectangle<int> labelBoundsX = Rectangle<int>(mainRect.getX(), mainRect.getY(), labelWidth, labelHeight);
            m_editableLabelX->setBounds(labelBoundsX);
            m_editableLabelX->getLabel().setFont(labelFont);
 
            // label Y
            Rectangle<int> labelBoundsY =
                    Rectangle<int>(mainRect.getWidth() - labelWidth, mainRect.getY(), labelWidth, labelHeight);
            m_editableLabelY->setBounds(labelBoundsY);
            m_editableLabelY->getLabel().setFont(labelFont);
 
            // label W
            Rectangle<int> labelBoundsW = Rectangle<int>(mainRect.getWidth() - labelWidth,
                                                         mainRect.getHeight() - labelHeight, labelWidth, labelHeight);
            m_editableLabelW->setBounds(labelBoundsW);
            m_editableLabelW->getLabel().setFont(labelFont);
 
            // label Z
            Rectangle<int> labelBoundsZ = Rectangle<int>(mainRect.getX(), mainRect.getHeight() - labelHeight,
                                                         labelWidth - constants.toggleOffset, labelHeight);
            m_editableLabelZ->setBounds(labelBoundsZ);
            m_editableLabelZ->getLabel().setFont(labelFont);
 
            // put toggle in the middle so it's visible for now
            toggleButtonBounds = Rectangle<int>((mainRect.getWidth() / 2.0f) - constants.toggleOffset,
                                                mainRect.getHeight() - labelHeight, labelWidth / 3, labelHeight);
            break;
        }
        case Kwidget_XyPad::Polar: {
            Rectangle<int> labelBoundsX;
            Rectangle<int> labelBoundsY;
            if (m_xyButton.getPaintBackground())
            {
                // label X
                labelBoundsX = Rectangle<int>(mainRect.getWidth() - labelWidth, mainRect.getHeight() - labelHeight,
                                              labelWidth, labelHeight);
                // label Y
                labelBoundsY = Rectangle<int>(mainRect.getX(), mainRect.getY(), labelWidth, labelHeight);
            }
            else // if we're dealing with a reformer attachment
            {
                // Calculate the center position for the labels
                int labelCenterX = mainRect.getX() + mainRect.getWidth() / 2;
                // Calculate half width of the label
                int halfLabelWidth = labelWidth / 2;
                // Calculate the Y position for the labels, adjusting for labelHeight
                int labelYPosition = mainRect.getY();
                // label X (centered underneath the xy button)
                labelBoundsX = Rectangle<int>(labelCenterX - halfLabelWidth, mainRect.getHeight() - labelHeight,
                                              labelWidth, labelHeight);
                // label Y (centered above the xy button)
                labelBoundsY = Rectangle<int>(labelCenterX - halfLabelWidth, labelYPosition, labelWidth, labelHeight);
            }
            m_editableLabelX->setBounds(labelBoundsX);
            m_editableLabelX->getLabel().setFont(labelFont);
            m_editableLabelY->setBounds(labelBoundsY);
            m_editableLabelY->getLabel().setFont(labelFont);
            // toggle button bounds
            toggleButtonBounds =
                    Rectangle<int>(mainRect.getX(), mainRect.getHeight() - labelHeight, labelWidth / 3, labelHeight);
            break;
        }
        }
 
        if (m_toggleVisibility == false && m_performMode == true)
        {
            m_editableLabelX->getLabel().setEditable(false);
            m_editableLabelY->getLabel().setEditable(false);
            if (currentMode == Kwidget_XyPad::FourZone || currentMode == Kwidget_XyPad::Peak ||
                currentMode == Kwidget_XyPad::Distance)
            {
                m_editableLabelW->getLabel().setEditable(false);
                m_editableLabelZ->getLabel().setEditable(false);
            }
            m_contextMenu.setVisible(false);
        }
        else
        {
            m_editableLabelX->getLabel().setEditable(false, false, true, true);
            m_editableLabelY->getLabel().setEditable(false, false, true, true);
            if (currentMode == Kwidget_XyPad::FourZone || currentMode == Kwidget_XyPad::Peak ||
                currentMode == Kwidget_XyPad::Distance)
            {
                m_editableLabelW->getLabel().setEditable(false, false, true, true);
                m_editableLabelZ->getLabel().setEditable(false, false, true, true);
            }
            m_contextMenu.setVisible(true);
        }
    }
 
    void KwidgetGUI_XyPad::setToggleVisibility(bool visible)
    {
        // set a boolean for visibility for the note toggle control
        // but only hide when m_toggleVisibility is false and we're
        // displaying in the perform mode.
        m_toggleVisibility = visible;
    }
 
    void KwidgetGUI_XyPad::showContextMenu()
    {
        PopupMenu menu;
        enum menuOptions
        {
            NoteTrigger = 1
        };
        menu.addItem(menuOptions::NoteTrigger, "Note Trigger", true,
                     getOwner().getParameter(Parameters::toggleOn)->isOn());
 
        std::function<void(int)> menuCallback = [&](int itemResultID) {
            switch (static_cast<menuOptions>(itemResultID))
            {
            case menuOptions::NoteTrigger:
                // Get the parameter again since menu callback may be separated in scope
                auto noteTriggerParameter = getOwner().getParameter(Parameters::toggleOn);
                noteTriggerParameter->set(!noteTriggerParameter->isOn());
                break;
            }
        };
 
        menu.showMenuAsync(PopupMenu::Options{}
                                   .withTargetComponent(m_contextMenu)
                                   .withMinimumNumColumns(1)
                                   .withMinimumWidth(114)
                                   .withStandardItemHeight(20),
                           menuCallback);
    }
} // namespace krotos