/****************************************************************************

**

** Copyright (C) 2010 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 <private/qabstractspinbox_p.h>

#include <qspinbox.h>

#ifndef QT_NO_SPINBOX

#include <qlineedit.h>

#include <qlocale.h>

#include <qvalidator.h>

#include <qdebug.h>

#include <math.h>

#include <float.h>

QT_BEGIN_NAMESPACE

//#define QSPINBOX_QSBDEBUG

#ifdef QSPINBOX_QSBDEBUG

#  define QSBDEBUG qDebug

#else

#  define QSBDEBUG if (false) qDebug

#endif

class QSpinBoxPrivate : public QAbstractSpinBoxPrivate

{

    Q_DECLARE_PUBLIC(QSpinBox)

public:

    QSpinBoxPrivate();

    void emitSignals(EmitPolicy ep, const QVariant &);

    virtual QVariant valueFromText(const QString &n) const;

    virtual QString textFromValue(const QVariant &n) const;

    QVariant validateAndInterpret(QString &input, int &pos,

                                  QValidator::State &state) const;

    inline void init() {

        Q_Q(QSpinBox);

        q->setInputMethodHints(Qt::ImhDigitsOnly);

        setLayoutItemMargins(QStyle::SE_SpinBoxLayoutItem);

    }

};

class QDoubleSpinBoxPrivate : public QAbstractSpinBoxPrivate

{

    Q_DECLARE_PUBLIC(QDoubleSpinBox)

public:

    QDoubleSpinBoxPrivate();

    void emitSignals(EmitPolicy ep, const QVariant &);

    virtual QVariant valueFromText(const QString &n) const;

    virtual QString textFromValue(const QVariant &n) const;

    QVariant validateAndInterpret(QString &input, int &pos,

                                  QValidator::State &state) const;

    double round(double input) const;

    // variables

    int decimals;

    inline void init() {

        Q_Q(QDoubleSpinBox);

        q->setInputMethodHints(Qt::ImhFormattedNumbersOnly);

    }

    // When fiddling with the decimals property, we may lose precision in these properties.

    double actualMin;

    double actualMax;

};

/*!

    \class QSpinBox

    \brief The QSpinBox class provides a spin box widget.

    \ingroup basicwidgets

    QSpinBox is designed to handle integers and discrete sets of

    values (e.g., month names); use QDoubleSpinBox for floating point

    values.

    QSpinBox allows the user to choose a value by clicking the up/down

    buttons or pressing up/down on the keyboard to increase/decrease

    the value currently displayed. The user can also type the value in

    manually. The spin box supports integer values but can be extended to

    use different strings with validate(), textFromValue() and valueFromText().

    Every time the value changes QSpinBox emits the valueChanged()

    signals. The current value can be fetched with value() and set

    with setValue().

    Clicking the up/down buttons or using the keyboard accelerator's

    up and down arrows will increase or decrease the current value in

    steps of size singleStep(). If you want to change this behaviour you

    can reimplement the virtual function stepBy(). The minimum and

    maximum value and the step size can be set using one of the

    constructors, and can be changed later with setMinimum(),

    setMaximum() and setSingleStep().

    Most spin boxes are directional, but QSpinBox can also operate as

    a circular spin box, i.e. if the range is 0-99 and the current

    value is 99, clicking "up" will give 0 if wrapping() is set to

    true. Use setWrapping() if you want circular behavior.

    The displayed value can be prepended and appended with arbitrary

    strings indicating, for example, currency or the unit of

    measurement. See setPrefix() and setSuffix(). The text in the spin

    box is retrieved with text() (which includes any prefix() and

    suffix()), or with cleanText() (which has no prefix(), no suffix()

    and no leading or trailing whitespace).

    It is often desirable to give the user a special (often default)

    choice in addition to the range of numeric values. See

    setSpecialValueText() for how to do this with QSpinBox.

    \table 100%

    \row \o \inlineimage windowsxp-spinbox.png Screenshot of a Windows XP spin box

         \o A spin box shown in the \l{Windows XP Style Widget Gallery}{Windows XP widget style}.

    \row \o \inlineimage plastique-spinbox.png Screenshot of a Plastique spin box

         \o A spin box shown in the \l{Plastique Style Widget Gallery}{Plastique widget style}.

    \row \o \inlineimage macintosh-spinbox.png Screenshot of a Macintosh spin box

         \o A spin box shown in the \l{Macintosh Style Widget Gallery}{Macintosh widget style}.

    \endtable

    \section1 Subclassing QSpinBox

    If using prefix(), suffix(), and specialValueText() don't provide

    enough control, you subclass QSpinBox and reimplement

    valueFromText() and textFromValue(). For example, here's the code

    for a custom spin box that allows the user to enter icon sizes

    (e.g., "32 x 32"):

    \snippet examples/widgets/icons/iconsizespinbox.cpp 1

    \codeline

    \snippet examples/widgets/icons/iconsizespinbox.cpp 2

    See the \l{widgets/icons}{Icons} example for the full source

    code.

    \sa QDoubleSpinBox, QDateTimeEdit, QSlider, {Spin Boxes Example}

*/

/*!

    \fn void QSpinBox::valueChanged(int i)

    This signal is emitted whenever the spin box's value is changed.

    The new value's integer value is passed in \a i.

*/

/*!

    \fn void QSpinBox::valueChanged(const QString &text)

    \overload

    The new value is passed literally in \a text with no prefix() or

    suffix().

*/

/*!

    Constructs a spin box with 0 as minimum value and 99 as maximum value, a

    step value of 1. The value is initially set to 0. It is parented to \a

    parent.

    \sa setMinimum(), setMaximum(), setSingleStep()

*/

QSpinBox::QSpinBox(QWidget *parent)

    : QAbstractSpinBox(*new QSpinBoxPrivate, parent)

{

    Q_D(QSpinBox);

    d->init();

}

#ifdef QT3_SUPPORT

/*!

    Use one of the constructors that doesn't take the \a name

    argument and then use setObjectName() instead.

*/

QSpinBox::QSpinBox(QWidget *parent, const char *name)

    : QAbstractSpinBox(*new QSpinBoxPrivate, parent)

{

    Q_D(QSpinBox);

    setObjectName(QString::fromAscii(name));

    d->init();

}

/*!

    Use one of the constructors that doesn't take the \a name

    argument and then use setObjectName() instead.

*/

QSpinBox::QSpinBox(int minimum, int maximum, int step, QWidget *parent, const char *name)

    : QAbstractSpinBox(*new QSpinBoxPrivate, parent)

{

    Q_D(QSpinBox);

    d->minimum = QVariant(qMin<int>(minimum, maximum));

    d->maximum = QVariant(qMax<int>(minimum, maximum));

    d->singleStep = QVariant(step);

    setObjectName(QString::fromAscii(name));

    d->init();

}

#endif

/*!

    \property QSpinBox::value

    \brief the value of the spin box

    setValue() will emit valueChanged() if the new value is different

    from the old one.

*/

int QSpinBox::value() const

{

    Q_D(const QSpinBox);

    return d->value.toInt();

}

void QSpinBox::setValue(int value)

{

    Q_D(QSpinBox);

    d->setValue(QVariant(value), EmitIfChanged);

}

/*!

    \property QSpinBox::prefix

    \brief the spin box's prefix

    The prefix is prepended to the start of the displayed value.

    Typical use is to display a unit of measurement or a currency

    symbol. For example:

    \snippet doc/src/snippets/code/src_gui_widgets_qspinbox.cpp 0

    To turn off the prefix display, set this property to an empty

    string. The default is no prefix. The prefix is not displayed when

    value() == minimum() and specialValueText() is set.

    If no prefix is set, prefix() returns an empty string.

    \sa suffix(), setSuffix(), specialValueText(), setSpecialValueText()

*/

QString QSpinBox::prefix() const

{

    Q_D(const QSpinBox);

    return d->prefix;

}

void QSpinBox::setPrefix(const QString &prefix)

{

    Q_D(QSpinBox);

    d->prefix = prefix;

    d->updateEdit();

    d->cachedSizeHint = QSize();

    updateGeometry();

}

/*!

    \property QSpinBox::suffix

    \brief the suffix of the spin box

    The suffix is appended to the end of the displayed value. Typical

    use is to display a unit of measurement or a currency symbol. For

    example:

    \snippet doc/src/snippets/code/src_gui_widgets_qspinbox.cpp 1

    To turn off the suffix display, set this property to an empty

    string. The default is no suffix. The suffix is not displayed for

    the minimum() if specialValueText() is set.

    If no suffix is set, suffix() returns an empty string.

    \sa prefix(), setPrefix(), specialValueText(), setSpecialValueText()

*/

QString QSpinBox::suffix() const

{

    Q_D(const QSpinBox);

    return d->suffix;

}

void QSpinBox::setSuffix(const QString &suffix)

{

    Q_D(QSpinBox);

    d->suffix = suffix;

    d->updateEdit();

    d->cachedSizeHint = QSize();

    updateGeometry();

}

/*!

    \property QSpinBox::cleanText

    \brief the text of the spin box excluding any prefix, suffix,

    or leading or trailing whitespace.

    \sa text, QSpinBox::prefix, QSpinBox::suffix

*/

QString QSpinBox::cleanText() const

{

    Q_D(const QSpinBox);

    return d->stripped(d->edit->displayText());

}

/*!

    \property QSpinBox::singleStep

    \brief the step value

    When the user uses the arrows to change the spin box's value the

    value will be incremented/decremented by the amount of the

    singleStep. The default value is 1. Setting a singleStep value of

    less than 0 does nothing.

*/

int QSpinBox::singleStep() const

{

    Q_D(const QSpinBox);

    return d->singleStep.toInt();

}

void QSpinBox::setSingleStep(int value)

{

    Q_D(QSpinBox);

    if (value >= 0) {

        d->singleStep = QVariant(value);

        d->updateEdit();

    }

}

/*!

    \property QSpinBox::minimum

    \brief the minimum value of the spin box

    When setting this property the \l maximum is adjusted

    if necessary to ensure that the range remains valid.

    The default minimum value is 0.

    \sa setRange()  specialValueText

*/

int QSpinBox::minimum() const

{

    Q_D(const QSpinBox);

    return d->minimum.toInt();

}

void QSpinBox::setMinimum(int minimum)

{

    Q_D(QSpinBox);

    const QVariant m(minimum);

    d->setRange(m, (d->variantCompare(d->maximum, m) > 0 ? d->maximum : m));

}

/*!

    \property QSpinBox::maximum

    \brief the maximum value of the spin box

    When setting this property the \l minimum is adjusted

    if necessary, to ensure that the range remains valid.

    The default maximum value is 99.

    \sa setRange() specialValueText

*/

int QSpinBox::maximum() const

{

    Q_D(const QSpinBox);

    return d->maximum.toInt();

}

void QSpinBox::setMaximum(int maximum)

{

    Q_D(QSpinBox);

    const QVariant m(maximum);

    d->setRange((d->variantCompare(d->minimum, m) < 0 ? d->minimum : m), m);

}

/*!

    Convenience function to set the \a minimum, and \a maximum values

    with a single function call.

    \snippet doc/src/snippets/code/src_gui_widgets_qspinbox.cpp 2

    is equivalent to:

    \snippet doc/src/snippets/code/src_gui_widgets_qspinbox.cpp 3

    \sa minimum maximum

*/

void QSpinBox::setRange(int minimum, int maximum)

{

    Q_D(QSpinBox);

    d->setRange(QVariant(minimum), QVariant(maximum));

}

/*!

    This virtual function is used by the spin box whenever it needs to

    display the given \a value. The default implementation returns a

    string containing \a value printed in the standard way using

    QWidget::locale().toString(), but with the thousand separator

    removed. Reimplementations may return anything. (See the example

    in the detailed description.)

    Note: QSpinBox does not call this function for specialValueText()

    and that neither prefix() nor suffix() should be included in the

    return value.

    If you reimplement this, you may also need to reimplement

    valueFromText() and validate()

    \sa valueFromText(), validate(), QLocale::groupSeparator()

*/

QString QSpinBox::textFromValue(int value) const

{

    QString str = locale().toString(value);

    if (qAbs(value) >= 1000 || value == INT_MIN) {

        str.remove(locale().groupSeparator());

    }

    return str;

}

/*!

    \fn int QSpinBox::valueFromText(const QString &text) const

    This virtual function is used by the spin box whenever it needs to

    interpret \a text entered by the user as a value.

    Subclasses that need to display spin box values in a non-numeric

    way need to reimplement this function.

    Note: QSpinBox handles specialValueText() separately; this

    function is only concerned with the other values.

    \sa textFromValue(), validate()

*/

int QSpinBox::valueFromText(const QString &text) const

{

    Q_D(const QSpinBox);

    QString copy = text;

    int pos = d->edit->cursorPosition();

    QValidator::State state = QValidator::Acceptable;

    return d->validateAndInterpret(copy, pos, state).toInt();

}

/*!

  \reimp

*/

QValidator::State QSpinBox::validate(QString &text, int &pos) const

{

    Q_D(const QSpinBox);

    QValidator::State state;

    d->validateAndInterpret(text, pos, state);

    return state;

}

/*!

  \reimp

*/

void QSpinBox::fixup(QString &input) const

{

    input.remove(locale().groupSeparator());

}

// --- QDoubleSpinBox ---