Add tst_flickableinterop: verify drag and tap handlers inside Flickable

Flickable can steal the grab from a PointerHandler the same way it can
steal from an Item: by filtering the children's events.  But within
the drag threshold, or if the DragHandler is dragging, the handlers
behave normally.

Change-Id: If1bc1f2e8d9aaebb590f3434a3018a9f1a1f1dac
Reviewed-by: Jan Arve Sæther <jan-arve.saether@qt.io>

6 files changed, 815 insertions, 0 deletions

diff --git a/tests/auto/quick/pointerhandlers/flickableinterop/data/FlashAnimation.qml b/tests/auto/quick/pointerhandlers/flickableinterop/data/FlashAnimation.qml
new file mode 100644
index 0000000000..b628255a3d
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/flickableinterop/data/FlashAnimation.qml
@@ -0,0 +1,57 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the manual tests of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of The Qt Company Ltd nor the names of its
+**     contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.0
+
+SequentialAnimation {
+    id: tapFlash
+    running: false
+    PropertyAction { value: false }
+    PauseAnimation { duration: 100 }
+    PropertyAction { value: true }
+    PauseAnimation { duration: 100 }
+    PropertyAction { value: false }
+    PauseAnimation { duration: 100 }
+    PropertyAction { value: true }
+    PauseAnimation { duration: 100 }
+    PropertyAction { value: false }
+    PauseAnimation { duration: 100 }
+    PropertyAction { value: true }
+}
diff --git a/tests/auto/quick/pointerhandlers/flickableinterop/data/Slider.qml b/tests/auto/quick/pointerhandlers/flickableinterop/data/Slider.qml
new file mode 100644
index 0000000000..35e7ee2177
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/flickableinterop/data/Slider.qml
@@ -0,0 +1,133 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of The Qt Company Ltd nor the names of its
+**     contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.8
+import Qt.labs.handlers 1.0
+
+Item {
+    id: root
+    property int value: 50
+    property int maximumValue: 99
+    property alias label: label.text
+    property alias tapEnabled: tap.enabled
+    property alias pressed: tap.isPressed
+    signal tapped
+
+    Rectangle {
+        id: slot
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.margins: 10
+        anchors.topMargin: 30
+        anchors.bottomMargin: 30
+        anchors.horizontalCenter: parent.horizontalCenter
+        width: 10
+        color: "black"
+        radius: width / 2
+        smooth: true
+    }
+
+    Rectangle {
+        id: glow
+        anchors.fill: knob
+        anchors.margins: -5
+        anchors.leftMargin: -2
+        anchors.horizontalCenterOffset: 1
+        radius: 5
+        color: "#4400FFFF"
+        opacity: dragHandler.active || tapFlash.running ? 1 : 0
+        FlashAnimation on visible {
+            id: tapFlash
+        }
+    }
+    Rectangle {
+        id: knob
+        objectName: "Slider Knob"
+        width: parent.width - 2
+        height: 20
+        radius: 5
+        color: "darkgray"
+        border.color: "black"
+        property bool programmatic: false
+        property real multiplier: root.maximumValue / (dragHandler.yAxis.maximum - dragHandler.yAxis.minimum)
+        onYChanged: if (!programmatic) root.value = root.maximumValue - (knob.y - dragHandler.yAxis.minimum) * multiplier
+        transformOrigin: Item.Center
+        function setValue(value) { knob.y = dragHandler.yAxis.maximum - value / knob.multiplier }
+        DragHandler {
+            id: dragHandler
+            objectName: label.text + " DragHandler"
+            xAxis.enabled: false
+            yAxis.minimum: slot.y
+            yAxis.maximum: slot.height + slot.y - knob.height
+        }
+        TapHandler {
+            id: tap
+            objectName: label.text + " TapHandler"
+            gesturePolicy: TapHandler.DragThreshold
+            onTapped: {
+                tapFlash.start()
+                root.tapped
+            }
+        }
+    }
+
+    Text {
+        font.pointSize: 16
+        color: "red"
+        anchors.bottom: parent.bottom
+        anchors.horizontalCenter: parent.horizontalCenter
+        text: root.value
+    }
+
+    Text {
+        id: label
+        font.pointSize: 12
+        color: "red"
+        anchors.top: parent.top
+        anchors.topMargin: 5
+        anchors.horizontalCenter: parent.horizontalCenter
+    }
+
+    Component.onCompleted: {
+        knob.programmatic = true
+        knob.setValue(root.value)
+        knob.programmatic = false
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/flickableinterop/data/TapHandlerButton.qml b/tests/auto/quick/pointerhandlers/flickableinterop/data/TapHandlerButton.qml
new file mode 100644
index 0000000000..af9b906861
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/flickableinterop/data/TapHandlerButton.qml
@@ -0,0 +1,100 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of The Qt Company Ltd nor the names of its
+**     contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.8
+import Qt.labs.handlers 1.0
+
+Rectangle {
+    id: root
+    property alias label: label.text
+    property alias pressed: tap.isPressed
+    property bool checked: false
+    property alias gesturePolicy: tap.gesturePolicy
+    property alias enabled: tap.enabled
+    signal tapped
+
+    width: label.implicitWidth * 1.5; height: label.implicitHeight * 2.0
+    border.color: "#9f9d9a"; border.width: 1; radius: height / 4; antialiasing: true
+
+    gradient: Gradient {
+        GradientStop { position: 0.0; color: tap.isPressed ? "#b8b5b2" : "#efebe7" }
+        GradientStop { position: 1.0; color: "#b8b5b2" }
+    }
+
+    TapHandler {
+        id: tap
+        objectName: label.text
+        longPressThreshold: 100 // CI can be insanely slow, so don't demand a timely release to generate onTapped
+        onTapped: {
+            tapFlash.start()
+            root.tapped()
+        }
+    }
+
+    Text {
+        id: label
+        font.pointSize: 14
+        text: "Button"
+        anchors.centerIn: parent
+    }
+
+    Rectangle {
+        anchors.fill: parent; anchors.margins: -5
+        color: "transparent"; border.color: "#4400FFFF"
+        border.width: 5; radius: root.radius; antialiasing: true
+        opacity: tapFlash.running ? 1 : 0
+        FlashAnimation on visible { id: tapFlash }
+    }
+
+    Rectangle {
+        objectName: "expandingCircle"
+        radius: tap.timeHeld * 100
+        visible: radius > 0 && tap.isPressed
+        border.width: 3
+        border.color: "cyan"
+        color: "transparent"
+        width: radius * 2
+        height: radius * 2
+        x: tap.scenePressPos.x - radius
+        y: tap.scenePressPos.y - radius
+        opacity: 0.25
+        Component.onCompleted: parent = root.parent
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/flickableinterop/data/flickableWithHandlers.qml b/tests/auto/quick/pointerhandlers/flickableinterop/data/flickableWithHandlers.qml
new file mode 100644
index 0000000000..7799dd0ec3
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/flickableinterop/data/flickableWithHandlers.qml
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of The Qt Company Ltd nor the names of its
+**     contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.8
+import Qt.labs.handlers 1.0
+
+Rectangle {
+    id: root
+    width: 400
+    height: 480
+    objectName: "root"
+    color: "#222222"
+
+    Flickable {
+        anchors.fill: parent
+        anchors.margins: 10
+        anchors.topMargin: 40
+        contentHeight: 600
+        contentWidth: 600
+//        pressDelay: TODO
+
+        Row {
+            spacing: 6
+            Slider {
+                label: "DragHandler"
+                objectName: "Slider"
+                value: 49; width: 100; height: 400
+            }
+            Column {
+                spacing: 6
+                TapHandlerButton {
+                    label: "TapHandler"
+                    objectName: "Button 1"
+                }
+                TapHandlerButton {
+                    label: "TapHandler"
+                    objectName: "Button 2"
+                }
+            }
+        }
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/flickableinterop/flickableinterop.pro b/tests/auto/quick/pointerhandlers/flickableinterop/flickableinterop.pro
new file mode 100644
index 0000000000..9075044bd3
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/flickableinterop/flickableinterop.pro
@@ -0,0 +1,15 @@
+CONFIG += testcase
+
+TARGET = tst_flickableinterop
+QT += core-private gui-private qml-private quick-private  testlib
+
+macos:CONFIG -= app_bundle
+
+SOURCES  += tst_flickableinterop.cpp
+
+include (../../../shared/util.pri)
+include (../../shared/util.pri)
+
+TESTDATA = data/*
+
+OTHER_FILES += data/flickableWithHandlers.qml data/Slider.qml
diff --git a/tests/auto/quick/pointerhandlers/flickableinterop/tst_flickableinterop.cpp b/tests/auto/quick/pointerhandlers/flickableinterop/tst_flickableinterop.cpp
new file mode 100644
index 0000000000..93b6d27f21
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/flickableinterop/tst_flickableinterop.cpp
@@ -0,0 +1,431 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+#include <QtGui/qstylehints.h>
+#include <QtQuick/qquickview.h>
+#include <QtQuick/qquickitem.h>
+#include <QtQuick/private/qquickflickable_p.h>
+#include <QtQuick/private/qquickpointerhandler_p.h>
+#include <QtQuick/private/qquickdraghandler_p.h>
+#include <QtQuick/private/qquicktaphandler_p.h>
+#include <qpa/qwindowsysteminterface.h>
+
+#include <private/qquickwindow_p.h>
+
+#include <QtQml/qqmlengine.h>
+#include <QtQml/qqmlproperty.h>
+
+#include "../../../shared/util.h"
+#include "../../shared/viewtestutil.h"
+
+Q_LOGGING_CATEGORY(lcPointerTests, "qt.quick.pointer.tests")
+
+class tst_FlickableInterop : public QQmlDataTest
+{
+    Q_OBJECT
+public:
+    tst_FlickableInterop()
+        :touchDevice(QTest::createTouchDevice())
+    {}
+
+private slots:
+    void initTestCase();
+
+    void touchTapButton();
+    void touchDragFlickableBehindButton();
+    void mouseClickButton();
+    void mouseDragFlickableBehindButton();
+    void touchDragSlider();
+    void touchDragFlickableBehindSlider();
+    void mouseDragSlider();
+    void mouseDragFlickableBehindSlider();
+
+private:
+    void createView(QScopedPointer<QQuickView> &window, const char *fileName);
+    QTouchDevice *touchDevice;
+};
+
+void tst_FlickableInterop::createView(QScopedPointer<QQuickView> &window, const char *fileName)
+{
+    window.reset(new QQuickView);
+    window->setSource(testFileUrl(fileName));
+    QTRY_COMPARE(window->status(), QQuickView::Ready);
+    QQuickViewTestUtil::centerOnScreen(window.data());
+    QQuickViewTestUtil::moveMouseAway(window.data());
+
+    window->show();
+    QVERIFY(QTest::qWaitForWindowActive(window.data()));
+    QVERIFY(window->rootObject() != 0);
+}
+
+void tst_FlickableInterop::initTestCase()
+{
+    // This test assumes that we don't get synthesized mouse events from QGuiApplication
+    qApp->setAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents, false);
+
+    QQmlDataTest::initTestCase();
+}
+
+void tst_FlickableInterop::touchTapButton()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>("Button 1");
+    QVERIFY(button);
+    QSignalSpy tappedSpy(button, SIGNAL(tapped()));
+
+    // Button changes pressed state and emits tapped on release
+    QPoint p1 = button->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(button->property("pressed").toBool());
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!button->property("pressed").toBool());
+    QCOMPARE(tappedSpy.count(), 1);
+
+    // We can drag <= dragThreshold and the button still acts normal, Flickable doesn't grab
+    p1 = button->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(button->property("pressed").toBool());
+    p1 += QPoint(dragThreshold, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(button->property("pressed").toBool());
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!button->property("pressed").toBool());
+    QCOMPARE(tappedSpy.count(), 2);
+}
+
+void tst_FlickableInterop::touchDragFlickableBehindButton()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>("Button 1");
+    QVERIFY(button);
+    QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>();
+    QVERIFY(flickable);
+    QSignalSpy tappedSpy(button, SIGNAL(tapped()));
+
+    // Button is no longer pressed if touchpoint goes beyond dragThreshold,
+    // because Flickable steals the grab
+    tappedSpy.clear();
+    QPoint p1 = button->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(button->property("pressed").toBool());
+    p1 += QPoint(dragThreshold, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(button->property("pressed").toBool());
+    int i = 0;
+    for (; i < 100 && !flickable->isMoving(); ++i) {
+        p1 += QPoint(1, 0);
+        QTest::touchEvent(window, touchDevice).move(1, p1, window);
+        QQuickTouchUtils::flush(window);
+    }
+    QVERIFY(flickable->isMoving());
+    qDebug() << "flickable started moving after" << i << "moves, when we got to" << p1;
+    QCOMPARE(i, 2);
+    QVERIFY(!button->property("pressed").toBool());
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(!button->property("pressed").toBool());
+    QCOMPARE(tappedSpy.count(), 0);
+}
+
+void tst_FlickableInterop::mouseClickButton()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>("Button 1");
+    QVERIFY(button);
+    QSignalSpy tappedSpy(button, SIGNAL(tapped()));
+
+    // Button changes pressed state and emits tapped on release
+    QPoint p1 = button->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(button->property("pressed").toBool());
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(!button->property("pressed").toBool());
+    QCOMPARE(tappedSpy.count(), 1);
+
+    // We can drag <= dragThreshold and the button still acts normal, Flickable doesn't grab
+    p1 = button->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(button->property("pressed").toBool());
+    p1 += QPoint(dragThreshold, 0);
+    QTest::mouseMove(window, p1);
+    QVERIFY(button->property("pressed").toBool());
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(!button->property("pressed").toBool());
+    QCOMPARE(tappedSpy.count(), 2);
+}
+
+void tst_FlickableInterop::mouseDragFlickableBehindButton()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>("Button 1");
+    QVERIFY(button);
+    QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>();
+    QVERIFY(flickable);
+    QSignalSpy tappedSpy(button, SIGNAL(tapped()));
+
+    // Button is no longer pressed if touchpoint goes beyond dragThreshold,
+    // because Flickable steals the grab
+    tappedSpy.clear();
+    QPoint p1 = button->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(button->property("pressed").toBool());
+    p1 += QPoint(dragThreshold, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QVERIFY(button->property("pressed").toBool());
+    int i = 0;
+    for (; i < 100 && !flickable->isMoving(); ++i) {
+        p1 += QPoint(1, 0);
+        QTest::mouseMove(window, p1);
+    }
+    qDebug() << "flickable started moving after" << i << "moves, when we got to" << p1;
+    QVERIFY(flickable->isMoving());
+    QCOMPARE(i, 2);
+    QVERIFY(!button->property("pressed").toBool());
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QVERIFY(!button->property("pressed").toBool());
+    QCOMPARE(tappedSpy.count(), 0);
+}
+
+void tst_FlickableInterop::touchDragSlider()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *slider = window->rootObject()->findChild<QQuickItem*>("Slider");
+    QVERIFY(slider);
+    QQuickDragHandler *drag = slider->findChild<QQuickDragHandler*>();
+    QVERIFY(drag);
+    QQuickItem *knob = slider->findChild<QQuickItem*>("Slider Knob");
+    QVERIFY(knob);
+    QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>();
+    QVERIFY(flickable);
+    QSignalSpy tappedSpy(knob->parent(), SIGNAL(tapped()));
+    QSignalSpy translationChangedSpy(drag, SIGNAL(translationChanged()));
+
+    // Drag the slider in the allowed (vertical) direction
+    tappedSpy.clear();
+    QPoint p1 = knob->mapToScene(knob->clipRect().center()).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(slider->property("pressed").toBool());
+    p1 += QPoint(0, dragThreshold);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(slider->property("pressed").toBool());
+    QCOMPARE(slider->property("value").toInt(), 49);
+    p1 += QPoint(0, 1);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    p1 += QPoint(0, 10);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(slider->property("value").toInt() < 49);
+    QVERIFY(!flickable->isMoving());
+    QVERIFY(!slider->property("pressed").toBool());
+
+    // Now that the DragHandler is active, the Flickable will not steal the grab
+    // even if we move a large distance horizontally
+    p1 += QPoint(dragThreshold * 2, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(!flickable->isMoving());
+
+    // Release, and do not expect the tapped signal
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(tappedSpy.count(), 0);
+    QCOMPARE(translationChangedSpy.count(), 1);
+}
+
+void tst_FlickableInterop::mouseDragSlider()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *slider = window->rootObject()->findChild<QQuickItem*>("Slider");
+    QVERIFY(slider);
+    QQuickDragHandler *drag = slider->findChild<QQuickDragHandler*>();
+    QVERIFY(drag);
+    QQuickItem *knob = slider->findChild<QQuickItem*>("Slider Knob");
+    QVERIFY(knob);
+    QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>();
+    QVERIFY(flickable);
+    QSignalSpy tappedSpy(knob->parent(), SIGNAL(tapped()));
+    QSignalSpy translationChangedSpy(drag, SIGNAL(translationChanged()));
+
+    // Drag the slider in the allowed (vertical) direction
+    tappedSpy.clear();
+    QPoint p1 = knob->mapToScene(knob->clipRect().center()).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(slider->property("pressed").toBool());
+    p1 += QPoint(0, dragThreshold);
+    QTest::mouseMove(window, p1);
+    QVERIFY(slider->property("pressed").toBool());
+    QCOMPARE(slider->property("value").toInt(), 49);
+    p1 += QPoint(0, 1);
+    QTest::mouseMove(window, p1);
+    p1 += QPoint(0, 10);
+    QTest::mouseMove(window, p1);
+    QVERIFY(slider->property("value").toInt() < 49);
+    QVERIFY(!flickable->isMoving());
+    QVERIFY(!slider->property("pressed").toBool());
+
+    // Now that the DragHandler is active, the Flickable will not steal the grab
+    // even if we move a large distance horizontally
+    p1 += QPoint(dragThreshold * 2, 0);
+    QTest::mouseMove(window, p1);
+    QVERIFY(!flickable->isMoving());
+
+    // Release, and do not expect the tapped signal
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QCOMPARE(tappedSpy.count(), 0);
+    QCOMPARE(translationChangedSpy.count(), 1);
+}
+
+void tst_FlickableInterop::touchDragFlickableBehindSlider()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *slider = window->rootObject()->findChild<QQuickItem*>("Slider");
+    QVERIFY(slider);
+    QQuickDragHandler *drag = slider->findChild<QQuickDragHandler*>();
+    QVERIFY(drag);
+    QQuickItem *knob = slider->findChild<QQuickItem*>("Slider Knob");
+    QVERIFY(knob);
+    QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>();
+    QVERIFY(flickable);
+    QSignalSpy tappedSpy(knob->parent(), SIGNAL(tapped()));
+    QSignalSpy translationChangedSpy(drag, SIGNAL(translationChanged()));
+
+    // Button is no longer pressed if touchpoint goes beyond dragThreshold,
+    // because Flickable steals the grab
+    tappedSpy.clear();
+    QPoint p1 = knob->mapToScene(knob->clipRect().center()).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(slider->property("pressed").toBool());
+    p1 += QPoint(dragThreshold, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(slider->property("pressed").toBool());
+    int i = 0;
+    for (; i < 100 && !flickable->isMoving(); ++i) {
+        p1 += QPoint(1, 0);
+        QTest::touchEvent(window, touchDevice).move(1, p1, window);
+        QQuickTouchUtils::flush(window);
+    }
+    qDebug() << "flickable started moving after" << i << "moves, when we got to" << p1;
+    QVERIFY(flickable->isMoving());
+    QCOMPARE(i, 2);
+    QVERIFY(!slider->property("pressed").toBool());
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(!slider->property("pressed").toBool());
+    QCOMPARE(tappedSpy.count(), 0);
+    QCOMPARE(translationChangedSpy.count(), 0);
+}
+
+void tst_FlickableInterop::mouseDragFlickableBehindSlider()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *slider = window->rootObject()->findChild<QQuickItem*>("Slider");
+    QVERIFY(slider);
+    QQuickDragHandler *drag = slider->findChild<QQuickDragHandler*>();
+    QVERIFY(drag);
+    QQuickItem *knob = slider->findChild<QQuickItem*>("Slider Knob");
+    QVERIFY(knob);
+    QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>();
+    QVERIFY(flickable);
+    QSignalSpy tappedSpy(knob->parent(), SIGNAL(tapped()));
+    QSignalSpy translationChangedSpy(drag, SIGNAL(translationChanged()));
+
+    // Button is no longer pressed if touchpoint goes beyond dragThreshold,
+    // because Flickable steals the grab
+    tappedSpy.clear();
+    QPoint p1 = knob->mapToScene(knob->clipRect().center()).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(slider->property("pressed").toBool());
+    p1 += QPoint(dragThreshold, 0);
+    QTest::mouseMove(window, p1);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(slider->property("pressed").toBool());
+    int i = 0;
+    for (; i < 100 && !flickable->isMoving(); ++i) {
+        p1 += QPoint(1, 0);
+        QTest::mouseMove(window, p1);
+    }
+    qDebug() << "flickable started moving after" << i << "moves, when we got to" << p1;
+    QVERIFY(flickable->isMoving());
+    QCOMPARE(i, 2);
+    QVERIFY(!slider->property("pressed").toBool());
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QCOMPARE(tappedSpy.count(), 0);
+    QCOMPARE(translationChangedSpy.count(), 0);
+}
+
+QTEST_MAIN(tst_FlickableInterop)
+
+#include "tst_flickableinterop.moc"
+