HelperClasses.cpp

Go to the documentation of this file.

namespace krotos
{
    bool& MonitoredBool::operator=(const bool& newVal)
    {
        m_changed = newVal != m_val;
        return m_val = newVal;
    }
 
    void ScrollAndZoomManager::initialise(int length)
    {
        m_length = length;
        m_zoomLimits.setStart(0);
        m_zoomLimits.setLength(m_length);
        resetZoomRange();
        m_zoomWindow = m_zoomLimits;
    }
 
    bool ScrollAndZoomManager::isSelectionEnabled() { return m_selectionEnabled && m_length > 0; }
 
    bool ScrollAndZoomManager::isZoomScrollEnabled() { return m_zoomScrollEnabled && m_length > 0; }
 
    void ScrollAndZoomManager::setZoomScrollEnabled(bool newState) { m_zoomScrollEnabled = newState; }
 
    void ScrollAndZoomManager::setSelectionEnabled(bool newState) { m_selectionEnabled = newState; }
 
    int ScrollAndZoomManager::getLength() { return m_zoomLimits.getLength(); }
 
    void ScrollAndZoomManager::resetZoomRange() { m_zoomRange = m_zoomLimits; }
 
    Range<float> ScrollAndZoomManager::getZoomWindowNormalisedToLimits()
    {
        if (m_zoomLimits.isEmpty())
        {
            return Range<float>(0.f, 1.f);
        }
        float normalisationFactor = 1.f / static_cast<float>(m_zoomLimits.getLength());
        return Range<float>(static_cast<float>(m_zoomWindow.getStart()) * normalisationFactor,
                            static_cast<float>(m_zoomWindow.getEnd()) * normalisationFactor);
    }
 
    Range<int> ScrollAndZoomManager::getZoomWindowRelativeToRange() { return m_zoomWindow - m_zoomRange.getStart(); }
 
    Range<float> ScrollAndZoomManager::getZoomWindowNormalisedToRange()
    {
        if (m_zoomRange.isEmpty())
        {
            return Range<float>(0.f, 1.f);
        }
        Range<int> zoomWindowRel = getZoomWindowRelativeToRange();
        float normalisationFactor = 1.f / static_cast<float>(m_zoomRange.getLength());
        return Range<float>(static_cast<float>(zoomWindowRel.getStart()) * normalisationFactor,
                            static_cast<float>(zoomWindowRel.getEnd()) * normalisationFactor);
    }
 
    void ScrollAndZoomManager::repositionZoomWindow(float newStart)
    {
        int start = static_cast<int>(static_cast<float>(m_zoomRange.getLength() * static_cast<float>(newStart)));
        Range<int> candidate = m_zoomWindow.movedToStartAt(m_zoomRange.getStart() + start);
        m_zoomWindow = m_zoomRange.constrainRange(candidate);
    }
 
    void ScrollAndZoomManager::zoom(int center, float amount)
    {
        float scale = 1.f + amount;
        Range<int> candidate;
        candidate.setStart(static_cast<int>(static_cast<float>(m_zoomWindow.getStart() - center) * scale) + center);
        candidate.setEnd(static_cast<int>(static_cast<float>(m_zoomWindow.getEnd() - center) * scale) + center);
 
        // zoom limiter
        if (candidate.getLength() <= m_minimumLength)
        {
            return;
        }
 
        m_zoomWindow = m_zoomRange.constrainRange(candidate);
    }
 
    void ScrollAndZoomManager::drag(int diff)
    {
        m_zoomWindow =
                m_zoomRange.constrainRange(Range<int>(m_zoomWindow.getStart() + diff, m_zoomWindow.getEnd() + diff));
    }
 
    int ScrollAndZoomManager::percentMouseXToSampleXAbsolute(float percentX)
    {
        return m_zoomWindow.getStart() + percentMouseXToSampleXRelative(percentX);
    }
 
    int ScrollAndZoomManager::percentMouseXToSampleXRelative(float percentX)
    {
        return static_cast<int>(static_cast<float>(m_zoomWindow.getLength()) * percentX);
    }
 
    int ScrollAndZoomManager::pixelsToSamples(int pixels, int waveformScreenWidth)
    {
        return static_cast<int>((static_cast<float>(pixels) / static_cast<float>(waveformScreenWidth)) *
                                static_cast<float>(m_zoomWindow.getLength()));
    }
 
    void ScrollAndZoomManager::setZoomRange(Range<int> newRange)
    {
        m_zoomWindow = m_zoomRange = m_zoomLimits.constrainRange(newRange);
    }
 
} // namespace krotos