Allow adaptive decimal stepping for QSpinBox and QDoubleSpinBox

Adds the feature of adaptive decimal step sizes for the QSpinBox and
QDoubleSpinBox. By performing a calculation in
QAbstractSpinBox::stepBy() we continuously set the step size one power
of ten below the current value.

So when the value is 1100, the step is set to 100, so stepping up once
increases it to 1200. For 1200 stepping up takes it to 1300. For
negative values stepping down from -1100 goes to -1200.

It also works for all decimal values. 0.041 is increased to 0.042 by
stepping once, and so on.

The step direction is taken into account to handle edges cases, so that
stepping down from 100 takes the value to 99 instead of 90. Thus, a
step up followed by a step down -- or vice versa -- lands on the
starting value; 99 -> 100 -> 99.

Setting this property effectively disregards singleStep, but preserves
its value so that it takes effect again when adaptive decimal step is
disabled.

Adaptive decimal step allows values to be easily set to reasonable
levels. If the spin box value is 12000, changing to 13000 often makes
more sense than to 12001. The feature is turned off be default, when
single stepping is desired.

The accelerated property allows values to be changed quickly, as well,
but it is imprecise. Holding down the button makes it hard to land on
an even thousand, like 12000 or 13000. Often you end up somewhere
nearby and would need a second adjustment to get to an even hundred or
thousand.

[ChangeLog][QtWidgets] Add option of adaptive decimal step size for
QSpinBox and QDoubleSpinBox.

Change-Id: I9f286479b821e240c8ea05c238932fc128c582bb
Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>

2 files changed, 212 insertions, 0 deletions

diff --git a/tests/auto/widgets/widgets/qdoublespinbox/tst_qdoublespinbox.cpp b/tests/auto/widgets/widgets/qdoublespinbox/tst_qdoublespinbox.cpp
index 59ddd54194..5382d5c6db 100644
--- a/tests/auto/widgets/widgets/qdoublespinbox/tst_qdoublespinbox.cpp
+++ b/tests/auto/widgets/widgets/qdoublespinbox/tst_qdoublespinbox.cpp
@@ -31,6 +31,7 @@
 #include <qapplication.h>
 #include <limits.h>
 
+#include <cmath>
 #include <float.h>
 
 #include <qspinbox.h>
@@ -135,6 +136,8 @@ private slots:
     void setGroupSeparatorShown_data();
     void setGroupSeparatorShown();
 
+    void adaptiveDecimalStep();
+
 public slots:
     void valueChangedHelper(const QString &);
     void valueChangedHelper(double);
@@ -1139,5 +1142,133 @@ void tst_QDoubleSpinBox::setGroupSeparatorShown()
     QCOMPARE(spinBox.value()+1000, 33000.44);
 }
 
+void tst_QDoubleSpinBox::adaptiveDecimalStep()
+{
+    DoubleSpinBox spinBox;
+    spinBox.setRange(-100000, 100000);
+    spinBox.setDecimals(4);
+    spinBox.setStepType(DoubleSpinBox::StepType::AdaptiveDecimalStepType);
+
+    // Positive values
+
+    spinBox.setValue(0);
+
+    // Go from 0 to 0.01
+    for (double i = 0; i < 0.00999; i += 0.0001) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(1);
+    }
+
+    // Go from 0.01 to 0.1
+    for (double i = 0.01; i < 0.0999; i += 0.001) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(1);
+    }
+
+    // Go from 0.1 to 1
+    for (double i = 0.1; i < 0.999; i += 0.01) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(1);
+    }
+
+    // Go from 1 to 10
+    for (double i = 1; i < 9.99; i += 0.1) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(1);
+    }
+
+    // Go from 10 to 100
+    for (int i = 10; i < 100; i++) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(1);
+    }
+
+    // Go from 100 to 1000
+    for (int i = 100; i < 1000; i += 10) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(1);
+    }
+
+    // Go from 1000 to 10000
+    for (int i = 1000; i < 10000; i += 100) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(1);
+    }
+
+    // Test decreasing the values now
+
+    // Go from 10000 down to 1000
+    for (int i = 10000; i > 1000; i -= 100) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(-1);
+    }
+
+    // Go from 1000 down to 100
+    for (int i = 1000; i > 100; i -= 10) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(-1);
+    }
+
+    // Negative values
+
+    spinBox.setValue(0);
+
+    // Go from 0 to -0.01
+    for (double i = 0; i > -0.00999; i -= 0.0001) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(-1);
+    }
+
+    // Go from -0.01 to -0.1
+    for (double i = -0.01; i > -0.0999; i -= 0.001) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(-1);
+    }
+
+    // Go from -0.1 to -1
+    for (double i = -0.1; i > -0.999; i -= 0.01) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(-1);
+    }
+
+    // Go from -1 to -10
+    for (double i = -1; i > -9.99; i -= 0.1) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(-1);
+    }
+
+    // Go from -10 to -100
+    for (int i = -10; i > -100; i--) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(-1);
+    }
+
+    // Go from -100 to -1000
+    for (int i = -100; i > -1000; i -= 10) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(-1);
+    }
+
+    // Go from 1000 to 10000
+    for (int i = -1000; i > -10000; i -= 100) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(-1);
+    }
+
+    // Test increasing the values now
+
+    // Go from -10000 up to -1000
+    for (int i = -10000; i < -1000; i += 100) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(1);
+    }
+
+    // Go from -1000 up to -100
+    for (int i = -1000; i < -100; i += 10) {
+        QVERIFY(qFuzzyCompare(spinBox.value(), i));
+        spinBox.stepBy(1);
+    }
+}
+
 QTEST_MAIN(tst_QDoubleSpinBox)
 #include "tst_qdoublespinbox.moc"
diff --git a/tests/auto/widgets/widgets/qspinbox/tst_qspinbox.cpp b/tests/auto/widgets/widgets/qspinbox/tst_qspinbox.cpp
index 07a2fd859d..5ee9160916 100644
--- a/tests/auto/widgets/widgets/qspinbox/tst_qspinbox.cpp
+++ b/tests/auto/widgets/widgets/qspinbox/tst_qspinbox.cpp
@@ -145,6 +145,8 @@ private slots:
 
     void wheelEvents();
 
+    void adaptiveDecimalStep();
+
 public slots:
     void valueChangedHelper(const QString &);
     void valueChangedHelper(int);
@@ -1240,5 +1242,84 @@ void tst_QSpinBox::wheelEvents()
 #endif
 }
 
+void tst_QSpinBox::adaptiveDecimalStep()
+{
+    SpinBox spinBox;
+    spinBox.setRange(-100000, 100000);
+    spinBox.setStepType(SpinBox::StepType::AdaptiveDecimalStepType);
+
+    // Positive values
+
+    spinBox.setValue(0);
+
+    // Go from 0 to 100
+    for (int i = 0; i < 100; i++) {
+        QCOMPARE(spinBox.value(), i);
+        spinBox.stepBy(1);
+    }
+
+    // Go from 100 to 1000
+    for (int i = 100; i < 1000; i += 10) {
+        QCOMPARE(spinBox.value(), i);
+        spinBox.stepBy(1);
+    }
+
+    // Go from 1000 to 10000
+    for (int i = 1000; i < 10000; i += 100) {
+        QCOMPARE(spinBox.value(), i);
+        spinBox.stepBy(1);
+    }
+
+    // Test decreasing the values now
+
+    // Go from 10000 down to 1000
+    for (int i = 10000; i > 1000; i -= 100) {
+        QCOMPARE(spinBox.value(), i);
+        spinBox.stepBy(-1);
+    }
+
+    // Go from 1000 down to 100
+    for (int i = 1000; i > 100; i -= 10) {
+        QCOMPARE(spinBox.value(), i);
+        spinBox.stepBy(-1);
+    }
+
+    // Negative values
+
+    spinBox.setValue(0);
+
+    // Go from 0 to -100
+    for (int i = 0; i > -100; i--) {
+        QCOMPARE(spinBox.value(), i);
+        spinBox.stepBy(-1);
+    }
+
+    // Go from -100 to -1000
+    for (int i = -100; i > -1000; i -= 10) {
+        QCOMPARE(spinBox.value(), i);
+        spinBox.stepBy(-1);
+    }
+
+    // Go from 1000 to 10000
+    for (int i = -1000; i > -10000; i -= 100) {
+        QCOMPARE(spinBox.value(), i);
+        spinBox.stepBy(-1);
+    }
+
+    // Test increasing the values now
+
+    // Go from -10000 up to -1000
+    for (int i = -10000; i < -1000; i += 100) {
+        QCOMPARE(spinBox.value(), i);
+        spinBox.stepBy(1);
+    }
+
+    // Go from -1000 up to -100
+    for (int i = -1000; i < -100; i += 10) {
+        QCOMPARE(spinBox.value(), i);
+        spinBox.stepBy(1);
+    }
+}
+
 QTEST_MAIN(tst_QSpinBox)
 #include "tst_qspinbox.moc"