qwt_abstract_slider.cpp

/******************************************************************************
 * 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 )
    {
        if ( qFuzzyCompare( scaleMap().pDist(), 360.0 ) )
        {
            // full circle scales: min and max are the same
 
            if ( qFuzzyCompare( value, vmax ) )
            {
                value = vmin;
            }
            else
            {
                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();
}
 
#include "moc_qwt_abstract_slider.cpp"