1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <qplatformdefs.h>

    43 #include <private/qabstractspinbox_p.h>

    44 #include <private/qdatetime_p.h>

    45 #include <private/qlineedit_p.h>

    46 #include <qabstractspinbox.h>

    47 

    48 #ifndef QT_NO_SPINBOX

    49 

    50 #include <qapplication.h>

    51 #include <qclipboard.h>

    52 #include <qdatetime.h>

    53 #include <qdatetimeedit.h>

    54 #include <qevent.h>

    55 #include <qmenu.h>

    56 #include <qpainter.h>

    57 #include <qpalette.h>

    58 #include <qstylepainter.h>

    59 #include <qdebug.h>

    60 #ifndef QT_NO_ACCESSIBILITY

    61 # include <qaccessible.h>

    62 #endif

    63 

    64 #if defined(Q_WS_X11)

    65 #include <limits.h>

    66 #endif

    67 

    68 #if defined(Q_OS_SYMBIAN)

    69 #include <w32std.h>

    70 #include <private/qt_s60_p.h>

    71 #endif

    72 

    73 //#define QABSTRACTSPINBOX_QSBDEBUG

    74 #ifdef QABSTRACTSPINBOX_QSBDEBUG

    75 #  define QASBDEBUG qDebug

    76 #else

    77 #  define QASBDEBUG if (false) qDebug

    78 #endif

    79 

    80 QT_BEGIN_NAMESPACE

    81 

    82 /*!

    83     \class QAbstractSpinBox

    84     \brief The QAbstractSpinBox class provides a spinbox and a line edit to

    85     display values.

    86 

    87     \ingroup abstractwidgets

    88 

    89     The class is designed as a common super class for widgets like

    90     QSpinBox, QDoubleSpinBox and QDateTimeEdit

    91 

    92     Here are the main properties of the class:

    93 

    94     \list 1

    95 

    96     \i \l text: The text that is displayed in the QAbstractSpinBox.

    97 

    98     \i \l alignment: The alignment of the text in the QAbstractSpinBox.

    99 

   100     \i \l wrapping: Whether the QAbstractSpinBox wraps from the

   101     minimum value to the maximum value and vica versa.

   102 

   103     \endlist

   104 

   105     QAbstractSpinBox provides a virtual stepBy() function that is

   106     called whenever the user triggers a step. This function takes an

   107     integer value to signify how many steps were taken. E.g. Pressing

   108     Qt::Key_Down will trigger a call to stepBy(-1).

   109 

   110     QAbstractSpinBox also provide a virtual function stepEnabled() to

   111     determine whether stepping up/down is allowed at any point. This

   112     function returns a bitset of StepEnabled.

   113 

   114     \sa QAbstractSlider, QSpinBox, QDoubleSpinBox, QDateTimeEdit,

   115         {Spin Boxes Example}

   116 */

   117 

   118 /*!

   119     \enum QAbstractSpinBox::StepEnabledFlag

   120 

   121     \value StepNone

   122     \value StepUpEnabled

   123     \value StepDownEnabled

   124 */

   125 

   126 /*!

   127   \fn void QAbstractSpinBox::editingFinished()

   128 

   129   This signal is emitted editing is finished. This happens when the

   130   spinbox loses focus and when enter is pressed.

   131 */

   132 

   133 /*!

   134     Constructs an abstract spinbox with the given \a parent with default

   135     \l wrapping, and \l alignment properties.

   136 */

   137 

   138 QAbstractSpinBox::QAbstractSpinBox(QWidget *parent)

   139     : QWidget(*new QAbstractSpinBoxPrivate, parent, 0)

   140 {

   141     Q_D(QAbstractSpinBox);

   142     d->init();

   143 }

   144 

   145 /*!

   146     \internal

   147 */

   148 QAbstractSpinBox::QAbstractSpinBox(QAbstractSpinBoxPrivate &dd, QWidget *parent)

   149     : QWidget(dd, parent, 0)

   150 {

   151     Q_D(QAbstractSpinBox);

   152     d->init();

   153 }

   154 

   155 /*!

   156     Called when the QAbstractSpinBox is destroyed.

   157 */

   158 

   159 QAbstractSpinBox::~QAbstractSpinBox()

   160 {

   161 }

   162 

   163 /*!

   164     \enum QAbstractSpinBox::ButtonSymbols

   165 

   166     This enum type describes the symbols that can be displayed on the buttons

   167     in a spin box.

   168 

   169     \inlineimage qspinbox-updown.png

   170     \inlineimage qspinbox-plusminus.png

   171 

   172     \value UpDownArrows Little arrows in the classic style.

   173     \value PlusMinus \bold{+} and \bold{-} symbols.

   174     \value NoButtons Don't display buttons.

   175 

   176     \sa QAbstractSpinBox::buttonSymbols

   177 */

   178 

   179 /*!

   180     \property QAbstractSpinBox::buttonSymbols

   181 

   182     \brief the current button symbol mode

   183 

   184     The possible values can be either \c UpDownArrows or \c PlusMinus.

   185     The default is \c UpDownArrows.

   186 

   187     Note that some styles might render PlusMinus and UpDownArrows

   188     identically.

   189 

   190     \sa ButtonSymbols

   191 */

   192 

   193 QAbstractSpinBox::ButtonSymbols QAbstractSpinBox::buttonSymbols() const

   194 {

   195     Q_D(const QAbstractSpinBox);

   196     return d->buttonSymbols;

   197 }

   198 

   199 void QAbstractSpinBox::setButtonSymbols(ButtonSymbols buttonSymbols)

   200 {

   201     Q_D(QAbstractSpinBox);

   202     if (d->buttonSymbols != buttonSymbols) {

   203         d->buttonSymbols = buttonSymbols;

   204         d->updateEditFieldGeometry();

   205         update();

   206     }

   207 }

   208 

   209 /*!

   210     \property QAbstractSpinBox::text

   211 

   212     \brief the spin box's text, including any prefix and suffix

   213 

   214     There is no default text.

   215 */

   216 

   217 QString QAbstractSpinBox::text() const

   218 {

   219     return lineEdit()->displayText();

   220 }

   221 

   222 

   223 /*!

   224     \property QAbstractSpinBox::specialValueText

   225     \brief the special-value text

   226 

   227     If set, the spin box will display this text instead of a numeric

   228     value whenever the current value is equal to minimum(). Typical use

   229     is to indicate that this choice has a special (default) meaning.

   230 

   231     For example, if your spin box allows the user to choose a scale factor

   232     (or zoom level) for displaying an image, and your application is able

   233     to automatically choose one that will enable the image to fit completely

   234     within the display window, you can set up the spin box like this:

   235 

   236     \snippet examples/widgets/spinboxes/window.cpp 3

   237 

   238     The user will then be able to choose a scale from 1% to 1000%

   239     or select "Auto" to leave it up to the application to choose. Your code

   240     must then interpret the spin box value of 0 as a request from the user

   241     to scale the image to fit inside the window.

   242 

   243     All values are displayed with the prefix and suffix (if set), \e

   244     except for the special value, which only shows the special value

   245     text. This special text is passed in the QSpinBox::valueChanged()

   246     signal that passes a QString.

   247 

   248     To turn off the special-value text display, call this function

   249     with an empty string. The default is no special-value text, i.e.

   250     the numeric value is shown as usual.

   251 

   252     If no special-value text is set, specialValueText() returns an

   253     empty string.

   254 */

   255 

   256 QString QAbstractSpinBox::specialValueText() const

   257 {

   258     Q_D(const QAbstractSpinBox);

   259     return d->specialValueText;

   260 }

   261 

   262 void QAbstractSpinBox::setSpecialValueText(const QString &specialValueText)

   263 {

   264     Q_D(QAbstractSpinBox);

   265 

   266     d->specialValueText = specialValueText;

   267     d->cachedSizeHint = QSize(); // minimumSizeHint doesn't care about specialValueText

   268     d->clearCache();

   269     d->updateEdit();

   270 }

   271 

   272 /*!

   273     \property QAbstractSpinBox::wrapping

   274 

   275     \brief whether the spin box is circular.

   276 

   277     If wrapping is true stepping up from maximum() value will take you

   278     to the minimum() value and vica versa. Wrapping only make sense if

   279     you have minimum() and maximum() values set.

   280 

   281     \snippet doc/src/snippets/code/src_gui_widgets_qabstractspinbox.cpp 0

   282 

   283     \sa QSpinBox::minimum(), QSpinBox::maximum()

   284 */

   285 

   286 bool QAbstractSpinBox::wrapping() const

   287 {

   288     Q_D(const QAbstractSpinBox);

   289     return d->wrapping;

   290 }

   291 

   292 void QAbstractSpinBox::setWrapping(bool wrapping)

   293 {

   294     Q_D(QAbstractSpinBox);

   295     d->wrapping = wrapping;

   296 }

   297 

   298 

   299 /*!

   300     \property QAbstractSpinBox::readOnly

   301     \brief whether the spin box is read only.

   302 

   303     In read-only mode, the user can still copy the text to the

   304     clipboard, or drag and drop the text;

   305     but cannot edit it.

   306 

   307     The QLineEdit in the QAbstractSpinBox does not show a cursor in

   308     read-only mode.

   309 

   310     \sa QLineEdit::readOnly

   311 */

   312 

   313 bool QAbstractSpinBox::isReadOnly() const

   314 {

   315     Q_D(const QAbstractSpinBox);

   316     return d->readOnly;

   317 }

   318 

   319 void QAbstractSpinBox::setReadOnly(bool enable)

   320 {

   321     Q_D(QAbstractSpinBox);

   322     d->readOnly = enable;

   323     d->edit->setReadOnly(enable);

   324     update();

   325 }

   326 

   327 /*!

   328     \property QAbstractSpinBox::keyboardTracking

   329     \brief whether keyboard tracking is enabled for the spinbox.

   330     \since 4.3

   331 

   332     If keyboard tracking is enabled (the default), the spinbox

   333     emits the valueChanged() signal while the new value is being

   334     entered from the keyboard.

   335 

   336     E.g. when the user enters the value 600 by typing 6, 0, and 0,

   337     the spinbox emits 3 signals with the values 6, 60, and 600

   338     respectively.

   339 

   340     If keyboard tracking is disabled, the spinbox doesn't emit the

   341     valueChanged() signal while typing. It emits the signal later,

   342     when the return key is pressed, when keyboard focus is lost, or

   343     when other spinbox functionality is used, e.g. pressing an arrow

   344     key.

   345 */

   346 

   347 bool QAbstractSpinBox::keyboardTracking() const

   348 {

   349     Q_D(const QAbstractSpinBox);

   350     return d->keyboardTracking;

   351 }

   352 

   353 void QAbstractSpinBox::setKeyboardTracking(bool enable)

   354 {

   355     Q_D(QAbstractSpinBox);

   356     d->keyboardTracking = enable;

   357 }

   358 

   359 /*!

   360     \property QAbstractSpinBox::frame

   361     \brief whether the spin box draws itself with a frame

   362 

   363     If enabled (the default) the spin box draws itself inside a frame,

   364     otherwise the spin box draws itself without any frame.

   365 */

   366 

   367 bool QAbstractSpinBox::hasFrame() const

   368 {

   369     Q_D(const QAbstractSpinBox);

   370     return d->frame;

   371 }

   372 

   373 

   374 void QAbstractSpinBox::setFrame(bool enable)

   375 {

   376     Q_D(QAbstractSpinBox);

   377     d->frame = enable;

   378     update();

   379     d->updateEditFieldGeometry();

   380 }

   381 

   382 /*!

   383     \property QAbstractSpinBox::accelerated

   384     \brief whether the spin box will accelerate the frequency of the steps when

   385     pressing the step Up/Down buttons.

   386     \since 4.2

   387 

   388     If enabled the spin box will increase/decrease the value faster

   389     the longer you hold the button down.

   390 */

   391 

   392 void QAbstractSpinBox::setAccelerated(bool accelerate)

   393 {

   394     Q_D(QAbstractSpinBox);

   395     d->accelerate = accelerate;

   396 

   397 }

   398 bool QAbstractSpinBox::isAccelerated() const

   399 {

   400     Q_D(const QAbstractSpinBox);

   401     return d->accelerate;

   402 }

   403 

   404 /*!

   405     \enum QAbstractSpinBox::CorrectionMode

   406 

   407     This enum type describes the mode the spinbox will use to correct

   408     an \l{QValidator::}{Intermediate} value if editing finishes.

   409 

   410     \value CorrectToPreviousValue The spinbox will revert to the last

   411                                   valid value.

   412 

   413     \value CorrectToNearestValue The spinbox will revert to the nearest

   414                                  valid value.

   415 

   416     \sa correctionMode

   417 */

   418 

   419 /*!

   420     \property QAbstractSpinBox::correctionMode

   421     \brief the mode to correct an \l{QValidator::}{Intermediate}

   422            value if editing finishes

   423     \since 4.2

   424 

   425     The default mode is QAbstractSpinBox::CorrectToPreviousValue.

   426 

   427     \sa acceptableInput, validate(), fixup()

   428 */

   429 void QAbstractSpinBox::setCorrectionMode(CorrectionMode correctionMode)

   430 {

   431     Q_D(QAbstractSpinBox);

   432     d->correctionMode = correctionMode;

   433 

   434 }

   435 QAbstractSpinBox::CorrectionMode QAbstractSpinBox::correctionMode() const

   436 {

   437     Q_D(const QAbstractSpinBox);

   438     return d->correctionMode;

   439 }

   440 

   441 

   442 /*!

   443   \property QAbstractSpinBox::acceptableInput

   444   \brief whether the input satisfies the current validation

   445   \since 4.2

   446 

   447   \sa validate(), fixup(), correctionMode

   448 */

   449 

   450 bool QAbstractSpinBox::hasAcceptableInput() const

   451 {

   452     Q_D(const QAbstractSpinBox);

   453     return d->edit->hasAcceptableInput();

   454 }

   455 

   456 /*!

   457     \property QAbstractSpinBox::alignment

   458     \brief the alignment of the spin box

   459 

   460     Possible Values are Qt::AlignLeft, Qt::AlignRight, and Qt::AlignHCenter.

   461 

   462     By default, the alignment is Qt::AlignLeft

   463 

   464     Attempting to set the alignment to an illegal flag combination

   465     does nothing.

   466 

   467     \sa Qt::Alignment

   468 */

   469 

   470 Qt::Alignment QAbstractSpinBox::alignment() const

   471 {

   472     Q_D(const QAbstractSpinBox);

   473 

   474     return (Qt::Alignment)d->edit->alignment();

   475 }

   476 

   477 void QAbstractSpinBox::setAlignment(Qt::Alignment flag)

   478 {

   479     Q_D(QAbstractSpinBox);

   480 

   481     d->edit->setAlignment(flag);

   482 }

   483 

   484 /*!

   485     Selects all the text in the spinbox except the prefix and suffix.

   486 */

   487 

   488 void QAbstractSpinBox::selectAll()

   489 {

   490     Q_D(QAbstractSpinBox);

   491 

   492 

   493     if (!d->specialValue()) {

   494         const int tmp = d->edit->displayText().size() - d->suffix.size();

   495         d->edit->setSelection(tmp, -(tmp - d->prefix.size()));

   496     } else {

   497         d->edit->selectAll();

   498     }

   499 }

   500 

   501 /*!

   502     Clears the lineedit of all text but prefix and suffix.

   503 */

   504 

   505 void QAbstractSpinBox::clear()

   506 {

   507     Q_D(QAbstractSpinBox);

   508 

   509     d->edit->setText(d->prefix + d->suffix);

   510     d->edit->setCursorPosition(d->prefix.size());

   511     d->cleared = true;

   512 }

   513 

   514 /*!

   515     Virtual function that determines whether stepping up and down is

   516     legal at any given time.

   517 

   518     The up arrow will be painted as disabled unless (stepEnabled() &

   519     StepUpEnabled) != 0.

   520 

   521     The default implementation will return (StepUpEnabled|

   522     StepDownEnabled) if wrapping is turned on. Else it will return

   523     StepDownEnabled if value is > minimum() or'ed with StepUpEnabled if

   524     value < maximum().

   525 

   526     If you subclass QAbstractSpinBox you will need to reimplement this function.

   527 

   528     \sa QSpinBox::minimum(), QSpinBox::maximum(), wrapping()

   529 */

   530 

   531 

   532 QAbstractSpinBox::StepEnabled QAbstractSpinBox::stepEnabled() const

   533 {

   534     Q_D(const QAbstractSpinBox);

   535     if (d->readOnly || d->type == QVariant::Invalid)

   536         return StepNone;

   537     if (d->wrapping)

   538         return StepEnabled(StepUpEnabled | StepDownEnabled);

   539     StepEnabled ret = StepNone;

   540     if (d->variantCompare(d->value, d->maximum) < 0) {

   541         ret |= StepUpEnabled;

   542     }

   543     if (d->variantCompare(d->value, d->minimum) > 0) {

   544         ret |= StepDownEnabled;

   545     }

   546     return ret;

   547 }

   548 

   549 /*!

   550    This virtual function is called by the QAbstractSpinBox to

   551    determine whether \a input is valid. The \a pos parameter indicates

   552    the position in the string. Reimplemented in the various

   553    subclasses.

   554 */

   555 

   556 QValidator::State QAbstractSpinBox::validate(QString & /* input */, int & /* pos */) const

   557 {

   558     return QValidator::Acceptable;

   559 }

   560 

   561 /*!

   562    This virtual function is called by the QAbstractSpinBox if the

   563    \a input is not validated to QValidator::Acceptable when Return is

   564    pressed or interpretText() is called. It will try to change the

   565    text so it is valid. Reimplemented in the various subclasses.

   566 */

   567 

   568 void QAbstractSpinBox::fixup(QString & /* input */) const

   569 {

   570 }

   571 

   572 /*!

   573   Steps up by one linestep

   574   Calling this slot is analogous to calling stepBy(1);

   575   \sa stepBy(), stepDown()

   576 */

   577 

   578 void QAbstractSpinBox::stepUp()

   579 {

   580     stepBy(1);

   581 }

   582 

   583 /*!

   584   Steps down by one linestep

   585   Calling this slot is analogous to calling stepBy(-1);

   586   \sa stepBy(), stepUp()

   587 */

   588 

   589 void QAbstractSpinBox::stepDown()

   590 {

   591     stepBy(-1);

   592 }

   593 /*!

   594     Virtual function that is called whenever the user triggers a step.

   595     The \a steps parameter indicates how many steps were taken, e.g.

   596     Pressing Qt::Key_Down will trigger a call to stepBy(-1),

   597     whereas pressing Qt::Key_Prior will trigger a call to

   598     stepBy(10).

   599 

   600     If you subclass QAbstractSpinBox you must reimplement this

   601     function. Note that this function is called even if the resulting

   602     value will be outside the bounds of minimum and maximum. It's this

   603     function's job to handle these situations.

   604 */

   605 

   606 void QAbstractSpinBox::stepBy(int steps)

   607 {

   608     Q_D(QAbstractSpinBox);

   609 

   610     const QVariant old = d->value;

   611     QString tmp = d->edit->displayText();

   612     int cursorPos = d->edit->cursorPosition();

   613     bool dontstep = false;

   614     EmitPolicy e = EmitIfChanged;

   615     if (d->pendingEmit) {

   616         dontstep = validate(tmp, cursorPos) != QValidator::Acceptable;

   617         d->cleared = false;

   618         d->interpret(NeverEmit);

   619         if (d->value != old)

   620             e = AlwaysEmit;

   621     }

   622     if (!dontstep) {

   623         d->setValue(d->bound(d->value + (d->singleStep * steps), old, steps), e);

   624     } else if (e == AlwaysEmit) {

   625         d->emitSignals(e, old);

   626     }

   627     selectAll();

   628 }

   629 

   630 /*!

   631     This function returns a pointer to the line edit of the spin box.

   632 */

   633 

   634 QLineEdit *QAbstractSpinBox::lineEdit() const

   635 {

   636     Q_D(const QAbstractSpinBox);

   637 

   638     return d->edit;

   639 }

   640 

   641 

   642 /*!

   643     \fn void QAbstractSpinBox::setLineEdit(QLineEdit *lineEdit)

   644 

   645     Sets the line edit of the spinbox to be \a lineEdit instead of the

   646     current line edit widget. \a lineEdit can not be 0.

   647 

   648     QAbstractSpinBox takes ownership of the new lineEdit

   649 

   650     If QLineEdit::validator() for the \a lineEdit returns 0, the internal

   651     validator of the spinbox will be set on the line edit.

   652 */

   653 

   654 void QAbstractSpinBox::setLineEdit(QLineEdit *lineEdit)

   655 {

   656     Q_D(QAbstractSpinBox);

   657 

   658     if (!lineEdit) {

   659         Q_ASSERT(lineEdit);

   660         return;

   661     }

   662     delete d->edit;

   663     d->edit = lineEdit;

   664     if (!d->edit->validator())

   665         d->edit->setValidator(d->validator);

   666 

   667     if (d->edit->parent() != this)

   668         d->edit->setParent(this);

   669 

   670     d->edit->setFrame(false);

   671     d->edit->setFocusProxy(this);

   672     d->edit->setAcceptDrops(false);

   673 

   674     if (d->type != QVariant::Invalid) {

   675         connect(d->edit, SIGNAL(textChanged(QString)),

   676                 this, SLOT(_q_editorTextChanged(QString)));

   677         connect(d->edit, SIGNAL(cursorPositionChanged(int,int)),

   678                 this, SLOT(_q_editorCursorPositionChanged(int,int)));

   679     }

   680     d->updateEditFieldGeometry();

   681     d->edit->setContextMenuPolicy(Qt::NoContextMenu);

   682 

   683     if (isVisible())

   684         d->edit->show();

   685     if (isVisible())

   686         d->updateEdit();

   687 }

   688 

   689 

   690 /*!

   691     This function interprets the text of the spin box. If the value

   692     has changed since last interpretation it will emit signals.

   693 */

   694 

   695 void QAbstractSpinBox::interpretText()

   696 {

   697     Q_D(QAbstractSpinBox);

   698     d->interpret(EmitIfChanged);

   699 }

   700 

   701 /*

   702     Reimplemented in 4.6, so be careful.

   703  */

   704 /*!

   705     \reimp

   706 */

   707 QVariant QAbstractSpinBox::inputMethodQuery(Qt::InputMethodQuery query) const

   708 {

   709     Q_D(const QAbstractSpinBox);

   710     return d->edit->inputMethodQuery(query);

   711 }

   712 

   713 /*!

   714     \reimp

   715 */

   716 

   717 bool QAbstractSpinBox::event(QEvent *event)

   718 {

   719     Q_D(QAbstractSpinBox);

   720     switch (event->type()) {

   721     case QEvent::FontChange:

   722     case QEvent::StyleChange:

   723         d->cachedSizeHint = d->cachedMinimumSizeHint = QSize();

   724         break;

   725     case QEvent::ApplicationLayoutDirectionChange:

   726     case QEvent::LayoutDirectionChange:

   727         d->updateEditFieldGeometry();

   728         break;

   729     case QEvent::HoverEnter:

   730     case QEvent::HoverLeave:

   731     case QEvent::HoverMove:

   732         if (const QHoverEvent *he = static_cast<const QHoverEvent *>(event))

   733             d->updateHoverControl(he->pos());

   734         break;

   735     case QEvent::ShortcutOverride:

   736         if (d->edit->event(event))

   737             return true;

   738         break;

   739 #ifdef QT_KEYPAD_NAVIGATION

   740     case QEvent::EnterEditFocus:

   741     case QEvent::LeaveEditFocus:

   742         if (QApplication::keypadNavigationEnabled()) {

   743             const bool b = d->edit->event(event);

   744             d->edit->setSelection(d->edit->displayText().size() - d->suffix.size(),0);

   745             if (event->type() == QEvent::LeaveEditFocus)

   746                 emit editingFinished();

   747             if (b)

   748                 return true;

   749         }

   750         break;

   751 #endif

   752     case QEvent::InputMethod:

   753         return d->edit->event(event);

   754     default:

   755         break;

   756     }

   757     return QWidget::event(event);

   758 }

   759 

   760 /*!

   761     \reimp

   762 */

   763 

   764 void QAbstractSpinBox::showEvent(QShowEvent *)

   765 {

   766     Q_D(QAbstractSpinBox);

   767     d->reset();

   768 

   769     if (d->ignoreUpdateEdit) {

   770         d->ignoreUpdateEdit = false;

   771     } else {

   772         d->updateEdit();

   773     }

   774 }

   775 

   776 /*!

   777     \reimp

   778 */

   779 

   780 void QAbstractSpinBox::changeEvent(QEvent *event)

   781 {

   782     Q_D(QAbstractSpinBox);

   783 

   784     switch (event->type()) {

   785         case QEvent::StyleChange:

   786             d->spinClickTimerInterval = style()->styleHint(QStyle::SH_SpinBox_ClickAutoRepeatRate, 0, this);

   787             d->spinClickThresholdTimerInterval =

   788                 style()->styleHint(QStyle::SH_SpinBox_ClickAutoRepeatThreshold, 0, this);

   789             d->reset();

   790             d->updateEditFieldGeometry();

   791             break;

   792         case QEvent::EnabledChange:

   793             if (!isEnabled()) {

   794                 d->reset();

   795             }

   796             break;

   797         case QEvent::ActivationChange:

   798             if (!isActiveWindow()){

   799                 d->reset();

   800                 if (d->pendingEmit) // pendingEmit can be true even if it hasn't changed.

   801                     d->interpret(EmitIfChanged); // E.g. 10 to 10.0

   802             }

   803             break;

   804         default:

   805             break;

   806     }

   807     QWidget::changeEvent(event);

   808 }

   809 

   810 /*!

   811     \reimp

   812 */

   813 

   814 void QAbstractSpinBox::resizeEvent(QResizeEvent *event)

   815 {

   816     Q_D(QAbstractSpinBox);

   817     QWidget::resizeEvent(event);

   818 

   819     d->updateEditFieldGeometry();

   820     update();

   821 }

   822 

   823 /*!

   824     \reimp

   825 */

   826 

   827 QSize QAbstractSpinBox::sizeHint() const

   828 {

   829     Q_D(const QAbstractSpinBox);

   830     if (d->cachedSizeHint.isEmpty()) {

   831         ensurePolished();

   832 

   833         const QFontMetrics fm(fontMetrics());

   834         int h = d->edit->sizeHint().height();

   835         int w = 0;

   836         QString s;

   837         s = d->prefix + d->textFromValue(d->minimum) + d->suffix + QLatin1Char(' ');

   838         s.truncate(18);

   839         w = qMax(w, fm.width(s));

   840         s = d->prefix + d->textFromValue(d->maximum) + d->suffix + QLatin1Char(' ');

   841         s.truncate(18);

   842         w = qMax(w, fm.width(s));

   843         if (d->specialValueText.size()) {

   844             s = d->specialValueText;

   845             w = qMax(w, fm.width(s));

   846         }

   847         w += 2; // cursor blinking space

   848 

   849         QStyleOptionSpinBox opt;

   850         initStyleOption(&opt);

   851         QSize hint(w, h);

   852         QSize extra(35, 6);

   853         opt.rect.setSize(hint + extra);

   854         extra += hint - style()->subControlRect(QStyle::CC_SpinBox, &opt,

   855                                                 QStyle::SC_SpinBoxEditField, this).size();

   856         // get closer to final result by repeating the calculation

   857         opt.rect.setSize(hint + extra);

   858         extra += hint - style()->subControlRect(QStyle::CC_SpinBox, &opt,

   859                                                 QStyle::SC_SpinBoxEditField, this).size();

   860         hint += extra;

   861 

   862         opt.rect = rect();

   863         d->cachedSizeHint = style()->sizeFromContents(QStyle::CT_SpinBox, &opt, hint, this)

   864                             .expandedTo(QApplication::globalStrut());

   865     }

   866     return d->cachedSizeHint;

   867 }

   868 

   869 /*!

   870     \reimp

   871 */

   872 

   873 QSize QAbstractSpinBox::minimumSizeHint() const

   874 {

   875     Q_D(const QAbstractSpinBox);

   876     if (d->cachedMinimumSizeHint.isEmpty()) {

   877         ensurePolished();

   878 

   879         const QFontMetrics fm(fontMetrics());

   880         int h = d->edit->minimumSizeHint().height();

   881         int w = fm.width(QLatin1String("1000"));

   882         w += 2; // cursor blinking space

   883 

   884         QStyleOptionSpinBox opt;

   885         initStyleOption(&opt);

   886         QSize hint(w, h);

   887         QSize extra(35, 6);

   888         opt.rect.setSize(hint + extra);

   889         extra += hint - style()->subControlRect(QStyle::CC_SpinBox, &opt,

   890                                                 QStyle::SC_SpinBoxEditField, this).size();

   891         // get closer to final result by repeating the calculation

   892         opt.rect.setSize(hint + extra);

   893         extra += hint - style()->subControlRect(QStyle::CC_SpinBox, &opt,

   894                                                 QStyle::SC_SpinBoxEditField, this).size();

   895         hint += extra;

   896 

   897         opt.rect = rect();

   898 

   899         d->cachedMinimumSizeHint = style()->sizeFromContents(QStyle::CT_SpinBox, &opt, hint, this)

   900                                    .expandedTo(QApplication::globalStrut());

   901     }

   902     return d->cachedMinimumSizeHint;

   903 }

   904 

   905 /*!

   906     \reimp

   907 */

   908 

   909 void QAbstractSpinBox::paintEvent(QPaintEvent *)

   910 {

   911     QStyleOptionSpinBox opt;

   912     initStyleOption(&opt);

   913     QStylePainter p(this);

   914     p.drawComplexControl(QStyle::CC_SpinBox, opt);

   915 }

   916 

   917 /*!

   918     \reimp

   919 

   920     This function handles keyboard input.

   921 

   922     The following keys are handled specifically:

   923     \table

   924     \row \i Enter/Return

   925          \i This will reinterpret the text and emit a signal even if the value has not changed

   926          since last time a signal was emitted.

   927     \row \i Up

   928          \i This will invoke stepBy(1)

   929     \row \i Down

   930          \i This will invoke stepBy(-1)

   931     \row \i Page up

   932          \i This will invoke stepBy(10)

   933     \row \i Page down

   934          \i This will invoke stepBy(-10)

   935     \endtable

   936 */

   937 

   938 

   939 void QAbstractSpinBox::keyPressEvent(QKeyEvent *event)

   940 {

   941     Q_D(QAbstractSpinBox);

   942 

   943     if (!event->text().isEmpty() && d->edit->cursorPosition() < d->prefix.size())

   944         d->edit->setCursorPosition(d->prefix.size());

   945 

   946     int steps = 1;

   947     bool isPgUpOrDown = false;

   948     switch (event->key()) {

   949     case Qt::Key_PageUp:

   950     case Qt::Key_PageDown:

   951         steps *= 10;

   952         isPgUpOrDown = true;

   953     case Qt::Key_Up:

   954     case Qt::Key_Down: {

   955 #ifdef QT_KEYPAD_NAVIGATION

   956         if (QApplication::keypadNavigationEnabled()) {

   957             // Reserve up/down for nav - use left/right for edit.

   958             if (!hasEditFocus() && (event->key() == Qt::Key_Up

   959                                     || event->key() == Qt::Key_Down)) {

   960                 event->ignore();

   961                 return;

   962             }

   963         }

   964 #endif

   965         event->accept();

   966         const bool up = (event->key() == Qt::Key_PageUp || event->key() == Qt::Key_Up);

   967         if (!(stepEnabled() & (up ? StepUpEnabled : StepDownEnabled)))

   968             return;

   969         if (!up)

   970             steps *= -1;

   971         if (style()->styleHint(QStyle::SH_SpinBox_AnimateButton, 0, this)) {

   972             d->buttonState = (Keyboard | (up ? Up : Down));

   973         }

   974         if (d->spinClickTimerId == -1)

   975             stepBy(steps);

   976         if(event->isAutoRepeat() && !isPgUpOrDown) {

   977             if(d->spinClickThresholdTimerId == -1 && d->spinClickTimerId == -1) {

   978                 d->updateState(up, true);

   979             }

   980         }

   981 #ifndef QT_NO_ACCESSIBILITY

   982         QAccessible::updateAccessibility(this, 0, QAccessible::ValueChanged);

   983 #endif

   984         return;

   985     }

   986 #ifdef QT_KEYPAD_NAVIGATION

   987     case Qt::Key_Left:

   988     case Qt::Key_Right:

   989         if (QApplication::keypadNavigationEnabled() && !hasEditFocus()) {

   990             event->ignore();

   991             return;

   992         }

   993         break;

   994     case Qt::Key_Back:

   995         if (QApplication::keypadNavigationEnabled() && !hasEditFocus()) {

   996             event->ignore();

   997             return;

   998         }

   999         break;

  1000 #endif

  1001     case Qt::Key_Enter:

  1002     case Qt::Key_Return:

  1003         d->edit->d_func()->control->clearUndo();

  1004         d->interpret(d->keyboardTracking ? AlwaysEmit : EmitIfChanged);

  1005         selectAll();

  1006         event->ignore();

  1007         emit editingFinished();

  1008         return;

  1009 

  1010 #ifdef QT_KEYPAD_NAVIGATION

  1011     case Qt::Key_Select:

  1012         if (QApplication::keypadNavigationEnabled()) {

  1013             // Toggles between left/right moving cursor and inc/dec.

  1014             setEditFocus(!hasEditFocus());

  1015         }

  1016         return;

  1017 #endif

  1018 

  1019 #ifdef Q_WS_X11 // only X11

  1020     case Qt::Key_U:

  1021         if (event->modifiers() & Qt::ControlModifier) {

  1022             event->accept();

  1023             if (!isReadOnly())

  1024                 clear();

  1025             return;

  1026         }

  1027         break;

  1028 #endif

  1029 

  1030     case Qt::Key_End:

  1031     case Qt::Key_Home:

  1032         if (event->modifiers() & Qt::ShiftModifier) {

  1033             int currentPos = d->edit->cursorPosition();

  1034             const QString text = d->edit->displayText();

  1035             if (event->key() == Qt::Key_End) {

  1036                 if ((currentPos == 0 && !d->prefix.isEmpty()) || text.size() - d->suffix.size() <= currentPos) {

  1037                     break; // let lineedit handle this

  1038                 } else {

  1039                     d->edit->setSelection(currentPos, text.size() - d->suffix.size() - currentPos);

  1040                 }

  1041             } else {

  1042                 if ((currentPos == text.size() && !d->suffix.isEmpty()) || currentPos <= d->prefix.size()) {

  1043                     break; // let lineedit handle this

  1044                 } else {

  1045                     d->edit->setSelection(currentPos, d->prefix.size() - currentPos);

  1046                 }

  1047             }

  1048             event->accept();

  1049             return;

  1050         }

  1051         break;

  1052 

  1053     default:

  1054 #ifndef QT_NO_SHORTCUT

  1055         if (event == QKeySequence::SelectAll) {

  1056             selectAll();

  1057             event->accept();

  1058             return;

  1059         }

  1060 #endif

  1061         break;

  1062     }

  1063 

  1064     d->edit->event(event);

  1065     if (!isVisible())

  1066         d->ignoreUpdateEdit = true;

  1067 }

  1068 

  1069 /*!

  1070     \reimp

  1071 */

  1072 

  1073 void QAbstractSpinBox::keyReleaseEvent(QKeyEvent *event)

  1074 {

  1075     Q_D(QAbstractSpinBox);

  1076 

  1077     if (d->buttonState & Keyboard && !event->isAutoRepeat())  {

  1078         d->reset();

  1079     } else {

  1080         d->edit->event(event);

  1081     }

  1082 }

  1083 

  1084 /*!

  1085     \reimp

  1086 */

  1087 

  1088 #ifndef QT_NO_WHEELEVENT

  1089 void QAbstractSpinBox::wheelEvent(QWheelEvent *event)

  1090 {

  1091     const int steps = (event->delta() > 0 ? 1 : -1);

  1092     if (stepEnabled() & (steps > 0 ? StepUpEnabled : StepDownEnabled))

  1093         stepBy(event->modifiers() & Qt::ControlModifier ? steps * 10 : steps);

  1094     event->accept();

  1095 }

  1096 #endif

  1097 

  1098 

  1099 /*!

  1100     \reimp

  1101 */

  1102 void QAbstractSpinBox::focusInEvent(QFocusEvent *event)

  1103 {

  1104     Q_D(QAbstractSpinBox);

  1105 

  1106     d->edit->event(event);

  1107     if (event->reason() == Qt::TabFocusReason || event->reason() == Qt::BacktabFocusReason) {

  1108         selectAll();

  1109     }

  1110     QWidget::focusInEvent(event);

  1111 }

  1112 

  1113 /*!

  1114     \reimp

  1115 */

  1116 

  1117 void QAbstractSpinBox::focusOutEvent(QFocusEvent *event)

  1118 {

  1119     Q_D(QAbstractSpinBox);

  1120 

  1121     if (d->pendingEmit)

  1122         d->interpret(EmitIfChanged);

  1123 

  1124     d->reset();

  1125     d->edit->event(event);

  1126     d->updateEdit();

  1127     QWidget::focusOutEvent(event);

  1128 

  1129 #ifdef QT_KEYPAD_NAVIGATION

  1130     // editingFinished() is already emitted on LeaveEditFocus

  1131     if (!QApplication::keypadNavigationEnabled())

  1132 #endif

  1133     emit editingFinished();

  1134 }

  1135