qquickdoublespinbox.cpp

Go to the documentation of this file.

// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
#include "qquickdoublespinbox_p.h"
 
#include <private/qquickcontrol_p_p.h>
#include <private/qquickindicatorbutton_p.h>
#include <private/qquicktextinput_p.h>
 
#include <private/qqmlengine_p.h>
 
#include <QtQml/qqmlinfo.h>
 
QT_BEGIN_NAMESPACE
 
/*!
    \qmltype DoubleSpinBox
    \inherits Control
//!     \nativetype QQuickDoubleSpinBox
    \inqmlmodule QtQuick.Controls
    \ingroup qtquickcontrols-input
    \ingroup qtquickcontrols-focusscopes
    \since 6.11
    \brief Allows the user to select from a set of preset floating-point
        values.
 
    \image qtquickcontrols-doublespinbox.png
           {Spin box displaying decimal values}
 
    DoubleSpinBox is similar to \l SpinBox, except that it supports double
    values rather than integer. The user can choose a value by clicking the up
    or down indicator buttons, or by pressing up or down on the keyboard.
    Optionally, DoubleSpinBox can be also made \l editable, so the user can
    enter a text value in the input field.
 
    By default, DoubleSpinBox provides discrete values in the range of
    \c [0.00-99.99] with a \l stepSize of \c 1.0.
 
    \snippet qtquickcontrols-doublespinbox.qml 1
 
    \sa SpinBox, Tumbler, {Customizing DoubleSpinBox},
        {Focus Management in Qt Quick Controls}
*/
 
/*!
    \include qquickspinbox.qdocinc {valueModified} {DoubleSpinBox}
*/
 
class QQuickDoubleSpinBoxPrivate
    : public QQuickAbstractSpinBox<QQuickDoubleSpinBox, double>::QQuickAbstractSpinBoxPrivate
{
    Q_DECLARE_PUBLIC(QQuickDoubleSpinBox)
 
public:
    QQuickDoubleSpinBoxPrivate();
 
    bool setValue(double newValue, bool wrap, ValueStatus modified) override;
 
    void updateValue() override;
    void updateDisplayText() override;
 
    void contentItemTextChanged();
 
    QString evaluateTextFromValue(double val, int decimals) const;
    double evaluateValueFromText(const QString &text) const;
 
    double round(double input) const;
 
    int decimals = 2;
 
private:
    friend class QQuickAbstractSpinBox<QQuickDoubleSpinBox, double>::QQuickAbstractSpinBoxPrivate;
};
 
QQuickDoubleSpinBoxPrivate::QQuickDoubleSpinBoxPrivate()
    : QQuickAbstractSpinBox<QQuickDoubleSpinBox, double>::QQuickAbstractSpinBoxPrivate()
{
    from = 0.0;
    to = 99.99;
}
 
/*!
    \internal
 
    modified indicates if the value was modified by the user and not programatically.
    This is then passed on to updateDisplayText to indicate that the user has modified
    the value, so it may need to trigger an update of the contentItem's text, too.
*/
 
bool QQuickDoubleSpinBoxPrivate::setValue(double newValue, bool wrap, ValueStatus modified)
{
    Q_Q(QQuickDoubleSpinBox);
    double correctedValue = newValue;
    if (q->isComponentComplete())
        correctedValue = boundValue(newValue, wrap);
 
    if (modified == ValueStatus::Unmodified && qFuzzyCompare(newValue, correctedValue)
        && qFuzzyCompare(newValue, value))
        return false;
 
    const bool emitSignals = (value != correctedValue);
    value = correctedValue;
 
    updateDisplayText();
    updateUpEnabled();
    updateDownEnabled();
 
    // Only emit the signals if the corrected value is not the same as the
    // original value to avoid unnecessary updates.
    if (emitSignals) {
        emit q->valueChanged();
        if (modified == ValueStatus::Modified)
            emit q->valueModified();
    }
    return true;
}
 
void QQuickDoubleSpinBoxPrivate::updateValue()
{
    if (!contentItem)
        return;
 
    const QVariant text = contentItem->property("text");
    if (text.isValid())
        setValue(evaluateValueFromText(text.toString()), false /* wrap */, ValueStatus::Modified);
}
 
void QQuickDoubleSpinBoxPrivate::updateDisplayText()
{
    setDisplayText(evaluateTextFromValue(value, decimals));
}
 
void QQuickDoubleSpinBoxPrivate::contentItemTextChanged()
{
    Q_Q(QQuickDoubleSpinBox);
 
    QQuickTextInput *inputTextItem = qobject_cast<QQuickTextInput *>(q->contentItem());
    if (!inputTextItem)
        return;
    setDisplayText(inputTextItem->text());
}
 
QString QQuickDoubleSpinBoxPrivate::evaluateTextFromValue(double val, int decimals) const
{
    Q_Q(const QQuickDoubleSpinBox);
 
    QString text;
    QQmlEngine *engine = qmlEngine(q);
    if (engine && textFromValue.isCallable()) {
        QJSValue loc;
#if QT_CONFIG(qml_locale)
        loc = QJSValuePrivate::fromReturnedValue(
                engine->handle()->fromData(QMetaType::fromType<QLocale>(), &locale));
#endif
        text = textFromValue.call(QJSValueList() << val << decimals << loc).toString();
    } else {
        text = locale.toString(val, 'f', decimals);
    }
    return text;
}
 
double QQuickDoubleSpinBoxPrivate::evaluateValueFromText(const QString &text) const
{
    Q_Q(const QQuickDoubleSpinBox);
    double value;
    QQmlEngine *engine = qmlEngine(q);
    if (engine && valueFromText.isCallable()) {
        QJSValue loc;
#if QT_CONFIG(qml_locale)
        loc = QJSValuePrivate::fromReturnedValue(
                engine->handle()->fromData(QMetaType::fromType<QLocale>(), &locale));
#endif
        value = valueFromText.call(QJSValueList() << text << loc).toNumber();
    } else {
        value = locale.toDouble(text);
    }
    return value;
}
 
double QQuickDoubleSpinBoxPrivate::round(double value) const
{
    return QString::number(value, 'f', decimals).toDouble();
}
 
QQuickDoubleSpinBox::QQuickDoubleSpinBox(QQuickItem *parent)
    : QQuickControl(*(new QQuickDoubleSpinBoxPrivate), parent),
      QQuickAbstractSpinBox<QQuickDoubleSpinBox, double>()
{
}
 
QQuickDoubleSpinBox::~QQuickDoubleSpinBox() { }
 
/*!
    \include qquickspinbox.qdocinc {from} {double} {DoubleSpinBox} {0.0}
*/
 
void QQuickDoubleSpinBox::setFrom(double from)
{
    Q_D(QQuickDoubleSpinBox);
    const double newFrom = d->round(from);
    if (qFuzzyCompare(d->from, newFrom))
        return;
 
    d->from = newFrom;
    emit fromChanged();
    if (isComponentComplete()) {
        if (!d->setValue(d->round(d->value), false /* wrap */,
                         QQuickDoubleSpinBoxPrivate::ValueStatus::Unmodified)) {
            d->updateUpEnabled();
            d->updateDownEnabled();
        }
    }
}
 
/*!
    \include qquickspinbox.qdocinc {to} {double} {DoubleSpinBox} {99.99}
*/
 
void QQuickDoubleSpinBox::setTo(double to)
{
    Q_D(QQuickDoubleSpinBox);
    const double newTo = d->round(to);
    if (qFuzzyCompare(d->to, newTo))
        return;
 
    d->to = newTo;
    emit toChanged();
    if (isComponentComplete()) {
        if (!d->setValue(d->round(d->value), false /* wrap */,
                         QQuickDoubleSpinBoxPrivate::ValueStatus::Unmodified)) {
            d->updateUpEnabled();
            d->updateDownEnabled();
        }
    }
}
 
/*!
    \include qquickspinbox.qdocinc {value-prop} {double} {DoubleSpinBox} {0.0}
*/
 
void QQuickDoubleSpinBox::setValue(double value)
{
    Q_D(QQuickDoubleSpinBox);
    d->setValue(d->round(value), false /* wrap */,
                QQuickDoubleSpinBoxPrivate::ValueStatus::Unmodified);
}
 
/*!
    \include qquickspinbox.qdocinc {stepSize} {double} {DoubleSpinBox} {1.0}
*/
 
void QQuickDoubleSpinBox::setStepSize(double step)
{
    Q_D(QQuickDoubleSpinBox);
    if (qFuzzyCompare(d->stepSize, step))
        return;
 
    d->stepSize = step;
    emit stepSizeChanged();
}
 
/*!
    \qmlproperty int QtQuick.Controls::DoubleSpinBox::decimals
 
    This property holds how many decimals the spinbox will use for displaying
    and interpreting doubles.
 
    The default value is \c 2.
 
    Changing the value of this property may affect \l from, \l to and \l value.
 
    \warning The maximum value for \a decimals is \c {DBL_MAX_10_EXP +
    DBL_DIG} (\c 323) because of the limitations of the double type.
*/
 
int QQuickDoubleSpinBox::decimals() const
{
    Q_D(const QQuickDoubleSpinBox);
 
    return d->decimals;
}
 
void QQuickDoubleSpinBox::setDecimals(int decimals)
{
    Q_D(QQuickDoubleSpinBox);
    d->decimals = qBound(0, decimals, DBL_MAX_10_EXP + DBL_DIG);
 
    // Make sure values are rounded.
    setFrom(from());
    setTo(to());
    setValue(value());
    d->updateValue();
    emit decimalsChanged();
}
 
/*!
    \include qquickspinbox.qdocinc {editable} {DoubleSpinBox}
*/
 
#if QT_CONFIG(validator)
/*!
    \qmlproperty Validator QtQuick.Controls::DoubleSpinBox::validator
 
    This property holds the input text validator for editable spinboxes. By
    default, DoubleSpinBox uses \l DoubleValidator to accept input of double numbers.
 
    \code
    DoubleSpinBox {
        id: control
        validator: DoubleValidator {
            locale: control.locale.name
            bottom: Math.min(control.from, control.to)
            top: Math.max(control.from, control.to)
        }
    }
    \endcode
 
    \sa editable, textFromValue, valueFromText, {Control::locale}{locale},
        {Validating Input Text}
*/
#endif
 
/*!
    \qmlproperty function QtQuick.Controls::DoubleSpinBox::textFromValue
 
    This property holds a callback function that is called whenever
    a double value needs to be converted to display text.
 
    The default function can be overridden to display custom text for a given
    value. This applies to both editable and non-editable spinboxes;
    for example, when using the up and down buttons or a mouse wheel to
    increment and decrement the value, the new value is converted to display
    text using this function.
 
    The callback function signature is \c {string function(value, decimals, locale)}.
    The function can have two or three arguments, where the first argument
    is the value to be converted, the second argument is the number of decimals,
    and the optional third argument is the locale that should be used for
    the conversion, if applicable.
 
    The default implementation does the conversion using
    \l {string Number::toLocaleString(locale, format, precision)}{Number.toLocaleString}():
 
    \code
    textFromValue: function(value, decimals, locale) {
        return Number(value).toLocaleString(locale, 'f', decimals);
    }
    \endcode
 
    \note When applying a custom \c textFromValue implementation for editable
    spinboxes, a matching \l valueFromText implementation must be provided
    to be able to convert the custom text back to a double value.
 
    \sa valueFromText, validator, {Control::locale}{locale}
*/
QJSValue QQuickDoubleSpinBox::textFromValue() const
{
    Q_D(const QQuickDoubleSpinBox);
    if (!d->textFromValue.isCallable()) {
        QQmlEngine *engine = qmlEngine(this);
        if (engine) {
            d->textFromValue = engine->evaluate(
                    QStringLiteral("(function(value, decimals, locale) { return "
                                   "Number(value).toLocaleString(locale, 'f', decimals); })"));
        }
    }
    return d->textFromValue;
}
 
/*!
    \qmlproperty function QtQuick.Controls::DoubleSpinBox::valueFromText
 
    This property holds a callback function that is called whenever
    input text needs to be converted to a double value.
 
    This function only needs to be overridden when \l textFromValue
    is overridden for an editable spinbox.
 
    The callback function signature is \c {int function(text, locale)}.
    The function can have one or two arguments, where the first argument
    is the text to be converted, and the optional second argument is the
    locale that should be used for the conversion, if applicable.
 
    The default implementation does the conversion using
    \l {QtQml::Locale}{Number.fromLocaleString()}:
 
    \code
    valueFromText: function(text, locale) { return Number.fromLocaleString(locale, text); }
    \endcode
 
    \note When applying a custom \l textFromValue implementation for editable
    spinboxes, a matching \c valueFromText implementation must be provided
    to be able to convert the custom text back to a double value.
 
    \sa textFromValue, validator, {Control::locale}{locale}
*/
QJSValue QQuickDoubleSpinBox::valueFromText() const
{
    Q_D(const QQuickDoubleSpinBox);
    if (!d->valueFromText.isCallable()) {
        QQmlEngine *engine = qmlEngine(this);
        if (engine)
            d->valueFromText = engine->evaluate(QStringLiteral(
                    "(function(text, locale) { return Number.fromLocaleString(locale, text); })"));
    }
    return d->valueFromText;
}
 
/*!
    \include qquickindicatorbutton.qdocinc {properties} {DoubleSpinBox} {up}
 
    \include qquickspinbox.qdocinc {indicator-enabled} {DoubleSpinBox} {up} {to}
 
    \sa increase()
*/
 
/*!
    \include qquickindicatorbutton.qdocinc {properties} {DoubleSpinBox} {down}
 
    \include qquickspinbox.qdocinc {indicator-enabled} {DoubleSpinBox} {down} {from}
 
    \sa decrease()
*/
 
/*!
    \include qquickspinbox.qdocinc {inputMethodHints} {DoubleSpinBox}
*/
 
/*!
    \include qquickspinbox.qdocinc {inputMethodComposing} {DoubleSpinBox}
*/
 
/*!
    \since QtQuick.Controls 2.3 (Qt 5.10)
    \include qquickspinbox.qdocinc {wrap} {DoubleSpinBox}
*/
 
void QQuickDoubleSpinBox::setWrap(bool wrap)
{
    Q_D(QQuickDoubleSpinBox);
    if (d->wrap == wrap)
        return;
 
    d->wrap = wrap;
    if (qFuzzyCompare(d->value, d->from) || qFuzzyCompare(d->value, d->to)) {
        d->updateUpEnabled();
        d->updateDownEnabled();
    }
    emit wrapChanged();
}
 
/*!
    \qmlproperty string QtQuick.Controls::DoubleSpinBox::displayText
    \readonly
 
    This property holds the textual value of the spinbox.
 
    The value of the property is based on \l textFromValue and \l {Control::}
    {locale}, and equal to:
    \badcode
    let text = spinBox.textFromValue(spinBox.value, spinBox.decimals, spinBox.locale)
    \endcode
 
    \sa textFromValue
*/
 
/*!
    \include qquickspinbox.qdocinc {increase} {DoubleSpinBox}
*/
 
void QQuickDoubleSpinBox::increase()
{
    QQuickAbstractSpinBox<QQuickDoubleSpinBox, double>::increase();
}
 
/*!
    \include qquickspinbox.qdocinc {decrease} {DoubleSpinBox}
*/
 
void QQuickDoubleSpinBox::decrease()
{
    QQuickAbstractSpinBox<QQuickDoubleSpinBox, double>::decrease();
}
 
void QQuickDoubleSpinBox::contentItemChange(QQuickItem *newItem, QQuickItem *oldItem)
{
    Q_D(QQuickDoubleSpinBox);
    if (QQuickTextInput *oldInput = qobject_cast<QQuickTextInput *>(oldItem)) {
        disconnect(oldInput, &QQuickTextInput::inputMethodComposingChanged, this,
                   &QQuickDoubleSpinBox::inputMethodComposingChanged);
        QObjectPrivate::disconnect(oldInput, &QQuickTextInput::textChanged, d,
                                   &QQuickDoubleSpinBoxPrivate::contentItemTextChanged);
    }
 
    if (newItem) {
        newItem->setActiveFocusOnTab(true);
        if (d->activeFocus)
            newItem->forceActiveFocus(static_cast<Qt::FocusReason>(d->focusReason));
#if QT_CONFIG(cursor)
        if (d->editable)
            newItem->setCursor(Qt::IBeamCursor);
#endif
 
        if (QQuickTextInput *newInput = qobject_cast<QQuickTextInput *>(newItem)) {
            connect(newInput, &QQuickTextInput::inputMethodComposingChanged, this,
                    &QQuickDoubleSpinBox::inputMethodComposingChanged);
            QObjectPrivate::connect(newInput, &QQuickTextInput::textChanged, d,
                                    &QQuickDoubleSpinBoxPrivate::contentItemTextChanged);
        }
    }
}
 
QQuickControlPrivate *QQuickDoubleSpinBox::d_base_func()
{
    Q_D(QQuickDoubleSpinBox);
    return d;
}
const QQuickControlPrivate *QQuickDoubleSpinBox::d_base_func() const
{
    Q_D(const QQuickDoubleSpinBox);
    return d;
}
 
QT_END_NAMESPACE
 
#include "moc_qquickdoublespinbox_p.cpp"