XYButton.cpp

Go to the documentation of this file.

#include "XYButton.h"
 
namespace krotos
{
    const std::string XYButton::analyticsEventMouseDown{"analyticsEventMouseDown"};
 
    XYButton::XYButton(String xLabel, String /*yLabel*/) : Button(xLabel)
    {
        m_background = Drawable::createFromImageData(KrotosBinaryData::XYPad_Background_png,
                                                     KrotosBinaryData::XYPad_Background_pngSize);
    }
 
    void XYButton::paintOverChildren(Graphics& g)
    {
        if (m_paintBackground)
        {
            m_background->drawWithin(g, m_bounds.toFloat(), RectanglePlacement::stretchToFit, 1.0f);
 
            if (m_maskStreched)
            {
                m_twoZoneMask->drawWithin(g, m_maskBounds.toFloat(), RectanglePlacement::stretchToFit, 0.1f);
            }
            else
            {
                m_twoZoneMask->drawWithin(g, m_maskBounds.toFloat(), RectanglePlacement::stretchToFit, 0.2f);
            }
        }
 
        // Flip the y axis to convert GUI coords to screen coords
        auto flippedPuckPosition = Point<float>(m_puckPosition.x, 1.f - m_puckPosition.y);
 
        // Scale movement to the size of the boundary
        m_scaledPuckPosition = flippedPuckPosition *
                               Point<float>(m_puckBoundary.toFloat().getWidth(), m_puckBoundary.toFloat().getHeight());
 
        // Center the movement with respect to the overall bounds
        m_scaledPuckPosition +=
                Point<float>(static_cast<float>(m_layout.puckRadius), static_cast<float>(m_layout.puckRadius));
 
        if (m_paintBackground) // draw classic puck
        {
            // Ellipse lines are measured to the center of the line, so make the
            // draw bounds smaller by line thickness so we get the diameter we
            // need
            const int puckDrawDiameter = m_layout.puckDiameter - m_layout.puckLineWidth;
 
            // Create an enclosing rectangle for the puck
            m_puckBounds = Rectangle<float>(0.f, 0.f, static_cast<float>(puckDrawDiameter),
                                            static_cast<float>(puckDrawDiameter))
                                   .withCentre(m_scaledPuckPosition);
 
            // Draw the puck
            if (m_mouseOverPuck && !m_mouseIsDown)
            {
                g.setColour(m_layout.colourPuckMouseOver);
                g.fillEllipse(m_puckBounds); // Fill in the center
            }
            else if (m_mouseIsDown)
            {
                g.setColour(m_layout.colourPuckMouseDown);
            }
            else
            {
                g.setColour(m_layout.colourPuckDefault);
            }
 
            // fillEllipse is smaller in diameter than drawEllipse by line thickness, and is not anti-aliased
            // so will filled ellipse we still draw in the drawEllipse below to bring diameter back to size and
            // smoothness
            g.drawEllipse(m_puckBounds, static_cast<float>(m_layout.puckLineWidth)); // Draw the outline
        }
        else // draw crosshair
        {
            float minOpacity = 0.0f;
            float maxOpacity = m_mouseOverPuck || m_mouseIsDown ? 1.0f : 0.5f;
 
            Colour crosshairColor = Colours::white;
 
            g.setColour(crosshairColor);
 
            // Horizontal line (top)
            drawGradientLine(g, m_scaledPuckPosition.x - m_layout.crosshairGap / 2, m_scaledPuckPosition.y,
                             m_scaledPuckPosition.x - m_layout.crosshairLength / 2, m_scaledPuckPosition.y,
                             m_layout.crosshairLineWidth, minOpacity, maxOpacity);
 
            // Horizontal line (bottom)
            drawGradientLine(g, m_scaledPuckPosition.x + m_layout.crosshairGap / 2, m_scaledPuckPosition.y,
                             m_scaledPuckPosition.x + m_layout.crosshairLength / 2, m_scaledPuckPosition.y,
                             m_layout.crosshairLineWidth, minOpacity, maxOpacity);
 
            // Vertical line (left)
            drawGradientLine(g, m_scaledPuckPosition.x, m_scaledPuckPosition.y - m_layout.crosshairGap / 2,
                             m_scaledPuckPosition.x, m_scaledPuckPosition.y - m_layout.crosshairLength / 2,
                             m_layout.crosshairLineWidth, minOpacity, maxOpacity);
 
            // Vertical line (right)
            drawGradientLine(g, m_scaledPuckPosition.x, m_scaledPuckPosition.y + m_layout.crosshairGap / 2,
                             m_scaledPuckPosition.x, m_scaledPuckPosition.y + m_layout.crosshairLength / 2,
                             m_layout.crosshairLineWidth, minOpacity, maxOpacity);
 
            // Draw a hollow square box with rounded corners to represent the crosshair gap when the mouse is down
            if (m_mouseIsDown)
            {
                float squareSize = m_layout.crosshairGap; // set the square size to be the same as the gap
                float xStart = m_scaledPuckPosition.x - squareSize / 2;
                float yStart = m_scaledPuckPosition.y - squareSize / 2;
                float cornerRadius = 1.0f;
 
                // create a path object to draw the rounded rectangle
                Path roundedRectPath;
 
                // Define the four corners of the rectangle with rounded corners
                roundedRectPath.addRoundedRectangle(xStart, yStart, squareSize, squareSize, cornerRadius);
 
                // Use the strokePath method to draw the path with the specified line width
                g.strokePath(roundedRectPath, PathStrokeType(m_layout.crosshairLineWidth));
            }
        }
    }
 
    void XYButton::drawGradientLine(Graphics& g, float startX, float startY, float endX, float endY, float lineWidth,
                                    float minOpacity, float maxOpacity)
    {
        float steps = std::max(std::abs(endX - startX), std::abs(endY - startY));
        float xStep = (endX - startX) / steps;
        float yStep = (endY - startY) / steps;
 
        float opacityStep = (maxOpacity - minOpacity) / steps;
 
        for (int i = 0; i < steps; ++i)
        {
            float xStart = startX + i * xStep;
            float yStart = startY + i * yStep;
            float xEnd = startX + (i + 1) * xStep;
            float yEnd = startY + (i + 1) * yStep;
 
            float opacity = maxOpacity - i * opacityStep;
            g.setOpacity(opacity);
 
            g.drawLine(xStart, yStart, xEnd, yEnd, lineWidth);
        }
        // reset opacity
        g.setOpacity(1.0f);
    }
 
    void XYButton::resized()
    {
        m_bounds = getLocalBounds();
        m_puckBoundary = m_bounds.reduced(m_layout.puckRadius);
 
        if (m_maskStreched)
        {
            m_maskBounds = m_bounds.expanded(m_bounds.getWidth() / 2);
        }
        else
        {
            m_wholeBounds = getLocalBounds();
            m_wholeBounds.removeFromBottom(15);
            m_wholeBounds.removeFromLeft(8);
            m_wholeBounds.removeFromRight(8);
            m_maskBounds = m_wholeBounds;
        }
    }
 
    void XYButton::setToggleValue(float x)
    {
        if (x == 1.0f)
            m_toggleValue = true;
        else if (x == 0.0f)
            m_toggleValue = false;
    }
 
    bool XYButton::getToggleValue() { return m_toggleValue; }
 
    void XYButton::setPuckPosition(Point<int> position)
    {
        auto clampedOffsetPos =
                m_puckBoundary.getConstrainedPoint(position).toFloat(); // Clamp the raw position within m_puckBoundary
        clampedOffsetPos -= Point<int>(m_layout.puckRadius, m_layout.puckRadius)
                                    .toFloat(); // Offset it by puck radius to center puck on mouse pointer
        clampedOffsetPos /= Point<int>(m_puckBoundary.getWidth(), m_puckBoundary.getHeight())
                                    .toFloat();                // Convert from pixel values to normalised 0.0f -> 1.0f
        clampedOffsetPos.setY(1.0f - clampedOffsetPos.getY()); // Flip the Y axis to match screen coords to GUI coords
        setNormalisedPuckPosition(clampedOffsetPos);
    }
 
    void XYButton::setNormalisedPuckPosition(Point<float> pos)
    {
        m_puckPosition = pos;
        if (puckPositionChanged != nullptr)
            puckPositionChanged(pos);
        repaint();
    }
 
    void XYButton::mouseMove(const MouseEvent& event)
    {
        // check if the mouse is over the circular puck
        float puckRadius = m_layout.puckRadius;
        Point<float> puckCenter = m_scaledPuckPosition;
 
        float distanceToPuck = event.position.getDistanceFrom(puckCenter);
 
        bool isMouseOverPuck = distanceToPuck <= puckRadius;
 
        // check if the mouse is over the crosshair lines
        // convert mouse position to scaled coordinates
        Point<float> mousePosition = event.position;
        mousePosition =
                mousePosition * Point<float>(m_puckBoundary.toFloat().getWidth(), m_puckBoundary.toFloat().getHeight());
        mousePosition += Point<float>(static_cast<float>(m_layout.puckRadius), static_cast<float>(m_layout.puckRadius));
 
        // calculate the boundaries of the crosshair lines
        Rectangle<float> horizontalTopLine(m_scaledPuckPosition.x - m_layout.crosshairLength / 2,
                                           m_scaledPuckPosition.y - m_layout.crosshairLineWidth / 2,
                                           m_layout.crosshairLength, m_layout.crosshairLineWidth);
 
        Rectangle<float> horizontalBottomLine(m_scaledPuckPosition.x - m_layout.crosshairLength / 2,
                                              m_scaledPuckPosition.y - m_layout.crosshairLineWidth / 2,
                                              m_layout.crosshairLength, m_layout.crosshairLineWidth);
 
        Rectangle<float> verticalLeftLine(m_scaledPuckPosition.x - m_layout.crosshairLineWidth / 2,
                                          m_scaledPuckPosition.y - m_layout.crosshairLength / 2,
                                          m_layout.crosshairLineWidth, m_layout.crosshairLength);
 
        Rectangle<float> verticalRightLine(m_scaledPuckPosition.x - m_layout.crosshairLineWidth / 2,
                                           m_scaledPuckPosition.y - m_layout.crosshairLength / 2,
                                           m_layout.crosshairLineWidth, m_layout.crosshairLength);
 
        // check if the mouse is over any of the crosshair lines
        bool isMouseOverCrosshair =
                horizontalTopLine.contains(mousePosition) || horizontalBottomLine.contains(mousePosition) ||
                verticalLeftLine.contains(mousePosition) || verticalRightLine.contains(mousePosition);
 
        // update the mouseOverPuck state based on both conditions
        m_mouseOverPuck = isMouseOverPuck || isMouseOverCrosshair;
 
        repaint();
    }
 
    void XYButton::mouseDrag(const MouseEvent& event)
    {
        setPuckPosition(event.getPosition());
        Button::mouseDrag(event);
    }
 
    void XYButton::mouseDown(const MouseEvent& event)
    {
        // Broadcasting to action listeners that an analytics event took place
        sendActionMessage(analyticsEventMouseDown);
 
        m_mouseIsDown = true;
 
        setMouseCursor(MouseCursor::NoCursor);
 
        setPuckPosition(event.getPosition());
        Button::mouseDown(event);
 
        if (dragStarted != nullptr)
            dragStarted();
    }
 
    void XYButton::mouseUp(const MouseEvent& event)
    {
        m_mouseIsDown = false;
 
        setMouseCursor(MouseCursor::NormalCursor);
 
        Button::mouseUp(event);
 
        if (dragEnded != nullptr)
            dragEnded();
    }
 
    void XYButton::createMask(const void* data, const size_t numBytes)
    {
        m_twoZoneMask = Drawable::createFromImageData(data, numBytes);
    }
 
    XYButtonParameterAttachment::XYButtonParameterAttachment(RangedAudioParameter& xParam, RangedAudioParameter& yParam,
                                                             RangedAudioParameter& clickParam,
                                                             RangedAudioParameter& toggleParam, XYButton& xy,
                                                             UndoManager* /*um*/)
        : m_xyButton(xy), m_xAttachment(xParam, [this](float x) { setXValue(x); }),
          m_yAttachment(yParam, [this](float y) { setYValue(y); }), m_clickAttachment(clickParam, {}),
          m_toggleAttachment(toggleParam, [this](float x) { setToggleValue(x); })
    {
        sendInitialUpdate();
 
        m_xyButton.dragStarted = [this] {
            m_xAttachment.beginGesture();
            m_yAttachment.beginGesture();
            if (m_xyButton.getToggleValue())
            {
                m_clickAttachment.setValueAsCompleteGesture(1.0f);
            }
        };
 
        m_xyButton.dragEnded = [this] {
            m_xAttachment.endGesture();
            m_yAttachment.endGesture();
            if (m_xyButton.getToggleValue())
            {
                m_clickAttachment.setValueAsCompleteGesture(0.0f);
            }
        };
 
        m_xyButton.puckPositionChanged = [this](Point<float> p) {
            if (!m_ignoreCallbacks)
            {
                m_xAttachment.setValueAsPartOfGesture(p.getX());
                m_yAttachment.setValueAsPartOfGesture(p.getY());
            }
        };
    }
 
    XYButtonParameterAttachment::~XYButtonParameterAttachment() { m_xyButton.puckPositionChanged = nullptr; }
 
    void XYButtonParameterAttachment::sendInitialUpdate()
    {
        m_xAttachment.sendInitialUpdate();
        m_yAttachment.sendInitialUpdate();
        m_toggleAttachment.sendInitialUpdate();
    }
 
    void XYButtonParameterAttachment::setXValue(float x)
    {
        const ScopedValueSetter<bool> svs(m_ignoreCallbacks, true);
 
        auto pos = m_xyButton.getPuckPosition();
        pos.setX(x);
 
        m_xyButton.setNormalisedPuckPosition(pos);
    }
 
    void XYButtonParameterAttachment::setYValue(float y)
    {
        const ScopedValueSetter<bool> svs(m_ignoreCallbacks, true);
 
        auto pos = m_xyButton.getPuckPosition();
        pos.setY(y);
 
        m_xyButton.setNormalisedPuckPosition(pos);
    }
 
    void XYButtonParameterAttachment::setToggleValue(float x) { m_xyButton.setToggleValue(x); }
} // namespace krotos