/*!
\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;
}
}
void QwtWheel::mouseReleaseEvent( QMouseEvent *event )
{
Q_UNUSED( event );
if ( !d_data->isScrolling )
return;
d_data->isScrolling = false;
bool startFlying = false;
if ( d_data->mass > 0.0 )
{
const int ms = d_data->time.elapsed();
if ( ( qFabs( d_data->speed ) > 0.0 ) && ( ms < 50 ) )
startFlying = true;
}
if ( startFlying )
{
d_data->flyingValue =
boundedValue( d_data->mouseValue - d_data->mouseOffset );
d_data->timerId = startTimer( d_data->updateInterval );
}
else
{
if ( d_data->pendingValueChanged )
Q_EMIT valueChanged( d_data->value );
}
d_data->pendingValueChanged = false;
d_data->mouseOffset = 0.0;
Q_EMIT wheelReleased();
}
/*!
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 );
}
}
