qwt_abstract_slider.cpp

/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * 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 <qevent.h>
#include <qdatetime.h>
#include "qwt_abstract_slider.h"
#include "qwt_math.h"

#ifndef WHEEL_DELTA
#define WHEEL_DELTA 120
#endif

class QwtAbstractSlider::PrivateData
{
public:
    PrivateData():
        scrollMode(ScrNone),
        mouseOffset(0.0),
        tracking(true),
        tmrID(0),
        updTime(150),
        mass(0.0),
        readOnly(false)
    {
    }

    int scrollMode;
    double mouseOffset;
    int direction;
    int tracking;

    int tmrID;
    int updTime;
    int timerTick;
    QTime time;
    double speed;
    double mass;
    Qt::Orientation orientation;
    bool readOnly;
};

QwtAbstractSlider::QwtAbstractSlider(
        Qt::Orientation orientation, QWidget *parent): 
    QWidget(parent, NULL)
{
    d_data = new QwtAbstractSlider::PrivateData;
    d_data->orientation = orientation;

#if QT_VERSION >= 0x040000
    using namespace Qt;
#endif
    setFocusPolicy(TabFocus);
}

QwtAbstractSlider::~QwtAbstractSlider()
{
    if(d_data->tmrID) 
        killTimer(d_data->tmrID);

    delete d_data;
}

void QwtAbstractSlider::setReadOnly(bool readOnly)
{
    d_data->readOnly = readOnly;
    update();
}

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

void QwtAbstractSlider::setOrientation(Qt::Orientation o)
{
    d_data->orientation = o;
}

Qt::Orientation QwtAbstractSlider::orientation() const
{
    return d_data->orientation;
}


void QwtAbstractSlider::stopMoving() 
{
    if(d_data->tmrID)
    {
        killTimer(d_data->tmrID);
        d_data->tmrID = 0;
    }
}

void QwtAbstractSlider::setUpdateTime(int t) 
{
    if (t < 50) 
        t = 50;
    d_data->updTime = t;
}


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

    const QPoint &p = e->pos();

    d_data->timerTick = 0;

    getScrollMode(p, d_data->scrollMode, d_data->direction);
    stopMoving();
    
    switch(d_data->scrollMode)
    {
        case ScrPage:
        case ScrTimer:
            d_data->mouseOffset = 0;
            d_data->tmrID = startTimer(qwtMax(250, 2 * d_data->updTime));
            break;
        
        case ScrMouse:
            d_data->time.start();
            d_data->speed = 0;
            d_data->mouseOffset = getValue(p) - value();
            emit sliderPressed();
            break;
        
        default:
            d_data->mouseOffset = 0;
            d_data->direction = 0;
            break;
    }
}


void QwtAbstractSlider::buttonReleased()
{
    if ((!d_data->tracking) || (value() != prevValue()))
        emit valueChanged(value());
}


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

    const double inc = step();
    
    switch(d_data->scrollMode) 
    {
        case ScrMouse:
        {
            setPosition(e->pos());
            d_data->direction = 0;
            d_data->mouseOffset = 0;
            if (d_data->mass > 0.0) 
            {
                const int ms = d_data->time.elapsed();
                if ((fabs(d_data->speed) >  0.0) && (ms < 50))
                    d_data->tmrID = startTimer(d_data->updTime);
            }
            else
            {
                d_data->scrollMode = ScrNone;
                buttonReleased();
            }
            emit sliderReleased();
            
            break;
        }

        case ScrDirect:
        {
            setPosition(e->pos());
            d_data->direction = 0;
            d_data->mouseOffset = 0;
            d_data->scrollMode = ScrNone;
            buttonReleased();
            break;
        }

        case ScrPage:
        {
            stopMoving();
            if (!d_data->timerTick)
                QwtDoubleRange::incPages(d_data->direction);
            d_data->timerTick = 0;
            buttonReleased();
            d_data->scrollMode = ScrNone;
            break;
        }

        case ScrTimer:
        {
            stopMoving();
            if (!d_data->timerTick)
                QwtDoubleRange::fitValue(value() + double(d_data->direction) * inc);
            d_data->timerTick = 0;
            buttonReleased();
            d_data->scrollMode = ScrNone;
            break;
        }

        default:
        {
            d_data->scrollMode = ScrNone;
            buttonReleased();
        }
    }
}


void QwtAbstractSlider::setPosition(const QPoint &p) 
{
    QwtDoubleRange::fitValue(getValue(p) - d_data->mouseOffset);
}


void QwtAbstractSlider::setTracking(bool enable)
{
    d_data->tracking = enable;
}

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

    if ( !isValid() )
        return;

    if (d_data->scrollMode == ScrMouse )
    {
        setPosition(e->pos());
        if (d_data->mass > 0.0) 
        {
            double ms = double(d_data->time.elapsed());
            if (ms < 1.0) 
                ms = 1.0;
            d_data->speed = (exactValue() - exactPrevValue()) / ms;
            d_data->time.start();
        }
        if (value() != prevValue())
            emit sliderMoved(value());
    }
}

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

    if ( !isValid() )
        return;

    int mode = ScrNone, direction = 0;

    // Give derived classes a chance to say ScrNone
    getScrollMode(e->pos(), mode, direction);
    if ( mode != ScrNone )
    {
        const int inc = e->delta() / WHEEL_DELTA;
        QwtDoubleRange::incPages(inc);
        if (value() != prevValue())
            emit sliderMoved(value());
    }
}

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

    if ( !isValid() )
        return;

    int increment = 0;
    switch ( e->key() ) 
    {
        case Qt::Key_Down:
            if ( orientation() == Qt::Vertical )
                increment = -1;
            break;
        case Qt::Key_Up:
            if ( orientation() == Qt::Vertical )
                increment = 1;
            break;
        case Qt::Key_Left:
            if ( orientation() == Qt::Horizontal )
                increment = -1;
            break;
        case Qt::Key_Right:
            if ( orientation() == Qt::Horizontal )
                increment = 1;
            break;
        default:;
            e->ignore();
    }

    if ( increment != 0 )
    {
        QwtDoubleRange::incValue(increment);
        if (value() != prevValue())
            emit sliderMoved(value());
    }
}

void QwtAbstractSlider::timerEvent(QTimerEvent *)
{
    const double inc = step();

    switch (d_data->scrollMode)
    {
        case ScrMouse:
        {
            if (d_data->mass > 0.0)
            {
                d_data->speed *= exp( - double(d_data->updTime) * 0.001 / d_data->mass );
                const double newval = 
                    exactValue() + d_data->speed * double(d_data->updTime);
                QwtDoubleRange::fitValue(newval);
                // stop if d_data->speed < one step per second
                if (fabs(d_data->speed) < 0.001 * fabs(step()))
                {
                    d_data->speed = 0;
                    stopMoving();
                    buttonReleased();
                }

            }
            else
               stopMoving();
            break;
        }

        case ScrPage:
        {
            QwtDoubleRange::incPages(d_data->direction);
            if (!d_data->timerTick) 
            {
                killTimer(d_data->tmrID);
                d_data->tmrID = startTimer(d_data->updTime);
            }
            break;
        }
        case ScrTimer:
        {
            QwtDoubleRange::fitValue(value() +  double(d_data->direction) * inc);
            if (!d_data->timerTick) 
            {
                killTimer(d_data->tmrID);
                d_data->tmrID = startTimer(d_data->updTime);
            }
            break;
        }
        default:
        {
            stopMoving();
            break;
        }
    }

    d_data->timerTick = 1;
}


void QwtAbstractSlider::valueChange() 
{
    if (d_data->tracking)
       emit valueChanged(value());  
}

void QwtAbstractSlider::setMass(double val)
{
    if (val < 0.001)
       d_data->mass = 0.0;
    else if (val > 100.0)
       d_data->mass = 100.0;
    else
       d_data->mass = val;
}

double QwtAbstractSlider::mass() const
{   
    return d_data->mass; 
}


void QwtAbstractSlider::setValue(double val)
{
    if (d_data->scrollMode == ScrMouse) 
        stopMoving();
    QwtDoubleRange::setValue(val);
}


void QwtAbstractSlider::fitValue(double value)
{
    if (d_data->scrollMode == ScrMouse) 
        stopMoving();
    QwtDoubleRange::fitValue(value);
}

void QwtAbstractSlider::incValue(int steps)
{
    if (d_data->scrollMode == ScrMouse) 
        stopMoving();
    QwtDoubleRange::incValue(steps);
}

void QwtAbstractSlider::setMouseOffset(double offset)
{
    d_data->mouseOffset = offset;
} 

double QwtAbstractSlider::mouseOffset() const
{
    return d_data->mouseOffset;
}

int QwtAbstractSlider::scrollMode() const
{
    return d_data->scrollMode;
}

---