Allow QDial to wrap value when wrapping property is set.

QDial's wrapping property allows for 360 degree revolutions when using
the mouse.  However whenever using the keyboard Up/Down/PageUp/PageDown
keys the QDial's value will stop at the minimum and maximum values.
This has been fixed to allow the bounds checker to account for the
wrapping property.

Merge-request: 2437
Reviewed-by: Pierre Rossi <pierre.rossi@nokia.com>

3 files changed, 80 insertions, 1 deletions

diff --git a/src/gui/widgets/qabstractslider_p.h b/src/gui/widgets/qabstractslider_p.h
index 19d1fca..d044131 100644
--- a/src/gui/widgets/qabstractslider_p.h
+++ b/src/gui/widgets/qabstractslider_p.h
@@ -117,7 +117,7 @@ public:
         ;
     }
 
-    inline int bound(int val) const { return qMax(minimum, qMin(maximum, val)); }
+    virtual int bound(int val) const { return qMax(minimum, qMin(maximum, val)); }
     inline int overflowSafeAdd(int add) const
     {
         int newValue = value + add;
diff --git a/src/gui/widgets/qdial.cpp b/src/gui/widgets/qdial.cpp
index a8d739f..bca5019 100644
--- a/src/gui/widgets/qdial.cpp
+++ b/src/gui/widgets/qdial.cpp
@@ -83,6 +83,7 @@ public:
     int valueFromPoint(const QPoint &) const;
     double angle(const QPoint &, const QPoint &) const;
     void init();
+    virtual int bound(int val) const;
 };
 
 void QDialPrivate::init()
@@ -97,6 +98,20 @@ void QDialPrivate::init()
 #endif
 }
 
+int QDialPrivate::bound(int val) const
+{
+    if (wrapping) {
+        if ((val >= minimum) && (val <= maximum))
+            return val;
+        val = minimum + ((val - minimum) % (maximum - minimum));
+        if (val < minimum)
+            val += maximum - minimum;
+        return val;
+    } else {
+        return QAbstractSliderPrivate::bound(val);
+    }
+}
+
 /*!
     Initialize \a option with the values from this QDial. This method
     is useful for subclasses when they need a QStyleOptionSlider, but don't want
diff --git a/tests/auto/qdial/tst_qdial.cpp b/tests/auto/qdial/tst_qdial.cpp
index 2428eae..92c2964 100644
--- a/tests/auto/qdial/tst_qdial.cpp
+++ b/tests/auto/qdial/tst_qdial.cpp
@@ -54,6 +54,7 @@ private slots:
     void getSetCheck();
     void valueChanged();
     void sliderMoved();
+    void wrappingCheck();
 };
 
 // Testing get/set functions
@@ -143,5 +144,68 @@ void tst_QDial::sliderMoved()
 
 }
 
+void tst_QDial::wrappingCheck()
+{
+    //This tests if dial will wrap past the maximum value back to the minimum
+    //and vice versa when changing the value with a keypress
+    QDial dial;
+    dial.setMinimum(0);
+    dial.setMaximum(100);
+    dial.setSingleStep(1);
+    dial.setWrapping(true);
+    dial.setValue(99);
+    dial.show();
+
+    { //set value to maximum but do not wrap
+        QTest::keyPress(&dial, Qt::Key_Up);
+        QCOMPARE( dial.value(), 100);
+    }
+
+    { //step up once more and wrap clockwise to minimum + 1
+        QTest::keyPress(&dial, Qt::Key_Up);
+        QCOMPARE( dial.value(), 1);
+    }
+
+    { //step down once, and wrap anti-clockwise to minimum, then again to maximum - 1
+        QTest::keyPress(&dial, Qt::Key_Down);
+        QCOMPARE( dial.value(), 0);
+
+        QTest::keyPress(&dial, Qt::Key_Down);
+        QCOMPARE( dial.value(), 99);
+    }
+
+    { //when wrapping property is false no wrapping will occur
+        dial.setWrapping(false);
+        dial.setValue(100);
+
+        QTest::keyPress(&dial, Qt::Key_Up);
+        QCOMPARE( dial.value(), 100);
+
+        dial.setValue(0);
+        QTest::keyPress(&dial, Qt::Key_Down);
+        QCOMPARE( dial.value(), 0);
+    }
+
+    { //When the step is really big or small, wrapping should still behave
+        dial.setWrapping(true);
+        dial.setValue(dial.minimum());
+        dial.setSingleStep(305);
+
+        QTest::keyPress(&dial, Qt::Key_Up);
+        QCOMPARE( dial.value(), 5);
+
+        dial.setValue(dial.minimum());
+        QTest::keyPress(&dial, Qt::Key_Down);
+        QCOMPARE( dial.value(), 95);
+
+        dial.setMinimum(-30);
+        dial.setMaximum(-4);
+        dial.setSingleStep(200);
+        dial.setValue(dial.minimum());
+        QTest::keyPress(&dial, Qt::Key_Down);
+        QCOMPARE( dial.value(), -22);
+    }
+}
+
 QTEST_MAIN(tst_QDial)
 #include "tst_qdial.moc"