diff -r 000000000000 -r 1918ee327afb src/gui/widgets/qabstractslider.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/gui/widgets/qabstractslider.cpp Mon Jan 11 14:00:40 2010 +0000 @@ -0,0 +1,980 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include "qabstractslider.h" +#include "qevent.h" +#include "qabstractslider_p.h" +#include "qdebug.h" +#ifndef QT_NO_ACCESSIBILITY +#include "qaccessible.h" +#endif +#ifdef QT_KEYPAD_NAVIGATION +#include "qtabwidget.h" // Needed in inTabWidget() +#endif // QT_KEYPAD_NAVIGATION +#include + +QT_BEGIN_NAMESPACE + +/*! + \class QAbstractSlider + \brief The QAbstractSlider class provides an integer value within a range. + + \ingroup abstractwidgets + + 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), singleStep(1), pageStep(10), + value(0), position(0), pressValue(-1), offset_accumulated(0), tracking(true), + blocktracking(false), pressed(false), + invertedAppearance(false), invertedControls(false), + orientation(Qt::Horizontal), repeatAction(QAbstractSlider::SliderNoAction) +{ +} + +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 QAbstractSliderPrivate::setSteps(int single, int page) +{ + Q_Q(QAbstractSlider); + singleStep = qAbs(single); + pageStep = qAbs(page); + q->sliderChange(QAbstractSlider::SliderStepsChange); +} + +/*! + Constructs an abstract slider. + + The \a parent arguments is sent to the QWidget constructor. + + The \l minimum defaults to 0, the \l maximum to 99, with a \l + singleStep size of 1 and a \l pageStep size of 10, and an initial + \l value of 0. +*/ +QAbstractSlider::QAbstractSlider(QWidget *parent) + :QWidget(*new QAbstractSliderPrivate, parent, 0) +{ +} + +/*! \internal */ +QAbstractSlider::QAbstractSlider(QAbstractSliderPrivate &dd, QWidget *parent) + :QWidget(dd, parent, 0) +{ +} + +/*! + Destroys the slider. +*/ +QAbstractSlider::~QAbstractSlider() +{ +} + +/*! + \property QAbstractSlider::orientation + \brief the orientation of the slider + + The orientation must be \l Qt::Vertical (the default) or \l + Qt::Horizontal. +*/ +void QAbstractSlider::setOrientation(Qt::Orientation orientation) +{ + Q_D(QAbstractSlider); + if (d->orientation == orientation) + return; + + d->orientation = orientation; + if (!testAttribute(Qt::WA_WState_OwnSizePolicy)) { + QSizePolicy sp = sizePolicy(); + sp.transpose(); + setSizePolicy(sp); + setAttribute(Qt::WA_WState_OwnSizePolicy, false); + } + update(); + updateGeometry(); +} + +Qt::Orientation QAbstractSlider::orientation() const +{ + Q_D(const QAbstractSlider); + return d->orientation; +} + + +/*! + \property QAbstractSlider::minimum + \brief the sliders's minimum value + + When setting this property, the \l maximum is adjusted if + necessary to ensure that the range remains valid. Also the + slider's current value is adjusted to be within the new range. + +*/ + +void QAbstractSlider::setMinimum(int min) +{ + Q_D(QAbstractSlider); + setRange(min, qMax(d->maximum, min)); +} + +int QAbstractSlider::minimum() const +{ + Q_D(const QAbstractSlider); + return d->minimum; +} + + +/*! + \property QAbstractSlider::maximum + \brief the slider's maximum value + + When setting this property, the \l minimum is adjusted if + necessary to ensure that the range remains valid. Also the + slider's current value is adjusted to be within the new range. + + +*/ + +void QAbstractSlider::setMaximum(int max) +{ + Q_D(QAbstractSlider); + setRange(qMin(d->minimum, max), max); +} + +int QAbstractSlider::maximum() const +{ + Q_D(const QAbstractSlider); + return d->maximum; +} + + + +/*! + \property QAbstractSlider::singleStep + \brief the single step. + + The smaller of two natural steps that an + abstract sliders provides and typically corresponds to the user + pressing an arrow key. + + \sa pageStep +*/ + +void QAbstractSlider::setSingleStep(int step) +{ + Q_D(QAbstractSlider); + if (step != d->singleStep) + d->setSteps(step, d->pageStep); +} + +int QAbstractSlider::singleStep() const +{ + Q_D(const QAbstractSlider); + return d->singleStep; +} + + +/*! + \property QAbstractSlider::pageStep + \brief the page step. + + The larger of two natural steps that an abstract slider provides + and typically corresponds to the user pressing PageUp or PageDown. + + \sa singleStep +*/ + +void QAbstractSlider::setPageStep(int step) +{ + Q_D(QAbstractSlider); + if (step != d->pageStep) + d->setSteps(d->singleStep, step); +} + +int QAbstractSlider::pageStep() const +{ + Q_D(const QAbstractSlider); + return d->pageStep; +} + +/*! + \property QAbstractSlider::tracking + \brief whether slider tracking is enabled + + If tracking is enabled (the default), the slider emits the + valueChanged() signal while the slider is being dragged. If + tracking is disabled, the slider emits the valueChanged() signal + only when the user releases the slider. + + \sa sliderDown +*/ +void QAbstractSlider::setTracking(bool enable) +{ + Q_D(QAbstractSlider); + d->tracking = enable; +} + +bool QAbstractSlider::hasTracking() const +{ + Q_D(const QAbstractSlider); + return d->tracking; +} + + +/*! + \property QAbstractSlider::sliderDown + \brief whether the slider is pressed down. + + The property is set by subclasses in order to let the abstract + slider know whether or not \l tracking has any effect. + + Changing the slider down property emits the sliderPressed() and + sliderReleased() signals. + +*/ +void QAbstractSlider::setSliderDown(bool down) +{ + Q_D(QAbstractSlider); + bool doEmit = d->pressed != down; + + d->pressed = down; + + if (doEmit) { + if (down) + emit sliderPressed(); + else + emit sliderReleased(); + } + + if (!down && d->position != d->value) + triggerAction(SliderMove); +} + +bool QAbstractSlider::isSliderDown() const +{ + Q_D(const QAbstractSlider); + return d->pressed; +} + + +/*! + \property QAbstractSlider::sliderPosition + \brief the current slider position + + If \l tracking is enabled (the default), this is identical to \l value. +*/ +void QAbstractSlider::setSliderPosition(int position) +{ + Q_D(QAbstractSlider); + position = d->bound(position); + if (position == d->position) + return; + d->position = position; + if (!d->tracking) + update(); + if (d->pressed) + emit sliderMoved(position); + if (d->tracking && !d->blocktracking) + triggerAction(SliderMove); +} + +int QAbstractSlider::sliderPosition() const +{ + Q_D(const QAbstractSlider); + return d->position; +} + + +/*! + \property QAbstractSlider::value + \brief the slider's current value + + The slider forces the value to be within the legal range: \l + minimum <= \c value <= \l maximum. + + Changing the value also changes the \l sliderPosition. +*/ + + +int QAbstractSlider::value() const +{ + Q_D(const QAbstractSlider); + return d->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); +} + +/*! + \property QAbstractSlider::invertedAppearance + \brief whether or not a slider shows its values inverted. + + If this property is false (the default), the minimum and maximum will + be shown in its classic position for the inherited widget. If the + value is true, the minimum and maximum appear at their opposite location. + + Note: This property makes most sense for sliders and dials. For + scroll bars, the visual effect of the scroll bar subcontrols depends on + whether or not the styles understand inverted appearance; most styles + ignore this property for scroll bars. +*/ + +bool QAbstractSlider::invertedAppearance() const +{ + Q_D(const QAbstractSlider); + return d->invertedAppearance; +} + +void QAbstractSlider::setInvertedAppearance(bool invert) +{ + Q_D(QAbstractSlider); + d->invertedAppearance = invert; + update(); +} + + +/*! + \property QAbstractSlider::invertedControls + \brief whether or not the slider inverts its wheel and key events. + + If this property is false, scrolling the mouse wheel "up" and using keys + like page up will increase the slider's value towards its maximum. Otherwise + pressing page up will move value towards the slider's minimum. +*/ + + +bool QAbstractSlider::invertedControls() const +{ + Q_D(const QAbstractSlider); + return d->invertedControls; +} + +void QAbstractSlider::setInvertedControls(bool invert) +{ + Q_D(QAbstractSlider); + d->invertedControls = invert; +} + +/*! Triggers a slider \a action. Possible actions are \l + SliderSingleStepAdd, \l SliderSingleStepSub, \l SliderPageStepAdd, + \l SliderPageStepSub, \l SliderToMinimum, \l SliderToMaximum, and \l + SliderMove. + + \sa actionTriggered() + */ +void QAbstractSlider::triggerAction(SliderAction action) +{ + Q_D(QAbstractSlider); + d->blocktracking = true; + switch (action) { + case SliderSingleStepAdd: + setSliderPosition(d->overflowSafeAdd(d->singleStep)); + break; + case SliderSingleStepSub: + setSliderPosition(d->overflowSafeAdd(-d->singleStep)); + break; + case SliderPageStepAdd: + setSliderPosition(d->overflowSafeAdd(d->pageStep)); + break; + case SliderPageStepSub: + setSliderPosition(d->overflowSafeAdd(-d->pageStep)); + break; + case SliderToMinimum: + setSliderPosition(d->minimum); + break; + case SliderToMaximum: + setSliderPosition(d->maximum); + break; + case SliderMove: + case SliderNoAction: + break; + }; + emit actionTriggered(action); + d->blocktracking = false; + setValue(d->position); +} + +/*! Sets action \a action to be triggered repetitively in intervals +of \a repeatTime, after an initial delay of \a thresholdTime. + +\sa triggerAction() repeatAction() + */ +void QAbstractSlider::setRepeatAction(SliderAction action, int thresholdTime, int repeatTime) +{ + Q_D(QAbstractSlider); + if ((d->repeatAction = action) == SliderNoAction) { + d->repeatActionTimer.stop(); + } else { + d->repeatActionTime = repeatTime; + d->repeatActionTimer.start(thresholdTime, this); + } +} + +/*! + Returns the current repeat action. + \sa setRepeatAction() + */ +QAbstractSlider::SliderAction QAbstractSlider::repeatAction() const +{ + Q_D(const QAbstractSlider); + return d->repeatAction; +} + +/*!\reimp + */ +void QAbstractSlider::timerEvent(QTimerEvent *e) +{ + Q_D(QAbstractSlider); + if (e->timerId() == d->repeatActionTimer.timerId()) { + if (d->repeatActionTime) { // was threshold time, use repeat time next time + d->repeatActionTimer.start(d->repeatActionTime, this); + d->repeatActionTime = 0; + } + if (d->repeatAction == SliderPageStepAdd) + d->setAdjustedSliderPosition(d->overflowSafeAdd(d->pageStep)); + else if (d->repeatAction == SliderPageStepSub) + d->setAdjustedSliderPosition(d->overflowSafeAdd(-d->pageStep)); + else + triggerAction(d->repeatAction); + } +} + +/*! + Reimplement this virtual function to track slider changes such as + \l SliderRangeChange, \l SliderOrientationChange, \l + SliderStepsChange, or \l SliderValueChange. The default + implementation only updates the display and ignores the \a change + parameter. + */ +void QAbstractSlider::sliderChange(SliderChange) +{ + update(); +} + + +/*! + \reimp +*/ +#ifndef QT_NO_WHEELEVENT +void QAbstractSlider::wheelEvent(QWheelEvent * e) +{ + Q_D(QAbstractSlider); + e->ignore(); + if (e->orientation() != d->orientation && !rect().contains(e->pos())) + return; + + qreal currentOffset = qreal(e->delta()) / 120; + d->offset_accumulated += currentOffset; + if (int(d->offset_accumulated) == 0) { + // QAbstractSlider works on integer values. So if the accumulated + // offset is less than +/- 1, we need to wait until we get more + // wheel events (this means that the wheel resolution is higher than + // 15 degrees, e.g. when using mac mighty mouse/trackpad): + return; + } + + int stepsToScroll; + if ((e->modifiers() & Qt::ControlModifier) || (e->modifiers() & Qt::ShiftModifier)) { + stepsToScroll = currentOffset > 0 ? d->pageStep : -d->pageStep; + } else { + // Calculate the number of steps to scroll (per 15 degrees of rotate): +#ifdef Q_OS_MAC + // On mac, since mouse wheel scrolling is accelerated and + // fine tuned by the OS, we skip applying acceleration: + stepsToScroll = int(d->offset_accumulated); +#else + stepsToScroll = int(d->offset_accumulated) * QApplication::wheelScrollLines() * d->singleStep; +#endif + stepsToScroll = qBound(-d->pageStep, stepsToScroll, d->pageStep); + } + + if (d->invertedControls) + stepsToScroll = -stepsToScroll; + + int prevValue = d->value; + d->position = d->overflowSafeAdd(stepsToScroll); // value will be updated by triggerAction() + triggerAction(SliderMove); + + if (prevValue == d->value) { + d->offset_accumulated = 0; + } else { + d->offset_accumulated -= int(d->offset_accumulated); + e->accept(); + } +} +#endif +#ifdef QT_KEYPAD_NAVIGATION +/*! + \internal + + Tells us if it there is currently a reachable widget by keypad navigation in + a certain \a orientation. + If no navigation is possible, occuring key events in that \a orientation may + be used to interact with the value in the focussed widget, even though it + currently has not the editFocus. + + \sa QWidgetPrivate::widgetInNavigationDirection(), QWidget::hasEditFocus() +*/ +inline static bool canKeypadNavigate(Qt::Orientation orientation) +{ + return orientation == Qt::Horizontal? + (QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionEast) + || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionWest)) + :(QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionNorth) + || QWidgetPrivate::widgetInNavigationDirection(QWidgetPrivate::DirectionSouth)); +} +/*! + \internal + + Checks, if the \a widget is inside a QTabWidget. If is is inside + one, left/right key events will be used to switch between tabs in keypad + navigation. If there is no QTabWidget, the horizontal key events can be used to + interact with the value in the focussed widget, even though it currently has + not the editFocus. + + \sa QWidget::hasEditFocus() +*/ +inline static bool inTabWidget(QWidget *widget) +{ + for (QWidget *tabWidget = widget; tabWidget; tabWidget = tabWidget->parentWidget()) + if (qobject_cast(tabWidget)) + return true; + return false; +} +#endif // QT_KEYPAD_NAVIGATION +/*! + \reimp +*/ +void QAbstractSlider::keyPressEvent(QKeyEvent *ev) +{ + Q_D(QAbstractSlider); + SliderAction action = SliderNoAction; + switch (ev->key()) { +#ifdef QT_KEYPAD_NAVIGATION + case Qt::Key_Select: + if (QApplication::keypadNavigationEnabled()) + setEditFocus(!hasEditFocus()); + else + ev->ignore(); + break; + case Qt::Key_Back: + if (QApplication::keypadNavigationEnabled() && hasEditFocus()) { + setValue(d->origValue); + setEditFocus(false); + } else + ev->ignore(); + break; +#endif + + // It seems we need to use invertedAppearance for Left and right, otherwise, things look weird. + case Qt::Key_Left: +#ifdef QT_KEYPAD_NAVIGATION + // In QApplication::KeypadNavigationDirectional, we want to change the slider + // value if there is no left/right navigation possible and if this slider is not + // inside a tab widget. + if (QApplication::keypadNavigationEnabled() + && (!hasEditFocus() && QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder + || d->orientation == Qt::Vertical + || !hasEditFocus() && (canKeypadNavigate(Qt::Horizontal) || inTabWidget(this)))) { + ev->ignore(); + return; + } + if (QApplication::keypadNavigationEnabled() && d->orientation == Qt::Vertical) + action = d->invertedControls ? SliderSingleStepSub : SliderSingleStepAdd; + else +#endif + if (isRightToLeft()) + action = d->invertedAppearance ? SliderSingleStepSub : SliderSingleStepAdd; + else + action = !d->invertedAppearance ? SliderSingleStepSub : SliderSingleStepAdd; + break; + case Qt::Key_Right: +#ifdef QT_KEYPAD_NAVIGATION + // Same logic as in Qt::Key_Left + if (QApplication::keypadNavigationEnabled() + && (!hasEditFocus() && QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder + || d->orientation == Qt::Vertical + || !hasEditFocus() && (canKeypadNavigate(Qt::Horizontal) || inTabWidget(this)))) { + ev->ignore(); + return; + } + if (QApplication::keypadNavigationEnabled() && d->orientation == Qt::Vertical) + action = d->invertedControls ? SliderSingleStepAdd : SliderSingleStepSub; + else +#endif + if (isRightToLeft()) + action = d->invertedAppearance ? SliderSingleStepAdd : SliderSingleStepSub; + else + action = !d->invertedAppearance ? SliderSingleStepAdd : SliderSingleStepSub; + break; + case Qt::Key_Up: +#ifdef QT_KEYPAD_NAVIGATION + // In QApplication::KeypadNavigationDirectional, we want to change the slider + // value if there is no up/down navigation possible. + if (QApplication::keypadNavigationEnabled() + && (QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder + || d->orientation == Qt::Horizontal + || !hasEditFocus() && canKeypadNavigate(Qt::Vertical))) { + ev->ignore(); + break; + } +#endif + action = d->invertedControls ? SliderSingleStepSub : SliderSingleStepAdd; + break; + case Qt::Key_Down: +#ifdef QT_KEYPAD_NAVIGATION + // Same logic as in Qt::Key_Up + if (QApplication::keypadNavigationEnabled() + && (QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder + || d->orientation == Qt::Horizontal + || !hasEditFocus() && canKeypadNavigate(Qt::Vertical))) { + ev->ignore(); + break; + } +#endif + action = d->invertedControls ? SliderSingleStepAdd : SliderSingleStepSub; + break; + case Qt::Key_PageUp: + action = d->invertedControls ? SliderPageStepSub : SliderPageStepAdd; + break; + case Qt::Key_PageDown: + action = d->invertedControls ? SliderPageStepAdd : SliderPageStepSub; + break; + case Qt::Key_Home: + action = SliderToMinimum; + break; + case Qt::Key_End: + action = SliderToMaximum; + break; + default: + ev->ignore(); + break; + } + if (action) + triggerAction(action); +} + +/*! + \reimp +*/ +void QAbstractSlider::changeEvent(QEvent *ev) +{ + Q_D(QAbstractSlider); + switch (ev->type()) { + case QEvent::EnabledChange: + if (!isEnabled()) { + d->repeatActionTimer.stop(); + setSliderDown(false); + } + // fall through... + default: + QWidget::changeEvent(ev); + } +} + +/*! + \reimp +*/ +bool QAbstractSlider::event(QEvent *e) +{ +#ifdef QT_KEYPAD_NAVIGATION + Q_D(QAbstractSlider); + switch (e->type()) { + case QEvent::FocusIn: + d->origValue = d->value; + break; + default: + break; + } +#endif + + return QWidget::event(e); +} + +/*! \fn int QAbstractSlider::minValue() const + + Use minimum() instead. +*/ + +/*! \fn int QAbstractSlider::maxValue() const + + Use maximum() instead. +*/ + +/*! \fn int QAbstractSlider::lineStep() const + + Use singleStep() instead. +*/ + +/*! \fn void QAbstractSlider::setMinValue(int v) + + Use setMinimum() instead. +*/ + +/*! \fn void QAbstractSlider::setMaxValue(int v) + + Use setMaximum() instead. +*/ + +/*! \fn void QAbstractSlider::setLineStep(int v) + + Use setSingleStep() instead. +*/ + +/*! \fn void QAbstractSlider::addPage() + + Use triggerAction(QAbstractSlider::SliderPageStepAdd) instead. +*/ + +/*! \fn void QAbstractSlider::subtractPage() + + Use triggerAction(QAbstractSlider::SliderPageStepSub) instead. +*/ + +/*! \fn void QAbstractSlider::addLine() + + Use triggerAction(QAbstractSlider::SliderSingleStepAdd) instead. +*/ + +/*! \fn void QAbstractSlider::subtractLine() + + Use triggerAction(QAbstractSlider::SliderSingleStepSub) instead. +*/ + +/*! \fn void QAbstractSlider::setSteps(int single, int page) + + Use setSingleStep(\a single) followed by setPageStep(\a page) + instead. +*/ + +QT_END_NAMESPACE