qwt_abstract_slider.cpp

Go to the documentation of this file.

/******************************************************************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2002   Uwe Rathmann
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the Qwt License, Version 1.0
 *****************************************************************************/

#include "qwt_abstract_slider.h"
#include "qwt_scale_map.h"
#include "qwt_scale_div.h"
#include "qwt_math.h"

#include <qevent.h>

static double qwtAlignToScaleDiv(
    const QwtAbstractSlider* slider, double value )
{
    const QwtScaleDiv& sd = slider->scaleDiv();

    const int tValue = slider->transform( value );

    if ( tValue == slider->transform( sd.lowerBound() ) )
        return sd.lowerBound();

    if ( tValue == slider->transform( sd.upperBound() ) )
        return sd.upperBound();

    for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
    {
        const QList< double > ticks = sd.ticks( i );
        for ( int j = 0; j < ticks.size(); j++ )
        {
            if ( slider->transform( ticks[ j ] ) == tValue )
                return ticks[ j ];
        }
    }

    return value;
}

class QwtAbstractSlider::PrivateData
{
  public:
    PrivateData()
        : isScrolling( false )
        , isTracking( true )
        , pendingValueChanged( false )
        , readOnly( false )
        , totalSteps( 100 )
        , singleSteps( 1 )
        , pageSteps( 10 )
        , stepAlignment( true )
        , isValid( false )
        , value( 0.0 )
        , wrapping( false )
        , invertedControls( false )
    {
    }

    bool isScrolling;
    bool isTracking;
    bool pendingValueChanged;

    bool readOnly;

    uint totalSteps;
    uint singleSteps;
    uint pageSteps;
    bool stepAlignment;

    bool isValid;
    double value;

    bool wrapping;
    bool invertedControls;
};

QwtAbstractSlider::QwtAbstractSlider( QWidget* parent )
    : QwtAbstractScale( parent )
{
    m_data = new QwtAbstractSlider::PrivateData;

    setScale( 0.0, 100.0 );
    setFocusPolicy( Qt::StrongFocus );
}

QwtAbstractSlider::~QwtAbstractSlider()
{
    delete m_data;
}

void QwtAbstractSlider::setValid( bool on )
{
    if ( on != m_data->isValid )
    {
        m_data->isValid = on;
        sliderChange();

        Q_EMIT valueChanged( m_data->value );
    }
}

bool QwtAbstractSlider::isValid() const
{
    return m_data->isValid;
}

void QwtAbstractSlider::setReadOnly( bool on )
{
    if ( m_data->readOnly != on )
    {
        m_data->readOnly = on;
        setFocusPolicy( on ? Qt::StrongFocus : Qt::NoFocus );

        update();
    }
}

bool QwtAbstractSlider::isReadOnly() const
{
    return m_data->readOnly;
}

void QwtAbstractSlider::setTracking( bool on )
{
    m_data->isTracking = on;
}

bool QwtAbstractSlider::isTracking() const
{
    return m_data->isTracking;
}

void QwtAbstractSlider::mousePressEvent( QMouseEvent* event )
{
    if ( isReadOnly() )
    {
        event->ignore();
        return;
    }

    if ( !m_data->isValid || lowerBound() == upperBound() )
        return;

    m_data->isScrolling = isScrollPosition( event->pos() );

    if ( m_data->isScrolling )
    {
        m_data->pendingValueChanged = false;

        Q_EMIT sliderPressed();
    }
}

void QwtAbstractSlider::mouseMoveEvent( QMouseEvent* event )
{
    if ( isReadOnly() )
    {
        event->ignore();
        return;
    }

    if ( m_data->isValid && m_data->isScrolling )
    {
        double value = scrolledTo( event->pos() );
        if ( value != m_data->value )
        {
            value = boundedValue( value );

            if ( m_data->stepAlignment )
            {
                value = alignedValue( value );
            }
            else
            {
                value = qwtAlignToScaleDiv( this, value );
            }

            if ( value != m_data->value )
            {
                m_data->value = value;

                sliderChange();

                Q_EMIT sliderMoved( m_data->value );

                if ( m_data->isTracking )
                    Q_EMIT valueChanged( m_data->value );
                else
                    m_data->pendingValueChanged = true;
            }
        }
    }
}

void QwtAbstractSlider::mouseReleaseEvent( QMouseEvent* event )
{
    if ( isReadOnly() )
    {
        event->ignore();
        return;
    }

    if ( m_data->isScrolling && m_data->isValid )
    {
        m_data->isScrolling = false;

        if ( m_data->pendingValueChanged )
            Q_EMIT valueChanged( m_data->value );

        Q_EMIT sliderReleased();
    }
}

void QwtAbstractSlider::wheelEvent( QWheelEvent* event )
{
    if ( isReadOnly() )
    {
        event->ignore();
        return;
    }

    if ( !m_data->isValid || m_data->isScrolling )
        return;

#if QT_VERSION < 0x050000
    const int wheelDelta = event->delta();
#else
    const QPoint delta = event->angleDelta();
    const int wheelDelta = ( qAbs( delta.x() ) > qAbs( delta.y() ) )
        ? delta.x() : delta.y();
#endif

    int numSteps = 0;

    if ( ( event->modifiers() & Qt::ControlModifier ) ||
        ( event->modifiers() & Qt::ShiftModifier ) )
    {
        // one page regardless of delta
        numSteps = m_data->pageSteps;
        if ( wheelDelta < 0 )
            numSteps = -numSteps;
    }
    else
    {
        const int numTurns = ( wheelDelta / 120 );
        numSteps = numTurns * m_data->singleSteps;
    }

    if ( m_data->invertedControls )
        numSteps = -numSteps;

    const double value = incrementedValue( m_data->value, numSteps );
    if ( value != m_data->value )
    {
        m_data->value = value;
        sliderChange();

        Q_EMIT sliderMoved( m_data->value );
        Q_EMIT valueChanged( m_data->value );
    }
}

void QwtAbstractSlider::keyPressEvent( QKeyEvent* event )
{
    if ( isReadOnly() )
    {
        event->ignore();
        return;
    }

    if ( !m_data->isValid || m_data->isScrolling )
        return;

    int numSteps = 0;
    double value = m_data->value;

    switch ( event->key() )
    {
        case Qt::Key_Left:
        {
            numSteps = -static_cast< int >( m_data->singleSteps );
            if ( isInverted() )
                numSteps = -numSteps;

            break;
        }
        case Qt::Key_Right:
        {
            numSteps = m_data->singleSteps;
            if ( isInverted() )
                numSteps = -numSteps;

            break;
        }
        case Qt::Key_Down:
        {
            numSteps = -static_cast< int >( m_data->singleSteps );
            if ( m_data->invertedControls )
                numSteps = -numSteps;
            break;
        }
        case Qt::Key_Up:
        {
            numSteps = m_data->singleSteps;
            if ( m_data->invertedControls )
                numSteps = -numSteps;

            break;
        }
        case Qt::Key_PageUp:
        {
            numSteps = m_data->pageSteps;
            if ( m_data->invertedControls )
                numSteps = -numSteps;
            break;
        }
        case Qt::Key_PageDown:
        {
            numSteps = -static_cast< int >( m_data->pageSteps );
            if ( m_data->invertedControls )
                numSteps = -numSteps;
            break;
        }
        case Qt::Key_Home:
        {
            value = minimum();
            break;
        }
        case Qt::Key_End:
        {
            value = maximum();
            break;
        }
        default:
        {
            event->ignore();
        }
    }

    if ( numSteps != 0 )
    {
        value = incrementedValue( m_data->value, numSteps );
    }

    if ( value != m_data->value )
    {
        m_data->value = value;
        sliderChange();

        Q_EMIT sliderMoved( m_data->value );
        Q_EMIT valueChanged( m_data->value );
    }
}

void QwtAbstractSlider::setTotalSteps( uint stepCount )
{
    m_data->totalSteps = stepCount;
}

uint QwtAbstractSlider::totalSteps() const
{
    return m_data->totalSteps;
}

void QwtAbstractSlider::setSingleSteps( uint stepCount )
{
    m_data->singleSteps = stepCount;
}

uint QwtAbstractSlider::singleSteps() const
{
    return m_data->singleSteps;
}

void QwtAbstractSlider::setPageSteps( uint stepCount )
{
    m_data->pageSteps = stepCount;
}

uint QwtAbstractSlider::pageSteps() const
{
    return m_data->pageSteps;
}

void QwtAbstractSlider::setStepAlignment( bool on )
{
    if ( on != m_data->stepAlignment )
    {
        m_data->stepAlignment = on;
    }
}

bool QwtAbstractSlider::stepAlignment() const
{
    return m_data->stepAlignment;
}

void QwtAbstractSlider::setValue( double value )
{
    value = qBound( minimum(), value, maximum() );

    const bool changed = ( m_data->value != value ) || !m_data->isValid;

    m_data->value = value;
    m_data->isValid = true;

    if ( changed )
    {
        sliderChange();
        Q_EMIT valueChanged( m_data->value );
    }
}

double QwtAbstractSlider::value() const
{
    return m_data->value;
}

void QwtAbstractSlider::setWrapping( bool on )
{
    m_data->wrapping = on;
}

bool QwtAbstractSlider::wrapping() const
{
    return m_data->wrapping;
}

void QwtAbstractSlider::setInvertedControls( bool on )
{
    m_data->invertedControls = on;
}

bool QwtAbstractSlider::invertedControls() const
{
    return m_data->invertedControls;
}

void QwtAbstractSlider::incrementValue( int stepCount )
{
    const double value = incrementedValue(
        m_data->value, stepCount );

    if ( value != m_data->value )
    {
        m_data->value = value;
        sliderChange();
    }
}

double QwtAbstractSlider::incrementedValue(
    double value, int stepCount ) const
{
    if ( m_data->totalSteps == 0 )
        return value;

    const QwtTransform* transformation =
        scaleMap().transformation();

    if ( transformation == NULL )
    {
        const double range = maximum() - minimum();
        value += stepCount * range / m_data->totalSteps;
    }
    else
    {
        QwtScaleMap map = scaleMap();
        map.setPaintInterval( 0, m_data->totalSteps );

        // we need equidistant steps according to
        // paint device coordinates
        const double range = transformation->transform( maximum() )
            - transformation->transform( minimum() );

        const double stepSize = range / m_data->totalSteps;

        double v = transformation->transform( value );

        v = qRound( v / stepSize ) * stepSize;
        v += stepCount * range / m_data->totalSteps;

        value = transformation->invTransform( v );
    }

    value = boundedValue( value );

    if ( m_data->stepAlignment )
        value = alignedValue( value );

    return value;
}

double QwtAbstractSlider::boundedValue( double value ) const
{
    const double vmin = minimum();
    const double vmax = maximum();

    if ( m_data->wrapping && vmin != vmax )
    {
        const int fullCircle = 360 * 16;

        const double pd = scaleMap().pDist();
        if ( int( pd / fullCircle ) * fullCircle == pd )
        {
            // full circle scales: min and max are the same
            const double range = vmax - vmin;

            if ( value < vmin )
            {
                value += std::ceil( ( vmin - value ) / range ) * range;
            }
            else if ( value > vmax )
            {
                value -= std::ceil( ( value - vmax ) / range ) * range;
            }
        }
        else
        {
            if ( value < vmin )
                value = vmax;
            else if ( value > vmax )
                value = vmin;
        }
    }
    else
    {
        value = qBound( vmin, value, vmax );
    }

    return value;
}

double QwtAbstractSlider::alignedValue( double value ) const
{
    if ( m_data->totalSteps == 0 )
        return value;

    double stepSize;

    if ( scaleMap().transformation() == NULL )
    {
        stepSize = ( maximum() - minimum() ) / m_data->totalSteps;
        if ( stepSize > 0.0 )
        {
            value = lowerBound() +
                qRound( ( value - lowerBound() ) / stepSize ) * stepSize;
        }
    }
    else
    {
        stepSize = ( scaleMap().p2() - scaleMap().p1() ) / m_data->totalSteps;

        if ( stepSize > 0.0 )
        {
            double v = scaleMap().transform( value );

            v = scaleMap().p1() +
                qRound( ( v - scaleMap().p1() ) / stepSize ) * stepSize;

            value = scaleMap().invTransform( v );
        }
    }

    if ( qAbs( stepSize ) > 1e-12 )
    {
        if ( qFuzzyCompare( value + 1.0, 1.0 ) )
        {
            // correct rounding error if value = 0
            value = 0.0;
        }
        else
        {
            // correct rounding error at the border
            if ( qFuzzyCompare( value, upperBound() ) )
                value = upperBound();
            else if ( qFuzzyCompare( value, lowerBound() ) )
                value = lowerBound();
        }
    }

    return value;
}

void QwtAbstractSlider::scaleChange()
{
    const double value = qBound( minimum(), m_data->value, maximum() );

    const bool changed = ( value != m_data->value );
    if ( changed )
    {
        m_data->value = value;
    }

    if ( m_data->isValid || changed )
        Q_EMIT valueChanged( m_data->value );

    updateGeometry();
    update();
}

void QwtAbstractSlider::sliderChange()
{
    update();
}

#if QWT_MOC_INCLUDE
#include "moc_qwt_abstract_slider.cpp"
#endif