Added application flags to translate between touch and mouse events.

The current way we do it of having the platform or touch plugin send
both mouse and touch events is not ideal. There's no good way to write
an application that works sanely both on a touch-only device and on a
desktop except by restricting yourself to only handling mouse events. If
you try to handle touch events you don't get any events at all on
desktop, and if you try to handle both, you end up getting duplicate
events on touch devices.

Instead, we should get rid of the code in the plugins that automatically
sends mouse events translated from touch events. This change enables
that by making the behaviour fully configurable in QtGui.

Two new application attributes are added to explicitly say whether
unhandled touch events should be sent as synthesized mouse events and
vice versa, and no duplicates are automatically sent as the current
situation. Synthesized mouse events are enabled by default.

We also get rid of the QTouchEvent::TouchPoint::Primary flag, which
was only used to signal that the windowing system automatically
generated mouse events for that touch point. Now we only generate mouse
events from the first touch point in the list.

Change-Id: I8e20f3480407ca8c31b42de0a4d2b319e1346b65
Reviewed-by: Laszlo Agocs <laszlo.p.agocs@nokia.com>
Reviewed-by: Jocelyn Turcotte <jocelyn.turcotte@nokia.com>
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@nokia.com>
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
Reviewed-by: Denis Dzyubenko <denis.dzyubenko@nokia.com>

1 files changed, 161 insertions, 9 deletions

diff --git a/tests/auto/gui/kernel/qwindow/tst_qwindow.cpp b/tests/auto/gui/kernel/qwindow/tst_qwindow.cpp
index 9244c86ca5..77fffef13a 100644
--- a/tests/auto/gui/kernel/qwindow/tst_qwindow.cpp
+++ b/tests/auto/gui/kernel/qwindow/tst_qwindow.cpp
@@ -54,6 +54,18 @@ private slots:
     void positioning();
     void isActive();
     void testInputEvents();
+    void touchToMouseTranslation();
+    void mouseToTouchTranslation();
+    void mouseToTouchLoop();
+    void initTestCase()
+    {
+        touchDevice = new QTouchDevice;
+        touchDevice->setType(QTouchDevice::TouchScreen);
+        QWindowSystemInterface::registerTouchDevice(touchDevice);
+    }
+
+private:
+    QTouchDevice *touchDevice;
 };
 
 
@@ -234,12 +246,22 @@ public:
         keyReleaseCode = event->key();
     }
     void mousePressEvent(QMouseEvent *event) {
-        mousePressButton = event->button();
+        if (ignoreMouse)
+            event->ignore();
+        else
+            mousePressButton = event->button();
     }
     void mouseReleaseEvent(QMouseEvent *event) {
-        mouseReleaseButton = event->button();
+        if (ignoreMouse)
+            event->ignore();
+        else
+            mouseReleaseButton = event->button();
     }
     void touchEvent(QTouchEvent *event) {
+        if (ignoreTouch) {
+            event->ignore();
+            return;
+        }
         QList<QTouchEvent::TouchPoint> points = event->touchPoints();
         for (int i = 0; i < points.count(); ++i) {
             switch (points.at(i).state()) {
@@ -249,6 +271,8 @@ public:
             case Qt::TouchPointReleased:
                 ++touchReleasedCount;
                 break;
+            default:
+                break;
             }
         }
     }
@@ -257,11 +281,14 @@ public:
         keyPressCode = keyReleaseCode = 0;
         mousePressButton = mouseReleaseButton = 0;
         touchPressedCount = touchReleasedCount = 0;
+        ignoreMouse = ignoreTouch = 0;
     }
 
     int keyPressCode, keyReleaseCode;
     int mousePressButton, mouseReleaseButton;
     int touchPressedCount, touchReleasedCount;
+
+    bool ignoreMouse, ignoreTouch;
 };
 
 void tst_QWindow::testInputEvents()
@@ -284,9 +311,32 @@ void tst_QWindow::testInputEvents()
     QCOMPARE(window.mousePressButton, int(Qt::LeftButton));
     QCOMPARE(window.mouseReleaseButton, int(Qt::LeftButton));
 
-    QTouchDevice *device = new QTouchDevice;
-    device->setType(QTouchDevice::TouchScreen);
-    QWindowSystemInterface::registerTouchDevice(device);
+    QList<QWindowSystemInterface::TouchPoint> points;
+    QWindowSystemInterface::TouchPoint tp1, tp2;
+    tp1.id = 1;
+    tp1.state = Qt::TouchPointPressed;
+    tp1.area = QRect(10, 10, 4, 4);
+    tp2.id = 2;
+    tp2.state = Qt::TouchPointPressed;
+    tp2.area = QRect(20, 20, 4, 4);
+    points << tp1 << tp2;
+    QWindowSystemInterface::handleTouchEvent(&window, touchDevice, points);
+    points[0].state = Qt::TouchPointReleased;
+    points[1].state = Qt::TouchPointReleased;
+    QWindowSystemInterface::handleTouchEvent(&window, touchDevice, points);
+    QCoreApplication::processEvents();
+    QTRY_COMPARE(window.touchPressedCount, 2);
+    QTRY_COMPARE(window.touchReleasedCount, 2);
+}
+
+void tst_QWindow::touchToMouseTranslation()
+{
+    InputTestWindow window;
+    window.ignoreTouch = true;
+    window.setGeometry(80, 80, 40, 40);
+    window.show();
+    QTest::qWaitForWindowShown(&window);
+
     QList<QWindowSystemInterface::TouchPoint> points;
     QWindowSystemInterface::TouchPoint tp1, tp2;
     tp1.id = 1;
@@ -294,13 +344,115 @@ void tst_QWindow::testInputEvents()
     tp2.id = 2;
     tp2.state = Qt::TouchPointPressed;
     points << tp1 << tp2;
-    QWindowSystemInterface::handleTouchEvent(&window, device, points);
+    QWindowSystemInterface::handleTouchEvent(&window, touchDevice, points);
+    points[0].state = Qt::TouchPointReleased;
+    points[1].state = Qt::TouchPointReleased;
+    QWindowSystemInterface::handleTouchEvent(&window, touchDevice, points);
+    QCoreApplication::processEvents();
+
+    QTRY_COMPARE(window.mousePressButton, int(Qt::LeftButton));
+    QTRY_COMPARE(window.mouseReleaseButton, int(Qt::LeftButton));
+
+    window.mousePressButton = 0;
+    window.mouseReleaseButton = 0;
+
+    window.ignoreTouch = false;
+
+    points[0].state = Qt::TouchPointPressed;
+    points[1].state = Qt::TouchPointPressed;
+    QWindowSystemInterface::handleTouchEvent(&window, touchDevice, points);
+    points[0].state = Qt::TouchPointReleased;
+    points[1].state = Qt::TouchPointReleased;
+    QWindowSystemInterface::handleTouchEvent(&window, touchDevice, points);
+    QCoreApplication::processEvents();
+
+    // no new mouse events should be generated since the input window handles the touch events
+    QTRY_COMPARE(window.mousePressButton, 0);
+    QTRY_COMPARE(window.mouseReleaseButton, 0);
+
+    qApp->setAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents, false);
+
+    window.ignoreTouch = true;
+    points[0].state = Qt::TouchPointPressed;
+    points[1].state = Qt::TouchPointPressed;
+    QWindowSystemInterface::handleTouchEvent(&window, touchDevice, points);
     points[0].state = Qt::TouchPointReleased;
     points[1].state = Qt::TouchPointReleased;
-    QWindowSystemInterface::handleTouchEvent(&window, device, points);
+    QWindowSystemInterface::handleTouchEvent(&window, touchDevice, points);
     QCoreApplication::processEvents();
-    QCOMPARE(window.touchPressedCount, 2);
-    QCOMPARE(window.touchReleasedCount, 2);
+
+    qApp->setAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents, true);
+
+    // mouse event synthesizing disabled
+    QTRY_COMPARE(window.mousePressButton, 0);
+    QTRY_COMPARE(window.mouseReleaseButton, 0);
+}
+
+void tst_QWindow::mouseToTouchTranslation()
+{
+    qApp->setAttribute(Qt::AA_SynthesizeTouchForUnhandledMouseEvents, true);
+
+    InputTestWindow window;
+    window.ignoreMouse = true;
+    window.setGeometry(80, 80, 40, 40);
+    window.show();
+    QTest::qWaitForWindowShown(&window);
+
+    QWindowSystemInterface::handleMouseEvent(&window, QPoint(10, 10), window.mapToGlobal(QPoint(10, 10)), Qt::LeftButton);
+    QWindowSystemInterface::handleMouseEvent(&window, QPoint(10, 10), window.mapToGlobal(QPoint(10, 10)), Qt::NoButton);
+    QCoreApplication::processEvents();
+
+    qApp->setAttribute(Qt::AA_SynthesizeTouchForUnhandledMouseEvents, false);
+
+    QTRY_COMPARE(window.touchPressedCount, 1);
+    QTRY_COMPARE(window.touchReleasedCount, 1);
+
+    qApp->setAttribute(Qt::AA_SynthesizeTouchForUnhandledMouseEvents, true);
+
+    window.ignoreMouse = false;
+
+    QWindowSystemInterface::handleMouseEvent(&window, QPoint(10, 10), window.mapToGlobal(QPoint(10, 10)), Qt::LeftButton);
+    QWindowSystemInterface::handleMouseEvent(&window, QPoint(10, 10), window.mapToGlobal(QPoint(10, 10)), Qt::NoButton);
+    QCoreApplication::processEvents();
+
+    qApp->setAttribute(Qt::AA_SynthesizeTouchForUnhandledMouseEvents, false);
+
+    // no new touch events should be generated since the input window handles the mouse events
+    QTRY_COMPARE(window.touchPressedCount, 1);
+    QTRY_COMPARE(window.touchReleasedCount, 1);
+
+    window.ignoreMouse = true;
+
+    QWindowSystemInterface::handleMouseEvent(&window, QPoint(10, 10), window.mapToGlobal(QPoint(10, 10)), Qt::LeftButton);
+    QWindowSystemInterface::handleMouseEvent(&window, QPoint(10, 10), window.mapToGlobal(QPoint(10, 10)), Qt::NoButton);
+    QCoreApplication::processEvents();
+
+    // touch event synthesis disabled
+    QTRY_COMPARE(window.touchPressedCount, 1);
+    QTRY_COMPARE(window.touchReleasedCount, 1);
+
+
+}
+
+void tst_QWindow::mouseToTouchLoop()
+{
+    // make sure there's no infinite loop when synthesizing both ways
+    qApp->setAttribute(Qt::AA_SynthesizeTouchForUnhandledMouseEvents, true);
+    qApp->setAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents, true);
+
+    InputTestWindow window;
+    window.ignoreMouse = true;
+    window.ignoreTouch = true;
+    window.setGeometry(80, 80, 40, 40);
+    window.show();
+    QTest::qWaitForWindowShown(&window);
+
+    QWindowSystemInterface::handleMouseEvent(&window, QPoint(10, 10), window.mapToGlobal(QPoint(10, 10)), Qt::LeftButton);
+    QWindowSystemInterface::handleMouseEvent(&window, QPoint(10, 10), window.mapToGlobal(QPoint(10, 10)), Qt::NoButton);
+    QCoreApplication::processEvents();
+
+    qApp->setAttribute(Qt::AA_SynthesizeTouchForUnhandledMouseEvents, false);
+    qApp->setAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents, false);
 }
 
 #include <tst_qwindow.moc>