/*! \brief Qt timer event The flying wheel effect is implemented using a timer \param event Timer event \sa updateInterval() */ void QwtWheel::timerEvent( QTimerEvent *event ) { if ( event->timerId() != d_data->timerId ) { QWidget::timerEvent( event ); return; } d_data->speed *= qExp( -d_data->updateInterval * 0.001 / d_data->mass ); d_data->flyingValue += d_data->speed * d_data->updateInterval; d_data->flyingValue = boundedValue( d_data->flyingValue ); double value = d_data->flyingValue; if ( d_data->stepAlignment ) value = alignedValue( value ); if ( qFabs( d_data->speed ) < 0.001 * d_data->singleStep ) { // stop if d_data->speed < one step per second stopFlying(); } if ( value != d_data->value ) { d_data->value = value; update(); if ( d_data->tracking || d_data->timerId == 0 ) Q_EMIT valueChanged( d_data->value ); } }
/*! \brief Handle wheel events In/Decrement the value \param event Wheel event */ void QwtWheel::wheelEvent( QWheelEvent *event ) { if ( !wheelRect().contains( event->pos() ) ) { event->ignore(); return; } if ( d_data->isScrolling ) return; stopFlying(); double increment = 0.0; if ( ( event->modifiers() & Qt::ControlModifier) || ( event->modifiers() & Qt::ShiftModifier ) ) { // one page regardless of delta increment = d_data->singleStep * d_data->pageStepCount; if ( event->delta() < 0 ) increment = -increment; } else { const int numSteps = event->delta() / 120; increment = d_data->singleStep * numSteps; } if ( d_data->orientation == Qt::Vertical && d_data->inverted ) increment = -increment; double value = boundedValue( d_data->value + increment ); if ( d_data->stepAlignment ) value = alignedValue( value ); if ( value != d_data->value ) { d_data->value = value; update(); Q_EMIT valueChanged( d_data->value ); Q_EMIT wheelMoved( d_data->value ); } }
/*! Increment a value \param value Value \param stepCount Number of steps \return Incremented value */ double QwtAbstractSlider::incrementedValue( double value, int stepCount ) const { if ( d_data->totalSteps == 0 ) return value; const QwtTransform *transformation = scaleMap().transformation(); if ( transformation == NULL ) { const double range = maximum() - minimum(); value += stepCount * range / d_data->totalSteps; } else { QwtScaleMap map = scaleMap(); map.setPaintInterval( 0, d_data->totalSteps ); // we need equidant steps according to // paint device coordinates const double range = transformation->transform( maximum() ) - transformation->transform( minimum() ); const double stepSize = range / d_data->totalSteps; double v = transformation->transform( value ); v = qRound( v / stepSize ) * stepSize; v += stepCount * range / d_data->totalSteps; value = transformation->invTransform( v ); } value = boundedValue( value ); if ( d_data->stepAlignment ) value = alignedValue( value ); return value; }
/*! Mouse Move Event handler \param event Mouse event */ void QwtAbstractSlider::mouseMoveEvent( QMouseEvent *event ) { if ( isReadOnly() ) { event->ignore(); return; } if ( d_data->isValid && d_data->isScrolling ) { double value = scrolledTo( event->pos() ); if ( value != d_data->value ) { value = boundedValue( value ); if ( d_data->stepAlignment ) { value = alignedValue( value ); } else { value = qwtAlignToScaleDiv( this, value ); } if ( value != d_data->value ) { d_data->value = value; sliderChange(); Q_EMIT sliderMoved( d_data->value ); if ( d_data->isTracking ) Q_EMIT valueChanged( d_data->value ); else d_data->pendingValueChanged = true; } } } }
/*! \brief Mouse Move Event handler Turn the wheel according to the mouse position \param event Mouse event */ void QwtWheel::mouseMoveEvent( QMouseEvent *event ) { if ( !d_data->isScrolling ) return; double mouseValue = valueAt( event->pos() ); if ( d_data->mass > 0.0 ) { double ms = d_data->time.restart(); // the interval when mouse move events are posted are somehow // random. To avoid unrealistic speed values we limit ms ms = qMax( ms, 5.0 ); d_data->speed = ( mouseValue - d_data->mouseValue ) / ms; } d_data->mouseValue = mouseValue; double value = boundedValue( mouseValue - d_data->mouseOffset ); if ( d_data->stepAlignment ) value = alignedValue( value ); if ( value != d_data->value ) { d_data->value = value; update(); Q_EMIT wheelMoved( d_data->value ); if ( d_data->tracking ) Q_EMIT valueChanged( d_data->value ); else d_data->pendingValueChanged = true; } }
/*! Handle key events - Qt::Key_Home\n Step to minimum() - Qt::Key_End\n Step to maximum() - Qt::Key_Up\n In case of a horizontal or not inverted vertical wheel the value will be incremented by the step size. For an inverted vertical wheel the value will be decremented by the step size. - Qt::Key_Down\n In case of a horizontal or not inverted vertical wheel the value will be decremented by the step size. For an inverted vertical wheel the value will be incremented by the step size. - Qt::Key_PageUp\n The value will be incremented by pageStepSize() * singleStepSize(). - Qt::Key_PageDown\n The value will be decremented by pageStepSize() * singleStepSize(). \param event Key event */ void QwtWheel::keyPressEvent( QKeyEvent *event ) { if ( d_data->isScrolling ) { // don't interfere mouse scrolling return; } double value = d_data->value; double increment = 0.0; switch ( event->key() ) { case Qt::Key_Down: { if ( d_data->orientation == Qt::Vertical && d_data->inverted ) increment = d_data->singleStep; else increment = -d_data->singleStep; break; } case Qt::Key_Up: { if ( d_data->orientation == Qt::Vertical && d_data->inverted ) increment = -d_data->singleStep; else increment = d_data->singleStep; break; } case Qt::Key_Left: { if ( d_data->orientation == Qt::Horizontal ) { if ( d_data->inverted ) increment = d_data->singleStep; else increment = -d_data->singleStep; } break; } case Qt::Key_Right: { if ( d_data->orientation == Qt::Horizontal ) { if ( d_data->inverted ) increment = -d_data->singleStep; else increment = d_data->singleStep; } break; } case Qt::Key_PageUp: { increment = d_data->pageStepCount * d_data->singleStep; break; } case Qt::Key_PageDown: { increment = -d_data->pageStepCount * d_data->singleStep; break; } case Qt::Key_Home: { value = d_data->minimum; break; } case Qt::Key_End: { value = d_data->maximum; break; } default:; { event->ignore(); } } if ( event->isAccepted() ) stopFlying(); if ( increment != 0.0 ) { value = boundedValue( d_data->value + increment ); if ( d_data->stepAlignment ) value = alignedValue( value ); } if ( value != d_data->value ) { d_data->value = value; update(); Q_EMIT valueChanged( d_data->value ); Q_EMIT wheelMoved( d_data->value ); } }