Merge lp:~faenil/ubuntu-ui-toolkit/addIgnoreSynthesizedEventsToMouseFilter into lp:ubuntu-ui-toolkit/staging

[Andrea Bernabei]

add the ignoreSynthesizedEvents property.

When the property is enabled, the Mouse filter ignores any synthesized mouse event, such as those created by the touch-to-mouse events synthesis.

Enabling this property makes it possible to only trigger the hovering logic ONLY when using a mouse, and not when using a touchscreen (as it happens when using MouseArea).

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1738
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2564/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-ci/1292
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/1294
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-ci/1294/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-ci/1291

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-ci/2564/rebuild

review: Approve (continuous-integration)

[Zsombor Egri (zsombi)]

Nais!!! ;)

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-autolanding/1386/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-amd64-autolanding/694
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-armhf-autolanding/693/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-sdk-team-ubuntu-ui-toolkit-staging-vivid-i386-autolanding/697

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'components.api'
--- components.api	2015-11-30 12:43:00 +0000
+++ components.api	2015-12-03 15:50:37 +0000
@@ -631,6 +631,7 @@
     property bool enabled
     property list<Item> forwardTo
     readonly property bool hoverEnabled
+    property bool ignoreSynthesizedEvents
     signal pressed(QQuickMouseEvent mouse, Item host)
     signal released(QQuickMouseEvent mouse, Item host)
     signal clicked(QQuickMouseEvent mouse, Item host)

=== modified file 'src/Ubuntu/Components/plugin/ucmouse.h'
--- src/Ubuntu/Components/plugin/ucmouse.h	2014-04-15 12:51:31 +0000
+++ src/Ubuntu/Components/plugin/ucmouse.h	2015-12-03 15:50:37 +0000
@@ -71,6 +71,10 @@
     Q_PROPERTY(int clickAndHoldThreshold READ clickAndHoldThreshold WRITE setClickAndHoldThreshold NOTIFY clickAndHoldThresholdChanged)
     Q_PROPERTY(QQmlListProperty<QQuickItem> forwardTo READ forwardTo)
     Q_PROPERTY(Priority priority READ priority WRITE setPriority NOTIFY priorityChanged)
+
+    //Added in 1.3, but we can't use REVISION because of QTBUG-40043
+    Q_PROPERTY(bool ignoreSynthesizedEvents MEMBER m_ignoreSynthesizedEvents NOTIFY ignoreSynthesizedEventsChanged)
+
     Q_ENUMS(Priority)
 public:
     enum Priority {
@@ -98,6 +102,7 @@
     void hoverEnabledChanged();
     void clickAndHoldThresholdChanged();
     void priorityChanged();
+    void ignoreSynthesizedEventsChanged();
 
     void pressed(QQuickMouseEvent *mouse, QQuickItem *host);
     void released(QQuickMouseEvent *mouse, QQuickItem *host);
@@ -151,6 +156,7 @@
     bool m_longPress:1;
     bool m_hovered:1;
     bool m_doubleClicked:1;
+    bool m_ignoreSynthesizedEvents:1;
 };
 QML_DECLARE_TYPEINFO(UCMouse, QML_HAS_ATTACHED_PROPERTIES)
 

=== modified file 'src/Ubuntu/Components/plugin/ucmousefilters.cpp'
--- src/Ubuntu/Components/plugin/ucmousefilters.cpp	2015-03-03 13:47:48 +0000
+++ src/Ubuntu/Components/plugin/ucmousefilters.cpp	2015-12-03 15:50:37 +0000
@@ -333,8 +333,48 @@
 
    Similar functionality for the case when the mouse event occurs outside of the
    owner is brought by the \l InverseMouse attached property.
+
+   \section1 Mouse events synthesis
+   QtQuick automatically creates artificial mouse events whenever a scene receives
+   touch events that are not consumed by any item (either by using MultiPointTouchArea
+   or a custom C++ item). The Mouse filter provides the possibility to ignore
+   synthesized mouse events by enabling the \l ignoreSynthesizedEvents
+   property.
+
+   This is really useful when, while developing a convergent application, the app developer
+   wants to avoid triggering the hovering logic using a touchscreen,
+   but still be able to handle the hover events when using a mouse, and at the same time
+   doesn't want to stop the mouse and touch events from propagating to items underneath the
+   MouseArea which handles the hovering.
+   The following is an example of how that functionaly can be implemented:
+   \qml
+    MouseArea {
+        id: proximityArea
+        anchors.fill: parent
+        propagateComposedEvents: true
+        hoverEnabled: true
+
+        //We use a separate variable to detect whether the area contains
+        //a mouse, because MouseArea's containsMouse is true even when
+        //tapping on it using a touchscreen (due to the touch events being
+        //converted to mouse events if no item consumes them).
+        property bool containsPointerDevice: false
+
+        //handle hover events using the Mouse filter instead of MouseArea, so that
+        //we can ignore synthesized mouse events and not trigger hover logic when the
+        //user is interacting with the app using a touch device.
+        Mouse.ignoreSynthesizedEvents: true
+        Mouse.onEntered: {
+            console.log("ONLY A MOUSE CAN TRIGGER THIS SLOT")
+            proximityArea.containsPointerDevice = true
+        }
+        Mouse.onExited: proximityArea.containsPointerDevice = false
+
+        //let mouse and touch events propagate underneath the mouse area
+        onPressed: mouse.accepted = false
+    }
+   \endqml
  */
-
 UCMouse::UCMouse(QObject *parent)
     : QObject(parent)
     , m_owner(qobject_cast<QQuickItem*>(parent))
@@ -349,6 +389,7 @@
     , m_longPress(false)
     , m_hovered(false)
     , m_doubleClicked(false)
+    , m_ignoreSynthesizedEvents(false)
 {
     // if owner is MouseArea or InverseMouseArea, connect to the acceptedButtons
     // and hoverEnabled change signals
@@ -420,6 +461,11 @@
 {
     bool result = false;
     Q_UNUSED(target);
+
+    if (m_ignoreSynthesizedEvents && event->source() == Qt::MouseEventSynthesizedByQt) {
+        return result;
+    }
+
     switch (event->type()) {
     case QEvent::MouseButtonPress:
     {
@@ -791,6 +837,20 @@
 }
 
 /*!
+   \qmlproperty bool Mouse::ignoreSynthesizedEvents
+   This property controls how the filter handles the mouse events
+   synthesized by Qt (e.g. the artificial mouse events created when
+   an original touch event is not consumed by any Item in the scene).
+
+   If the value is true, the filter will ignore the synthesized mouse
+   events.
+
+   More info at \l{Mouse events synthesis}.
+
+   The default value is false.
+ */
+
+/*!
    \qmlproperty Qt::MouseButtons Mouse::acceptedButtons
    \readonly
    The property holds the accepted mouse buttons of the owner.

=== added file 'tests/unit_x11/tst_mousefilters/FilterSynthesizedEvents.qml'
--- tests/unit_x11/tst_mousefilters/FilterSynthesizedEvents.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_mousefilters/FilterSynthesizedEvents.qml	2015-12-03 15:50:37 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2015 Canonical Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.4
+import Ubuntu.Components 1.3
+
+MouseArea {
+    width: units.gu(40)
+    height: units.gu(40)
+
+    objectName: "rootMouseArea"
+
+    MouseArea {
+        signal overlayPressed()
+        objectName: "overlayArea"
+        anchors.fill: parent
+
+        Mouse.enabled: true
+        Mouse.ignoreSynthesizedEvents: true
+    }
+}

=== modified file 'tests/unit_x11/tst_mousefilters/tst_mousefilters.pro'
--- tests/unit_x11/tst_mousefilters/tst_mousefilters.pro	2014-04-14 16:57:12 +0000
+++ tests/unit_x11/tst_mousefilters/tst_mousefilters.pro	2015-12-03 15:50:37 +0000
@@ -31,4 +31,5 @@
     DoubleClicked.qml \
     HoverEvent.qml \
     ForwardComposedEvents.qml \
-    ForwardEventChained.qml
+    ForwardEventChained.qml \
+    FilterSynthesizedEvents.qml

=== modified file 'tests/unit_x11/tst_mousefilters/tst_mousefilterstest.cpp'
--- tests/unit_x11/tst_mousefilters/tst_mousefilterstest.cpp	2014-11-25 09:58:33 +0000
+++ tests/unit_x11/tst_mousefilters/tst_mousefilterstest.cpp	2015-12-03 15:50:37 +0000
@@ -29,6 +29,7 @@
 #include "quickutils.h"
 #include "inversemouseareatype.h"
 #include "uctestcase.h"
+#include "uctestextras.h"
 #include <private/qquickevents_p_p.h>
 #include <private/qquickmousearea_p.h>
 
@@ -116,6 +117,8 @@
 
     void initTestCase()
     {
+        UCTestExtras::registerTouchDevice();
+
         QString modules(UBUNTU_QML_IMPORT_PATH);
         QVERIFY(QDir(modules).exists());
 
@@ -1101,6 +1104,65 @@
         QTest::mouseRelease(test.data(), Qt::LeftButton, 0, guPoint(20, 30));
         QTest::waitForEvents();
     }
+
+    void testCase_ignoreSynthesizedEvents() {
+        QScopedPointer<UbuntuTestCase> test(new UbuntuTestCase("FilterSynthesizedEvents.qml"));
+        QQuickMouseArea *rootMouseArea = qobject_cast<QQuickMouseArea *>(test->rootObject());
+        QQuickMouseArea* overlayArea = test->findItem<QQuickMouseArea *>("overlayArea");
+        UCMouse *overlayFilter = attachedFilter<UCMouse>(test->rootObject(), "overlayArea");
+
+        QCOMPARE(rootMouseArea != Q_NULLPTR, true);
+        QCOMPARE(overlayArea != Q_NULLPTR, true);
+        QCOMPARE(overlayFilter != Q_NULLPTR, true);
+
+        QSignalSpy areaPressed(rootMouseArea, SIGNAL(pressed(QQuickMouseEvent *)));
+        QSignalSpy overlayAreaPressed(overlayArea, SIGNAL(pressed(QQuickMouseEvent *)));
+        QSignalSpy overlayFilterPressed(overlayFilter, SIGNAL(pressed(QQuickMouseEvent*, QQuickItem*)));
+        QCOMPARE(overlayFilter->property("ignoreSynthesizedEvents").toBool(), true);
+
+        //we're assuming the priority is set to BeforeItem, the functionality is not priority-dependent anyway,
+        //just the outcome is.
+        QCOMPARE(overlayFilter->priority(), UCMouse::BeforeItem);
+        QCOMPARE(overlayArea->isEnabled(), true);
+
+        //send a touch event, which will be converted to a synthesized mouse event, since
+        //no item in this QML is handling touch events
+        UCTestExtras::touchPress(0, overlayArea, guPoint(15, 15));
+        QTest::waitForEvents();
+
+        QCOMPARE(areaPressed.count(), 0);
+        QCOMPARE(overlayAreaPressed.count(), 1);
+        QCOMPARE(overlayFilterPressed.count(), 0);
+        UCTestExtras::touchRelease(0, overlayArea, guPoint(15, 15));
+
+        QTest::waitForEvents();
+
+        overlayFilter->setProperty("ignoreSynthesizedEvents", false);
+        QCOMPARE(overlayFilter->property("ignoreSynthesizedEvents").toBool(), false);
+        UCTestExtras::touchPress(1, overlayArea, guPoint(15, 15));
+        QTest::waitForEvents();
+
+        QCOMPARE(areaPressed.count(), 0);
+        //the filter doesn't accept the pressed event by default
+        QCOMPARE(overlayAreaPressed.count(), 2);
+        QCOMPARE(overlayFilterPressed.count(), 1);
+        UCTestExtras::touchRelease(1, overlayArea, guPoint(15, 15));
+        QTest::waitForEvents();
+
+        overlayArea->setEnabled(false);
+        QCOMPARE(overlayArea->isEnabled(), false);
+
+        UCTestExtras::touchPress(2, overlayArea, guPoint(15, 15));
+        QTest::waitForEvents();
+
+        //the filter gets the event but its owner is not enabled, so we expect it
+        //to propagate to the area underneath
+        QCOMPARE(areaPressed.count(), 1);
+        QCOMPARE(overlayAreaPressed.count(), 2);
+        QCOMPARE(overlayFilterPressed.count(), 2);
+        UCTestExtras::touchRelease(2, overlayArea, guPoint(15, 15));
+        QTest::waitForEvents();
+    }
 };
 
 QTEST_MAIN(tst_mouseFilterTest)