void QSlider_QtDShell::__override_sliderChange(int change0, bool static_call)
{
if (static_call) {
QAbstractSlider::sliderChange((QAbstractSlider::SliderChange )change0);
} else {
sliderChange((QAbstractSlider::SliderChange )change0);
}
}
/*!
Set the value to be valid/invalid
\param on When true, the value is invalidated
\sa setValue()
*/
void QwtAbstractSlider::setValid( bool on )
{
if ( on != d_data->isValid )
{
d_data->isValid = on;
sliderChange();
Q_EMIT valueChanged( d_data->value );
}
}
/*!
Increment the slider
The step size depends on the number of totalSteps()
\param stepCount Number of steps
\sa setTotalSteps(), incrementedValue()
*/
void QwtAbstractSlider::incrementValue( int stepCount )
{
const double value = incrementedValue(
d_data->value, stepCount );
if ( value != d_data->value )
{
d_data->value = value;
sliderChange();
}
}
/*!
Sets the slider's minimum to \a min and its maximum to \a max.
If \a max is smaller than \a min, \a min becomes the only legal
value.
\sa minimum maximum
*/
void QAbstractSlider::setRange(int min, int max)
{
Q_D(QAbstractSlider);
int oldMin = d->minimum;
int oldMax = d->maximum;
d->minimum = min;
d->maximum = qMax(min, max);
if (oldMin != d->minimum || oldMax != d->maximum) {
sliderChange(SliderRangeChange);
emit rangeChanged(d->minimum, d->maximum);
setValue(d->value); // re-bound
}
}
/*!
Set the slider to the specified value
\param value New value
\sa setValid(), sliderChange(), valueChanged()
*/
void QwtAbstractSlider::setValue( double value )
{
value = qBound( minimum(), value, maximum() );
const bool changed = ( d_data->value != value ) || !d_data->isValid;
d_data->value = value;
d_data->isValid = true;
if ( changed )
{
sliderChange();
Q_EMIT valueChanged( d_data->value );
}
}
void QAbstractSlider::setValue(int value)
{
Q_D(QAbstractSlider);
value = d->bound(value);
if (d->value == value && d->position == value)
return;
d->value = value;
if (d->position != value) {
d->position = value;
if (d->pressed)
emit sliderMoved((d->position = value));
}
#ifndef QT_NO_ACCESSIBILITY
QAccessible::updateAccessibility(this, 0, QAccessible::ValueChanged);
#endif
sliderChange(SliderValueChange);
emit valueChanged(value);
}
/*!
Wheel Event handler
In/decreases the value by s number of steps. The direction
depends on the invertedControls() property.
When the control or shift modifier is pressed the wheel delta
( divided by 120 ) is mapped to an increment according to
pageSteps(). Otherwise it is mapped to singleSteps().
\param event Wheel event
*/
void QwtAbstractSlider::wheelEvent( QWheelEvent *event )
{
if ( isReadOnly() )
{
event->ignore();
return;
}
if ( !d_data->isValid || d_data->isScrolling )
return;
int numSteps = 0;
if ( ( event->modifiers() & Qt::ControlModifier) ||
( event->modifiers() & Qt::ShiftModifier ) )
{
// one page regardless of delta
numSteps = d_data->pageSteps;
if ( event->delta() < 0 )
numSteps = -numSteps;
}
else
{
const int numTurns = ( event->delta() / 120 );
numSteps = numTurns * d_data->singleSteps;
}
if ( d_data->invertedControls )
numSteps = -numSteps;
const double value = incrementedValue( d_data->value, numSteps );
if ( value != d_data->value )
{
d_data->value = value;
sliderChange();
Q_EMIT sliderMoved( d_data->value );
Q_EMIT valueChanged( d_data->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;
}
}
}
}
QT_BEGIN_NAMESPACE
/*!
\class QAbstractSlider
\brief The QAbstractSlider class provides an integer value within a range.
\ingroup abstractwidgets
\inmodule QtWidgets
The class is designed as a common super class for widgets like
QScrollBar, QSlider and QDial.
Here are the main properties of the class:
\list 1
\i \l value: The bounded integer that QAbstractSlider maintains.
\i \l minimum: The lowest possible value.
\i \l maximum: The highest possible value.
\i \l singleStep: The smaller of two natural steps that an
abstract sliders provides and typically corresponds to the user
pressing an arrow key.
\i \l pageStep: The larger of two natural steps that an abstract
slider provides and typically corresponds to the user pressing
PageUp or PageDown.
\i \l tracking: Whether slider tracking is enabled.
\i \l sliderPosition: The current position of the slider. If \l
tracking is enabled (the default), this is identical to \l value.
\endlist
Unity (1) may be viewed as a third step size. setValue() lets you
set the current value to any integer in the allowed range, not
just minimum() + \e n * singleStep() for integer values of \e n.
Some widgets may allow the user to set any value at all; others
may just provide multiples of singleStep() or pageStep().
QAbstractSlider emits a comprehensive set of signals:
\table
\header \i Signal \i Emitted when
\row \i \l valueChanged()
\i the value has changed. The \l tracking
determines whether this signal is emitted during user
interaction.
\row \i \l sliderPressed()
\i the user starts to drag the slider.
\row \i \l sliderMoved()
\i the user drags the slider.
\row \i \l sliderReleased()
\i the user releases the slider.
\row \i \l actionTriggered()
\i a slider action was triggerd.
\row \i \l rangeChanged()
\i a the range has changed.
\endtable
QAbstractSlider provides a virtual sliderChange() function that is
well suited for updating the on-screen representation of
sliders. By calling triggerAction(), subclasses trigger slider
actions. Two helper functions QStyle::sliderPositionFromValue() and
QStyle::sliderValueFromPosition() help subclasses and styles to map
screen coordinates to logical range values.
\sa QAbstractSpinBox, QSlider, QDial, QScrollBar, {Sliders Example}
*/
/*!
\enum QAbstractSlider::SliderAction
\value SliderNoAction
\value SliderSingleStepAdd
\value SliderSingleStepSub
\value SliderPageStepAdd
\value SliderPageStepSub
\value SliderToMinimum
\value SliderToMaximum
\value SliderMove
*/
/*!
\fn void QAbstractSlider::valueChanged(int value)
This signal is emitted when the slider value has changed, with the
new slider \a value as argument.
*/
/*!
\fn void QAbstractSlider::sliderPressed()
This signal is emitted when the user presses the slider with the
mouse, or programmatically when setSliderDown(true) is called.
\sa sliderReleased(), sliderMoved(), isSliderDown()
*/
/*!
\fn void QAbstractSlider::sliderMoved(int value)
This signal is emitted when sliderDown is true and the slider moves. This
usually happens when the user is dragging the slider. The \a value
is the new slider position.
This signal is emitted even when tracking is turned off.
\sa setTracking(), valueChanged(), isSliderDown(),
sliderPressed(), sliderReleased()
*/
/*!
\fn void QAbstractSlider::sliderReleased()
This signal is emitted when the user releases the slider with the
mouse, or programmatically when setSliderDown(false) is called.
\sa sliderPressed() sliderMoved() sliderDown
*/
/*!
\fn void QAbstractSlider::rangeChanged(int min, int max)
This signal is emitted when the slider range has changed, with \a
min being the new minimum, and \a max being the new maximum.
\sa minimum, maximum
*/
/*!
\fn void QAbstractSlider::actionTriggered(int action)
This signal is emitted when the slider action \a action is
triggered. Actions are \l SliderSingleStepAdd, \l
SliderSingleStepSub, \l SliderPageStepAdd, \l SliderPageStepSub,
\l SliderToMinimum, \l SliderToMaximum, and \l SliderMove.
When the signal is emitted, the \l sliderPosition has been
adjusted according to the action, but the \l value has not yet
been propagated (meaning the valueChanged() signal was not yet
emitted), and the visual display has not been updated. In slots
connected to this signal you can thus safely adjust any action by
calling setSliderPosition() yourself, based on both the action and
the slider's value.
\sa triggerAction()
*/
/*!
\enum QAbstractSlider::SliderChange
\value SliderRangeChange
\value SliderOrientationChange
\value SliderStepsChange
\value SliderValueChange
*/
QAbstractSliderPrivate::QAbstractSliderPrivate()
: minimum(0), maximum(99), pageStep(10), value(0), position(0), pressValue(-1),
singleStep(1), offset_accumulated(0), tracking(true),
blocktracking(false), pressed(false),
invertedAppearance(false), invertedControls(false),
orientation(Qt::Horizontal), repeatAction(QAbstractSlider::SliderNoAction)
#ifdef QT_KEYPAD_NAVIGATION
, isAutoRepeating(false)
, repeatMultiplier(1)
{
firstRepeat.invalidate();
#else
{
#endif
}
QAbstractSliderPrivate::~QAbstractSliderPrivate()
{
}
/*!
Sets the slider's minimum to \a min and its maximum to \a max.
If \a max is smaller than \a min, \a min becomes the only legal
value.
\sa minimum maximum
*/
void QAbstractSlider::setRange(int min, int max)
{
Q_D(QAbstractSlider);
int oldMin = d->minimum;
int oldMax = d->maximum;
d->minimum = min;
d->maximum = qMax(min, max);
if (oldMin != d->minimum || oldMax != d->maximum) {
sliderChange(SliderRangeChange);
emit rangeChanged(d->minimum, d->maximum);
setValue(d->value); // re-bound
}
}
void DhQSlider::DvhsliderChange(long x1) {
return sliderChange((QAbstractSlider::SliderChange)x1);
}
/*!
Handles key events
QwtAbstractSlider handles the following keys:
- Qt::Key_Left\n
Add/Subtract singleSteps() in direction to lowerBound();
- Qt::Key_Right\n
Add/Subtract singleSteps() in direction to upperBound();
- Qt::Key_Down\n
Subtract singleSteps(), when invertedControls() is false
- Qt::Key_Up\n
Add singleSteps(), when invertedControls() is false
- Qt::Key_PageDown\n
Subtract pageSteps(), when invertedControls() is false
- Qt::Key_PageUp\n
Add pageSteps(), when invertedControls() is false
- Qt::Key_Home\n
Set the value to the minimum()
- Qt::Key_End\n
Set the value to the maximum()
\param event Key event
\sa isReadOnly()
*/
void QwtAbstractSlider::keyPressEvent( QKeyEvent *event )
{
if ( isReadOnly() )
{
event->ignore();
return;
}
if ( !d_data->isValid || d_data->isScrolling )
return;
int numSteps = 0;
double value = d_data->value;
switch ( event->key() )
{
case Qt::Key_Left:
{
numSteps = -static_cast<int>( d_data->singleSteps );
if ( isInverted() )
numSteps = -numSteps;
break;
}
case Qt::Key_Right:
{
numSteps = d_data->singleSteps;
if ( isInverted() )
numSteps = -numSteps;
break;
}
case Qt::Key_Down:
{
numSteps = -static_cast<int>( d_data->singleSteps );
if ( d_data->invertedControls )
numSteps = -numSteps;
break;
}
case Qt::Key_Up:
{
numSteps = d_data->singleSteps;
if ( d_data->invertedControls )
numSteps = -numSteps;
break;
}
case Qt::Key_PageUp:
{
numSteps = d_data->pageSteps;
if ( d_data->invertedControls )
numSteps = -numSteps;
break;
}
case Qt::Key_PageDown:
{
numSteps = -static_cast<int>( d_data->pageSteps );
if ( d_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( d_data->value, numSteps );
}
if ( value != d_data->value )
{
d_data->value = value;
sliderChange();
Q_EMIT sliderMoved( d_data->value );
Q_EMIT valueChanged( d_data->value );
}
}
