/*!
\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 );
}
}
void
SoQtThumbWheel::mouseMoveEvent(QMouseEvent * event)
{
if (this->state != SoQtThumbWheel::Dragging)
return;
if (this->orient == SoQtThumbWheel::Vertical)
this->mouseLastPos = event->pos().y() - SHADEBORDERWIDTH - 6;
else
this->mouseLastPos = event->pos().x() - SHADEBORDERWIDTH - 6;
this->tempWheelValue = this->wheel->calculateValue(this->wheelValue,
this->mouseDownPos, this->mouseLastPos - this->mouseDownPos);
emit wheelMoved(this->tempWheelValue);
this->repaint();
}
/*!
\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 GdvCanvas3D::wheelEvent(QWheelEvent* e)
{
emit wheelMoved(e->delta());
}
/*!
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 );
}
}
