QQuickAbstractButton: handle touch events

This makes it possible to interact with multiple buttons at the same
time.

Change-Id: Ice17efcb8b6dc5337455cd38ee88c39dfef2baae
Reviewed-by: Mitch Curtis <mitch.curtis@qt.io>

4 files changed, 286 insertions, 0 deletions

diff --git a/tests/auto/controls/data/tst_button.qml b/tests/auto/controls/data/tst_button.qml
index ea1dda0b..025279f8 100644
--- a/tests/auto/controls/data/tst_button.qml
+++ b/tests/auto/controls/data/tst_button.qml
@@ -148,6 +148,100 @@ TestCase {
         verify(sequenceSpy.success)
     }
 
+    function test_touch() {
+        var control = createTemporaryObject(button, testCase)
+        verify(control)
+
+        var touch = touchEvent(control)
+        var sequenceSpy = signalSequenceSpy.createObject(control, {target: control})
+
+        // click
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true }],
+                                        ["downChanged", { "down": true }],
+                                        "pressed"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        verify(sequenceSpy.success)
+
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false }],
+                                        ["downChanged", { "down": false }],
+                                        "released",
+                                        "clicked"]
+        touch.release(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+
+        // release outside
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true }],
+                                        ["downChanged", { "down": true }],
+                                        "pressed"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        verify(sequenceSpy.success)
+
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false }],
+                                        ["downChanged", { "down": false }]]
+        touch.move(0, control, control.width * 2, control.height * 2).commit()
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+
+        sequenceSpy.expectedSequence = [["canceled", { "pressed": false }]]
+        touch.release(0, control, control.width * 2, control.height * 2).commit()
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+    }
+
+    function test_multiTouch() {
+        var control1 = createTemporaryObject(button, testCase)
+        verify(control1)
+
+        var pressedCount1 = 0
+
+        var pressedSpy1 = signalSpy.createObject(control1, {target: control1, signalName: "pressedChanged"})
+        verify(pressedSpy1.valid)
+
+        var touch = touchEvent(control1)
+        touch.press(0, control1, 0, 0).commit().move(0, control1, control1.width, control1.height).commit()
+
+        compare(pressedSpy1.count, ++pressedCount1)
+        compare(control1.pressed, true)
+
+        // second touch point on the same control is ignored
+        touch.stationary(0).press(1, control1, 0, 0).commit()
+        touch.stationary(0).move(1, control1).commit()
+        touch.stationary(0).release(1).commit()
+
+        compare(pressedSpy1.count, pressedCount1)
+        compare(control1.pressed, true)
+
+        var control2 = createTemporaryObject(button, testCase, {y: control1.height})
+        verify(control2)
+        waitForRendering(control2)
+
+        var pressedCount2 = 0
+
+        var pressedSpy2 = signalSpy.createObject(control2, {target: control2, signalName: "pressedChanged"})
+        verify(pressedSpy2.valid)
+
+        // press the second button
+        touch.stationary(0).press(2, control2, 0, 0).commit()
+
+        compare(pressedSpy2.count, ++pressedCount2)
+        compare(control2.pressed, true)
+
+        compare(pressedSpy1.count, pressedCount1)
+        compare(control1.pressed, true)
+
+        // release both buttons
+        touch.release(0, control1).release(2, control2).commit()
+
+        compare(pressedSpy2.count, ++pressedCount2)
+        compare(control2.pressed, false)
+
+        compare(pressedSpy1.count, ++pressedCount1)
+        compare(control1.pressed, false)
+    }
+
     function test_keys() {
         var control = createTemporaryObject(button, testCase)
         verify(control)
diff --git a/tests/auto/controls/data/tst_checkbox.qml b/tests/auto/controls/data/tst_checkbox.qml
index eb052e12..cd46b431 100644
--- a/tests/auto/controls/data/tst_checkbox.qml
+++ b/tests/auto/controls/data/tst_checkbox.qml
@@ -196,6 +196,69 @@ TestCase {
         verify(sequenceSpy.success)
     }
 
+    function test_touch() {
+        var control = createTemporaryObject(checkBox, testCase)
+        verify(control)
+
+        var touch = touchEvent(control)
+
+        var sequenceSpy = signalSequenceSpy.createObject(control, {target: control})
+
+        // check
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true, "checked": false, "checkState": Qt.Unchecked }],
+                                        "pressed"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        verify(sequenceSpy.success)
+
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false, "checked": false, "checkState": Qt.Unchecked }],
+                                        ["checkStateChanged", { "pressed": false, "checked": true, "checkState": Qt.Checked }],
+                                        ["checkedChanged", { "pressed": false, "checked": true, "checkState": Qt.Checked }],
+                                        "toggled",
+                                        "released",
+                                        "clicked"]
+        touch.release(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.checked, true)
+        compare(control.checkState, Qt.Checked)
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+
+        // uncheck
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true, "checked": true, "checkState": Qt.Checked }],
+                                        "pressed"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        verify(sequenceSpy.success)
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false, "checked": true, "checkState": Qt.Checked }],
+                                        ["checkStateChanged", { "pressed": false, "checked": false, "checkState": Qt.Unchecked }],
+                                        ["checkedChanged", { "pressed": false, "checked": false, "checkState": Qt.Unchecked }],
+                                        "toggled",
+                                        "released",
+                                        "clicked"]
+        touch.release(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.checked, false)
+        compare(control.checkState, Qt.Unchecked)
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+
+        // release outside
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true, "checked": false, "checkState": Qt.Unchecked }],
+                                        "pressed"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        verify(sequenceSpy.success)
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false, "checked": false, "checkState": Qt.Unchecked }]]
+        touch.move(0, control, control.width * 2, control.height * 2).commit()
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+        sequenceSpy.expectedSequence = [["canceled", { "pressed": false, "checked": false, "checkState": Qt.Unchecked }]]
+        touch.release(0, control, control.width * 2, control.height * 2).commit()
+        compare(control.checked, false)
+        compare(control.checkState, Qt.Unchecked)
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+    }
+
     function test_keys() {
         var control = createTemporaryObject(checkBox, testCase)
         verify(control)
diff --git a/tests/auto/controls/data/tst_delaybutton.qml b/tests/auto/controls/data/tst_delaybutton.qml
index 722c676c..c30bec68 100644
--- a/tests/auto/controls/data/tst_delaybutton.qml
+++ b/tests/auto/controls/data/tst_delaybutton.qml
@@ -169,6 +169,81 @@ TestCase {
         verify(sequenceSpy.success)
     }
 
+    function test_touch() {
+        var control = createTemporaryObject(delayButton, testCase)
+        verify(control)
+
+        var touch = touchEvent(control)
+
+        var sequenceSpy = signalSequenceSpy.createObject(control, {target: control})
+
+        // click
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true }],
+                                        ["downChanged", { "down": true }],
+                                        "pressed",
+                                        ["pressedChanged", { "pressed": false }],
+                                        ["downChanged", { "down": false }],
+                                        "released",
+                                        "clicked"]
+        touch.press(0, control).commit()
+        touch.release(0, control).commit()
+        verify(sequenceSpy.success)
+
+        // check
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true }],
+                                        ["downChanged", { "down": true }],
+                                        "pressed",
+                                        "activated"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        tryVerify(function() { return sequenceSpy.success})
+
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false }],
+                                        ["downChanged", { "down": false }],
+                                        ["checkedChanged", { "checked": true }],
+                                        "released",
+                                        "clicked"]
+        touch.release(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+
+        // uncheck
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true }],
+                                        ["downChanged", { "down": true }],
+                                        "pressed"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        verify(sequenceSpy.success)
+
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false }],
+                                        ["downChanged", { "down": false }],
+                                        ["checkedChanged", { "checked": false }],
+                                        "released",
+                                        "clicked"]
+        touch.release(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+
+        // release outside
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true }],
+                                        ["downChanged", { "down": true }],
+                                        "pressed"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        verify(sequenceSpy.success)
+
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false }],
+                                        ["downChanged", { "down": false }]]
+        touch.move(0, control, control.width * 2, control.height * 2).commit()
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+
+        sequenceSpy.expectedSequence = [["canceled", { "pressed": false }]]
+        touch.release(0, control, control.width * 2, control.height * 2).commit()
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+    }
+
     function test_keys() {
         var control = createTemporaryObject(delayButton, testCase)
         verify(control)
diff --git a/tests/auto/controls/data/tst_radiobutton.qml b/tests/auto/controls/data/tst_radiobutton.qml
index e9f1d82c..e878e1ba 100644
--- a/tests/auto/controls/data/tst_radiobutton.qml
+++ b/tests/auto/controls/data/tst_radiobutton.qml
@@ -156,6 +156,60 @@ TestCase {
         verify(sequenceSpy.success)
     }
 
+    function test_touch() {
+        var control = createTemporaryObject(radioButton, testCase)
+        verify(control)
+
+        var touch = touchEvent(control)
+
+        var sequenceSpy = signalSequenceSpy.createObject(control, {target: control})
+
+        // check
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true, "checked": false }],
+                                        "pressed"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        verify(sequenceSpy.success)
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false, "checked": false }],
+                                        ["checkedChanged", { "pressed": false, "checked": true }],
+                                        "toggled",
+                                        "released",
+                                        "clicked"]
+        touch.release(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.checked, true)
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+
+        // attempt uncheck
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true, "checked": true }],
+                                        "pressed"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        verify(sequenceSpy.success)
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false, "checked": true }],
+                                        "released",
+                                        "clicked"]
+        touch.release(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.checked, true)
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+
+        // release outside
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": true, "checked": true }],
+                                        "pressed"]
+        touch.press(0, control, control.width / 2, control.height / 2).commit()
+        compare(control.pressed, true)
+        verify(sequenceSpy.success)
+        sequenceSpy.expectedSequence = [["pressedChanged", { "pressed": false, "checked": true }]]
+        touch.move(0, control, control.width * 2, control.height * 2).commit()
+        compare(control.pressed, false)
+        sequenceSpy.expectedSequence = [["canceled", { "pressed": false, "checked": true }]]
+        touch.release(0, control, control.width * 2, control.height * 2).commit()
+        compare(control.checked, true)
+        compare(control.pressed, false)
+        verify(sequenceSpy.success)
+    }
+
     function test_keys() {
         var control = createTemporaryObject(radioButton, testCase)
         verify(control)