AreaSelectionComp.cpp

Go to the documentation of this file.

namespace krotos
{
    AreaSelectionComp::AreaSelectionComp(bool drawBackground, bool drawMarqueeBackground, bool useEndPoint)
        : m_drawBackground(drawBackground), m_drawMarqueeBackground(drawMarqueeBackground), m_useEndPoint(useEndPoint)
    {
    }
 
    AreaSelectionComp::~AreaSelectionComp() {}
 
    void AreaSelectionComp::addListener(Listener* Listener) { m_listeners.add(Listener); }
 
    void AreaSelectionComp::removeListener(Listener* Listener) { m_listeners.remove(Listener); }
 
    void AreaSelectionComp::paint(juce::Graphics& g)
    {
        if (!isEnabled())
            return;
 
        float transaprencyCoef = 0.1f;
        float markerLineWidth = 1.f;
 
        int width = getWidth();
        int height = getHeight();
 
        int drawSelectionStart = m_selectionStart;
 
        if (m_waveformMode == WaveformMode::bothLines) // sampler
        {
            if (drawSelectionStart >= width)
                drawSelectionStart = width - 2; // keep the line in the drawable area
 
            int drawSelectionEnd = m_selectionEnd;
 
            if (m_drawBackground)
                g.fillAll(Colour(109, 109, 109));
 
            if (inAreaSelectMode == true)
            {
                g.setColour(Colours::red);
                drawZoomedLine(g, {float(drawSelectionStart), 0.f, float(drawSelectionStart), float(height)},
                               markerLineWidth);
 
                if (m_useEndPoint == true)
                {
                    g.setColour(Colours::green);
                    drawZoomedLine(g, {float(drawSelectionEnd), 0.f, float(drawSelectionEnd), float(height)},
                                   markerLineWidth);
 
                    if (drawSelectionStart < drawSelectionEnd)
                    {
                        g.setColour(Colour::fromFloatRGBA(1.0f, 1.0f, 1.0f, transaprencyCoef));
                        Rectangle<int> zoomedRect =
                                Rectangle<int>(drawSelectionStart, 0, drawSelectionEnd - drawSelectionStart, height);
                        drawZoomedRect(g, zoomedRect.toFloat());
                    }
 
                    else
                    {
                        g.setColour(Colour::fromFloatRGBA(1.0f, 0.0f, 0.0f, transaprencyCoef));
                        Rectangle<int> zoomedRect =
                                Rectangle<int>(drawSelectionEnd, 0, drawSelectionStart - drawSelectionEnd, height);
                        // Rectangle<int> zoomedRect = Rectangle<int>(drawSelectionStart, 0, drawSelectionEnd -
                        // drawSelectionStart, height);
                        drawZoomedRect(g, zoomedRect.toFloat());
                    }
                }
            }
        }
        else if (m_waveformMode == WaveformMode::onlyStartLine) // granular
        {
            if (drawSelectionStart >= width)
                drawSelectionStart = width - 2; // keep the line in the drawable area
 
            if (m_drawBackground)
                g.fillAll(Colour(109, 109, 109));
 
            if (inAreaSelectMode == true)
            {
                g.setColour(Colours::red);
                drawZoomedLine(g, {float(drawSelectionStart), 0.f, float(drawSelectionStart), float(height)},
                               markerLineWidth);
            }
        }
        else if (m_waveformMode == WaveformMode::noLine) // vehicle
        {
            if (m_drawBackground)
                g.fillAll(Colour(109, 109, 109));
        }
    }
 
    void AreaSelectionComp::setStartPointInPercentage(float percentage, float nonModulatedPercentage)
    {
 
        float newValue = percentage;
        if (m_dragging == true && nonModulatedPercentage != -1.0f)
        {
            newValue = nonModulatedPercentage;
        }
        newValue = jlimit<float>(0.f, 1.f, newValue);
        m_startPosPercentage = newValue;
        m_selectionStart = int(std::round(newValue * getWidth()));
 
        if (m_useEndPoint == true)
        {
            m_selectionWidth = m_selectionEnd - m_selectionStart;
        }
        repaint();
    }
 
    void AreaSelectionComp::setEndPointInPercentage(float percentage)
    {
        percentage = jlimit<float>(0.f, 1.f, percentage);
        if (m_useEndPoint == true)
        {
            m_endPosPercentage = percentage;
            m_selectionEnd = int(std::round(percentage * (getWidth() - m_lineWidth)));
            m_selectionWidth = m_selectionEnd - m_selectionStart;
        }
        else
        {
            m_selectionWidth = 0;
        }
 
        repaint();
    }
 
    float AreaSelectionComp::getStartPosInPercentage()
    {
        m_startPosPercentage = static_cast<float>(m_selectionStart) / (getWidth());
        return m_startPosPercentage;
    }
 
    float AreaSelectionComp::getEndPosInPercentage()
    {
        m_endPosPercentage = static_cast<float>(m_selectionEnd) / (getWidth() - m_lineWidth);
        return m_endPosPercentage;
    }
 
    void AreaSelectionComp::toggleAreaOrControl(bool toggleState)
    {
        inAreaSelectMode = toggleState;
 
        if (inAreaSelectMode == true)
        {
            setEnabled(true);
        }
        else
        {
            setEnabled(false);
        }
        repaint();
    }
 
    void AreaSelectionComp::determineMinSelectionWidth(float sampleRate, float numSamples)
    {
        int width = getWidth();
 
        m_minSelectionWidth = int((width * sampleRate) / numSamples);
    }
 
    void AreaSelectionComp::modifierKeysChanged(const ModifierKeys& modifiers)
    {
        if (modifiers.isShiftDown())
            m_shiftKeyPressed = true;
        else
            m_shiftKeyPressed = false;
    }
 
    void AreaSelectionComp::mouseDown(const MouseEvent& event)
    {
        auto zf = getHorizontalZoomFactor();
        auto zc = getHorizontalZoomCenter();
        auto width = float(getWidth());
        auto x = float(event.x);
        // Position of the mouse
        int mx = static_cast<int>((x - zc * width) * zf + zc * width);
        // Interval of grabbing at each side
 
        if (isEnabled() == true)
        {
            Range<int> leftMarqueeRange(m_selectionStart - m_grabAreaWidth, m_selectionStart + m_grabAreaWidth);
            Range<int> constraintRangeA(0, getWidth() - m_lineWidth);
            leftMarqueeRange = constraintRangeA.constrainRange(leftMarqueeRange);
 
            Range<int> rightMarqueeRange(m_selectionEnd - m_grabAreaWidth, m_selectionEnd + m_grabAreaWidth);
            rightMarqueeRange = constraintRangeA.constrainRange(rightMarqueeRange);
 
            if (leftMarqueeRange.contains(mx))
            {
                m_leftBarWasSelected = true;
                m_rightBarWasSelected = false;
            }
            else if (rightMarqueeRange.contains(mx))
            {
                m_leftBarWasSelected = false;
                m_rightBarWasSelected = true;
            }
            // Case of Indicators  overlapping
            if (leftMarqueeRange.contains(mx) && rightMarqueeRange.contains(mx))
            {
                if (mx < m_selectionStart)
                {
                    m_leftBarWasSelected = true;
                    m_rightBarWasSelected = false;
                }
                else
                {
                    m_leftBarWasSelected = false;
                    m_rightBarWasSelected = true;
                }
            }
        }
    }
 
    void AreaSelectionComp::mouseDrag(const MouseEvent& event)
    {
        if (isEnabled() == true)
        {
            auto zf = getHorizontalZoomFactor();
            auto zc = getHorizontalZoomCenter();
            auto width = float(getWidth());
            auto x = float(event.x);
            // position of the mouse
            int mx = static_cast<int>((x - zc * width) * zf + zc * width);
 
            // you are holding the left bar
            if (m_leftBarWasSelected)
            {
                // Check start is not behind 0
                if (mx < 0)
                {
                    m_selectionStart = 0;
                }
                else
                {
                    m_selectionStart = mx;
 
                    // dont allow start to exceed end , sampler mode
                    if (m_waveformMode == WaveformMode::bothLines)
                    {
                        if (m_selectionStart >= m_selectionEnd)
                        {
                            m_selectionStart = m_selectionEnd;
                        }
                    }
                }
            }
            // you are holding the right bar, sampler mode
            else if (m_rightBarWasSelected && m_waveformMode == WaveformMode::bothLines)
            {
                m_selectionEnd = mx;
                // dont allow  end to exceed right border
                if (m_selectionEnd > getWidth() - m_lineWidth)
                {
                    m_selectionEnd = getWidth() - m_lineWidth;
                }
                // dont allow end to exceed start
                if (m_selectionEnd <= m_selectionStart)
                    m_selectionEnd = m_selectionStart;
            }
        }
 
        m_listeners.call(&AreaSelectionComp::Listener::sampleAreaChanged, this, getStartPosInPercentage(),
                         getEndPosInPercentage());
        repaint();
    }
 
    void AreaSelectionComp::mouseUp(const MouseEvent&)
    {
        if (isEnabled() == true)
        {
            m_shiftDragging = false;
            m_listeners.call(&AreaSelectionComp::Listener::sampleAreaChanged, this, getStartPosInPercentage(),
                             getEndPosInPercentage());
        }
 
        m_dragging = false;
        m_leftBarWasSelected = false;
        m_rightBarWasSelected = false;
    }
 
    void AreaSelectionComp::setWaveformMode(WaveformMode mode) { m_waveformMode = mode; }
} // namespace krotos