1 files changed, 88 insertions, 2 deletions

diff --git a/src/gui/util/qvalidator.cpp b/src/gui/util/qvalidator.cpp
index 6f93738340..52dfad11a4 100644
--- a/src/gui/util/qvalidator.cpp
+++ b/src/gui/util/qvalidator.cpp
@@ -543,6 +543,8 @@ public:
     QDoubleValidator::Notation notation;
 
     QValidator::State validateWithLocale(QString & input, QLocaleData::NumberMode numMode, const QLocale &locale) const;
+    void fixupWithLocale(QString &input, QLocaleData::NumberMode numMode,
+                         const QLocale &locale) const;
 };
 
 
@@ -554,8 +556,7 @@ public:
     \inmodule QtGui
 
     QDoubleValidator provides an upper bound, a lower bound, and a
-    limit on the number of digits after the decimal point. It does not
-    provide a fixup() function.
+    limit on the number of digits after the decimal point.
 
     You can set the acceptable range in one call with setRange(), or
     with setBottom() and setTop(). Set the number of decimal places
@@ -712,6 +713,91 @@ QValidator::State QDoubleValidatorPrivate::validateWithLocale(QString &input, QL
 }
 
 /*!
+    \since 6.3
+    \overload
+
+    Attempts to fix the \a input string to an \l Acceptable representation of a
+    double.
+
+    The format of the number is determined by \l notation(), \l decimals(),
+    \l locale() and the latter's \l {QLocale::}{numberOptions()}.
+
+    To comply with \l notation(), when \l ScientificNotation is used, the fixed
+    value will be represented in its normalized form, which means that any
+    non-zero value will have one non-zero digit before the decimal point.
+
+    \snippet code/src_gui_util_qvalidator.cpp 7
+
+    To comply with \l decimals(), when it is \c {-1} the number of digits used
+    will be determined by \l QLocale::FloatingPointShortest. Otherwise, the
+    fractional part of the number is truncated (with rounding, as appropriate)
+    if its length exceeds \l decimals(). When \l notation() is
+    \l ScientificNotation this is done after the number has been put into its
+    normalized form.
+
+    \snippet code/src_gui_util_qvalidator.cpp 8
+
+    \note If \l decimals() is set to, and the string provides, more than
+    \c {std::numeric_limits<double>::digits10}, digits beyond that many in the
+    fractional part may be changed. The resulting string shall encode the same
+    floating-point number, when parsed to a \c double.
+*/
+void QDoubleValidator::fixup(QString &input) const
+{
+    Q_D(const QDoubleValidator);
+    const auto numberMode = d->notation == StandardNotation ? QLocaleData::DoubleStandardMode
+                                                            : QLocaleData::DoubleScientificMode;
+
+    d->fixupWithLocale(input, numberMode, locale());
+}
+
+void QDoubleValidatorPrivate::fixupWithLocale(QString &input, QLocaleData::NumberMode numMode,
+                                              const QLocale &locale) const
+{
+    Q_Q(const QDoubleValidator);
+    QByteArray buff;
+    // Passing -1 as the number of decimals, because fixup() exists to improve
+    // an Intermediate value, if it can.
+    if (!locale.d->m_data->validateChars(input, numMode, &buff, -1, locale.numberOptions()))
+        return;
+
+    // buff now contains data in C locale.
+    bool ok = false;
+    const double entered = buff.toDouble(&ok);
+    if (ok) {
+        // Here we need to adjust the output format accordingly
+        char mode;
+        if (numMode == QLocaleData::DoubleStandardMode) {
+            mode = 'f';
+        } else {
+            // scientific mode can be either 'e' or 'E'
+            mode = input.contains(QChar::fromLatin1('E')) ? 'E' : 'e';
+        }
+        int precision;
+        if (q->dec < 0) {
+            precision = QLocale::FloatingPointShortest;
+        } else {
+            if (mode == 'f') {
+                const auto decimalPointIndex = buff.indexOf('.');
+                precision = decimalPointIndex >= 0 ? buff.size() - decimalPointIndex - 1 : 0;
+            } else {
+                auto eIndex = buff.indexOf('e');
+                // No need to check for 'E' because we can get only 'e' after a
+                // call to validateChars()
+                if (eIndex < 0)
+                    eIndex = buff.size();
+                precision = eIndex - (buff.contains('.') ? 1 : 0)
+                        - (buff.startsWith('-') || buff.startsWith('+') ? 1 : 0);
+            }
+            // Use q->dec to limit the number of decimals, because we want the
+            // fixup() result to pass validate().
+            precision = qMin(precision, q->dec);
+        }
+        input = locale.toString(entered, mode, precision);
+    }
+}
+
+/*!
     Sets the validator to accept doubles from \a minimum to \a maximum
     inclusive, with at most \a decimals digits after the decimal
     point.