Merge "Merge branch 'wip/pointerhandler' into dev" into refs/staging/dev

111 files changed, 10679 insertions, 294 deletions

diff --git a/examples/quick/shared/LauncherList.qml b/examples/quick/shared/LauncherList.qml
index ba9ee6c5d2..2d1d29c585 100644
--- a/examples/quick/shared/LauncherList.qml
+++ b/examples/quick/shared/LauncherList.qml
@@ -52,6 +52,15 @@ Rectangle {
         myModel.append({"name":name, "description":desc, "url":url})
     }
 
+    function hideExample()
+    {
+        ei.visible = false;
+    }
+    function showExample(url)
+    {
+        ei.exampleUrl = url;
+    }
+
     // The container rectangle here is used to give a nice "feel" when
     // transitioning into an example.
     Rectangle {
diff --git a/src/imports/handlers/handlers.pro b/src/imports/handlers/handlers.pro
new file mode 100644
index 0000000000..0e32644773
--- /dev/null
+++ b/src/imports/handlers/handlers.pro
@@ -0,0 +1,11 @@
+CXX_MODULE = qml
+TARGET  = handlersplugin
+TARGETPATH = Qt/labs/handlers
+IMPORT_VERSION = 1.0
+
+SOURCES += \
+    plugin.cpp
+
+QT += quick-private qml-private
+
+load(qml_plugin)
diff --git a/src/imports/handlers/plugin.cpp b/src/imports/handlers/plugin.cpp
new file mode 100644
index 0000000000..bc1ae244d3
--- /dev/null
+++ b/src/imports/handlers/plugin.cpp
@@ -0,0 +1,88 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtQml/qqmlextensionplugin.h>
+
+#include <private/qquickhandlersmodule_p.h>
+
+static void initResources()
+{
+#ifdef QT_STATIC
+    Q_INIT_RESOURCE(qmake_Qt_labs_handlers);
+#endif
+}
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \qmlmodule Qt.labs.handlers 1.0
+    \title Qt Quick Pointer Handlers
+    \ingroup qmlmodules
+    \brief Provides QML types for handling pointer events.
+
+    This QML module contains types for handling pointer events, which are an abstraction
+    of mouse, touch and tablet events.
+
+    To use the types in this module, import the module with the following line:
+
+    \code
+    import Qt.labs.handlers 1.0
+    \endcode
+*/
+
+
+//![class decl]
+class QtQuickHandlersPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID QQmlExtensionInterface_iid)
+public:
+    QtQuickHandlersPlugin(QObject *parent = 0) : QQmlExtensionPlugin(parent) { initResources(); }
+    void registerTypes(const char *uri) Q_DECL_OVERRIDE
+    {
+        Q_ASSERT(QLatin1String(uri) == QLatin1String("Qt.labs.handlers"));
+        Q_UNUSED(uri);
+        QQuickHandlersModule::defineModule();
+    }
+};
+//![class decl]
+
+QT_END_NAMESPACE
+
+#include "plugin.moc"
diff --git a/src/imports/handlers/qmldir b/src/imports/handlers/qmldir
new file mode 100644
index 0000000000..4896348c2e
--- /dev/null
+++ b/src/imports/handlers/qmldir
@@ -0,0 +1,5 @@
+module Qt.labs.handlers
+plugin handlersplugin
+classname QtQuickHandlersPlugin
+typeinfo plugins.qmltypes
+
diff --git a/src/imports/imports.pro b/src/imports/imports.pro
index 3c7f96eff9..5d7e434884 100644
--- a/src/imports/imports.pro
+++ b/src/imports/imports.pro
@@ -14,6 +14,7 @@ qtConfig(statemachine): SUBDIRS += statemachine
 
 qtHaveModule(quick) {
     SUBDIRS += \
+        handlers \
         layouts \
         qtquick2 \
         window \
diff --git a/src/quick/handlers/handlers.pri b/src/quick/handlers/handlers.pri
new file mode 100644
index 0000000000..17066bb33a
--- /dev/null
+++ b/src/quick/handlers/handlers.pri
@@ -0,0 +1,20 @@
+HEADERS += \
+    $$PWD/qquickdraghandler_p.h \
+    $$PWD/qquickhandlersmodule_p.h \
+    $$PWD/qquickmultipointerhandler_p.h \
+    $$PWD/qquickpinchhandler_p.h \
+    $$PWD/qquickpointerdevicehandler_p.h \
+    $$PWD/qquickpointerhandler_p.h \
+    $$PWD/qquickpointersinglehandler_p.h \
+    $$PWD/qquicktaphandler_p.h \
+
+SOURCES += \
+    $$PWD/qquickdraghandler.cpp \
+    $$PWD/qquickhandlersmodule.cpp \
+    $$PWD/qquickmultipointerhandler.cpp \
+    $$PWD/qquickpinchhandler.cpp \
+    $$PWD/qquickpointerdevicehandler.cpp \
+    $$PWD/qquickpointerhandler.cpp \
+    $$PWD/qquickpointersinglehandler.cpp \
+    $$PWD/qquicktaphandler.cpp \
+
diff --git a/src/quick/handlers/qquickdraghandler.cpp b/src/quick/handlers/qquickdraghandler.cpp
new file mode 100644
index 0000000000..b41e1f6c9d
--- /dev/null
+++ b/src/quick/handlers/qquickdraghandler.cpp
@@ -0,0 +1,210 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickdraghandler_p.h"
+#include <private/qquickwindow_p.h>
+#include <QDebug>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \qmltype DragHandler
+    \instantiates QQuickDragHandler
+    \inqmlmodule QtQuick
+    \ingroup qtquick-handlers
+    \brief Handler for dragging
+
+    DragHandler is a handler that is used to interactively move an Item.
+
+    At this time, drag-and-drop is not yet supported.
+
+    \sa Drag, MouseArea
+*/
+
+QQuickDragHandler::QQuickDragHandler(QObject *parent)
+    : QQuickPointerSingleHandler(parent)
+{
+}
+
+QQuickDragHandler::~QQuickDragHandler()
+{
+}
+
+bool QQuickDragHandler::wantsEventPoint(QQuickEventPoint *point)
+{
+    // If we've already been interested in a point, stay interested, even if it has strayed outside bounds.
+    return ((point->state() != QQuickEventPoint::Pressed && this->point().id() == point->pointId())
+            || QQuickPointerSingleHandler::wantsEventPoint(point));
+}
+
+void QQuickDragHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point)
+{
+    if (grabber == this && stateChange == QQuickEventPoint::GrabExclusive)
+        // In case the grab got handled over from another grabber, we might not get the Press
+        initializeTargetStartPos(point);
+    enforceConstraints();
+    QQuickPointerSingleHandler::onGrabChanged(grabber, stateChange, point);
+}
+
+void QQuickDragHandler::onActiveChanged()
+{
+    if (!active())
+        m_targetStartPos = QPointF();
+}
+
+void QQuickDragHandler::handleEventPoint(QQuickEventPoint *point)
+{
+    point->setAccepted();
+    switch (point->state()) {
+    case QQuickEventPoint::Pressed:
+        initializeTargetStartPos(point);
+        setPassiveGrab(point);
+        break;
+    case QQuickEventPoint::Updated: {
+        QPointF delta = point->scenePos() - point->scenePressPos();
+        if (!m_xAxis.enabled())
+            delta.setX(0);
+        if (!m_yAxis.enabled())
+            delta.setY(0);
+        if (active()) {
+            setTranslation(delta);
+            if (target() && target()->parentItem()) {
+                QPointF pos = target()->parentItem()->mapFromScene(m_targetStartPos + delta);
+                enforceAxisConstraints(&pos);
+                moveTarget(pos, point);
+            }
+        } else if (!point->exclusiveGrabber() &&
+                   ((m_xAxis.enabled() && QQuickWindowPrivate::dragOverThreshold(delta.x(), Qt::XAxis, point)) ||
+                    (m_yAxis.enabled() && QQuickWindowPrivate::dragOverThreshold(delta.y(), Qt::YAxis, point)))) {
+            setExclusiveGrab(point);
+            if (auto parent = parentItem()) {
+                if (point->pointerEvent()->asPointerTouchEvent())
+                    parent->setKeepTouchGrab(true);
+                // tablet and mouse are treated the same by Item's legacy event handling, and
+                // touch becomes synth-mouse for Flickable, so we need to prevent stealing
+                // mouse grab too, whenever dragging occurs in an enabled direction
+                parent->setKeepMouseGrab(true);
+            }
+        }
+    } break;
+    default:
+        break;
+    }
+}
+
+void QQuickDragHandler::enforceConstraints()
+{
+    if (!target() || !target()->parentItem())
+        return;
+    QPointF pos = target()->position();
+    QPointF copy(pos);
+    enforceAxisConstraints(&pos);
+    if (pos != copy)
+        target()->setPosition(pos);
+}
+
+void QQuickDragHandler::enforceAxisConstraints(QPointF *localPos)
+{
+    if (m_xAxis.enabled())
+        localPos->setX(qBound(m_xAxis.minimum(), localPos->x(), m_xAxis.maximum()));
+    if (m_yAxis.enabled())
+        localPos->setY(qBound(m_yAxis.minimum(), localPos->y(), m_yAxis.maximum()));
+}
+
+void QQuickDragHandler::initializeTargetStartPos(QQuickEventPoint *point)
+{
+    if (target() && target()->parentItem() && m_targetStartPos.isNull()) {    // prefer the m_targetStartPos we got when it got Pressed.
+        m_targetStartPos = target()->parentItem()->mapToScene(target()->position());
+        if (!target()->contains(point->pos())) {
+            // If pressed outside of target item, move the target item so that the touchpoint is in its center,
+            // while still respecting the axis constraints.
+            const QPointF center = target()->parentItem()->mapFromScene(point->scenePos());
+            const QPointF pointCenteredInItemPos = target()->parentItem()->mapToScene(center - QPointF(target()->width(), target()->height())/2);
+            if (m_xAxis.enabled())
+                m_targetStartPos.setX(pointCenteredInItemPos.x());
+            if (m_yAxis.enabled())
+                m_targetStartPos.setY(pointCenteredInItemPos.y());
+        }
+    }
+}
+
+void QQuickDragHandler::setTranslation(const QPointF &trans)
+{
+    if (trans == m_translation) // fuzzy compare?
+        return;
+    m_translation = trans;
+    emit translationChanged();
+}
+
+
+QQuickDragAxis::QQuickDragAxis()
+  : m_minimum(-DBL_MAX)
+  , m_maximum(DBL_MAX)
+  , m_enabled(true)
+{
+}
+
+void QQuickDragAxis::setMinimum(qreal minimum)
+{
+    if (m_minimum == minimum)
+        return;
+
+    m_minimum = minimum;
+    emit minimumChanged();
+}
+
+void QQuickDragAxis::setMaximum(qreal maximum)
+{
+    if (m_maximum == maximum)
+        return;
+
+    m_maximum = maximum;
+    emit maximumChanged();
+}
+
+void QQuickDragAxis::setEnabled(bool enabled)
+{
+    if (m_enabled == enabled)
+        return;
+
+    m_enabled = enabled;
+    emit enabledChanged();
+}
+
+QT_END_NAMESPACE
diff --git a/src/quick/handlers/qquickdraghandler_p.h b/src/quick/handlers/qquickdraghandler_p.h
new file mode 100644
index 0000000000..54fef697f7
--- /dev/null
+++ b/src/quick/handlers/qquickdraghandler_p.h
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKDRAGHANDLER_H
+#define QQUICKDRAGHANDLER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickpointersinglehandler_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q_AUTOTEST_EXPORT QQuickDragAxis : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal minimum READ minimum WRITE setMinimum NOTIFY minimumChanged)
+    Q_PROPERTY(qreal maximum READ maximum WRITE setMaximum NOTIFY maximumChanged)
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
+
+public:
+    QQuickDragAxis();
+
+    qreal minimum() const { return m_minimum; }
+    void setMinimum(qreal minimum);
+
+    qreal maximum() const { return m_maximum; }
+    void setMaximum(qreal maximum);
+
+    bool enabled() const { return m_enabled; }
+    void setEnabled(bool enabled);
+
+signals:
+    void minimumChanged();
+    void maximumChanged();
+    void enabledChanged();
+
+private:
+    qreal m_minimum;
+    qreal m_maximum;
+    bool m_enabled;
+};
+
+class Q_AUTOTEST_EXPORT QQuickDragHandler : public QQuickPointerSingleHandler
+{
+    Q_OBJECT
+    Q_PROPERTY(QQuickDragAxis * xAxis READ xAxis CONSTANT)
+    Q_PROPERTY(QQuickDragAxis * yAxis READ yAxis CONSTANT)
+    Q_PROPERTY(QPointF translation READ translation NOTIFY translationChanged)
+
+public:
+    explicit QQuickDragHandler(QObject *parent = 0);
+    ~QQuickDragHandler();
+
+    void handleEventPoint(QQuickEventPoint *point) override;
+
+    QQuickDragAxis *xAxis() { return &m_xAxis; }
+    QQuickDragAxis *yAxis() { return &m_yAxis; }
+
+    QPointF translation() const { return m_translation; }
+    void setTranslation(const QPointF &trans);
+
+    Q_INVOKABLE void enforceConstraints();
+
+Q_SIGNALS:
+//    void gestureStarted(QQuickGestureEvent *gesture);
+    void translationChanged();
+
+protected:
+    bool wantsEventPoint(QQuickEventPoint *point) override;
+    void onActiveChanged() override;
+    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point) override;
+
+private:
+    void ungrab();
+    void enforceAxisConstraints(QPointF *localPos);
+    void initializeTargetStartPos(QQuickEventPoint *point);
+
+private:
+    QPointF m_targetStartPos;
+    QPointF m_translation;
+    QQuickDragAxis m_xAxis;
+    QQuickDragAxis m_yAxis;
+
+    friend class QQuickDragAxis;
+};
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QQuickDragHandler)
+QML_DECLARE_TYPE(QQuickDragAxis)
+
+#endif // QQUICKDRAGHANDLER_H
diff --git a/src/quick/handlers/qquickhandlersmodule.cpp b/src/quick/handlers/qquickhandlersmodule.cpp
new file mode 100644
index 0000000000..4a3a1f6aa2
--- /dev/null
+++ b/src/quick/handlers/qquickhandlersmodule.cpp
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickhandlersmodule_p.h"
+#include "qquickpointerhandler_p.h"
+#include "qquickdraghandler_p.h"
+#include "qquickpinchhandler_p.h"
+#include "qquicktaphandler_p.h"
+
+static void initResources()
+{
+#ifdef QT_STATIC
+    Q_INIT_RESOURCE(qmake_Qt_labs_handlers);
+#endif
+}
+
+QT_BEGIN_NAMESPACE
+
+static QQmlPrivate::AutoParentResult handler_autoParent(QObject *obj, QObject *parent)
+{
+    if (qmlobject_cast<QQuickItem *>(parent)) {
+        QQuickPointerHandler *handler = qmlobject_cast<QQuickPointerHandler *>(obj);
+        if (handler) {
+            handler->setParent(parent);
+            return QQmlPrivate::Parented;
+        }
+    }
+    return QQmlPrivate::IncompatibleObject;
+}
+
+static void qt_quickhandlers_defineModule(const char *uri, int major, int minor)
+{
+    QQmlPrivate::RegisterAutoParent autoparent = { 0, &handler_autoParent };
+    QQmlPrivate::qmlregister(QQmlPrivate::AutoParentRegistration, &autoparent);
+    qmlRegisterUncreatableType<QQuickPointerEvent>(uri, major, minor, "PointerEvent",
+        QQuickPointerHandler::tr("PointerEvent is only available as a parameter of several signals in PointerHandler"));
+    qmlRegisterUncreatableType<QQuickPointerDevice>(uri, major, minor, "PointerDevice",
+        QQuickPointerHandler::tr("PointerDevice is only available as a property of PointerEvent"));
+    qRegisterMetaType<QPointingDeviceUniqueId>("QPointingDeviceUniqueId");
+    qmlRegisterUncreatableType<QPointingDeviceUniqueId>(uri, major, minor, "PointingDeviceUniqueId",
+        QQuickPointerHandler::tr("PointingDeviceUniqueId is only available as a property of PointerEvent"));
+
+    qmlRegisterType<QQuickPointerHandler>(uri,major,minor,"PointerHandler");
+    qmlRegisterType<QQuickDragHandler>(uri,major,minor,"DragHandler");
+    qmlRegisterUncreatableType<QQuickDragAxis>(uri, major, minor, "DragAxis",
+        QQuickDragHandler::tr("DragAxis is only available as a grouped property of DragHandler"));
+    qmlRegisterType<QQuickPinchHandler>(uri,major,minor,"PinchHandler");
+    qmlRegisterType<QQuickTapHandler>(uri,major,minor,"TapHandler");
+    qRegisterMetaType<QQuickHandlerPoint>();
+}
+
+void QQuickHandlersModule::defineModule()
+{
+    initResources();
+
+    const char uri[] = "Qt.labs.handlers";
+    int majorVersion = 1;
+    int minorVersion = 0;
+
+    qt_quickhandlers_defineModule(uri, majorVersion, minorVersion);
+}
+
+QT_END_NAMESPACE
diff --git a/src/quick/handlers/qquickhandlersmodule_p.h b/src/quick/handlers/qquickhandlersmodule_p.h
new file mode 100644
index 0000000000..7eb8d39b98
--- /dev/null
+++ b/src/quick/handlers/qquickhandlersmodule_p.h
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKHANDLERSMODULE_P_H
+#define QQUICKHANDLERSMODULE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qqml.h>
+#include <private/qtquickglobal_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_PRIVATE_EXPORT QQuickHandlersModule
+{
+public:
+    static void defineModule();
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKHANDLERSMODULE_P_H
+
diff --git a/src/quick/handlers/qquickmultipointerhandler.cpp b/src/quick/handlers/qquickmultipointerhandler.cpp
new file mode 100644
index 0000000000..a605b3f12e
--- /dev/null
+++ b/src/quick/handlers/qquickmultipointerhandler.cpp
@@ -0,0 +1,248 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickmultipointerhandler_p.h"
+#include <private/qquickitem_p.h>
+#include <QLineF>
+#include <QMouseEvent>
+#include <QDebug>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    An intermediate class (not registered as a QML type)
+    for the type of handler which requires and acts upon a specific number
+    of multiple touchpoints.
+*/
+QQuickMultiPointerHandler::QQuickMultiPointerHandler(QObject *parent, int requiredPointCount)
+    : QQuickPointerDeviceHandler(parent)
+    , m_requiredPointCount(requiredPointCount)
+    , m_pointDistanceThreshold(0)
+{
+}
+
+QQuickMultiPointerHandler::~QQuickMultiPointerHandler()
+{
+}
+
+bool QQuickMultiPointerHandler::wantsPointerEvent(QQuickPointerEvent *event)
+{
+    if (!QQuickPointerDeviceHandler::wantsPointerEvent(event))
+        return false;
+
+    if (sameAsCurrentPoints(event))
+        return true;
+
+    const QVector<QQuickEventPoint *> candidatePoints = eligiblePoints(event);
+    const bool ret = (candidatePoints.size() == m_requiredPointCount);
+    if (ret)
+        m_currentPoints = candidatePoints;
+    return ret;
+}
+
+QVector<QQuickEventPoint *> QQuickMultiPointerHandler::eligiblePoints(QQuickPointerEvent *event)
+{
+    QVector<QQuickEventPoint *> ret;
+    int c = event->pointCount();
+    QRectF targetBounds = target()->mapRectToScene(target()->boundingRect())
+            .marginsAdded(QMarginsF(m_pointDistanceThreshold, m_pointDistanceThreshold, m_pointDistanceThreshold, m_pointDistanceThreshold));
+    // If one or more points are newly pressed or released, all non-released points are candidates for this handler.
+    // In other cases however, do not steal the grab: that is, if a point has a grabber,
+    // it's not a candidate for this handler.
+    bool stealingAllowed = event->isPressEvent() || event->isReleaseEvent();
+    for (int i = 0; i < c; ++i) {
+        QQuickEventPoint *p = event->point(i);
+        if (!stealingAllowed) {
+            QObject *exclusiveGrabber = p->exclusiveGrabber();
+            if (exclusiveGrabber && exclusiveGrabber != this)
+                continue;
+        }
+        if (p->state() != QQuickEventPoint::Released && targetBounds.contains(p->scenePos()))
+            ret << p;
+    }
+    return ret;
+}
+
+void QQuickMultiPointerHandler::setRequiredPointCount(int c)
+{
+    if (m_requiredPointCount == c)
+        return;
+
+    m_requiredPointCount = c;
+    emit requiredPointCountChanged();
+}
+
+void QQuickMultiPointerHandler::setPointDistanceThreshold(qreal pointDistanceThreshold)
+{
+    if (m_pointDistanceThreshold == pointDistanceThreshold)
+        return;
+
+    m_pointDistanceThreshold = pointDistanceThreshold;
+    emit pointDistanceThresholdChanged();
+}
+
+bool QQuickMultiPointerHandler::sameAsCurrentPoints(QQuickPointerEvent *event)
+{
+    bool ret = true;
+    int c = event->pointCount();
+    if (c != m_currentPoints.size())
+        return false;
+    // TODO optimize: either ensure the points are sorted,
+    // or use std::equal with a predicate
+    for (int i = 0; ret && i < c; ++i) {
+        if (event->point(i)->state() == QQuickEventPoint::Released)
+            return false;
+        bool found = false;
+        int pointId = event->point(i)->pointId();
+        for (QQuickEventPoint *o : qAsConst(m_currentPoints))
+            if (o && pointId == o->pointId())
+                found = true;
+        if (!found)
+            ret = false;
+    }
+    return ret;
+}
+
+// TODO make templates for these functions somehow?
+QPointF QQuickMultiPointerHandler::touchPointCentroid()
+{
+    QPointF ret;
+    if (Q_UNLIKELY(m_currentPoints.size() == 0))
+        return ret;
+    for (QQuickEventPoint *point : qAsConst(m_currentPoints))
+        ret += point->scenePos();
+    return ret / m_currentPoints.size();
+}
+
+QVector2D QQuickMultiPointerHandler::touchPointCentroidVelocity()
+{
+    QVector2D ret;
+    if (Q_UNLIKELY(m_currentPoints.size() == 0))
+        return ret;
+    for (QQuickEventPoint *point : qAsConst(m_currentPoints))
+        ret += point->velocity();
+    return ret / m_currentPoints.size();
+}
+
+qreal QQuickMultiPointerHandler::averageTouchPointDistance(const QPointF &ref)
+{
+    qreal ret = 0;
+    if (Q_UNLIKELY(m_currentPoints.size() == 0))
+        return ret;
+    for (QQuickEventPoint *point : qAsConst(m_currentPoints))
+        ret += QVector2D(point->scenePos() - ref).length();
+    return ret / m_currentPoints.size();
+}
+
+qreal QQuickMultiPointerHandler::averageStartingDistance(const QPointF &ref)
+{
+    // TODO cache it in setActive()?
+    qreal ret = 0;
+    if (Q_UNLIKELY(m_currentPoints.size() == 0))
+        return ret;
+    for (QQuickEventPoint *point : qAsConst(m_currentPoints))
+        ret += QVector2D(point->sceneGrabPos() - ref).length();
+    return ret / m_currentPoints.size();
+}
+
+QVector<QQuickMultiPointerHandler::PointData> QQuickMultiPointerHandler::angles(const QPointF &ref) const
+{
+    QVector<PointData> angles;
+    angles.reserve(m_currentPoints.count());
+    for (QQuickEventPoint *point : qAsConst(m_currentPoints)) {
+        qreal angle = QLineF(ref, point->scenePos()).angle();
+        angles.append(PointData(point->pointId(), -angle));     // convert to clockwise, to be consistent with QQuickItem::rotation
+    }
+    return angles;
+}
+
+qreal QQuickMultiPointerHandler::averageAngleDelta(const QVector<PointData> &old, const QVector<PointData> &newAngles)
+{
+    qreal avgAngleDelta = 0;
+    int numSamples = 0;
+
+    auto oldBegin = old.constBegin();
+
+    for (PointData newData : newAngles) {
+        quint64 id = newData.id;
+        auto it = std::find_if(oldBegin, old.constEnd(), [id] (PointData pd) { return pd.id == id; });
+        qreal angleD = 0;
+        if (it != old.constEnd()) {
+            PointData oldData = *it;
+            // We might rotate from 359 degrees to 1 degree. However, this
+            // should be interpreted as a rotation of +2 degrees instead of
+            // -358 degrees. Therefore, we call remainder() to translate the angle
+            // to be in the range [-180, 180] (-350 to +10 etc)
+            angleD = remainder(newData.angle - oldData.angle, qreal(360));
+            // optimization: narrow down the O(n^2) search to optimally O(n)
+            // if both vectors have the same points and they are in the same order
+            if (it == oldBegin)
+                ++oldBegin;
+            numSamples++;
+        }
+        avgAngleDelta += angleD;
+    }
+    if (numSamples > 1)
+        avgAngleDelta /= numSamples;
+
+    return avgAngleDelta;
+}
+
+void QQuickMultiPointerHandler::acceptPoints(const QVector<QQuickEventPoint *> &points)
+{
+    for (QQuickEventPoint* point : points)
+        point->setAccepted();
+}
+
+bool QQuickMultiPointerHandler::grabPoints(QVector<QQuickEventPoint *> points)
+{
+    bool canGrab = true;
+    for (QQuickEventPoint* point : points) {
+        auto grabber = point->grabberItem();
+        if (grabber && (grabber->keepMouseGrab() || grabber->keepTouchGrab()))
+            canGrab = false;
+    }
+    if (canGrab) {
+        for (QQuickEventPoint* point : points)
+            setExclusiveGrab(point);
+    }
+    return canGrab;
+}
+
+QT_END_NAMESPACE
diff --git a/src/quick/handlers/qquickmultipointerhandler_p.h b/src/quick/handlers/qquickmultipointerhandler_p.h
new file mode 100644
index 0000000000..1bbc2f2fa3
--- /dev/null
+++ b/src/quick/handlers/qquickmultipointerhandler_p.h
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKPOINTERMULTIHANDLER_H
+#define QQUICKPOINTERMULTIHANDLER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickitem.h"
+#include "qevent.h"
+#include "qquickpointerdevicehandler_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q_AUTOTEST_EXPORT QQuickMultiPointerHandler : public QQuickPointerDeviceHandler
+{
+    Q_OBJECT
+    Q_PROPERTY(int requiredPointCount READ requiredPointCount WRITE setRequiredPointCount NOTIFY requiredPointCountChanged)
+    Q_PROPERTY(qreal pointDistanceThreshold READ pointDistanceThreshold WRITE setPointDistanceThreshold NOTIFY pointDistanceThresholdChanged)
+
+public:
+    explicit QQuickMultiPointerHandler(QObject *parent = 0, int requiredPointCount = 2);
+    ~QQuickMultiPointerHandler();
+
+    int requiredPointCount() const { return m_requiredPointCount; }
+    void setRequiredPointCount(int c);
+
+    qreal pointDistanceThreshold() const { return m_pointDistanceThreshold; }
+    void setPointDistanceThreshold(qreal pointDistanceThreshold);
+
+signals:
+    void requiredPointCountChanged();
+    void pointDistanceThresholdChanged();
+
+protected:
+    struct PointData {
+        PointData() : id(0), angle(0) {}
+        PointData(quint64 id, qreal angle) : id(id), angle(angle) {}
+        quint64 id;
+        qreal angle;
+    };
+
+    bool wantsPointerEvent(QQuickPointerEvent *event) override;
+    bool sameAsCurrentPoints(QQuickPointerEvent *event);
+    QVector<QQuickEventPoint *> eligiblePoints(QQuickPointerEvent *event);
+    QPointF touchPointCentroid();
+    QVector2D touchPointCentroidVelocity();
+    qreal averageTouchPointDistance(const QPointF &ref);
+    qreal averageStartingDistance(const QPointF &ref);
+    qreal averageTouchPointAngle(const QPointF &ref);
+    qreal averageStartingAngle(const QPointF &ref);
+    QVector<PointData> angles(const QPointF &ref) const;
+    static qreal averageAngleDelta(const QVector<PointData> &old, const QVector<PointData> &newAngles);
+    void acceptPoints(const QVector<QQuickEventPoint *> &points);
+    bool grabPoints(QVector<QQuickEventPoint *> points);
+
+protected:
+    QVector<QQuickEventPoint *> m_currentPoints;
+    int m_requiredPointCount;
+    qreal m_pointDistanceThreshold;
+};
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QQuickMultiPointerHandler)
+
+#endif // QQUICKPOINTERMULTIHANDLER_H
diff --git a/src/quick/handlers/qquickpinchhandler.cpp b/src/quick/handlers/qquickpinchhandler.cpp
new file mode 100644
index 0000000000..465a49a6fd
--- /dev/null
+++ b/src/quick/handlers/qquickpinchhandler.cpp
@@ -0,0 +1,311 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickpinchhandler_p.h"
+#include <QtQuick/qquickwindow.h>
+#include <private/qsgadaptationlayer_p.h>
+#include <private/qquickitem_p.h>
+#include <private/qguiapplication_p.h>
+#include <private/qquickwindow_p.h>
+#include <QEvent>
+#include <QMouseEvent>
+#include <QDebug>
+#include <qpa/qplatformnativeinterface.h>
+
+QT_BEGIN_NAMESPACE
+
+Q_LOGGING_CATEGORY(lcPinchHandler, "qt.quick.handler.pinch")
+
+/*!
+    \qmltype PinchHandler
+    \instantiates QQuickPinchHandler
+    \inqmlmodule QtQuick
+    \ingroup qtquick-handlers
+    \brief Handler for pinch gestures
+
+    PinchHandler is a handler that is used to interactively rotate and zoom an Item.
+*/
+
+QQuickPinchHandler::QQuickPinchHandler(QObject *parent)
+    : QQuickMultiPointerHandler(parent, 2)
+    , m_activeScale(1)
+    , m_activeRotation(0)
+    , m_activeTranslation(0,0)
+    , m_minimumScale(-qInf())
+    , m_maximumScale(qInf())
+    , m_minimumRotation(-qInf())
+    , m_maximumRotation(qInf())
+    , m_minimumX(-qInf())
+    , m_maximumX(qInf())
+    , m_minimumY(-qInf())
+    , m_maximumY(qInf())
+    , m_pinchOrigin(PinchCenter)
+    , m_startScale(1)
+    , m_startRotation(0)
+{
+}
+
+QQuickPinchHandler::~QQuickPinchHandler()
+{
+}
+
+void QQuickPinchHandler::setMinimumScale(qreal minimumScale)
+{
+    if (m_minimumScale == minimumScale)
+        return;
+
+    m_minimumScale = minimumScale;
+    emit minimumScaleChanged();
+}
+
+void QQuickPinchHandler::setMaximumScale(qreal maximumScale)
+{
+    if (m_maximumScale == maximumScale)
+        return;
+
+    m_maximumScale = maximumScale;
+    emit maximumScaleChanged();
+}
+
+void QQuickPinchHandler::setMinimumRotation(qreal minimumRotation)
+{
+    if (m_minimumRotation == minimumRotation)
+        return;
+
+    m_minimumRotation = minimumRotation;
+    emit minimumRotationChanged();
+}
+
+void QQuickPinchHandler::setMaximumRotation(qreal maximumRotation)
+{
+    if (m_maximumRotation == maximumRotation)
+        return;
+
+    m_maximumRotation = maximumRotation;
+    emit maximumRotationChanged();
+}
+
+void QQuickPinchHandler::setPinchOrigin(QQuickPinchHandler::PinchOrigin pinchOrigin)
+{
+    if (m_pinchOrigin == pinchOrigin)
+        return;
+
+    m_pinchOrigin = pinchOrigin;
+    emit pinchOriginChanged();
+}
+
+/*!
+    \qmlproperty QQuickPinchHandler::minimumX
+
+    The minimum acceptable x coordinate of the centroid
+ */
+void QQuickPinchHandler::setMinimumX(qreal minX)
+{
+    if (m_minimumX == minX)
+        return;
+    m_minimumX = minX;
+    emit minimumXChanged();
+}
+
+/*!
+    \qmlproperty QQuickPinchHandler::maximumX
+
+    The maximum acceptable x coordinate of the centroid
+ */
+void QQuickPinchHandler::setMaximumX(qreal maxX)
+{
+    if (m_maximumX == maxX)
+        return;
+    m_maximumX = maxX;
+    emit maximumXChanged();
+}
+
+/*!
+    \qmlproperty QQuickPinchHandler::minimumY
+
+    The minimum acceptable y coordinate of the centroid
+ */
+void QQuickPinchHandler::setMinimumY(qreal minY)
+{
+    if (m_minimumY == minY)
+        return;
+    m_minimumY = minY;
+    emit minimumYChanged();
+}
+
+/*!
+    \qmlproperty QQuickPinchHandler::maximumY
+
+    The maximum acceptable y coordinate of the centroid
+ */
+void QQuickPinchHandler::setMaximumY(qreal maxY)
+{
+    if (m_maximumY == maxY)
+        return;
+    m_maximumY = maxY;
+    emit maximumYChanged();
+}
+
+/*!
+    \qmlproperty QQuickPinchHandler::minimumTouchPoints
+
+    The pinch begins when this number of fingers are pressed.
+    Until then, PinchHandler tracks the positions of any pressed fingers,
+    but if it's an insufficient number, it does not scale or rotate
+    its \l target, and the \l active property will remain false.
+*/
+
+/*!
+    \qmlproperty QQuickPinchHandler::active
+*/
+
+void QQuickPinchHandler::onActiveChanged()
+{
+    if (active()) {
+        if (const QQuickItem *t = target()) {
+            m_startScale = t->scale(); // TODO incompatible with independent x/y scaling
+            m_startRotation = t->rotation();
+            m_startCentroid = touchPointCentroid();
+            m_startAngles = angles(m_startCentroid);
+            m_startDistance = averageTouchPointDistance(m_startCentroid);
+            QVector3D xformOrigin(t->transformOriginPoint());
+            m_startMatrix = QMatrix4x4();
+            m_startMatrix.translate(t->x(), t->y());
+            m_startMatrix.translate(xformOrigin);
+            m_startMatrix.scale(m_startScale);
+            m_startMatrix.rotate(m_startRotation, 0, 0, -1);
+            m_startMatrix.translate(-xformOrigin);
+            m_activeRotation = 0;
+            m_activeTranslation = QPointF(0,0);
+            qCInfo(lcPinchHandler) << "activated with starting scale" << m_startScale << "rotation" << m_startRotation;
+        }
+    } else {
+        qCInfo(lcPinchHandler) << "deactivated with scale" << m_activeScale << "rotation" << m_activeRotation;
+    }
+}
+
+void QQuickPinchHandler::handlePointerEventImpl(QQuickPointerEvent *event)
+{
+    Q_UNUSED(event)
+    if (Q_UNLIKELY(lcPinchHandler().isDebugEnabled())) {
+        for (QQuickEventPoint *point : qAsConst(m_currentPoints))
+            qCDebug(lcPinchHandler) << point->state() << point->sceneGrabPos() << "->" << point->scenePos();
+    }
+
+    bool containsReleasedPoints = event->isReleaseEvent();
+    if (!active() && !containsReleasedPoints) {
+        // Verify that least one of the points have moved beyond threshold needed to activate the handler
+        for (QQuickEventPoint *point : qAsConst(m_currentPoints)) {
+            if (QQuickWindowPrivate::dragOverThreshold(point)) {
+                if (grabPoints(m_currentPoints))
+                    setActive(true);
+                break;
+            }
+        }
+        if (!active())
+            return;
+    }
+    // TODO check m_pinchOrigin: right now it acts like it's set to PinchCenter
+    m_centroid = touchPointCentroid();
+    m_centroidVelocity = touchPointCentroidVelocity();
+    QRectF bounds(m_minimumX, m_minimumY, m_maximumX, m_maximumY);
+    // avoid mapping the minima and maxima, as they might have unmappable values
+    // such as -inf/+inf. Because of this we perform the bounding to min/max in local coords.
+    QPointF centroidParentPos;
+    if (target() && target()->parentItem()) {
+        centroidParentPos = target()->parentItem()->mapFromScene(m_centroid);
+        centroidParentPos = QPointF(qBound(bounds.left(), centroidParentPos.x(), bounds.right()),
+                                   qBound(bounds.top(), centroidParentPos.y(), bounds.bottom()));
+    }
+    // 1. scale
+    const qreal dist = averageTouchPointDistance(m_centroid);
+    m_activeScale = dist / m_startDistance;
+    m_activeScale = qBound(m_minimumScale/m_startScale, m_activeScale, m_maximumScale/m_startScale);
+    const qreal scale = m_startScale * m_activeScale;
+
+    // 2. rotate
+    QVector<PointData> newAngles = angles(m_centroid);
+    const qreal angleDelta = averageAngleDelta(m_startAngles, newAngles);
+    m_activeRotation += angleDelta;
+    const qreal totalRotation = m_startRotation + m_activeRotation;
+    const qreal rotation = qBound(m_minimumRotation, totalRotation, m_maximumRotation);
+    m_activeRotation += (rotation - totalRotation);   //adjust for the potential bounding above
+    m_startAngles = std::move(newAngles);
+
+    if (target() && target()->parentItem()) {
+        // 3. Drag/translate
+        const QPointF centroidStartParentPos = target()->parentItem()->mapFromScene(m_startCentroid);
+        m_activeTranslation = centroidParentPos - centroidStartParentPos;
+
+        // apply rotation + scaling around the centroid - then apply translation.
+        QMatrix4x4 mat;
+
+        const QVector3D centroidParentVector(centroidParentPos);
+        mat.translate(centroidParentVector);
+        mat.rotate(m_activeRotation, 0, 0, 1);
+        mat.scale(m_activeScale);
+        mat.translate(-centroidParentVector);
+        mat.translate(QVector3D(m_activeTranslation));
+
+        mat = mat * m_startMatrix;
+
+        QPointF xformOriginPoint = target()->transformOriginPoint();
+        QPointF pos = mat * xformOriginPoint;
+        pos -= xformOriginPoint;
+
+        target()->setPosition(pos);
+        target()->setRotation(rotation);
+        target()->setScale(scale);
+
+
+        // TODO some translation inadvertently happens; try to hold the chosen pinch origin in place
+
+        qCDebug(lcPinchHandler) << "centroid" << m_startCentroid << "->"  << m_centroid
+                                << ", distance" << m_startDistance << "->" << dist
+                                << ", startScale" << m_startScale << "->" << scale
+                                << ", activeRotation" << m_activeRotation
+                                << ", rotation" << rotation;
+    }
+
+    if (!containsReleasedPoints)
+        acceptPoints(m_currentPoints);
+    emit updated();
+}
+
+QT_END_NAMESPACE
diff --git a/src/quick/handlers/qquickpinchhandler_p.h b/src/quick/handlers/qquickpinchhandler_p.h
new file mode 100644
index 0000000000..6768196909
--- /dev/null
+++ b/src/quick/handlers/qquickpinchhandler_p.h
@@ -0,0 +1,173 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKPINCHHANDLER_H
+#define QQUICKPINCHHANDLER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickitem.h"
+#include "qevent.h"
+#include "qquickmultipointerhandler_p.h"
+#include <private/qquicktranslate_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_AUTOTEST_EXPORT QQuickPinchHandler : public QQuickMultiPointerHandler
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal minimumScale READ minimumScale WRITE setMinimumScale NOTIFY minimumScaleChanged)
+    Q_PROPERTY(qreal maximumScale READ maximumScale WRITE setMaximumScale NOTIFY maximumScaleChanged)
+    Q_PROPERTY(qreal minimumRotation READ minimumRotation WRITE setMinimumRotation NOTIFY minimumRotationChanged)
+    Q_PROPERTY(qreal maximumRotation READ maximumRotation WRITE setMaximumRotation NOTIFY maximumRotationChanged)
+    Q_PROPERTY(PinchOrigin pinchOrigin READ pinchOrigin WRITE setPinchOrigin NOTIFY pinchOriginChanged)
+    Q_PROPERTY(QPointF centroid READ centroid NOTIFY updated)
+    Q_PROPERTY(QVector2D centroidVelocity READ centroidVelocity NOTIFY updated)
+    Q_PROPERTY(qreal scale READ scale NOTIFY updated)
+    Q_PROPERTY(qreal rotation READ rotation NOTIFY updated)
+    Q_PROPERTY(QPointF translation READ translation NOTIFY updated)
+    Q_PROPERTY(qreal minimumX READ minimumX WRITE setMinimumX NOTIFY minimumXChanged)
+    Q_PROPERTY(qreal maximumX READ maximumX WRITE setMaximumX NOTIFY maximumXChanged)
+    Q_PROPERTY(qreal minimumY READ minimumY WRITE setMinimumY NOTIFY minimumYChanged)
+    Q_PROPERTY(qreal maximumY READ maximumY WRITE setMaximumY NOTIFY maximumYChanged)
+
+public:
+    enum PinchOrigin {
+        FirstPoint, PinchCenter, TargetCenter
+    };
+    Q_ENUM(PinchOrigin)
+
+    explicit QQuickPinchHandler(QObject *parent = 0);
+    ~QQuickPinchHandler();
+
+    qreal minimumScale() const { return m_minimumScale; }
+    void setMinimumScale(qreal minimumScale);
+
+    qreal maximumScale() const { return m_maximumScale; }
+    void setMaximumScale(qreal maximumScale);
+
+    qreal minimumRotation() const { return m_minimumRotation; }
+    void setMinimumRotation(qreal minimumRotation);
+
+    qreal maximumRotation() const { return m_maximumRotation; }
+    void setMaximumRotation(qreal maximumRotation);
+
+    PinchOrigin pinchOrigin() const { return m_pinchOrigin; }
+    void setPinchOrigin(PinchOrigin pinchOrigin);
+
+    QPointF translation() const { return m_activeTranslation; }
+    qreal scale() const { return m_activeScale; }
+    qreal rotation() const { return m_activeRotation; }
+    QPointF centroid() const { return m_centroid; }
+    QVector2D centroidVelocity() const { return m_centroidVelocity; }
+
+    qreal minimumX() const { return m_minimumX; }
+    void setMinimumX(qreal minX);
+    qreal maximumX() const { return m_maximumX; }
+    void setMaximumX(qreal maxX);
+    qreal minimumY() const { return m_minimumY; }
+    void setMinimumY(qreal minY);
+    qreal maximumY() const { return m_maximumY; }
+    void setMaximumY(qreal maxY);
+
+signals:
+    void requiredPointCountChanged();
+    void minimumScaleChanged();
+    void maximumScaleChanged();
+    void minimumRotationChanged();
+    void maximumRotationChanged();
+    void minimumXChanged();
+    void maximumXChanged();
+    void minimumYChanged();
+    void maximumYChanged();
+    void pinchOriginChanged();
+    void updated();
+
+protected:
+    void onActiveChanged() override;
+    void handlePointerEventImpl(QQuickPointerEvent *event) override;
+
+private:
+    // properties
+    qreal m_activeScale;
+    qreal m_activeRotation;
+    QPointF m_activeTranslation;
+    QPointF m_centroid;
+    QVector2D m_centroidVelocity;
+
+    qreal m_minimumScale;
+    qreal m_maximumScale;
+
+    qreal m_minimumRotation;
+    qreal m_maximumRotation;
+
+    qreal m_minimumX;
+    qreal m_maximumX;
+    qreal m_minimumY;
+    qreal m_maximumY;
+
+    PinchOrigin m_pinchOrigin;
+
+    // internal
+    qreal m_startScale;
+    qreal m_startRotation;
+    QPointF m_startCentroid;
+    qreal m_startDistance;
+    QPointF m_startPos;
+
+    QVector<PointData> m_startAngles;
+    QMatrix4x4 m_startMatrix;
+    QQuickMatrix4x4 m_transform;
+
+};
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QQuickPinchHandler)
+
+#endif // QQUICKPINCHHANDLER_H
diff --git a/src/quick/handlers/qquickpointerdevicehandler.cpp b/src/quick/handlers/qquickpointerdevicehandler.cpp
new file mode 100644
index 0000000000..203f712179
--- /dev/null
+++ b/src/quick/handlers/qquickpointerdevicehandler.cpp
@@ -0,0 +1,133 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickpointerdevicehandler_p.h"
+#include <private/qquickitem_p.h>
+#include <QMouseEvent>
+#include <QDebug>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    An intermediate class (not registered as a QML type)
+    for handlers which allow filtering based on device type,
+    pointer type, or device-specific buttons (such as mouse or stylus buttons).
+ */
+QQuickPointerDeviceHandler::QQuickPointerDeviceHandler(QObject *parent)
+    : QQuickPointerHandler(parent)
+    , m_acceptedDevices(QQuickPointerDevice::AllDevices)
+    , m_acceptedPointerTypes(QQuickPointerDevice::AllPointerTypes)
+    , m_acceptedModifiers(Qt::KeyboardModifierMask)
+{
+}
+
+QQuickPointerDeviceHandler::~QQuickPointerDeviceHandler()
+{
+}
+
+void QQuickPointerDeviceHandler::setAcceptedDevices(QQuickPointerDevice::DeviceTypes acceptedDevices)
+{
+    if (m_acceptedDevices == acceptedDevices)
+        return;
+
+    m_acceptedDevices = acceptedDevices;
+    emit acceptedDevicesChanged();
+}
+
+void QQuickPointerDeviceHandler::setAcceptedPointerTypes(QQuickPointerDevice::PointerTypes acceptedPointerTypes)
+{
+    if (m_acceptedPointerTypes == acceptedPointerTypes)
+        return;
+
+    m_acceptedPointerTypes = acceptedPointerTypes;
+    emit acceptedPointerTypesChanged();
+}
+
+/*!
+     \qmlproperty QQuickPointerDeviceHandler::acceptedModifiers
+
+     If this property is set, it will require the given keyboard modifiers to
+     be pressed in order to react to pointer events, and otherwise ignore them.
+
+     If this property is set to Qt.KeyboardModifierMask (the default value),
+     then the PointerHandler ignores the modifier keys.
+
+     For example an Item could have two handlers of the same type, one of which
+     is enabled only if the required keyboard modifiers are pressed:
+
+     \qml
+     Item {
+        TapHandler {
+            acceptedModifiers: Qt.ControlModifier
+            onTapped: console.log("control-tapped")
+        }
+        TapHandler {
+            acceptedModifiers: Qt.NoModifier
+            onTapped: console.log("tapped")
+        }
+     }
+     \endqml
+*/
+void QQuickPointerDeviceHandler::setAcceptedModifiers(Qt::KeyboardModifiers acceptedModifiers)
+{
+    if (m_acceptedModifiers == acceptedModifiers)
+        return;
+
+    m_acceptedModifiers = acceptedModifiers;
+    emit acceptedModifiersChanged();
+}
+
+bool QQuickPointerDeviceHandler::wantsPointerEvent(QQuickPointerEvent *event)
+{
+    if (!QQuickPointerHandler::wantsPointerEvent(event))
+        return false;
+    qCDebug(lcPointerHandlerDispatch) << objectName()
+        << "checking device type" << m_acceptedDevices
+        << "pointer type" << m_acceptedPointerTypes
+        << "modifiers" << m_acceptedModifiers;
+    if ((event->device()->type() & m_acceptedDevices) == 0)
+        return false;
+    if ((event->device()->pointerType() & m_acceptedPointerTypes) == 0)
+        return false;
+    if (m_acceptedModifiers != Qt::KeyboardModifierMask && event->modifiers() != m_acceptedModifiers)
+        return false;
+    return true;
+}
+
+QT_END_NAMESPACE
diff --git a/src/quick/handlers/qquickpointerdevicehandler_p.h b/src/quick/handlers/qquickpointerdevicehandler_p.h
new file mode 100644
index 0000000000..9e30fa0be4
--- /dev/null
+++ b/src/quick/handlers/qquickpointerdevicehandler_p.h
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKPOINTERDEVICEHANDLER_H
+#define QQUICKPOINTERDEVICEHANDLER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickpointerhandler_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q_AUTOTEST_EXPORT QQuickPointerDeviceHandler : public QQuickPointerHandler
+{
+    Q_OBJECT
+    Q_PROPERTY(QQuickPointerDevice::DeviceTypes acceptedDevices READ acceptedDevices WRITE setAcceptedDevices NOTIFY acceptedDevicesChanged)
+    Q_PROPERTY(QQuickPointerDevice::PointerTypes acceptedPointerTypes READ acceptedPointerTypes WRITE setAcceptedPointerTypes NOTIFY acceptedPointerTypesChanged)
+    Q_PROPERTY(Qt::KeyboardModifiers acceptedModifiers READ acceptedModifiers WRITE setAcceptedModifiers NOTIFY acceptedModifiersChanged)
+
+public:
+    explicit QQuickPointerDeviceHandler(QObject *parent = 0);
+    ~QQuickPointerDeviceHandler();
+
+    QQuickPointerDevice::DeviceTypes acceptedDevices() const { return m_acceptedDevices; }
+    QQuickPointerDevice::PointerTypes acceptedPointerTypes() const { return m_acceptedPointerTypes; }
+    Qt::KeyboardModifiers acceptedModifiers() const { return m_acceptedModifiers; }
+
+public slots:
+    void setAcceptedDevices(QQuickPointerDevice::DeviceTypes acceptedDevices);
+    void setAcceptedPointerTypes(QQuickPointerDevice::PointerTypes acceptedPointerTypes);
+    void setAcceptedModifiers(Qt::KeyboardModifiers acceptedModifiers);
+
+Q_SIGNALS:
+    void acceptedDevicesChanged();
+    void acceptedPointerTypesChanged();
+    void acceptedModifiersChanged();
+
+protected:
+    bool wantsPointerEvent(QQuickPointerEvent *event) override;
+
+protected:
+    QQuickPointerDevice::DeviceTypes m_acceptedDevices;
+    QQuickPointerDevice::PointerTypes m_acceptedPointerTypes;
+    Qt::KeyboardModifiers m_acceptedModifiers;
+};
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QQuickPointerDeviceHandler)
+
+#endif // QQUICKPOINTERDEVICEHANDLER_H
diff --git a/src/quick/handlers/qquickpointerhandler.cpp b/src/quick/handlers/qquickpointerhandler.cpp
new file mode 100644
index 0000000000..1ed80c0a5b
--- /dev/null
+++ b/src/quick/handlers/qquickpointerhandler.cpp
@@ -0,0 +1,255 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickpointerhandler_p.h"
+
+QT_BEGIN_NAMESPACE
+
+Q_LOGGING_CATEGORY(lcPointerHandlerDispatch, "qt.quick.handler.dispatch")
+Q_LOGGING_CATEGORY(lcPointerHandlerActive, "qt.quick.handler.active")
+
+/*!
+    \qmltype PointerHandler
+    \instantiates QQuickPointerHandler
+    \inqmlmodule QtQuick
+    \ingroup qtquick-handlers
+    \brief Handler for pointer events
+
+    PointerHandler is a handler for pointer events regardless of source.
+    They may represent events from a touch, mouse or tablet device.
+*/
+
+QQuickPointerHandler::QQuickPointerHandler(QObject *parent)
+  : QObject(parent)
+  , m_currentEvent(nullptr)
+  , m_target(nullptr)
+  , m_enabled(true)
+  , m_active(false)
+  , m_targetExplicitlySet(false)
+  , m_hadKeepMouseGrab(false)
+  , m_hadKeepTouchGrab(false)
+{
+}
+
+QQuickPointerHandler::~QQuickPointerHandler()
+{
+    QQuickItem *parItem = parentItem();
+    if (parItem) {
+        QQuickItemPrivate *p = QQuickItemPrivate::get(parItem);
+        p->extra.value().pointerHandlers.removeOne(this);
+    }
+}
+
+/*!
+    Notification that the grab has changed in some way which is relevant to this handler.
+    The \a grabber (subject) will be the PointerHandler whose state is changing,
+    or null if the state change regards an Item. (TODO do we have any such cases?)
+    The \a stateChange (verb) tells what happened.
+    The \a point (object) is the point that was grabbed or ungrabbed.
+    EventPoint has the sole responsibility to call this function.
+    The PointerHandler must react in whatever way is appropriate, and must
+    emit the relevant signals (for the benefit of QML code).
+    A subclass is allowed to override this virtual function, but must always
+    call its parent class's implementation in addition to (usually after)
+    whatever custom behavior it implements.
+*/
+void QQuickPointerHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point)
+{
+    qCDebug(lcPointerHandlerDispatch) << point << stateChange << grabber;
+    Q_ASSERT(point);
+    if (grabber == this) {
+        bool wasCanceled = false;
+        emit grabChanged(point);
+        switch (stateChange) {
+        case QQuickEventPoint::GrabPassive:
+        case QQuickEventPoint::GrabExclusive:
+            break;
+        case QQuickEventPoint::CancelGrabPassive:
+        case QQuickEventPoint::CancelGrabExclusive:
+            wasCanceled = true; // the grab was stolen by something else
+            Q_FALLTHROUGH();
+        case QQuickEventPoint::UngrabPassive:
+        case QQuickEventPoint::UngrabExclusive:
+            setActive(false);
+            point->setAccepted(false);
+            if (auto par = parentItem()) {
+                par->setKeepMouseGrab(m_hadKeepMouseGrab);
+                par->setKeepTouchGrab(m_hadKeepTouchGrab);
+            }
+        case QQuickEventPoint::OverrideGrabPassive:
+            // Passive grab is still there, but we won't receive point updates right now.
+            // No need to notify about this.
+            return;
+        }
+        if (wasCanceled)
+            emit canceled(point);
+        else
+            emit grabChanged(point);
+    }
+}
+
+void QQuickPointerHandler::setPassiveGrab(QQuickEventPoint *point, bool grab)
+{
+    qCDebug(lcPointerHandlerDispatch) << point << grab;
+    if (grab) {
+        point->setGrabberPointerHandler(this, false);
+    } else {
+        point->removePassiveGrabber(this);
+    }
+}
+
+void QQuickPointerHandler::setExclusiveGrab(QQuickEventPoint *point, bool grab)
+{
+    // TODO m_hadKeepMouseGrab m_hadKeepTouchGrab
+    qCDebug(lcPointerHandlerDispatch) << point << grab;
+    // Don't allow one handler to cancel another's grab, unless it is stealing it for itself
+    if (!grab && point->grabberPointerHandler() != this)
+        return;
+    point->setGrabberPointerHandler(grab ? this : nullptr, true);
+}
+
+void QQuickPointerHandler::cancelAllGrabs(QQuickEventPoint *point)
+{
+    qCDebug(lcPointerHandlerDispatch) << point;
+    point->cancelAllGrabs(this);
+}
+
+QPointF QQuickPointerHandler::eventPos(const QQuickEventPoint *point) const
+{
+    return (target() ? target()->mapFromScene(point->scenePos()) : point->scenePos());
+}
+
+bool QQuickPointerHandler::parentContains(const QQuickEventPoint *point) const
+{
+    if (point) {
+        if (QQuickItem *par = parentItem())
+            return par->contains(par->mapFromScene(point->scenePos()));
+    }
+    return false;
+}
+
+/*!
+     \qmlproperty QQuickPointerHandler::enabled
+
+     If a PointerHandler is disabled, it will reject all events
+     and no signals will be emitted.
+
+     TODO is it too extreme not even to emit pressed/updated/released?
+     or should we disable only the higher-level interpretation, in subclasses?
+*/
+void QQuickPointerHandler::setEnabled(bool enabled)
+{
+    if (m_enabled == enabled)
+        return;
+
+    m_enabled = enabled;
+    emit enabledChanged();
+}
+
+void QQuickPointerHandler::setTarget(QQuickItem *target)
+{
+    m_targetExplicitlySet = true;
+    if (m_target == target)
+        return;
+
+    m_target = target;
+    emit targetChanged();
+}
+
+QQuickItem *QQuickPointerHandler::target() const
+{
+    if (!m_targetExplicitlySet)
+        return parentItem();
+    return m_target;
+}
+
+void QQuickPointerHandler::handlePointerEvent(QQuickPointerEvent *event)
+{
+    bool wants = wantsPointerEvent(event);
+    qCDebug(lcPointerHandlerDispatch) << metaObject()->className() << objectName()
+                                      << "on" << parentItem()->metaObject()->className() << parentItem()->objectName()
+                                      << (wants ? "WANTS" : "DECLINES") << event;
+    if (wants) {
+        handlePointerEventImpl(event);
+    } else {
+        setActive(false);
+        int pCount = event->pointCount();
+        for (int i = 0; i < pCount; ++i) {
+            QQuickEventPoint *pt = event->point(i);
+            if (pt->grabberPointerHandler() == this && pt->state() != QQuickEventPoint::Stationary)
+                pt->cancelExclusiveGrab();
+        }
+    }
+    event->device()->eventDeliveryTargets().append(this);
+}
+
+bool QQuickPointerHandler::wantsPointerEvent(QQuickPointerEvent *event)
+{
+    Q_UNUSED(event)
+    return m_enabled;
+}
+
+void QQuickPointerHandler::setActive(bool active)
+{
+    if (m_active != active) {
+        qCDebug(lcPointerHandlerActive) << this << m_active << "->" << active;
+        m_active = active;
+        onActiveChanged();
+        emit activeChanged();
+    }
+}
+
+void QQuickPointerHandler::handlePointerEventImpl(QQuickPointerEvent *event)
+{
+    m_currentEvent = event;
+}
+
+/*!
+    \qmlproperty QQuickPointerHandler::parent
+
+    The \l Item which is the scope of the handler; the Item in which it was declared.
+    The handler will handle events on behalf of this Item, which means a
+    pointer event is relevant if at least one of its event points occurs within
+    the Item's interior.  Initially \l target() is the same, but target()
+    can be reassigned.
+
+    \sa QQuickPointerHandler::target(), QObject::parent()
+*/
+
+QT_END_NAMESPACE
diff --git a/src/quick/handlers/qquickpointerhandler_p.h b/src/quick/handlers/qquickpointerhandler_p.h
new file mode 100644
index 0000000000..24a058275d
--- /dev/null
+++ b/src/quick/handlers/qquickpointerhandler_p.h
@@ -0,0 +1,125 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKPOINTERHANDLER_H
+#define QQUICKPOINTERHANDLER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qevent.h"
+
+#include <QtQuick/private/qquickevents_p_p.h>
+#include <QtQuick/private/qquickitem_p.h>
+
+QT_BEGIN_NAMESPACE
+
+Q_DECLARE_LOGGING_CATEGORY(lcPointerHandlerDispatch)
+
+class Q_QUICK_PRIVATE_EXPORT QQuickPointerHandler : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
+    Q_PROPERTY(bool active READ active NOTIFY activeChanged)
+    Q_PROPERTY(QQuickItem * target READ target WRITE setTarget NOTIFY targetChanged)
+    Q_PROPERTY(QQuickItem * parent READ parentItem CONSTANT)
+
+public:
+    explicit QQuickPointerHandler(QObject *parent = 0);
+    virtual ~QQuickPointerHandler();
+
+public:
+    bool enabled() const { return m_enabled; }
+    void setEnabled(bool enabled);
+
+    bool active() const { return m_active; }
+
+    QQuickItem *target() const;
+    void setTarget(QQuickItem *target);
+
+    QQuickItem * parentItem() const { return static_cast<QQuickItem *>(QObject::parent()); }
+
+    void handlePointerEvent(QQuickPointerEvent *event);
+
+Q_SIGNALS:
+    void enabledChanged();
+    void activeChanged();
+    void targetChanged();
+    void grabChanged(QQuickEventPoint *point);
+    void canceled(QQuickEventPoint *point);
+
+protected:
+    QQuickPointerEvent *currentEvent() { return m_currentEvent; }
+    virtual bool wantsPointerEvent(QQuickPointerEvent *event);
+    virtual void handlePointerEventImpl(QQuickPointerEvent *event);
+    void setActive(bool active);
+    virtual void onActiveChanged() { }
+    virtual void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point);
+    void setPassiveGrab(QQuickEventPoint *point, bool grab = true);
+    void setExclusiveGrab(QQuickEventPoint *point, bool grab = true);
+    void cancelAllGrabs(QQuickEventPoint *point);
+    QPointF eventPos(const QQuickEventPoint *point) const;
+    bool parentContains(const QQuickEventPoint *point) const;
+
+private:
+    QQuickPointerEvent *m_currentEvent;
+    QQuickItem *m_target;
+    bool m_enabled : 1;
+    bool m_active : 1;
+    bool m_targetExplicitlySet : 1;
+    bool m_hadKeepMouseGrab : 1;    // some handlers override target()->setKeepMouseGrab(); this remembers previous state
+    bool m_hadKeepTouchGrab : 1;    // some handlers override target()->setKeepTouchGrab(); this remembers previous state
+
+    friend class QQuickEventPoint;
+    friend class QQuickWindowPrivate;
+};
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QQuickPointerHandler)
+
+#endif // QQUICKPOINTERHANDLER_H
diff --git a/src/quick/handlers/qquickpointersinglehandler.cpp b/src/quick/handlers/qquickpointersinglehandler.cpp
new file mode 100644
index 0000000000..0b0f482d8d
--- /dev/null
+++ b/src/quick/handlers/qquickpointersinglehandler.cpp
@@ -0,0 +1,243 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickpointersinglehandler_p.h"
+
+QT_BEGIN_NAMESPACE
+Q_DECLARE_LOGGING_CATEGORY(DBG_TOUCH_TARGET)
+
+/*!
+    An intermediate class (not registered as a QML type)
+    for the most common handlers: those which expect only a single point.
+    wantsPointerEvent() will choose the first point which is inside the
+    \l target item, and return true as long as the event contains that point.
+    Override handleEventPoint() to implement a single-point handler.
+*/
+
+QQuickPointerSingleHandler::QQuickPointerSingleHandler(QObject *parent)
+  : QQuickPointerDeviceHandler(parent)
+  , m_acceptedButtons(Qt::LeftButton)
+  , m_ignoreAdditionalPoints(false)
+{
+}
+
+bool QQuickPointerSingleHandler::wantsPointerEvent(QQuickPointerEvent *event)
+{
+    if (!QQuickPointerDeviceHandler::wantsPointerEvent(event))
+        return false;
+    if (event->device()->pointerType() != QQuickPointerDevice::Finger &&
+            (event->buttons() & m_acceptedButtons) == 0 && (event->button() & m_acceptedButtons) == 0)
+        return false;
+
+    if (m_pointInfo.m_id) {
+        // We already know which one we want, so check whether it's there.
+        // It's expected to be an update or a release.
+        // If we no longer want it, cancel the grab.
+        int candidatePointCount = 0;
+        QQuickEventPoint *point = nullptr;
+        int c = event->pointCount();
+        for (int i = 0; i < c; ++i) {
+            QQuickEventPoint *p = event->point(i);
+            if (wantsEventPoint(p)) {
+                ++candidatePointCount;
+                if (p->pointId() == m_pointInfo.m_id)
+                    point = p;
+            }
+        }
+        if (point) {
+            if (candidatePointCount == 1 || (candidatePointCount > 1 && m_ignoreAdditionalPoints)) {
+                point->setAccepted();
+                return true;
+            } else {
+                point->cancelAllGrabs(this);
+            }
+        } else {
+            qCWarning(DBG_TOUCH_TARGET) << this << "pointId" << hex << m_pointInfo.m_id
+                << "is missing from current event, but was neither canceled nor released";
+            return false;
+        }
+    } else {
+        // We have not yet chosen a point; choose the first one for which wantsEventPoint() returns true.
+        int candidatePointCount = 0;
+        int c = event->pointCount();
+        QQuickEventPoint *chosen = nullptr;
+        for (int i = 0; i < c; ++i) {
+            QQuickEventPoint *p = event->point(i);
+            if (!p->exclusiveGrabber() && wantsEventPoint(p)) {
+                if (!chosen)
+                    chosen = p;
+                ++candidatePointCount;
+            }
+        }
+        if (chosen && candidatePointCount == 1) {
+            m_pointInfo.m_id = chosen->pointId();
+            chosen->setAccepted();
+        }
+    }
+    return m_pointInfo.m_id;
+}
+
+void QQuickPointerSingleHandler::handlePointerEventImpl(QQuickPointerEvent *event)
+{
+    QQuickPointerDeviceHandler::handlePointerEventImpl(event);
+    QQuickEventPoint *currentPoint = event->pointById(m_pointInfo.m_id);
+    Q_ASSERT(currentPoint);
+    if (!m_pointInfo.m_id || !currentPoint->isAccepted()) {
+        reset();
+    } else {
+        if (event->asPointerTouchEvent()) {
+            QQuickEventTouchPoint *tp = static_cast<QQuickEventTouchPoint *>(currentPoint);
+            m_pointInfo.m_uniqueId = tp->uniqueId();
+            m_pointInfo.m_rotation = tp->rotation();
+            m_pointInfo.m_pressure = tp->pressure();
+            m_pointInfo.m_ellipseDiameters = tp->ellipseDiameters();
+        } else if (event->asPointerTabletEvent()) {
+            // TODO
+        } else {
+            m_pointInfo.m_uniqueId = event->device()->uniqueId();
+            m_pointInfo.m_rotation = 0;
+            m_pointInfo.m_pressure = event->buttons() ? 1 : 0;
+            m_pointInfo.m_ellipseDiameters = QSizeF();
+        }
+        m_pointInfo.m_position = currentPoint->pos();
+        m_pointInfo.m_scenePosition = currentPoint->scenePos();
+        if (currentPoint->state() == QQuickEventPoint::Updated)
+            m_pointInfo.m_velocity = currentPoint->velocity();
+        handleEventPoint(currentPoint);
+        switch (currentPoint->state()) {
+        case QQuickEventPoint::Pressed:
+            m_pointInfo.m_pressPosition = currentPoint->pos();
+            m_pointInfo.m_scenePressPosition = currentPoint->scenePos();
+            m_pointInfo.m_pressedButtons = event->buttons();
+            break;
+        case QQuickEventPoint::Released:
+            setExclusiveGrab(currentPoint, false);
+            reset();
+            break;
+        default:
+            m_pointInfo.m_pressedButtons = event->buttons();
+            break;
+        }
+        emit pointChanged();
+    }
+}
+
+bool QQuickPointerSingleHandler::wantsEventPoint(QQuickEventPoint *point)
+{
+    return parentContains(point);
+}
+
+void QQuickPointerSingleHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point)
+{
+    if (grabber != this)
+        return;
+    switch (stateChange) {
+    case QQuickEventPoint::GrabExclusive:
+        m_pointInfo.m_sceneGrabPosition = point->sceneGrabPos();
+        setActive(true);
+        QQuickPointerHandler::onGrabChanged(grabber, stateChange, point);
+        break;
+    case QQuickEventPoint::GrabPassive:
+        m_pointInfo.m_sceneGrabPosition = point->sceneGrabPos();
+        QQuickPointerHandler::onGrabChanged(grabber, stateChange, point);
+        break;
+    case QQuickEventPoint::OverrideGrabPassive:
+        return; // don't emit
+    case QQuickEventPoint::UngrabPassive:
+    case QQuickEventPoint::UngrabExclusive:
+    case QQuickEventPoint::CancelGrabPassive:
+    case QQuickEventPoint::CancelGrabExclusive:
+        // the grab is lost or relinquished, so the point is no longer relevant
+        QQuickPointerHandler::onGrabChanged(grabber, stateChange, point);
+        reset();
+        break;
+    }
+    emit singlePointGrabChanged();
+}
+
+void QQuickPointerSingleHandler::setIgnoreAdditionalPoints(bool v)
+{
+    m_ignoreAdditionalPoints = v;
+}
+
+void QQuickPointerSingleHandler::moveTarget(QPointF pos, QQuickEventPoint *point)
+{
+    target()->setPosition(pos);
+    m_pointInfo.m_scenePosition = point->scenePos();
+    m_pointInfo.m_position = target()->mapFromScene(m_pointInfo.m_scenePosition);
+}
+
+void QQuickPointerSingleHandler::setAcceptedButtons(Qt::MouseButtons buttons)
+{
+    if (m_acceptedButtons == buttons)
+        return;
+
+    m_acceptedButtons = buttons;
+    emit acceptedButtonsChanged();
+}
+
+void QQuickPointerSingleHandler::reset()
+{
+    setActive(false);
+    m_pointInfo.reset();
+}
+
+QQuickHandlerPoint::QQuickHandlerPoint()
+    : m_id(0)
+    , m_rotation(0)
+    , m_pressure(0)
+{}
+
+void QQuickHandlerPoint::reset()
+{
+    m_id = 0;
+    m_uniqueId = QPointingDeviceUniqueId();
+    m_position = QPointF();
+    m_scenePosition = QPointF();
+    m_pressPosition = QPointF();
+    m_scenePressPosition = QPointF();
+    m_sceneGrabPosition = QPointF();
+    m_velocity = QVector2D();
+    m_rotation = 0;
+    m_pressure = 0;
+    m_ellipseDiameters = QSizeF();
+    m_pressedButtons = Qt::NoButton;
+}
+
+QT_END_NAMESPACE
diff --git a/src/quick/handlers/qquickpointersinglehandler_p.h b/src/quick/handlers/qquickpointersinglehandler_p.h
new file mode 100644
index 0000000000..8898a1600b
--- /dev/null
+++ b/src/quick/handlers/qquickpointersinglehandler_p.h
@@ -0,0 +1,154 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKPOINTERSINGLEHANDLER_H
+#define QQUICKPOINTERSINGLEHANDLER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickpointerdevicehandler_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QQuickPointerSingleHandler;
+
+class Q_QUICK_PRIVATE_EXPORT QQuickHandlerPoint {
+    Q_GADGET
+    Q_PROPERTY(int id READ id)
+    Q_PROPERTY(QPointingDeviceUniqueId uniqueId READ uniqueId)
+    Q_PROPERTY(QPointF position READ position)
+    Q_PROPERTY(QPointF scenePosition READ scenePosition)
+    Q_PROPERTY(QPointF pressPosition READ pressPosition)
+    Q_PROPERTY(QPointF scenePressPosition READ scenePressPosition)
+    Q_PROPERTY(QPointF sceneGrabPosition READ sceneGrabPosition)
+    Q_PROPERTY(Qt::MouseButtons pressedButtons READ pressedButtons)
+    Q_PROPERTY(QVector2D velocity READ velocity)
+    Q_PROPERTY(qreal rotation READ rotation)
+    Q_PROPERTY(qreal pressure READ pressure)
+    Q_PROPERTY(QSizeF ellipseDiameters READ ellipseDiameters)
+
+public:
+    QQuickHandlerPoint();
+
+    int id() const { return m_id; }
+    Qt::MouseButtons pressedButtons() const { return m_pressedButtons; }
+    QPointF pressPosition() const { return m_pressPosition; }
+    QPointF scenePressPosition() const { return m_scenePressPosition; }
+    QPointF sceneGrabPosition() const { return m_sceneGrabPosition; }
+    QPointF position() const { return m_position; }
+    QPointF scenePosition() const { return m_scenePosition; }
+    QVector2D velocity() const { return m_velocity; }
+    qreal rotation() const { return m_rotation; }
+    qreal pressure() const { return m_pressure; }
+    QSizeF ellipseDiameters() const { return m_ellipseDiameters; }
+    QPointingDeviceUniqueId uniqueId() const { return m_uniqueId; }
+
+private:
+    void reset();
+    int m_id;
+    QPointingDeviceUniqueId m_uniqueId;
+    Qt::MouseButtons m_pressedButtons;
+    QPointF m_position;
+    QPointF m_scenePosition;
+    QPointF m_pressPosition;
+    QPointF m_scenePressPosition;
+    QPointF m_sceneGrabPosition;
+    QVector2D m_velocity;
+    qreal m_rotation;
+    qreal m_pressure;
+    QSizeF m_ellipseDiameters;
+    friend class QQuickPointerSingleHandler;
+};
+
+class Q_QUICK_PRIVATE_EXPORT QQuickPointerSingleHandler : public QQuickPointerDeviceHandler
+{
+    Q_OBJECT
+    Q_PROPERTY(Qt::MouseButtons acceptedButtons READ acceptedButtons WRITE setAcceptedButtons NOTIFY acceptedButtonsChanged)
+    Q_PROPERTY(QQuickHandlerPoint point READ point NOTIFY pointChanged)
+public:
+    explicit QQuickPointerSingleHandler(QObject *parent = 0);
+    virtual ~QQuickPointerSingleHandler() { }
+
+    Qt::MouseButtons acceptedButtons() const { return m_acceptedButtons; }
+    void setAcceptedButtons(Qt::MouseButtons buttons);
+
+    QQuickHandlerPoint point() const { return m_pointInfo; }
+
+Q_SIGNALS:
+    void pointChanged();
+    void singlePointGrabChanged(); // QQuickPointerHandler::grabChanged signal can't be a property notifier here
+    void acceptedButtonsChanged();
+
+protected:
+    bool wantsPointerEvent(QQuickPointerEvent *event) override;
+    virtual bool wantsEventPoint(QQuickEventPoint *point);
+    void handlePointerEventImpl(QQuickPointerEvent *event) override;
+    virtual void handleEventPoint(QQuickEventPoint *point) = 0;
+
+    QQuickEventPoint *currentPoint(QQuickPointerEvent *ev) { return ev->pointById(m_pointInfo.m_id); }
+    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point) override;
+
+    void setIgnoreAdditionalPoints(bool v = true);
+
+    void moveTarget(QPointF pos, QQuickEventPoint *point);
+
+private:
+    void reset();
+
+private:
+    QQuickHandlerPoint m_pointInfo;
+    Qt::MouseButtons m_acceptedButtons;
+    bool m_ignoreAdditionalPoints : 1;
+};
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QQuickHandlerPoint)
+QML_DECLARE_TYPE(QQuickPointerSingleHandler)
+
+#endif // QQUICKPOINTERSINGLEHANDLER_H
diff --git a/src/quick/handlers/qquicktaphandler.cpp b/src/quick/handlers/qquicktaphandler.cpp
new file mode 100644
index 0000000000..272c6de000
--- /dev/null
+++ b/src/quick/handlers/qquicktaphandler.cpp
@@ -0,0 +1,353 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquicktaphandler_p.h"
+#include <qpa/qplatformtheme.h>
+#include <private/qguiapplication_p.h>
+#include <QtGui/qstylehints.h>
+
+QT_BEGIN_NAMESPACE
+
+Q_LOGGING_CATEGORY(lcTapHandler, "qt.quick.handler.tap")
+
+qreal QQuickTapHandler::m_multiTapInterval(0.0);
+// single tap distance is the same as the drag threshold
+int QQuickTapHandler::m_mouseMultiClickDistanceSquared(-1);
+int QQuickTapHandler::m_touchMultiTapDistanceSquared(-1);
+
+/*!
+    \qmltype TapHandler
+    \instantiates QQuickTapHandler
+    \inqmlmodule QtQuick
+    \ingroup qtquick-handlers
+    \brief Handler for taps and clicks
+
+    TapHandler is a handler for taps on a touchscreen or clicks on a mouse.
+
+    Detection of a valid tap gesture depends on \l gesturePolicy.
+    Note that buttons (such as QPushButton) are often implemented not to care
+    whether the press and release occur close together: if you press the button
+    and then change your mind, you need to drag all the way off the edge of the
+    button in order to cancel the click.  Therefore the default
+    \l gesturePolicy is \l ReleaseWithinBounds.  If you want to require
+    that the press and release are close together in both space and time,
+    set it to \l DragThreshold.
+
+    For multi-tap gestures (double-tap, triple-tap etc.), the distance moved
+    must not exceed QPlatformTheme::MouseDoubleClickDistance with mouse and
+    QPlatformTheme::TouchDoubleTapDistance with touch, and the time between
+    taps must not exceed QStyleHints::mouseDoubleClickInterval().
+
+    \sa MouseArea
+*/
+
+QQuickTapHandler::QQuickTapHandler(QObject *parent)
+    : QQuickPointerSingleHandler(parent)
+    , m_pressed(false)
+    , m_gesturePolicy(ReleaseWithinBounds)
+    , m_tapCount(0)
+    , m_longPressThreshold(-1)
+    , m_lastTapTimestamp(0.0)
+{
+    if (m_mouseMultiClickDistanceSquared < 0) {
+        m_multiTapInterval = qApp->styleHints()->mouseDoubleClickInterval() / 1000.0;
+        m_mouseMultiClickDistanceSquared = QGuiApplicationPrivate::platformTheme()->
+                    themeHint(QPlatformTheme::MouseDoubleClickDistance).toInt();
+        m_mouseMultiClickDistanceSquared *= m_mouseMultiClickDistanceSquared;
+        m_touchMultiTapDistanceSquared = QGuiApplicationPrivate::platformTheme()->
+                    themeHint(QPlatformTheme::TouchDoubleTapDistance).toInt();
+        m_touchMultiTapDistanceSquared *= m_touchMultiTapDistanceSquared;
+    }
+}
+
+QQuickTapHandler::~QQuickTapHandler()
+{
+}
+
+static bool dragOverThreshold(QQuickEventPoint *point)
+{
+    QPointF delta = point->scenePos() - point->scenePressPos();
+    return (QQuickWindowPrivate::dragOverThreshold(delta.x(), Qt::XAxis, point) ||
+            QQuickWindowPrivate::dragOverThreshold(delta.y(), Qt::YAxis, point));
+}
+
+bool QQuickTapHandler::wantsEventPoint(QQuickEventPoint *point)
+{
+    // If the user has not violated any constraint, it could be a tap.
+    // Otherwise we want to give up the grab so that a competing handler
+    // (e.g. DragHandler) gets a chance to take over.
+    // Don't forget to emit released in case of a cancel.
+    bool ret = false;
+    switch (point->state()) {
+    case QQuickEventPoint::Pressed:
+    case QQuickEventPoint::Released:
+        ret = parentContains(point);
+        break;
+    case QQuickEventPoint::Updated:
+        switch (m_gesturePolicy) {
+        case DragThreshold:
+            ret = !dragOverThreshold(point);
+            break;
+        case WithinBounds:
+            ret = parentContains(point);
+            break;
+        case ReleaseWithinBounds:
+            ret = point->pointId() == this->point().id();
+            break;
+        }
+        break;
+    case QQuickEventPoint::Stationary:
+        // Never react in any way when the point hasn't moved.
+        // In autotests, the point's position may not even be correct, because
+        // QTest::touchEvent(window, touchDevice).stationary(1)
+        // provides no opportunity to give a position, so it ends up being random.
+        break;
+    }
+    // If this is the grabber, returning false from this function will cancel the grab,
+    // so onGrabChanged(this, CancelGrabExclusive, point) and setPressed(false) will be called.
+    // But when m_gesturePolicy is DragThreshold, we don't get an exclusive grab, but
+    // we still don't want to be pressed anymore.
+    if (!ret && point->pointId() == this->point().id() && point->state() != QQuickEventPoint::Stationary)
+        setPressed(false, true, point);
+    return ret;
+}
+
+void QQuickTapHandler::handleEventPoint(QQuickEventPoint *point)
+{
+    switch (point->state()) {
+    case QQuickEventPoint::Pressed:
+        setPressed(true, false, point);
+        break;
+    case QQuickEventPoint::Released:
+        if ((point->pointerEvent()->buttons() & acceptedButtons()) == Qt::NoButton)
+            setPressed(false, false, point);
+        break;
+    default:
+        break;
+    }
+}
+
+/*!
+    \qmlproperty longPressThreshold
+
+    The time in seconds that an event point must be pressed in order to
+    trigger a long press gesture and emit the \l longPressed() signal.
+    If the point is released before this time limit, a tap can be detected
+    if the \l gesturePolicy constraint is satisfied. The default value is
+    QStyleHints::mousePressAndHoldInterval() converted to seconds.
+*/
+qreal QQuickTapHandler::longPressThreshold() const
+{
+    return longPressThresholdMilliseconds() / 1000.0;
+}
+
+void QQuickTapHandler::setLongPressThreshold(qreal longPressThreshold)
+{
+    int ms = qRound(longPressThreshold * 1000);
+    if (m_longPressThreshold == ms)
+        return;
+
+    m_longPressThreshold = ms;
+    emit longPressThresholdChanged();
+}
+
+int QQuickTapHandler::longPressThresholdMilliseconds() const
+{
+    return (m_longPressThreshold < 0 ? QGuiApplication::styleHints()->mousePressAndHoldInterval() : m_longPressThreshold);
+}
+
+void QQuickTapHandler::timerEvent(QTimerEvent *event)
+{
+    if (event->timerId() == m_longPressTimer.timerId()) {
+        m_longPressTimer.stop();
+        qCDebug(lcTapHandler) << objectName() << "longPressed";
+        emit longPressed();
+    }
+}
+
+/*!
+    \qmlproperty gesturePolicy
+
+    The spatial constraint for a tap or long press gesture to be recognized,
+    in addition to the constraint that the release must occur before
+    \l longPressThreshold has elapsed. If these constraints are not satisfied,
+    the \l tapped signal is not emitted, and \l tapCount is not incremented.
+    If the spatial constraint is violated, \l isPressed transitions immediately
+    from true to false, regardless of the time held.
+
+    \c DragThreshold means that the event point must not move significantly.
+    If the mouse, finger or stylus moves past the system-wide drag threshold
+    (QStyleHints::startDragDistance), the tap gesture is canceled, even if
+    the button or finger is still pressed. This policy can be useful whenever
+    TapHandler needs to cooperate with other pointer handlers (for example
+    \l DragHandler), because in this case TapHandler will never grab.
+
+    \c WithinBounds means that if the event point leaves the bounds of the
+    \l target item, the tap gesture is canceled. The TapHandler will grab on
+    press, but release the grab as soon as the boundary constraint is no
+    longer satisfied.
+
+    \c ReleaseWithinBounds (the default value) means that at the time of release
+    (the mouse button is released or the finger is lifted), if the event point
+    is outside the bounds of the \l target item, a tap gesture is not
+    recognized. This is the default value, because it corresponds to typical
+    button behavior: you can cancel a click by dragging outside the button, and
+    you can also change your mind by dragging back inside the button before
+    release. Note that it's necessary for TapHandler to grab on press and
+    retain it until release (greedy grab) in order to detect this gesture.
+*/
+void QQuickTapHandler::setGesturePolicy(QQuickTapHandler::GesturePolicy gesturePolicy)
+{
+    if (m_gesturePolicy == gesturePolicy)
+        return;
+
+    m_gesturePolicy = gesturePolicy;
+    emit gesturePolicyChanged();
+}
+
+/*!
+    \qmlproperty pressed
+
+    This property will be true whenever the mouse or touch point is pressed,
+    and any movement since the press is compliant with the current
+    \l gesturePolicy. When the event point is released or the policy is
+    violated, pressed will change to false.
+*/
+void QQuickTapHandler::setPressed(bool press, bool cancel, QQuickEventPoint *point)
+{
+    if (m_pressed != press) {
+        qCDebug(lcTapHandler) << objectName() << "pressed" << m_pressed << "->" << press << (cancel ? "CANCEL" : "") << point;
+        m_pressed = press;
+        connectPreRenderSignal(press);
+        updateTimeHeld();
+        if (press) {
+            m_longPressTimer.start(longPressThresholdMilliseconds(), this);
+            m_holdTimer.start();
+        } else {
+            m_longPressTimer.stop();
+            m_holdTimer.invalidate();
+        }
+        if (press) {
+            // on press, grab before emitting changed signals
+            if (m_gesturePolicy == DragThreshold)
+                setPassiveGrab(point, press);
+            else
+                setExclusiveGrab(point, press);
+        }
+        if (!cancel && !press && parentContains(point)) {
+            if (point->timeHeld() < longPressThreshold()) {
+                // Assuming here that pointerEvent()->timestamp() is in ms.
+                qreal ts = point->pointerEvent()->timestamp() / 1000.0;
+                if (ts - m_lastTapTimestamp < m_multiTapInterval &&
+                        QVector2D(point->scenePos() - m_lastTapPos).lengthSquared() <
+                        (point->pointerEvent()->device()->type() == QQuickPointerDevice::Mouse ?
+                         m_mouseMultiClickDistanceSquared : m_touchMultiTapDistanceSquared))
+                    ++m_tapCount;
+                else
+                    m_tapCount = 1;
+                qCDebug(lcTapHandler) << objectName() << "tapped" << m_tapCount << "times";
+                emit tapped(point);
+                emit tapCountChanged();
+                m_lastTapTimestamp = ts;
+                m_lastTapPos = point->scenePos();
+            } else {
+                qCDebug(lcTapHandler) << objectName() << "tap threshold" << longPressThreshold() << "exceeded:" << point->timeHeld();
+            }
+        }
+        emit pressedChanged();
+        if (!press && m_gesturePolicy != DragThreshold) {
+            // on release, ungrab after emitting changed signals
+            setExclusiveGrab(point, press);
+        }
+    }
+}
+
+void QQuickTapHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point)
+{
+    QQuickPointerSingleHandler::onGrabChanged(grabber, stateChange, point);
+    bool isCanceled = stateChange == QQuickEventPoint::CancelGrabExclusive || stateChange == QQuickEventPoint::CancelGrabPassive;
+    if (grabber == this && (isCanceled || point->state() == QQuickEventPoint::Released))
+        setPressed(false, isCanceled, point);
+}
+
+void QQuickTapHandler::connectPreRenderSignal(bool conn)
+{
+    if (conn)
+        connect(parentItem()->window(), &QQuickWindow::beforeSynchronizing, this, &QQuickTapHandler::updateTimeHeld);
+    else
+        disconnect(parentItem()->window(), &QQuickWindow::beforeSynchronizing, this, &QQuickTapHandler::updateTimeHeld);
+}
+
+void QQuickTapHandler::updateTimeHeld()
+{
+    emit timeHeldChanged();
+}
+
+/*!
+    \qmlproperty tapCount
+
+    The number of taps which have occurred within the time and space
+    constraints to be considered a single gesture.  For example, to detect
+    a double-tap, you can write
+
+    \qml
+    Rectangle {
+        width: 100; height: 30
+        signal doubleTap
+        TapHandler {
+            acceptedButtons: Qt.AllButtons
+            onTapped: if (tapCount == 2) doubleTap()
+        }
+    }
+*/
+
+/*!
+    \qmlproperty timeHeld
+
+    The amount of time in seconds that a pressed point has been held, without
+    moving beyond the drag threshold. It will be updated at least once per
+    frame rendered, which enables rendering an animation showing the progress
+    towards an action which will be triggered by a long-press. It is also
+    possible to trigger one of a series of actions depending on how long the
+    press is held.
+
+    A value less than zero means no point is being held within this handler's Item.
+*/
+
+QT_END_NAMESPACE
diff --git a/src/quick/handlers/qquicktaphandler_p.h b/src/quick/handlers/qquicktaphandler_p.h
new file mode 100644
index 0000000000..0e9a6f0411
--- /dev/null
+++ b/src/quick/handlers/qquicktaphandler_p.h
@@ -0,0 +1,132 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKTAPHANDLER_H
+#define QQUICKTAPHANDLER_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qquickitem.h"
+#include "qevent.h"
+#include "qquickpointersinglehandler_p.h"
+#include <QtCore/qbasictimer.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_AUTOTEST_EXPORT QQuickTapHandler : public QQuickPointerSingleHandler
+{
+    Q_OBJECT
+    Q_PROPERTY(bool isPressed READ isPressed NOTIFY pressedChanged)
+    Q_PROPERTY(int tapCount READ tapCount NOTIFY tapCountChanged)
+    Q_PROPERTY(qreal timeHeld READ timeHeld NOTIFY timeHeldChanged)
+    Q_PROPERTY(qreal longPressThreshold READ longPressThreshold WRITE setLongPressThreshold NOTIFY longPressThresholdChanged)
+    Q_PROPERTY(GesturePolicy gesturePolicy READ gesturePolicy WRITE setGesturePolicy NOTIFY gesturePolicyChanged)
+
+public:
+    enum GesturePolicy {
+        DragThreshold,
+        WithinBounds,
+        ReleaseWithinBounds
+    };
+    Q_ENUM(GesturePolicy)
+
+    explicit QQuickTapHandler(QObject *parent = 0);
+    ~QQuickTapHandler();
+
+    bool isPressed() const { return m_pressed; }
+
+    int tapCount() const { return m_tapCount; }
+    qreal timeHeld() const { return (m_holdTimer.isValid() ? m_holdTimer.elapsed() / 1000.0 : -1.0); }
+
+    qreal longPressThreshold() const;
+    void setLongPressThreshold(qreal longPressThreshold);
+
+    GesturePolicy gesturePolicy() const { return m_gesturePolicy; }
+    void setGesturePolicy(GesturePolicy gesturePolicy);
+
+Q_SIGNALS:
+    void pressedChanged();
+    void tapCountChanged();
+    void timeHeldChanged();
+    void longPressThresholdChanged();
+    void gesturePolicyChanged();
+    void tapped(QQuickEventPoint *point);
+    void longPressed();
+
+protected:
+    void onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point) override;
+    void timerEvent(QTimerEvent *event) override;
+    bool wantsEventPoint(QQuickEventPoint *point) override;
+    void handleEventPoint(QQuickEventPoint *point) override;
+
+private:
+    void setPressed(bool press, bool cancel, QQuickEventPoint *point);
+    int longPressThresholdMilliseconds() const;
+    void connectPreRenderSignal(bool conn = true);
+    void updateTimeHeld();
+
+private:
+    bool m_pressed;
+    GesturePolicy m_gesturePolicy;
+    int m_tapCount;
+    int m_longPressThreshold;
+    QBasicTimer m_longPressTimer;
+    QElapsedTimer m_holdTimer;
+    QPointF m_lastTapPos;
+    qreal m_lastTapTimestamp;
+
+    static qreal m_multiTapInterval;
+    static int m_mouseMultiClickDistanceSquared;
+    static int m_touchMultiTapDistanceSquared;
+};
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QQuickTapHandler)
+
+#endif // QQUICKTAPHANDLER_H
diff --git a/src/quick/items/qquickevents.cpp b/src/quick/items/qquickevents.cpp
index 448b63c347..1e0d268f93 100644
--- a/src/quick/items/qquickevents.cpp
+++ b/src/quick/items/qquickevents.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2017 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtQuick module of the Qt Toolkit.
@@ -38,8 +38,10 @@
 ****************************************************************************/
 
 #include "qquickevents_p_p.h"
+#include <QtCore/qmap.h>
 #include <QtGui/private/qguiapplication_p.h>
 #include <QtQuick/private/qquickitem_p.h>
+#include <QtQuick/private/qquickpointerhandler_p.h>
 #include <QtQuick/private/qquickwindow_p.h>
 #include <private/qdebug_p.h>
 
@@ -448,7 +450,15 @@ Item {
 typedef QHash<QTouchDevice *, QQuickPointerDevice *> PointerDeviceForTouchDeviceHash;
 Q_GLOBAL_STATIC(PointerDeviceForTouchDeviceHash, g_touchDevices)
 
-Q_GLOBAL_STATIC_WITH_ARGS(QQuickPointerDevice, g_genericMouseDevice,
+struct ConstructableQQuickPointerDevice : public QQuickPointerDevice
+{
+    ConstructableQQuickPointerDevice(DeviceType devType, PointerType pType, Capabilities caps,
+                              int maxPoints, int buttonCount, const QString &name,
+                              qint64 uniqueId = 0)
+        : QQuickPointerDevice(devType, pType, caps, maxPoints, buttonCount, name, uniqueId) {}
+
+};
+Q_GLOBAL_STATIC_WITH_ARGS(ConstructableQQuickPointerDevice, g_genericMouseDevice,
                             (QQuickPointerDevice::Mouse,
                              QQuickPointerDevice::GenericPointer,
                              QQuickPointerDevice::Position | QQuickPointerDevice::Scroll | QQuickPointerDevice::Hover,
@@ -457,6 +467,22 @@ Q_GLOBAL_STATIC_WITH_ARGS(QQuickPointerDevice, g_genericMouseDevice,
 typedef QHash<qint64, QQuickPointerDevice *> PointerDeviceForDeviceIdHash;
 Q_GLOBAL_STATIC(PointerDeviceForDeviceIdHash, g_tabletDevices)
 
+// debugging helpers
+static const char *pointStateString(const QQuickEventPoint *point)
+{
+    static const QMetaEnum stateMetaEnum = point->metaObject()->enumerator(point->metaObject()->indexOfEnumerator("State"));
+    return stateMetaEnum.valueToKey(point->state());
+}
+
+static const QString pointDeviceName(const QQuickEventPoint *point)
+{
+    auto device = static_cast<const QQuickPointerEvent *>(point->parent())->device();
+    QString deviceName = (device ? device->name() : QLatin1String("null device"));
+    deviceName.resize(16, ' '); // shorten, and align in case of sequential output
+    return deviceName;
+}
+
+
 QQuickPointerDevice *QQuickPointerDevice::touchDevice(QTouchDevice *d)
 {
     if (g_touchDevices->contains(d))
@@ -505,37 +531,241 @@ QQuickPointerDevice *QQuickPointerDevice::tabletDevice(qint64 id)
     return nullptr;
 }
 
-void QQuickEventPoint::reset(Qt::TouchPointState state, QPointF scenePos, quint64 pointId, ulong timestamp)
+void QQuickEventPoint::reset(Qt::TouchPointState state, const QPointF &scenePos, int pointId, ulong timestamp, const QVector2D &velocity)
 {
     m_scenePos = scenePos;
     m_pointId = pointId;
-    m_valid = true;
     m_accept = false;
     m_state = static_cast<QQuickEventPoint::State>(state);
     m_timestamp = timestamp;
-    if (state == Qt::TouchPointPressed)
+    if (state == Qt::TouchPointPressed) {
         m_pressTimestamp = timestamp;
-    // TODO calculate velocity
+        m_scenePressPos = scenePos;
+    }
+    m_velocity = (Q_LIKELY(velocity.isNull()) ? estimatedVelocity() : velocity);
+}
+
+void QQuickEventPoint::localizePosition(QQuickItem *target)
+{
+    if (target)
+        m_pos = target->mapFromScene(scenePos());
+    else
+        m_pos = QPointF();
+}
+
+/*!
+    If this point has an exclusive grabber, returns a pointer to it; else
+    returns null, if there is no grabber.  The grabber could be either
+    an Item or a PointerHandler.
+*/
+QObject *QQuickEventPoint::exclusiveGrabber() const
+{
+    return m_exclusiveGrabber.data();
+}
+
+/*!
+    Set the given Item or PointerHandler as the exclusive grabber of this point.
+    If there was already an exclusive grab, it will be canceled.  If there
+    were passive grabbers, they will continue to lurk, but the exclusive grab
+    is a behavioral override of the passive grab as long as it remains.
+    If you already know whether the grabber is to be an Item or a PointerHandler,
+    you should instead call setGrabberItem() or setGrabberPointerHandler(),
+    because it is slightly more efficient.
+*/
+void QQuickEventPoint::setExclusiveGrabber(QObject *grabber)
+{
+    if (QQuickPointerHandler *phGrabber = qmlobject_cast<QQuickPointerHandler *>(grabber))
+        setGrabberPointerHandler(phGrabber, true);
+    else
+        setGrabberItem(static_cast<QQuickItem *>(grabber));
+}
+
+/*!
+    If the exclusive grabber of this point is an Item, returns a
+    pointer to that Item; else returns null, if there is no grabber or if
+    the grabber is a PointerHandler.
+*/
+QQuickItem *QQuickEventPoint::grabberItem() const
+{
+    return (m_grabberIsHandler ? nullptr : static_cast<QQuickItem *>(m_exclusiveGrabber.data()));
+}
+
+/*!
+    Set the given Item \a grabber as the exclusive grabber of this point.
+    If there was already an exclusive grab, it will be canceled.  If there
+    were passive grabbers, they will continue to lurk, but the exclusive grab
+    is a behavioral override of the passive grab as long as it remains.
+*/
+void QQuickEventPoint::setGrabberItem(QQuickItem *grabber)
+{
+    if (grabber != m_exclusiveGrabber.data()) {
+        if (Q_UNLIKELY(lcPointerGrab().isDebugEnabled())) {
+            qCDebug(lcPointerGrab) << pointDeviceName(this) << "point" << hex << m_pointId << pointStateString(this)
+                                   << ": grab" << m_exclusiveGrabber << "->" << grabber;
+        }
+        QQuickPointerHandler *oldGrabberHandler = grabberPointerHandler();
+        QQuickItem *oldGrabberItem = grabberItem();
+        m_exclusiveGrabber = QPointer<QObject>(grabber);
+        m_grabberIsHandler = false;
+        m_sceneGrabPos = m_scenePos;
+        if (oldGrabberHandler)
+            oldGrabberHandler->onGrabChanged(oldGrabberHandler, CancelGrabExclusive, this);
+        else if (oldGrabberItem && oldGrabberItem != grabber && grabber && pointerEvent()->asPointerTouchEvent())
+            oldGrabberItem->touchUngrabEvent();
+        for (QPointer<QQuickPointerHandler> passiveGrabber : m_passiveGrabbers)
+            passiveGrabber->onGrabChanged(passiveGrabber, OverrideGrabPassive, this);
+    }
+}
+
+/*!
+    If the exclusive grabber of this point is a PointerHandler, returns a
+    pointer to that handler; else returns null, if there is no grabber or if
+    the grabber is an Item.
+*/
+QQuickPointerHandler *QQuickEventPoint::grabberPointerHandler() const
+{
+    return (m_grabberIsHandler ? static_cast<QQuickPointerHandler *>(m_exclusiveGrabber.data()) : nullptr);
+}
+
+/*!
+    Set the given PointerHandler \a grabber as grabber of this point. If \a
+    exclusive is true, it will override any other grabs; if false, \a grabber
+    will be added to the list of passive grabbers of this point.
+*/
+void QQuickEventPoint::setGrabberPointerHandler(QQuickPointerHandler *grabber, bool exclusive)
+{
+    if (Q_UNLIKELY(lcPointerGrab().isDebugEnabled())) {
+        if (exclusive) {
+            if (m_exclusiveGrabber != grabber)
+                qCDebug(lcPointerGrab) << pointDeviceName(this) << "point" << hex << m_pointId << pointStateString(this)
+                                       << ": grab (exclusive)" << m_exclusiveGrabber << "->" << grabber;
+        } else {
+            qCDebug(lcPointerGrab) << pointDeviceName(this) << "point" << hex << m_pointId << pointStateString(this)
+                                   << ": grab (passive)" << grabber;
+        }
+    }
+    if (exclusive) {
+        if (grabber != m_exclusiveGrabber.data()) {
+            if (grabber) {
+                // set variables before notifying the new grabber
+                m_exclusiveGrabber = QPointer<QObject>(grabber);
+                m_grabberIsHandler = true;
+                m_sceneGrabPos = m_scenePos;
+                grabber->onGrabChanged(grabber, GrabExclusive, this);
+                for (QPointer<QQuickPointerHandler> passiveGrabber : m_passiveGrabbers) {
+                    if (passiveGrabber != grabber)
+                        passiveGrabber->onGrabChanged(grabber, OverrideGrabPassive, this);
+                }
+            } else if (QQuickPointerHandler *oldGrabberPointerHandler = qmlobject_cast<QQuickPointerHandler *>(m_exclusiveGrabber.data())) {
+                oldGrabberPointerHandler->onGrabChanged(oldGrabberPointerHandler, UngrabExclusive, this);
+            } else if (!m_exclusiveGrabber.isNull()) {
+                // If there is a previous grabber and it's not a PointerHandler, it must be an Item.
+                QQuickItem *oldGrabberItem = static_cast<QQuickItem *>(m_exclusiveGrabber.data());
+                // If this point came from a touchscreen, notify that previous grabber Item that it's losing its touch grab.
+                if (pointerEvent()->asPointerTouchEvent())
+                    oldGrabberItem->touchUngrabEvent();
+            }
+            // set variables after notifying the old grabber
+            m_exclusiveGrabber = QPointer<QObject>(grabber);
+            m_grabberIsHandler = true;
+            m_sceneGrabPos = m_scenePos;
+        }
+    } else {
+        if (!grabber) {
+            qDebug() << "can't set passive grabber to null";
+            return;
+        }
+        auto ptr = QPointer<QQuickPointerHandler>(grabber);
+        if (!m_passiveGrabbers.contains(ptr)) {
+            m_passiveGrabbers.append(ptr);
+            grabber->onGrabChanged(grabber, GrabPassive, this);
+        }
+    }
+}
+
+/*!
+    If this point has an existing exclusive grabber (Item or PointerHandler),
+    inform the grabber that its grab is canceled, and remove it as grabber.
+    This normally happens when the grab is stolen by another Item.
+*/
+void QQuickEventPoint::cancelExclusiveGrab()
+{
+    if (m_exclusiveGrabber.isNull())
+        qWarning("cancelGrab: no grabber");
+    else
+        cancelExclusiveGrabImpl();
+}
+
+void QQuickEventPoint::cancelExclusiveGrabImpl(QTouchEvent *cancelEvent)
+{
+    if (m_exclusiveGrabber.isNull())
+        return;
+    if (Q_UNLIKELY(lcPointerGrab().isDebugEnabled())) {
+        qCDebug(lcPointerGrab) << pointDeviceName(this) << "point" << hex << m_pointId << pointStateString(this)
+                               << ": grab (exclusive)" << m_exclusiveGrabber << "-> nullptr";
+    }
+    if (auto handler = grabberPointerHandler()) {
+        handler->onGrabChanged(handler, CancelGrabExclusive, this);
+    } else if (auto item = grabberItem()) {
+        if (cancelEvent)
+            QCoreApplication::sendEvent(item, cancelEvent);
+        else
+            item->touchUngrabEvent();
+    }
+    m_exclusiveGrabber.clear();
+}
+
+/*!
+    If this point has the given \a handler as a passive grabber,
+    inform the grabber that its grab is canceled, and remove it as grabber.
+    This normally happens when another Item or PointerHandler does an exclusive grab.
+*/
+void QQuickEventPoint::cancelPassiveGrab(QQuickPointerHandler *handler)
+{
+    if (removePassiveGrabber(handler)) {
+        if (Q_UNLIKELY(lcPointerGrab().isDebugEnabled())) {
+            qCDebug(lcPointerGrab) << pointDeviceName(this) << "point" << hex << m_pointId << pointStateString(this)
+                                   << ": grab (passive)" << handler << "removed";
+        }
+        handler->onGrabChanged(handler, CancelGrabPassive, this);
+    }
 }
 
-QQuickItem *QQuickEventPoint::grabber() const
+/*!
+    If this point has the given \a handler as a passive grabber, remove it as grabber.
+    Returns true if it was removed, false if it wasn't a grabber.
+*/
+bool QQuickEventPoint::removePassiveGrabber(QQuickPointerHandler *handler)
 {
-    return m_grabber.data();
+    return m_passiveGrabbers.removeOne(handler);
 }
 
-void QQuickEventPoint::setGrabber(QQuickItem *grabber)
+/*!
+    If the given \a handler is grabbing this point passively, exclusively
+    or both, cancel the grab and remove it as grabber.
+    This normally happens when the handler decides that the behavior of this
+    point can no longer satisfy the handler's behavioral constraints within
+    the remainder of the gesture which the user is performing: for example
+    the handler tries to detect a tap but a drag is occurring instead, or
+    it tries to detect a drag in one direction but the drag is going in
+    another direction.  In such cases the handler no longer needs or wants
+    to be informed of any further movements of this point.
+*/
+void QQuickEventPoint::cancelAllGrabs(QQuickPointerHandler *handler)
 {
-    if (Q_UNLIKELY(lcPointerGrab().isDebugEnabled()) && m_grabber.data() != grabber) {
-        auto device = static_cast<const QQuickPointerEvent *>(parent())->device();
-        static const QMetaEnum stateMetaEnum = metaObject()->enumerator(metaObject()->indexOfEnumerator("State"));
-        QString deviceName = (device ? device->name() : QLatin1String("null device"));
-        deviceName.resize(16, ' '); // shorten, and align in case of sequential output
-        qCDebug(lcPointerGrab) << deviceName << "point" << hex << m_pointId << stateMetaEnum.valueToKey(state())
-                               << ": grab" << m_grabber << "->" << grabber;
+    if (m_exclusiveGrabber == handler) {
+        handler->onGrabChanged(handler, CancelGrabExclusive, this);
+        m_exclusiveGrabber.clear();
     }
-    m_grabber = QPointer<QQuickItem>(grabber);
+    cancelPassiveGrab(handler);
 }
 
+/*!
+    Set this point as \a accepted (true) or rejected (false).
+    Accepting a point is intended to stop event propagation.
+    It does not imply any kind of grab, passive or exclusive.
+    TODO explain further under what conditions propagation really does stop...
+*/
 void QQuickEventPoint::setAccepted(bool accepted)
 {
     if (m_accept != accepted) {
@@ -550,12 +780,74 @@ QQuickEventTouchPoint::QQuickEventTouchPoint(QQuickPointerTouchEvent *parent)
 
 void QQuickEventTouchPoint::reset(const QTouchEvent::TouchPoint &tp, ulong timestamp)
 {
-    QQuickEventPoint::reset(tp.state(), tp.scenePos(), tp.id(), timestamp);
+    QQuickEventPoint::reset(tp.state(), tp.scenePos(), tp.id(), timestamp, tp.velocity());
+    m_exclusiveGrabber.clear();
+    m_passiveGrabbers.clear();
     m_rotation = tp.rotation();
     m_pressure = tp.pressure();
+    m_ellipseDiameters = tp.ellipseDiameters();
     m_uniqueId = tp.uniqueId();
 }
 
+struct PointVelocityData {
+    QVector2D velocity;
+    QPointF pos;
+    ulong timestamp;
+};
+
+typedef QMap<quint64, PointVelocityData*> PointDataForPointIdMap;
+Q_GLOBAL_STATIC(PointDataForPointIdMap, g_previousPointData)
+static const int PointVelocityAgeLimit = 500; // milliseconds
+
+/*!
+    \internal
+    Estimates the velocity based on a weighted average of all previous velocities.
+    The older the velocity is, the less significant it becomes for the estimate.
+*/
+QVector2D QQuickEventPoint::estimatedVelocity() const
+{
+    PointVelocityData *prevPoint = g_previousPointData->value(m_pointId);
+    if (!prevPoint) {
+        // cleanup events older than PointVelocityAgeLimit
+        auto end = g_previousPointData->end();
+        for (auto it = g_previousPointData->begin(); it != end; ) {
+            PointVelocityData *data = it.value();
+            if (m_timestamp - data->timestamp > PointVelocityAgeLimit) {
+                it = g_previousPointData->erase(it);
+                delete data;
+            } else {
+                ++it;
+            }
+        }
+        // TODO optimize: stop this dynamic memory thrashing
+        prevPoint = new PointVelocityData;
+        prevPoint->velocity = QVector2D();
+        prevPoint->timestamp = 0;
+        prevPoint->pos = QPointF();
+        g_previousPointData->insert(m_pointId, prevPoint);
+    }
+    if (prevPoint) {
+        const ulong timeElapsed = m_timestamp - prevPoint->timestamp;
+        if (timeElapsed == 0)   // in case we call estimatedVelocity() twice on the same QQuickEventPoint
+            return m_velocity;
+
+        QVector2D newVelocity;
+        if (prevPoint->timestamp != 0)
+            newVelocity = QVector2D(m_scenePos - prevPoint->pos)/timeElapsed;
+
+        // VERY simple kalman filter: does a weighted average
+        // where the older velocities get less and less significant
+        static const float KalmanGain = 0.7f;
+        QVector2D filteredVelocity = newVelocity * KalmanGain + m_velocity * (1.0f - KalmanGain);
+
+        prevPoint->velocity = filteredVelocity;
+        prevPoint->pos = m_scenePos;
+        prevPoint->timestamp = m_timestamp;
+        return filteredVelocity;
+    }
+    return QVector2D();
+}
+
 /*!
     \internal
     \class QQuickPointerEvent
@@ -581,11 +873,14 @@ QQuickPointerEvent *QQuickPointerMouseEvent::reset(QEvent *event)
         return this;
 
     m_device = QQuickPointerDevice::genericMouseDevice();
+    m_device->eventDeliveryTargets().clear();
     m_button = ev->button();
     m_pressedButtons = ev->buttons();
     Qt::TouchPointState state = Qt::TouchPointStationary;
     switch (ev->type()) {
     case QEvent::MouseButtonPress:
+        m_mousePoint->clearPassiveGrabbers();
+        Q_FALLTHROUGH();
     case QEvent::MouseButtonDblClick:
         state = Qt::TouchPointPressed;
         break;
@@ -598,10 +893,15 @@ QQuickPointerEvent *QQuickPointerMouseEvent::reset(QEvent *event)
     default:
         break;
     }
-    m_mousePoint->reset(state, ev->windowPos(), 0, ev->timestamp());  // mouse is 0
+    m_mousePoint->reset(state, ev->windowPos(), quint64(1) << 24, ev->timestamp());  // mouse has device ID 1
     return this;
 }
 
+void QQuickPointerMouseEvent::localize(QQuickItem *target)
+{
+    m_mousePoint->localizePosition(target);
+}
+
 QQuickPointerEvent *QQuickPointerTouchEvent::reset(QEvent *event)
 {
     auto ev = static_cast<QTouchEvent*>(event);
@@ -610,6 +910,7 @@ QQuickPointerEvent *QQuickPointerTouchEvent::reset(QEvent *event)
         return this;
 
     m_device = QQuickPointerDevice::touchDevice(ev->device());
+    m_device->eventDeliveryTargets().clear();
     m_button = Qt::NoButton;
     m_pressedButtons = Qt::NoButton;
 
@@ -620,32 +921,63 @@ QQuickPointerEvent *QQuickPointerTouchEvent::reset(QEvent *event)
     for (int i = m_touchPoints.size(); i < newPointCount; ++i)
         m_touchPoints.insert(i, new QQuickEventTouchPoint(this));
 
-    // Make sure the grabbers are right from one event to the next
-    QVector<QQuickItem*> grabbers;
-    // Copy all grabbers, because the order of points might have changed in the event.
+    // Make sure the grabbers and on-pressed values are right from one event to the next
+    struct ToPreserve {
+        int pointId; // just for double-checking
+        ulong pressTimestamp;
+        QPointF scenePressPos;
+        QPointF sceneGrabPos;
+        QObject * grabber;
+        QVector <QPointer <QQuickPointerHandler> > passiveGrabbers;
+
+        ToPreserve() : pointId(0), pressTimestamp(0), grabber(nullptr) {}
+    };
+    QVector<ToPreserve> preserves(newPointCount); // jar of pickled touchpoints, in order of points in the _new_ event
+
+    // Copy stuff we need to preserve, because the order of points might have changed in the event.
     // The ID is all that we can rely on (release might remove the first point etc).
     for (int i = 0; i < newPointCount; ++i) {
-        QQuickItem *grabber = nullptr;
-        if (auto point = pointById(tps.at(i).id()))
-            grabber = point->grabber();
-        grabbers.append(grabber);
+        int pid = tps.at(i).id();
+        if (auto point = pointById(pid)) {
+            preserves[i].pointId = pid;
+            preserves[i].pressTimestamp = point->m_pressTimestamp;
+            preserves[i].scenePressPos = point->scenePressPos();
+            preserves[i].sceneGrabPos = point->sceneGrabPos();
+            preserves[i].grabber = point->exclusiveGrabber();
+            preserves[i].passiveGrabbers = point->passiveGrabbers();
+        }
     }
 
     for (int i = 0; i < newPointCount; ++i) {
         auto point = m_touchPoints.at(i);
         point->reset(tps.at(i), ev->timestamp());
+        const auto &preserved = preserves.at(i);
         if (point->state() == QQuickEventPoint::Pressed) {
-            if (grabbers.at(i))
+            if (preserved.grabber)
                 qWarning() << "TouchPointPressed without previous release event" << point;
-            point->setGrabber(nullptr);
+            point->setGrabberItem(nullptr);
+            point->clearPassiveGrabbers();
         } else {
-            point->setGrabber(grabbers.at(i));
+            // Restore the grabbers without notifying (don't call onGrabChanged)
+            Q_ASSERT(preserved.pointId == 0 || preserved.pointId == point->pointId());
+            point->m_pressTimestamp = preserved.pressTimestamp;
+            point->m_scenePressPos = preserved.scenePressPos;
+            point->m_sceneGrabPos = preserved.sceneGrabPos;
+            point->m_exclusiveGrabber = preserved.grabber;
+            point->m_grabberIsHandler = (qmlobject_cast<QQuickPointerHandler *>(point->m_exclusiveGrabber) != nullptr);
+            point->m_passiveGrabbers = preserved.passiveGrabbers;
         }
     }
     m_pointCount = newPointCount;
     return this;
 }
 
+void QQuickPointerTouchEvent::localize(QQuickItem *target)
+{
+    for (auto point : qAsConst(m_touchPoints))
+        point->localizePosition(target);
+}
+
 QQuickEventPoint *QQuickPointerMouseEvent::point(int i) const {
     if (i == 0)
         return m_mousePoint;
@@ -659,8 +991,8 @@ QQuickEventPoint *QQuickPointerTouchEvent::point(int i) const {
 }
 
 QQuickEventPoint::QQuickEventPoint(QQuickPointerEvent *parent)
-  : QObject(parent), m_pointId(0), m_grabber(nullptr), m_timestamp(0), m_pressTimestamp(0),
-    m_state(QQuickEventPoint::Released), m_valid(false), m_accept(false)
+  : QObject(parent), m_pointId(0), m_exclusiveGrabber(nullptr), m_timestamp(0), m_pressTimestamp(0),
+    m_state(QQuickEventPoint::Released), m_accept(false), m_grabberIsHandler(false)
 {
     Q_UNUSED(m_reserved);
 }
@@ -674,6 +1006,15 @@ bool QQuickPointerMouseEvent::allPointsAccepted() const {
     return m_mousePoint->isAccepted();
 }
 
+bool QQuickPointerMouseEvent::allUpdatedPointsAccepted() const {
+    return m_mousePoint->state() == QQuickEventPoint::Pressed || m_mousePoint->isAccepted();
+}
+
+bool QQuickPointerMouseEvent::allPointsGrabbed() const
+{
+    return m_mousePoint->exclusiveGrabber() != nullptr;
+}
+
 QMouseEvent *QQuickPointerMouseEvent::asMouseEvent(const QPointF &localPos) const
 {
     auto event = static_cast<QMouseEvent *>(m_event);
@@ -681,16 +1022,31 @@ QMouseEvent *QQuickPointerMouseEvent::asMouseEvent(const QPointF &localPos) cons
     return event;
 }
 
-QVector<QQuickItem *> QQuickPointerMouseEvent::grabbers() const
+/*!
+    Returns the exclusive grabber of this event, if any, in a vector.
+*/
+QVector<QObject *> QQuickPointerMouseEvent::exclusiveGrabbers() const
 {
-    QVector<QQuickItem *> result;
-    if (QQuickItem *grabber = m_mousePoint->grabber())
+    QVector<QObject *> result;
+    if (QObject *grabber = m_mousePoint->exclusiveGrabber())
         result << grabber;
     return result;
 }
 
+/*!
+    Remove all passive and exclusive grabbers of this event, without notifying.
+*/
 void QQuickPointerMouseEvent::clearGrabbers() const {
-    m_mousePoint->setGrabber(nullptr);
+    m_mousePoint->setGrabberItem(nullptr);
+    m_mousePoint->clearPassiveGrabbers();
+}
+
+/*!
+    Returns whether the given \a handler is the exclusive grabber of this event.
+*/
+bool QQuickPointerMouseEvent::hasExclusiveGrabber(const QQuickPointerHandler *handler) const
+{
+    return m_mousePoint->exclusiveGrabber() == handler;
 }
 
 bool QQuickPointerMouseEvent::isPressEvent() const
@@ -700,6 +1056,24 @@ bool QQuickPointerMouseEvent::isPressEvent() const
             (me->buttons() & me->button()) == me->buttons());
 }
 
+bool QQuickPointerMouseEvent::isDoubleClickEvent() const
+{
+    auto me = static_cast<QMouseEvent*>(m_event);
+    return (me->type() == QEvent::MouseButtonDblClick);
+}
+
+bool QQuickPointerMouseEvent::isUpdateEvent() const
+{
+    auto me = static_cast<QMouseEvent*>(m_event);
+    return me->type() == QEvent::MouseMove;
+}
+
+bool QQuickPointerMouseEvent::isReleaseEvent() const
+{
+    auto me = static_cast<QMouseEvent*>(m_event);
+    return me->type() == QEvent::MouseButtonRelease;
+}
+
 bool QQuickPointerTouchEvent::allPointsAccepted() const {
     for (int i = 0; i < m_pointCount; ++i) {
         if (!m_touchPoints.at(i)->isAccepted())
@@ -708,12 +1082,32 @@ bool QQuickPointerTouchEvent::allPointsAccepted() const {
     return true;
 }
 
-QVector<QQuickItem *> QQuickPointerTouchEvent::grabbers() const
-{
-    QVector<QQuickItem *> result;
+bool QQuickPointerTouchEvent::allUpdatedPointsAccepted() const {
     for (int i = 0; i < m_pointCount; ++i) {
         auto point = m_touchPoints.at(i);
-        if (QQuickItem *grabber = point->grabber()) {
+        if (point->state() != QQuickEventPoint::Pressed && !point->isAccepted())
+            return false;
+    }
+    return true;
+}
+
+bool QQuickPointerTouchEvent::allPointsGrabbed() const
+{
+    for (int i = 0; i < m_pointCount; ++i) {
+        if (!m_touchPoints.at(i)->exclusiveGrabber())
+            return false;
+    }
+    return true;
+}
+
+/*!
+    Returns the exclusive grabbers of all points in this event, if any, in a vector.
+*/
+QVector<QObject *> QQuickPointerTouchEvent::exclusiveGrabbers() const
+{
+    QVector<QObject *> result;
+    for (int i = 0; i < m_pointCount; ++i) {
+        if (QObject *grabber = m_touchPoints.at(i)->exclusiveGrabber()) {
             if (!result.contains(grabber))
                 result << grabber;
         }
@@ -721,9 +1115,27 @@ QVector<QQuickItem *> QQuickPointerTouchEvent::grabbers() const
     return result;
 }
 
+/*!
+    Remove all passive and exclusive grabbers of all touchpoints in this event,
+    without notifying.
+*/
 void QQuickPointerTouchEvent::clearGrabbers() const {
+    for (auto point: m_touchPoints) {
+        point->setGrabberItem(nullptr);
+        point->clearPassiveGrabbers();
+    }
+}
+
+/*!
+    Returns whether the given \a handler is the exclusive grabber of any
+    touchpoint within this event.
+*/
+bool QQuickPointerTouchEvent::hasExclusiveGrabber(const QQuickPointerHandler *handler) const
+{
     for (auto point: m_touchPoints)
-        point->setGrabber(nullptr);
+        if (point->exclusiveGrabber() == handler)
+            return true;
+    return false;
 }
 
 bool QQuickPointerTouchEvent::isPressEvent() const
@@ -731,6 +1143,16 @@ bool QQuickPointerTouchEvent::isPressEvent() const
     return static_cast<QTouchEvent*>(m_event)->touchPointStates() & Qt::TouchPointPressed;
 }
 
+bool QQuickPointerTouchEvent::isUpdateEvent() const
+{
+    return static_cast<QTouchEvent*>(m_event)->touchPointStates() & (Qt::TouchPointMoved | Qt::TouchPointStationary);
+}
+
+bool QQuickPointerTouchEvent::isReleaseEvent() const
+{
+    return static_cast<QTouchEvent*>(m_event)->touchPointStates() & Qt::TouchPointReleased;
+}
+
 QVector<QPointF> QQuickPointerEvent::unacceptedPressedPointScenePositions() const
 {
     QVector<QPointF> points;
@@ -793,15 +1215,15 @@ QMouseEvent *QQuickPointerTouchEvent::syntheticMouseEvent(int pointID, QQuickIte
     \l {QQuickEventPoint::pointId}{pointId}.
     Returns nullptr if there is no point with that ID.
 
-    \fn QQuickPointerEvent::pointById(quint64 pointId) const
+    \fn QQuickPointerEvent::pointById(int pointId) const
 */
-QQuickEventPoint *QQuickPointerMouseEvent::pointById(quint64 pointId) const {
+QQuickEventPoint *QQuickPointerMouseEvent::pointById(int pointId) const {
     if (m_mousePoint && pointId == m_mousePoint->pointId())
         return m_mousePoint;
     return nullptr;
 }
 
-QQuickEventPoint *QQuickPointerTouchEvent::pointById(quint64 pointId) const {
+QQuickEventPoint *QQuickPointerTouchEvent::pointById(int pointId) const {
     auto it = std::find_if(m_touchPoints.constBegin(), m_touchPoints.constEnd(),
         [pointId](const QQuickEventTouchPoint *tp) { return tp->pointId() == pointId; } );
     if (it != m_touchPoints.constEnd())
@@ -831,7 +1253,12 @@ const QTouchEvent::TouchPoint *QQuickPointerTouchEvent::touchPointById(int point
     \internal
     Make a new QTouchEvent, giving it a subset of the original touch points.
 
-    Returns a nullptr if all points are stationary or there are no points inside the item.
+    Returns a nullptr if all points are stationary, or there are no points inside the item,
+    or none of the points were pressed inside and the item was not grabbing any of them
+    and isFiltering is false.  When isFiltering is true, it is assumed that the item
+    cares about all points which are inside its bounds, because most filtering items
+    need to monitor eventpoint movements until a drag threshold is exceeded or the
+    requirements for a gesture to be recognized are met in some other way.
 */
 QTouchEvent *QQuickPointerTouchEvent::touchEventForItem(QQuickItem *item, bool isFiltering) const
 {
@@ -841,19 +1268,24 @@ QTouchEvent *QQuickPointerTouchEvent::touchEventForItem(QQuickItem *item, bool i
     // Or else just document that velocity is always scene-relative and is not scaled and rotated with the item
     // but that would require changing tst_qquickwindow::touchEvent_velocity(): it expects transformed velocity
 
+    bool anyPressOrReleaseInside = false;
+    bool anyGrabber = false;
     QMatrix4x4 transformMatrix(QQuickItemPrivate::get(item)->windowToItemTransform());
     for (int i = 0; i < m_pointCount; ++i) {
         auto p = m_touchPoints.at(i);
         if (p->isAccepted())
             continue;
         // include points where item is the grabber
-        bool isGrabber = p->grabber() == item;
-        // include newly pressed points inside the bounds
-        bool isPressInside = p->state() == QQuickEventPoint::Pressed && item->contains(item->mapFromScene(p->scenePos()));
+        bool isGrabber = p->exclusiveGrabber() == item;
+        if (isGrabber)
+            anyGrabber = true;
+        // include points inside the bounds if no other item is the grabber or if the item is filtering
+        bool isInside = item->contains(item->mapFromScene(p->scenePos()));
+        bool hasAnotherGrabber = p->exclusiveGrabber() && p->exclusiveGrabber() != item;
 
         // filtering: (childMouseEventFilter) include points that are grabbed by children of the target item
         bool grabberIsChild = false;
-        auto parent = p->grabber();
+        auto parent = p->grabberItem();
         while (isFiltering && parent) {
             if (parent == item) {
                 grabberIsChild = true;
@@ -862,11 +1294,11 @@ QTouchEvent *QQuickPointerTouchEvent::touchEventForItem(QQuickItem *item, bool i
             parent = parent->parentItem();
         }
 
-        // when filtering, send points that are grabbed by a child and points that are not grabbed but inside
-        bool filterRelevant = isFiltering && (grabberIsChild || (!p->grabber() && item->contains(item->mapFromScene(p->scenePos()))));
-        if (!(isGrabber || isPressInside || filterRelevant))
+        bool filterRelevant = isFiltering && grabberIsChild;
+        if (!(isGrabber || (isInside && (!hasAnotherGrabber || isFiltering)) || filterRelevant))
             continue;
-
+        if ((p->state() == QQuickEventPoint::Pressed || p->state() == QQuickEventPoint::Released) && isInside)
+            anyPressOrReleaseInside = true;
         const QTouchEvent::TouchPoint *tp = touchPointById(p->pointId());
         if (tp) {
             eventStates |= tp->state();
@@ -880,7 +1312,9 @@ QTouchEvent *QQuickPointerTouchEvent::touchEventForItem(QQuickItem *item, bool i
         }
     }
 
-    if (eventStates == Qt::TouchPointStationary || touchPoints.isEmpty())
+    // Now touchPoints will have only points which are inside the item.
+    // But if none of them were just pressed inside, and the item has no other reason to care, ignore them anyway.
+    if (eventStates == Qt::TouchPointStationary || touchPoints.isEmpty() || (!anyPressOrReleaseInside && !anyGrabber && !isFiltering))
         return nullptr;
 
     // if all points have the same state, set the event type accordingly
@@ -942,7 +1376,12 @@ Q_QUICK_PRIVATE_EXPORT QDebug operator<<(QDebug dbg, const QQuickPointerDevice *
 Q_QUICK_PRIVATE_EXPORT QDebug operator<<(QDebug dbg, const QQuickPointerEvent *event) {
     QDebugStateSaver saver(dbg);
     dbg.nospace();
-    dbg << "QQuickPointerEvent(dev:";
+    dbg << "QQuickPointerEvent(";
+    if (event->isValid())
+        dbg << event->timestamp();
+    else
+        dbg << "invalid";
+    dbg << " dev:";
     QtDebugUtils::formatQEnum(dbg, event->device()->type());
     if (event->buttons() != Qt::NoButton) {
         dbg << " buttons:";
@@ -959,7 +1398,7 @@ Q_QUICK_PRIVATE_EXPORT QDebug operator<<(QDebug dbg, const QQuickPointerEvent *e
 Q_QUICK_PRIVATE_EXPORT QDebug operator<<(QDebug dbg, const QQuickEventPoint *event) {
     QDebugStateSaver saver(dbg);
     dbg.nospace();
-    dbg << "QQuickEventPoint(valid:" << event->isValid() << " accepted:" << event->isAccepted()
+    dbg << "QQuickEventPoint(accepted:" << event->isAccepted()
         << " state:";
     QtDebugUtils::formatQEnum(dbg, event->state());
     dbg << " scenePos:" << event->scenePos() << " id:" << hex << event->pointId() << dec
diff --git a/src/quick/items/qquickevents_p_p.h b/src/quick/items/qquickevents_p_p.h
index 3735d68a85..0d6e06ac41 100644
--- a/src/quick/items/qquickevents_p_p.h
+++ b/src/quick/items/qquickevents_p_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2017 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtQuick module of the Qt Toolkit.
@@ -68,6 +68,7 @@ class QQuickPointerEvent;
 class QQuickPointerMouseEvent;
 class QQuickPointerTabletEvent;
 class QQuickPointerTouchEvent;
+class QQuickPointerHandler;
 
 class QQuickKeyEvent : public QObject
 {
@@ -251,12 +252,17 @@ private:
 class Q_QUICK_PRIVATE_EXPORT QQuickEventPoint : public QObject
 {
     Q_OBJECT
+    Q_PROPERTY(QQuickPointerEvent *event READ pointerEvent)
+    Q_PROPERTY(QPointF pos READ pos)
     Q_PROPERTY(QPointF scenePos READ scenePos)
+    Q_PROPERTY(QPointF scenePressPos READ scenePressPos)
+    Q_PROPERTY(QPointF sceneGrabPos READ sceneGrabPos)
     Q_PROPERTY(State state READ state)
-    Q_PROPERTY(quint64 pointId READ pointId)
+    Q_PROPERTY(int pointId READ pointId)
     Q_PROPERTY(qreal timeHeld READ timeHeld)
+    Q_PROPERTY(QVector2D velocity READ velocity)
     Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted)
-    Q_PROPERTY(QQuickItem *grabber READ grabber WRITE setGrabber)
+    Q_PROPERTY(QObject *exclusiveGrabber READ exclusiveGrabber WRITE setExclusiveGrabber)
 
 public:
     enum State {
@@ -266,35 +272,79 @@ public:
         Released    = Qt::TouchPointReleased
         // Canceled    = Qt::TouchPointReleased << 1 // 0x10 // TODO maybe
     };
-    Q_ENUM(State)
+    Q_DECLARE_FLAGS(States, State)
+    Q_FLAG(States)
+
+    enum GrabState {
+        GrabPassive = 0x01,
+        UngrabPassive = 0x02,
+        CancelGrabPassive = 0x03,
+        OverrideGrabPassive = 0x04,
+        GrabExclusive = 0x10,
+        UngrabExclusive = 0x20,
+        CancelGrabExclusive = 0x30,
+    };
+    Q_ENUM(GrabState)
 
     QQuickEventPoint(QQuickPointerEvent *parent);
 
-    void reset(Qt::TouchPointState state, QPointF scenePos, quint64 pointId, ulong timestamp);
-
-    void invalidate() { m_valid = false; }
+    void reset(Qt::TouchPointState state, const QPointF &scenePos, int pointId, ulong timestamp, const QVector2D &velocity = QVector2D());
+    void localizePosition(QQuickItem *target);
 
     QQuickPointerEvent *pointerEvent() const;
+    QPointF pos() const { return m_pos; }
     QPointF scenePos() const { return m_scenePos; }
+    QPointF scenePressPos() const { return m_scenePressPos; }
+    QPointF sceneGrabPos() const { return m_sceneGrabPos; }
+    QVector2D velocity() const { return m_velocity; }
     State state() const { return m_state; }
-    quint64 pointId() const { return m_pointId; }
-    bool isValid() const { return m_valid; }
+    int pointId() const { return m_pointId; }
     qreal timeHeld() const { return (m_timestamp - m_pressTimestamp) / 1000.0; }
     bool isAccepted() const { return m_accept; }
     void setAccepted(bool accepted = true);
-    QQuickItem *grabber() const;
-    void setGrabber(QQuickItem *grabber);
+    QObject *exclusiveGrabber() const;
+    void setExclusiveGrabber(QObject *exclusiveGrabber);
+
+    QQuickItem *grabberItem() const;
+    Q_DECL_DEPRECATED QQuickItem *grabber() const { return grabberItem(); }
+    void setGrabberItem(QQuickItem *exclusiveGrabber);
+
+    QQuickPointerHandler *grabberPointerHandler() const;
+    void setGrabberPointerHandler(QQuickPointerHandler *exclusiveGrabber, bool exclusive = false);
+
+    void cancelExclusiveGrab();
+    void cancelPassiveGrab(QQuickPointerHandler *handler);
+    bool removePassiveGrabber(QQuickPointerHandler *handler);
+    void cancelAllGrabs(QQuickPointerHandler *handler);
+
+    QVector<QPointer <QQuickPointerHandler> > passiveGrabbers() const { return m_passiveGrabbers; }
+    void setPassiveGrabbers(const QVector<QPointer <QQuickPointerHandler> > &grabbers) { m_passiveGrabbers = grabbers; }
+    void clearPassiveGrabbers() { m_passiveGrabbers.clear(); }
+
+protected:
+    void cancelExclusiveGrabImpl(QTouchEvent *cancelEvent = nullptr);
 
 private:
+    QVector2D estimatedVelocity() const;
+
+protected:
+    QPointF m_pos;
     QPointF m_scenePos;
-    quint64 m_pointId;
-    QPointer<QQuickItem> m_grabber;
+    QPointF m_scenePressPos;
+    QPointF m_sceneGrabPos;
+    QVector2D m_velocity;
+    int m_pointId;
+    QPointer<QObject> m_exclusiveGrabber;
+    QVector<QPointer <QQuickPointerHandler> > m_passiveGrabbers;
     ulong m_timestamp;
     ulong m_pressTimestamp;
     State m_state;
-    bool m_valid : 1;
     bool m_accept : 1;
-    int m_reserved : 30;
+    bool m_grabberIsHandler : 1;
+    int m_reserved : 29;
+
+    friend class QQuickPointerTouchEvent;
+    friend class QQuickWindowPrivate;
 
     Q_DISABLE_COPY(QQuickEventPoint)
 };
@@ -304,6 +354,7 @@ class Q_QUICK_PRIVATE_EXPORT QQuickEventTouchPoint : public QQuickEventPoint
     Q_OBJECT
     Q_PROPERTY(qreal rotation READ rotation)
     Q_PROPERTY(qreal pressure READ pressure)
+    Q_PROPERTY(QSizeF ellipseDiameters READ ellipseDiameters)
     Q_PROPERTY(QPointingDeviceUniqueId uniqueId READ uniqueId)
 
 public:
@@ -313,13 +364,17 @@ public:
 
     qreal rotation() const { return m_rotation; }
     qreal pressure() const { return m_pressure; }
+    QSizeF ellipseDiameters() const { return m_ellipseDiameters; }
     QPointingDeviceUniqueId uniqueId() const { return m_uniqueId; }
 
 private:
     qreal m_rotation;
     qreal m_pressure;
+    QSizeF m_ellipseDiameters;
     QPointingDeviceUniqueId m_uniqueId;
 
+    friend class QQuickPointerTouchEvent;
+
     Q_DISABLE_COPY(QQuickEventTouchPoint)
 };
 
@@ -350,8 +405,12 @@ public: // property accessors
 
 public: // helpers for C++ only (during event delivery)
     virtual QQuickPointerEvent *reset(QEvent *ev) = 0;
+    virtual void localize(QQuickItem *target) = 0;
 
     virtual bool isPressEvent() const = 0;
+    virtual bool isDoubleClickEvent() const { return false; }
+    virtual bool isUpdateEvent() const = 0;
+    virtual bool isReleaseEvent() const = 0;
     virtual QQuickPointerMouseEvent *asPointerMouseEvent() { return nullptr; }
     virtual QQuickPointerTouchEvent *asPointerTouchEvent() { return nullptr; }
     virtual QQuickPointerTabletEvent *asPointerTabletEvent() { return nullptr; }
@@ -360,15 +419,18 @@ public: // helpers for C++ only (during event delivery)
     virtual const QQuickPointerTabletEvent *asPointerTabletEvent() const { return nullptr; }
     bool isValid() const { return m_event != nullptr; }
     virtual bool allPointsAccepted() const = 0;
+    virtual bool allUpdatedPointsAccepted() const = 0;
+    virtual bool allPointsGrabbed() const = 0;
     bool isAccepted() { return m_event->isAccepted(); }
     void setAccepted(bool accepted) { m_event->setAccepted(accepted); }
     QVector<QPointF> unacceptedPressedPointScenePositions() const;
 
     virtual int pointCount() const = 0;
     virtual QQuickEventPoint *point(int i) const = 0;
-    virtual QQuickEventPoint *pointById(quint64 pointId) const = 0;
-    virtual QVector<QQuickItem *> grabbers() const = 0;
+    virtual QQuickEventPoint *pointById(int pointId) const = 0;
+    virtual QVector<QObject *> exclusiveGrabbers() const = 0;
     virtual void clearGrabbers() const = 0;
+    virtual bool hasExclusiveGrabber(const QQuickPointerHandler *handler) const = 0;
 
     ulong timestamp() const { return m_event->timestamp(); }
 
@@ -389,15 +451,22 @@ public:
         : QQuickPointerEvent(parent, device), m_mousePoint(new QQuickEventPoint(this)) { }
 
     QQuickPointerEvent *reset(QEvent *) override;
+    void localize(QQuickItem *target) override;
     bool isPressEvent() const override;
+    bool isDoubleClickEvent() const override;
+    bool isUpdateEvent() const override;
+    bool isReleaseEvent() const override;
     QQuickPointerMouseEvent *asPointerMouseEvent() override { return this; }
     const QQuickPointerMouseEvent *asPointerMouseEvent() const override { return this; }
     int pointCount() const override { return 1; }
     QQuickEventPoint *point(int i) const override;
-    QQuickEventPoint *pointById(quint64 pointId) const override;
+    QQuickEventPoint *pointById(int pointId) const override;
     bool allPointsAccepted() const override;
-    QVector<QQuickItem *> grabbers() const override;
+    bool allUpdatedPointsAccepted() const override;
+    bool allPointsGrabbed() const override;
+    QVector<QObject *> exclusiveGrabbers() const override;
     void clearGrabbers() const override;
+    bool hasExclusiveGrabber(const QQuickPointerHandler *handler) const override;
 
     QMouseEvent *asMouseEvent(const QPointF& localPos) const;
 
@@ -418,16 +487,22 @@ public:
     { }
 
     QQuickPointerEvent *reset(QEvent *) override;
+    void localize(QQuickItem *target) override;
     bool isPressEvent() const override;
+    bool isUpdateEvent() const override;
+    bool isReleaseEvent() const override;
     QQuickPointerTouchEvent *asPointerTouchEvent() override { return this; }
     const QQuickPointerTouchEvent *asPointerTouchEvent() const override { return this; }
     int pointCount() const override { return m_pointCount; }
     QQuickEventPoint *point(int i) const override;
-    QQuickEventPoint *pointById(quint64 pointId) const override;
+    QQuickEventPoint *pointById(int pointId) const override;
     const QTouchEvent::TouchPoint *touchPointById(int pointId) const;
     bool allPointsAccepted() const override;
-    QVector<QQuickItem *> grabbers() const override;
+    bool allUpdatedPointsAccepted() const override;
+    bool allPointsGrabbed() const override;
+    QVector<QObject *> exclusiveGrabbers() const override;
     void clearGrabbers() const override;
+    bool hasExclusiveGrabber(const QQuickPointerHandler *handler) const override;
 
     QMouseEvent *syntheticMouseEvent(int pointID, QQuickItem *relativeTo) const;
     QTouchEvent *touchEventForItem(QQuickItem *item, bool isFiltering = false) const;
@@ -497,13 +572,6 @@ public:
     Q_ENUM(CapabilityFlag)
     Q_FLAG(Capabilities)
 
-    QQuickPointerDevice(DeviceType devType, PointerType pType, Capabilities caps, int maxPoints, int buttonCount, const QString &name, qint64 uniqueId = 0)
-      : m_deviceType(devType), m_pointerType(pType), m_capabilities(caps)
-      , m_maximumTouchPoints(maxPoints), m_buttonCount(buttonCount), m_name(name)
-      , m_uniqueId(QPointingDeviceUniqueId::fromNumericId(uniqueId))
-    {
-    }
-
     DeviceType type() const { return m_deviceType; }
     PointerType pointerType() const { return m_pointerType; }
     Capabilities capabilities() const { return m_capabilities; }
@@ -518,6 +586,17 @@ public:
     static QQuickPointerDevice *genericMouseDevice();
     static QQuickPointerDevice *tabletDevice(qint64);
 
+    QVector<QQuickPointerHandler *> &eventDeliveryTargets() { return m_eventDeliveryTargets; }
+
+private:
+    QQuickPointerDevice(DeviceType devType, PointerType pType, Capabilities caps, int maxPoints, int buttonCount, const QString &name, qint64 uniqueId = 0)
+      : m_deviceType(devType), m_pointerType(pType), m_capabilities(caps)
+      , m_maximumTouchPoints(maxPoints), m_buttonCount(buttonCount), m_name(name)
+      , m_uniqueId(QPointingDeviceUniqueId::fromNumericId(uniqueId))
+    {
+    }
+    ~QQuickPointerDevice() { }
+
 private:
     DeviceType m_deviceType;
     PointerType m_pointerType;
@@ -526,8 +605,10 @@ private:
     int m_buttonCount;
     QString m_name;
     QPointingDeviceUniqueId m_uniqueId;
+    QVector<QQuickPointerHandler *> m_eventDeliveryTargets; // during delivery, handlers which have already seen the event
 
     Q_DISABLE_COPY(QQuickPointerDevice)
+    friend struct ConstructableQQuickPointerDevice;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickPointerDevice::DeviceTypes)
diff --git a/src/quick/items/qquickflickable.cpp b/src/quick/items/qquickflickable.cpp
index a3bc7635a1..ce584cd283 100644
--- a/src/quick/items/qquickflickable.cpp
+++ b/src/quick/items/qquickflickable.cpp
@@ -44,6 +44,7 @@
 #include "qquickwindow_p.h"
 #include "qquickevents_p_p.h"
 
+#include <QtQuick/private/qquickpointerhandler_p.h>
 #include <QtQuick/private/qquicktransition_p.h>
 #include <private/qqmlglobal_p.h>
 
@@ -269,6 +270,7 @@ void QQuickFlickablePrivate::init()
     qmlobject_connect(&velocityTimeline, QQuickTimeLine, SIGNAL(completed()),
                       q, QQuickFlickable, SLOT(velocityTimelineCompleted()))
     q->setAcceptedMouseButtons(Qt::LeftButton);
+    q->setAcceptTouchEvents(false); // rely on mouse events synthesized from touch
     q->setFiltersChildMouseEvents(true);
     QQuickItemPrivate *viewportPrivate = QQuickItemPrivate::get(contentItem);
     viewportPrivate->addItemChangeListener(this, QQuickItemPrivate::Geometry);
@@ -1547,6 +1549,8 @@ void QQuickFlickablePrivate::replayDelayedPress()
 
         // If we have the grab, release before delivering the event
         if (QQuickWindow *w = q->window()) {
+            QQuickWindowPrivate *wpriv = QQuickWindowPrivate::get(w);
+            wpriv->allowChildEventFiltering = false; // don't allow re-filtering during replay
             replayingPressEvent = true;
             if (w->mouseGrabberItem() == q)
                 q->ungrabMouse();
@@ -1554,6 +1558,7 @@ void QQuickFlickablePrivate::replayDelayedPress()
             // Use the event handler that will take care of finding the proper item to propagate the event
             QCoreApplication::sendEvent(w, mouseEvent.data());
             replayingPressEvent = false;
+            wpriv->allowChildEventFiltering = true;
         }
     }
 }
diff --git a/src/quick/items/qquickitem.cpp b/src/quick/items/qquickitem.cpp
index 1e71c20ff3..9f2d543387 100644
--- a/src/quick/items/qquickitem.cpp
+++ b/src/quick/items/qquickitem.cpp
@@ -67,6 +67,7 @@
 #include <QtQuick/private/qquickstate_p.h>
 #include <private/qquickitem_p.h>
 #include <QtQuick/private/qquickaccessibleattached_p.h>
+#include <QtQuick/private/qquickpointerhandler_p.h>
 
 #include <private/qv4engine_p.h>
 #include <private/qv4object_p.h>
@@ -3189,6 +3190,11 @@ QQuickItemPrivate::QQuickItemPrivate()
     , antialiasingValid(false)
     , isTabFence(false)
     , replayingPressEvent(false)
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+    , touchEnabled(true)
+#else
+    , touchEnabled(false)
+#endif
     , dirtyAttributes(0)
     , nextDirtyItem(0)
     , prevDirtyItem(0)
@@ -3240,7 +3246,14 @@ void QQuickItemPrivate::data_append(QQmlListProperty<QObject> *prop, QObject *o)
     } else {
         if (o->inherits("QGraphicsItem"))
             qWarning("Cannot add a QtQuick 1.0 item (%s) into a QtQuick 2.0 scene!", o->metaObject()->className());
-        else {
+        else if (QQuickPointerHandler *pointerHandler = qmlobject_cast<QQuickPointerHandler *>(o)) {
+            Q_ASSERT(pointerHandler->parentItem() == that);
+            // Accept all buttons, and leave filtering to pointerEvent() and/or user JS,
+            // because there can be multiple handlers...
+            that->setAcceptedMouseButtons(Qt::AllButtons);
+            QQuickItemPrivate *p = QQuickItemPrivate::get(that);
+            p->extra.value().pointerHandlers.append(pointerHandler);
+        } else {
             QQuickWindow *thisWindow = qmlobject_cast<QQuickWindow *>(o);
             QQuickItem *item = that;
             QQuickWindow *itemWindow = that->window();
@@ -5105,6 +5118,28 @@ void QQuickItemPrivate::deliverShortcutOverrideEvent(QKeyEvent *event)
 }
 
 /*!
+    \internal
+    Deliver the \a event to all PointerHandlers which are in the pre-determined
+    eventDeliveryTargets() vector.  If \a avoidExclusiveGrabber is true, it skips
+    delivery to any handler which is the exclusive grabber of any point within this event
+    (because delivery to exclusive grabbers is handled separately).
+*/
+bool QQuickItemPrivate::handlePointerEvent(QQuickPointerEvent *event, bool avoidExclusiveGrabber)
+{
+    bool delivered = false;
+    QVector<QQuickPointerHandler *> &eventDeliveryTargets = event->device()->eventDeliveryTargets();
+    if (extra.isAllocated()) {
+        for (QQuickPointerHandler *handler : extra->pointerHandlers) {
+            if ((!avoidExclusiveGrabber || !event->hasExclusiveGrabber(handler)) && !eventDeliveryTargets.contains(handler)) {
+                handler->handlePointerEvent(event);
+                delivered = true;
+            }
+        }
+    }
+    return delivered;
+}
+
+/*!
     Called when \a change occurs for this item.
 
     \a value contains extra information relating to the change, when
@@ -7189,6 +7224,32 @@ void QQuickItem::setAcceptHoverEvents(bool enabled)
     d->setHasHoverInChild(enabled);
 }
 
+/*!
+    Returns whether touch events are accepted by this item.
+
+    The default value is false.
+
+    If this is false, then the item will not receive any touch events through
+    the touchEvent() function.
+*/
+bool QQuickItem::acceptTouchEvents() const
+{
+    Q_D(const QQuickItem);
+    return d->touchEnabled;
+}
+
+/*!
+    If \a enabled is true, this sets the item to accept touch events;
+    otherwise, touch events are not accepted by this item.
+
+    \sa acceptTouchEvents()
+*/
+void QQuickItem::setAcceptTouchEvents(bool accept)
+{
+    Q_D(QQuickItem);
+    d->touchEnabled = accept;
+}
+
 void QQuickItemPrivate::setHasCursorInChild(bool hasCursor)
 {
 #if QT_CONFIG(cursor)
diff --git a/src/quick/items/qquickitem.h b/src/quick/items/qquickitem.h
index 4a832bbf6f..25641f16f9 100644
--- a/src/quick/items/qquickitem.h
+++ b/src/quick/items/qquickitem.h
@@ -293,6 +293,8 @@ public:
     void setAcceptedMouseButtons(Qt::MouseButtons buttons);
     bool acceptHoverEvents() const;
     void setAcceptHoverEvents(bool enabled);
+    bool acceptTouchEvents() const;
+    void setAcceptTouchEvents(bool accept);
 
 #if QT_CONFIG(cursor)
     QCursor cursor() const;
@@ -449,6 +451,7 @@ private:
     Q_PRIVATE_SLOT(d_func(), void _q_resourceObjectDeleted(QObject *))
     Q_PRIVATE_SLOT(d_func(), quint64 _q_createJSWrapper(QV4::ExecutionEngine *))
 
+    friend class QQuickEventPoint;
     friend class QQuickWindow;
     friend class QQuickWindowPrivate;
     friend class QSGRenderer;
diff --git a/src/quick/items/qquickitem_p.h b/src/quick/items/qquickitem_p.h
index 74d70da2bc..d1aaf6026b 100644
--- a/src/quick/items/qquickitem_p.h
+++ b/src/quick/items/qquickitem_p.h
@@ -87,6 +87,7 @@ class QQuickItemKeyFilter;
 class QQuickLayoutMirroringAttached;
 class QQuickEnterKeyAttached;
 class QQuickScreenAttached;
+class QQuickPointerHandler;
 
 class QQuickContents : public QQuickItemChangeListener
 {
@@ -349,6 +350,7 @@ public:
         QQuickLayoutMirroringAttached* layoutDirectionAttached;
         QQuickEnterKeyAttached *enterKeyAttached;
         QQuickItemKeyFilter *keyHandler;
+        QVector<QQuickPointerHandler *> pointerHandlers;
 #if QT_CONFIG(quick_shadereffect)
         mutable QQuickItemLayer *layer;
 #endif
@@ -438,6 +440,7 @@ public:
     // focus chain and prevents tabbing outside.
     bool isTabFence:1;
     bool replayingPressEvent:1;
+    bool touchEnabled:1;
 
     enum DirtyType {
         TransformOrigin         = 0x00000001,
@@ -566,6 +569,8 @@ public:
 #endif
     void deliverShortcutOverrideEvent(QKeyEvent *);
 
+    virtual bool handlePointerEvent(QQuickPointerEvent *, bool avoidExclusiveGrabber = false);
+
     bool isTransparentForPositioner() const;
     void setTransparentForPositioner(bool trans);
 
diff --git a/src/quick/items/qquickmousearea.cpp b/src/quick/items/qquickmousearea.cpp
index d8bad7d793..96f34ef276 100644
--- a/src/quick/items/qquickmousearea.cpp
+++ b/src/quick/items/qquickmousearea.cpp
@@ -85,6 +85,7 @@ void QQuickMouseAreaPrivate::init()
 {
     Q_Q(QQuickMouseArea);
     q->setAcceptedMouseButtons(Qt::LeftButton);
+    q->setAcceptTouchEvents(false); // rely on mouse events synthesized from touch
     q->setFiltersChildMouseEvents(true);
     if (qmlVisualTouchDebugging()) {
         q->setFlag(QQuickItem::ItemHasContents);
diff --git a/src/quick/items/qquickmultipointtoucharea.cpp b/src/quick/items/qquickmultipointtoucharea.cpp
index d4c447a384..54136b1bbf 100644
--- a/src/quick/items/qquickmultipointtoucharea.cpp
+++ b/src/quick/items/qquickmultipointtoucharea.cpp
@@ -418,6 +418,7 @@ QQuickMultiPointTouchArea::QQuickMultiPointTouchArea(QQuickItem *parent)
     if (qmlVisualTouchDebugging()) {
         setFlag(QQuickItem::ItemHasContents);
     }
+    setAcceptTouchEvents(true);
 #ifdef Q_OS_OSX
     setAcceptHoverEvents(true); // needed to enable touch events on mouse hover.
 #endif
diff --git a/src/quick/items/qquickpincharea.cpp b/src/quick/items/qquickpincharea.cpp
index 3f6ce7b8ba..476acd3a3e 100644
--- a/src/quick/items/qquickpincharea.cpp
+++ b/src/quick/items/qquickpincharea.cpp
@@ -288,6 +288,7 @@ QQuickPinchArea::QQuickPinchArea(QQuickItem *parent)
 {
     Q_D(QQuickPinchArea);
     d->init();
+    setAcceptTouchEvents(true);
 #ifdef Q_OS_OSX
     setAcceptHoverEvents(true); // needed to enable touch events on mouse hover.
 #endif
diff --git a/src/quick/items/qquickrectangle.cpp b/src/quick/items/qquickrectangle.cpp
index 65284eb532..9308553a79 100644
--- a/src/quick/items/qquickrectangle.cpp
+++ b/src/quick/items/qquickrectangle.cpp
@@ -325,6 +325,9 @@ QQuickRectangle::QQuickRectangle(QQuickItem *parent)
 : QQuickItem(*(new QQuickRectanglePrivate), parent)
 {
     setFlag(ItemHasContents);
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+    setAcceptTouchEvents(false);
+#endif
 }
 
 void QQuickRectangle::doUpdate()
diff --git a/src/quick/items/qquickwindow.cpp b/src/quick/items/qquickwindow.cpp
index ce1016579c..7b331251f0 100644
--- a/src/quick/items/qquickwindow.cpp
+++ b/src/quick/items/qquickwindow.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2017 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtQuick module of the Qt Toolkit.
@@ -46,6 +46,7 @@
 #include "qquickevents_p_p.h"
 
 #include <private/qquickdrag_p.h>
+#include <private/qquickpointerhandler_p.h>
 
 #include <QtQuick/private/qsgrenderer_p.h>
 #include <QtQuick/private/qsgtexture_p.h>
@@ -499,6 +500,8 @@ QQuickWindowPrivate::QQuickWindowPrivate()
     , persistentSceneGraph(true)
     , lastWheelEventAccepted(false)
     , componentCompleted(true)
+    , allowChildEventFiltering(true)
+    , allowDoubleClick(true)
     , lastFocusReason(Qt::OtherFocusReason)
     , renderTarget(0)
     , renderTargetId(0)
@@ -652,7 +655,7 @@ bool QQuickWindowPrivate::deliverTouchAsMouse(QQuickItem *item, QQuickPointerEve
             if (!item->contains(pos))
                 break;
 
-            qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << p.id() << "->" << item;
+            qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << hex << p.id() << "->" << item;
             QScopedPointer<QMouseEvent> mousePress(touchToMouseEvent(QEvent::MouseButtonPress, p, event.data(), item, false));
 
             // Send a single press and see if that's accepted
@@ -664,7 +667,7 @@ bool QQuickWindowPrivate::deliverTouchAsMouse(QQuickItem *item, QQuickPointerEve
                 if (!q->mouseGrabberItem())
                     item->grabMouse();
                 auto pointerEventPoint = pointerEvent->pointById(p.id());
-                pointerEventPoint->setGrabber(item);
+                pointerEventPoint->setGrabberItem(item);
 
                 if (checkIfDoubleClicked(event->timestamp())) {
                     QScopedPointer<QMouseEvent> mouseDoubleClick(touchToMouseEvent(QEvent::MouseButtonDblClick, p, event.data(), item, false));
@@ -688,7 +691,7 @@ bool QQuickWindowPrivate::deliverTouchAsMouse(QQuickItem *item, QQuickPointerEve
                     QCoreApplication::sendEvent(item, me.data());
                     event->setAccepted(me->isAccepted());
                     if (me->isAccepted()) {
-                        qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << p.id() << "->" << mouseGrabberItem;
+                        qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << hex << p.id() << "->" << mouseGrabberItem;
                     }
                     return event->isAccepted();
                 } else {
@@ -744,39 +747,42 @@ void QQuickWindowPrivate::setMouseGrabber(QQuickItem *grabber)
     if (q->mouseGrabberItem() == grabber)
         return;
 
-    qCDebug(DBG_MOUSE_TARGET) << "grabber" << q->mouseGrabberItem() << "->" << grabber;
     QQuickItem *oldGrabber = q->mouseGrabberItem();
-    bool fromTouch = false;
+    qCDebug(DBG_MOUSE_TARGET) << "grabber" << oldGrabber << "->" << grabber;
 
     if (grabber && touchMouseId != -1 && touchMouseDevice) {
         // update the touch item for mouse touch id to the new grabber
         qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << hex << touchMouseId << "->" << q->mouseGrabberItem();
         auto point = pointerEventInstance(touchMouseDevice)->pointById(touchMouseId);
-        if (point)
-            point->setGrabber(grabber);
-        fromTouch = true;
+        if (point) {
+            auto originalEvent = pointerEventInstance(point->pointerEvent()->device());
+            for (int i = 0; i < originalEvent->pointCount(); ++i)
+                originalEvent->point(i)->cancelExclusiveGrab();
+            point->setGrabberItem(grabber);
+            for (auto handler : point->passiveGrabbers())
+                point->cancelPassiveGrab(handler);
+        }
     } else {
         QQuickPointerEvent *event = pointerEventInstance(QQuickPointerDevice::genericMouseDevice());
         Q_ASSERT(event->pointCount() == 1);
-        event->point(0)->setGrabber(grabber);
+        auto point = event->point(0);
+        point->setGrabberItem(grabber);
+        for (auto handler : point->passiveGrabbers())
+            point->cancelPassiveGrab(handler);
     }
 
+
     if (oldGrabber) {
         QEvent e(QEvent::UngrabMouse);
         QSet<QQuickItem *> hasFiltered;
-        if (!sendFilteredMouseEvent(oldGrabber->parentItem(), oldGrabber, &e, &hasFiltered)) {
+        if (!sendFilteredMouseEvent(oldGrabber->parentItem(), oldGrabber, &e, &hasFiltered))
             oldGrabber->mouseUngrabEvent();
-            if (fromTouch)
-                oldGrabber->touchUngrabEvent();
-        }
     }
 }
 
-void QQuickWindowPrivate::grabTouchPoints(QQuickItem *grabber, const QVector<int> &ids)
+void QQuickWindowPrivate::grabTouchPoints(QObject *grabber, const QVector<int> &ids)
 {
-    QSet<QQuickItem*> ungrab;
     for (int i = 0; i < ids.count(); ++i) {
-        // FIXME: deprecate this function, we need a device
         int id = ids.at(i);
         if (Q_UNLIKELY(id < 0)) {
             qWarning("ignoring grab of touchpoint %d", id);
@@ -784,11 +790,11 @@ void QQuickWindowPrivate::grabTouchPoints(QQuickItem *grabber, const QVector<int
         }
         if (id == touchMouseId) {
             auto point = pointerEventInstance(touchMouseDevice)->pointById(id);
-            auto touchMouseGrabber = point->grabber();
+            auto touchMouseGrabber = point->grabberItem();
             if (touchMouseGrabber) {
-                point->setGrabber(nullptr);
+                point->setExclusiveGrabber(nullptr);
                 touchMouseGrabber->mouseUngrabEvent();
-                ungrab.insert(touchMouseGrabber);
+                touchMouseGrabber->touchUngrabEvent();
                 touchMouseDevice = nullptr;
                 touchMouseId = -1;
             }
@@ -800,19 +806,23 @@ void QQuickWindowPrivate::grabTouchPoints(QQuickItem *grabber, const QVector<int
             auto point = pointerEventInstance(device)->pointById(id);
             if (!point)
                 continue;
-            QQuickItem *oldGrabber = point->grabber();
+            QObject *oldGrabber = point->exclusiveGrabber();
             if (oldGrabber == grabber)
                 continue;
-
-            point->setGrabber(grabber);
-            if (oldGrabber)
-                ungrab.insert(oldGrabber);
+            point->setExclusiveGrabber(grabber);
         }
     }
-    for (QQuickItem *oldGrabber : qAsConst(ungrab))
-        oldGrabber->touchUngrabEvent();
 }
 
+/*!
+    Ungrabs all touchpoint grabs and/or the mouse grab from the given item \a grabber.
+    This should not be called when processing a release event - that's redundant.
+    It is called in other cases, when the points may not be released, but the item
+    nevertheless must lose its grab due to becoming disabled, invisible, etc.
+    QQuickEventPoint::setGrabberItem() calls touchUngrabEvent() when all points are released,
+    but if not all points are released, it cannot be sure whether to call touchUngrabEvent()
+    or not; so we have to do it here.
+*/
 void QQuickWindowPrivate::removeGrabber(QQuickItem *grabber, bool mouse, bool touch)
 {
     Q_Q(QQuickWindow);
@@ -821,17 +831,19 @@ void QQuickWindowPrivate::removeGrabber(QQuickItem *grabber, bool mouse, bool to
         setMouseGrabber(nullptr);
     }
     if (Q_LIKELY(touch)) {
+        bool ungrab = false;
         const auto touchDevices = QQuickPointerDevice::touchDevices();
         for (auto device : touchDevices) {
             auto pointerEvent = pointerEventInstance(device);
             for (int i = 0; i < pointerEvent->pointCount(); ++i) {
-                if (pointerEvent->point(i)->grabber() == grabber) {
-                    pointerEvent->point(i)->setGrabber(nullptr);
-                    // FIXME send ungrab event only once
-                    grabber->touchUngrabEvent();
+                if (pointerEvent->point(i)->exclusiveGrabber() == grabber) {
+                    pointerEvent->point(i)->setGrabberItem(nullptr);
+                    ungrab = true;
                 }
             }
         }
+        if (ungrab)
+            grabber->touchUngrabEvent();
     }
 }
 
@@ -1495,12 +1507,12 @@ QQuickItem *QQuickWindow::mouseGrabberItem() const
         QQuickPointerEvent *event = d->pointerEventInstance(d->touchMouseDevice);
         auto point = event->pointById(d->touchMouseId);
         Q_ASSERT(point);
-        return point->grabber();
+        return point->grabberItem();
     }
 
     QQuickPointerEvent *event = d->pointerEventInstance(QQuickPointerDevice::genericMouseDevice());
     Q_ASSERT(event->pointCount());
-    return event->point(0)->grabber();
+    return event->point(0)->grabberItem();
 }
 
 
@@ -1649,36 +1661,75 @@ QMouseEvent *QQuickWindowPrivate::cloneMouseEvent(QMouseEvent *event, QPointF *t
 
 void QQuickWindowPrivate::deliverMouseEvent(QQuickPointerMouseEvent *pointerEvent)
 {
-    Q_Q(QQuickWindow);
     auto point = pointerEvent->point(0);
     lastMousePosition = point->scenePos();
-    QQuickItem *grabber = point->grabber();
-    if (grabber) {
-        // if the update consists of changing button state, then don't accept it
-        // unless the button is one in which the item is interested
-        if (pointerEvent->button() != Qt::NoButton
-                && grabber->acceptedMouseButtons()
-                && !(grabber->acceptedMouseButtons() & pointerEvent->button())) {
-            pointerEvent->setAccepted(false);
-            return;
-        }
 
-        // send update
-        QPointF localPos = grabber->mapFromScene(lastMousePosition);
-        auto me = pointerEvent->asMouseEvent(localPos);
-        me->accept();
-        q->sendEvent(grabber, me);
-        point->setAccepted(me->isAccepted());
+    if (point->exclusiveGrabber()) {
+        bool mouseIsReleased = (point->state() == QQuickEventPoint::Released && pointerEvent->buttons() == Qt::NoButton);
+        if (auto grabber = point->grabberItem()) {
+            if (sendFilteredPointerEvent(pointerEvent, grabber))
+                return;
+            // if the grabber is an Item:
+            // if the update consists of changing button state, don't accept it unless
+            // the button is one in which the grabber is interested
+            if (pointerEvent->button() != Qt::NoButton && grabber->acceptedMouseButtons()
+                    && !(grabber->acceptedMouseButtons() & pointerEvent->button())) {
+                pointerEvent->setAccepted(false);
+                return;
+            }
+
+            // send update
+            QPointF localPos = grabber->mapFromScene(lastMousePosition);
+            auto me = pointerEvent->asMouseEvent(localPos);
+            me->accept();
+            QCoreApplication::sendEvent(grabber, me);
+            point->setAccepted(me->isAccepted());
 
-        // release event, make sure to ungrab if there still is a grabber
-        if (me->type() == QEvent::MouseButtonRelease && !me->buttons() && q->mouseGrabberItem())
-            q->mouseGrabberItem()->ungrabMouse();
+            // release event: ungrab if no buttons are pressed anymore
+            if (mouseIsReleased)
+                setMouseGrabber(nullptr);
+        } else {
+            // if the grabber is not an Item, it must be a PointerHandler
+            auto handler = point->grabberPointerHandler();
+            pointerEvent->localize(handler->parentItem());
+            if (!sendFilteredPointerEvent(pointerEvent, handler->parentItem()))
+                handler->handlePointerEvent(pointerEvent);
+            if (mouseIsReleased) {
+                point->setGrabberPointerHandler(nullptr, true);
+                point->clearPassiveGrabbers();
+            }
+        }
     } else {
-        // send initial press
         bool delivered = false;
         if (pointerEvent->isPressEvent()) {
-            QSet<QQuickItem*> hasFiltered;
-            delivered = deliverPressEvent(pointerEvent, &hasFiltered);
+            // send initial press
+            delivered = deliverPressOrReleaseEvent(pointerEvent);
+        } else if (pointerEvent->device()->type() == QQuickPointerDevice::Mouse) {
+            // if this is an update or release from an actual mouse,
+            // and the point wasn't grabbed, deliver only to PointerHandlers:
+            // passive grabbers first, then the rest
+            const QVector<QQuickPointerHandler *> &eventDeliveryTargets = pointerEvent->device()->eventDeliveryTargets();
+            for (auto handler : point->passiveGrabbers()) {
+                // a null pointer in passiveGrabbers is unlikely, unless the grabbing handler was deleted dynamically
+                if (Q_LIKELY(handler) && !eventDeliveryTargets.contains(handler)) {
+                    if (!sendFilteredPointerEvent(pointerEvent, handler->parentItem()))
+                        handler->handlePointerEvent(pointerEvent);
+                }
+            }
+            // If some points weren't grabbed, deliver to non-grabber PointerHandlers in reverse paint order
+            if (!pointerEvent->allPointsGrabbed() && pointerEvent->buttons()) {
+                QVector<QQuickItem *> targetItems = pointerTargets(contentItem, point->scenePos(), false, false);
+                for (QQuickItem *item : targetItems) {
+                    QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
+                    pointerEvent->localize(item);
+                    if (!sendFilteredPointerEvent(pointerEvent, item)) {
+                        if (itemPrivate->handlePointerEvent(pointerEvent, true)) // avoid re-delivering to grabbers
+                            delivered = true;
+                    }
+                    if (point->exclusiveGrabber())
+                        break;
+                }
+            }
         }
 
         if (!delivered)
@@ -1881,19 +1932,16 @@ bool QQuickWindowPrivate::deliverTouchCancelEvent(QTouchEvent *event)
     Q_Q(QQuickWindow);
 
     // A TouchCancel event will typically not contain any points.
-    // Deliver it to all items that have active touches.
+    // Deliver it to all items and handlers that have active touches.
     QQuickPointerEvent *pointerEvent = pointerEventInstance(QQuickPointerDevice::touchDevice(event->device()));
-    QVector<QQuickItem *> grabbers = pointerEvent->grabbers();
-
-    for (QQuickItem *grabber: qAsConst(grabbers)) {
-        q->sendEvent(grabber, event);
-    }
+    for (int i = 0; i < pointerEvent->pointCount(); ++i)
+        pointerEvent->point(i)->cancelExclusiveGrabImpl(event);
     touchMouseId = -1;
     touchMouseDevice = nullptr;
     if (q->mouseGrabberItem())
         q->mouseGrabberItem()->ungrabMouse();
 
-    // The next touch event can only be a TouchBegin so clean up.
+    // The next touch event can only be a TouchBegin, so clean up.
     pointerEvent->clearGrabbers();
     return true;
 }
@@ -2030,8 +2078,6 @@ void QQuickWindow::mouseReleaseEvent(QMouseEvent *event)
 
 void QQuickWindowPrivate::handleMouseEvent(QMouseEvent *event)
 {
-    Q_Q(QQuickWindow);
-
     if (event->source() == Qt::MouseEventSynthesizedBySystem) {
         event->accept();
         return;
@@ -2052,7 +2098,8 @@ void QQuickWindowPrivate::handleMouseEvent(QMouseEvent *event)
     case QEvent::MouseButtonDblClick:
         Q_QUICK_INPUT_PROFILE(QQuickProfiler::Mouse, QQuickProfiler::InputMouseDoubleClick,
                               event->button(), event->buttons());
-        deliverPointerEvent(pointerEventInstance(event));
+        if (allowDoubleClick)
+            deliverPointerEvent(pointerEventInstance(event));
         break;
     case QEvent::MouseMove:
         Q_QUICK_INPUT_PROFILE(QQuickProfiler::Mouse, QQuickProfiler::InputMouseMove,
@@ -2064,7 +2111,7 @@ void QQuickWindowPrivate::handleMouseEvent(QMouseEvent *event)
         updateCursor(event->windowPos());
     #endif
 
-        if (!q->mouseGrabberItem()) {
+        if (!pointerEventInstance(QQuickPointerDevice::genericMouseDevice())->point(0)->exclusiveGrabber()) {
             QPointF last = lastMousePosition.isNull() ? event->windowPos() : lastMousePosition;
             lastMousePosition = event->windowPos();
 
@@ -2075,7 +2122,6 @@ void QQuickWindowPrivate::handleMouseEvent(QMouseEvent *event)
                 accepted = clearHover(event->timestamp());
             }
             event->setAccepted(accepted);
-            return;
         }
         deliverPointerEvent(pointerEventInstance(event));
         break;
@@ -2195,7 +2241,10 @@ void QQuickWindowPrivate::deliverPointerEvent(QQuickPointerEvent *event)
 
 // check if item or any of its child items contain the point
 // FIXME: should this be iterative instead of recursive?
-QVector<QQuickItem *> QQuickWindowPrivate::pointerTargets(QQuickItem *item, const QPointF &scenePos, bool checkMouseButtons) const
+// If checkMouseButtons is true, it means we are finding targets for a mouse event, so no item for which acceptedMouseButtons() is NoButton will be added.
+// If checkAcceptsTouch is true, it means we are finding targets for a touch event, so either acceptTouchEvents() must return true OR
+// it must accept a synth. mouse event, thus if acceptTouchEvents() returns false but acceptedMouseButtons() is true, gets added; if not, it doesn't.
+QVector<QQuickItem *> QQuickWindowPrivate::pointerTargets(QQuickItem *item, const QPointF &scenePos, bool checkMouseButtons, bool checkAcceptsTouch) const
 {
     QVector<QQuickItem *> targets;
     auto itemPrivate = QQuickItemPrivate::get(item);
@@ -2213,13 +2262,16 @@ QVector<QQuickItem *> QQuickWindowPrivate::pointerTargets(QQuickItem *item, cons
         auto childPrivate = QQuickItemPrivate::get(child);
         if (!child->isVisible() || !child->isEnabled() || childPrivate->culled)
             continue;
-        targets << pointerTargets(child, scenePos, false);
+        targets << pointerTargets(child, scenePos, checkMouseButtons, checkAcceptsTouch);
     }
 
-    if (item->contains(itemPos) && (!checkMouseButtons || itemPrivate->acceptedMouseButtons())) {
-        // add this item last - children take precedence
-        targets << item;
-    }
+    bool relevant = item->contains(itemPos);
+    if (relevant && checkMouseButtons && item->acceptedMouseButtons() == Qt::NoButton)
+        relevant = false;
+    if (relevant && checkAcceptsTouch && !(item->acceptTouchEvents() || item->acceptedMouseButtons()))
+        relevant = false;
+    if (relevant)
+        targets << item; // add this item last: children take precedence
     return targets;
 }
 
@@ -2249,11 +2301,12 @@ void QQuickWindowPrivate::deliverTouchEvent(QQuickPointerTouchEvent *event)
 {
     qCDebug(DBG_TOUCH) << " - delivering" << event->asTouchEvent();
 
-    QSet<QQuickItem *> hasFiltered;
     if (event->isPressEvent())
-        deliverPressEvent(event, &hasFiltered);
-    if (!event->allPointsAccepted())
-        deliverUpdatedTouchPoints(event, &hasFiltered);
+        deliverPressOrReleaseEvent(event);
+    if (!event->allUpdatedPointsAccepted())
+        deliverUpdatedTouchPoints(event);
+    if (event->isReleaseEvent())
+        deliverPressOrReleaseEvent(event, true);
 
     // Remove released points from itemForTouchPointId
     bool allReleased = true;
@@ -2263,7 +2316,7 @@ void QQuickWindowPrivate::deliverTouchEvent(QQuickPointerTouchEvent *event)
         if (point->state() == QQuickEventPoint::Released) {
             int id = point->pointId();
             qCDebug(DBG_TOUCH_TARGET) << "TP" << hex << id << "released";
-            point->setGrabber(nullptr);
+            point->setGrabberItem(nullptr);
             if (id == touchMouseId) {
                 touchMouseId = -1;
                 touchMouseDevice = nullptr;
@@ -2273,29 +2326,92 @@ void QQuickWindowPrivate::deliverTouchEvent(QQuickPointerTouchEvent *event)
         }
     }
 
-    if (allReleased && !event->grabbers().isEmpty()) {
-        qWarning() << "No release received for some grabbers" << event->grabbers();
+    if (allReleased && !event->exclusiveGrabbers().isEmpty()) {
+        qWarning() << "No release received for some grabbers" << event->exclusiveGrabbers();
         event->clearGrabbers();
     }
 }
 
 // Deliver touch points to existing grabbers
-bool QQuickWindowPrivate::deliverUpdatedTouchPoints(QQuickPointerTouchEvent *event, QSet<QQuickItem *> *hasFiltered)
-{
-    const auto grabbers = event->grabbers();
-    for (auto grabber : grabbers)
-        deliverMatchingPointsToItem(grabber, event, hasFiltered);
+void QQuickWindowPrivate::deliverUpdatedTouchPoints(QQuickPointerTouchEvent *event)
+{
+    const auto grabbers = event->exclusiveGrabbers();
+    for (auto grabber : grabbers) {
+        // The grabber is guaranteed to be either an item or a handler.
+        QQuickItem *receiver = qmlobject_cast<QQuickItem *>(grabber);
+        if (!receiver) {
+            // The grabber is not an item? It's a handler then.  Let it have the event first.
+            QQuickPointerHandler *handler = static_cast<QQuickPointerHandler *>(grabber);
+            receiver = static_cast<QQuickPointerHandler *>(grabber)->parentItem();
+            if (sendFilteredPointerEvent(event, receiver))
+                return;
+            event->localize(receiver);
+            handler->handlePointerEvent(event);
+            if (event->allPointsAccepted())
+                return;
+        }
+        // If the grabber is an item or the grabbing handler didn't handle it,
+        // then deliver the event to the item (which may have multiple handlers).
+        deliverMatchingPointsToItem(receiver, event);
+    }
 
-    return false;
+    // If some points weren't grabbed, deliver only to non-grabber PointerHandlers
+    if (!event->allPointsGrabbed()) {
+        int pointCount = event->pointCount();
+
+        // Deliver to each eventpoint's passive grabbers (but don't visit any handler more than once)
+        const QVector<QQuickPointerHandler *> &eventDeliveryTargets = event->device()->eventDeliveryTargets();
+        for (int i = 0; i < pointCount; ++i) {
+            QQuickEventPoint *point = event->point(i);
+            for (auto handler : point->passiveGrabbers()) {
+                if (Q_LIKELY(handler) && !eventDeliveryTargets.contains(handler)) {
+                    if (sendFilteredPointerEvent(event, handler->parentItem()))
+                        return;
+                    handler->handlePointerEvent(event);
+                }
+            }
+        }
+
+        // If some points weren't grabbed, deliver to non-grabber PointerHandlers in reverse paint order
+        if (!event->allPointsGrabbed()) {
+            QVector<QQuickItem *> targetItems;
+            for (int i = 0; i < pointCount; ++i) {
+                QQuickEventPoint *point = event->point(i);
+                if (point->state() == QQuickEventPoint::Pressed)
+                    continue; // presses were delivered earlier; not the responsibility of deliverUpdatedTouchPoints
+                QVector<QQuickItem *> targetItemsForPoint = pointerTargets(contentItem, point->scenePos(), false, false);
+                if (targetItems.count()) {
+                    targetItems = mergePointerTargets(targetItems, targetItemsForPoint);
+                } else {
+                    targetItems = targetItemsForPoint;
+                }
+            }
+
+            for (QQuickItem *item: targetItems) {
+                if (grabbers.contains(item))
+                    continue;
+                QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
+                event->localize(item);
+                itemPrivate->handlePointerEvent(event, true); // avoid re-delivering to grabbers
+                if (event->allPointsGrabbed())
+                    break;
+            }
+        }
+    }
 }
 
-// Deliver newly pressed touch points
-bool QQuickWindowPrivate::deliverPressEvent(QQuickPointerEvent *event, QSet<QQuickItem *> *hasFiltered)
+// Deliver an event containing newly pressed or released touch points
+bool QQuickWindowPrivate::deliverPressOrReleaseEvent(QQuickPointerEvent *event, bool handlersOnly)
 {
-    const QVector<QPointF> points = event->unacceptedPressedPointScenePositions();
+    int pointCount = event->pointCount();
     QVector<QQuickItem *> targetItems;
-    for (QPointF point: points) {
-        QVector<QQuickItem *> targetItemsForPoint = pointerTargets(contentItem, point, false);
+    bool isTouchEvent = (event->asPointerTouchEvent() != nullptr);
+    for (int i = 0; i < pointCount; ++i) {
+        auto point = event->point(i);
+        point->setAccepted(false); // because otherwise touchEventForItem will ignore it
+        if (point->grabberPointerHandler() && point->state() == QQuickEventPoint::Released)
+            point->setGrabberPointerHandler(nullptr, true);
+        QVector<QQuickItem *> targetItemsForPoint = pointerTargets(contentItem, point->scenePos(), !isTouchEvent, isTouchEvent);
         if (targetItems.count()) {
             targetItems = mergePointerTargets(targetItems, targetItemsForPoint);
         } else {
@@ -2303,8 +2419,18 @@ bool QQuickWindowPrivate::deliverPressEvent(QQuickPointerEvent *event, QSet<QQui
         }
     }
 
+    if (allowChildEventFiltering && !handlersOnly) {
+        updateFilteringParentItems(targetItems);
+        QQuickItem *filteredItem;
+        if (sendFilteredPointerEvent(event, nullptr, &filteredItem)) {
+            if (event->isAccepted())
+                return true;
+            targetItems.removeAll(filteredItem);
+        }
+    }
+
     for (QQuickItem *item: targetItems) {
-        deliverMatchingPointsToItem(item, event, hasFiltered);
+        deliverMatchingPointsToItem(item, event, handlersOnly);
         if (event->allPointsAccepted())
             break;
     }
@@ -2312,17 +2438,35 @@ bool QQuickWindowPrivate::deliverPressEvent(QQuickPointerEvent *event, QSet<QQui
     return event->allPointsAccepted();
 }
 
-bool QQuickWindowPrivate::deliverMatchingPointsToItem(QQuickItem *item, QQuickPointerEvent *pointerEvent, QSet<QQuickItem *> *hasFiltered)
+void QQuickWindowPrivate::deliverMatchingPointsToItem(QQuickItem *item, QQuickPointerEvent *pointerEvent, bool handlersOnly)
 {
     Q_Q(QQuickWindow);
+    QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
+    pointerEvent->localize(item);
+
+    // Let the Item's handlers (if any) have the event first.
+    // However, double click should never be delivered to handlers.
+    if (!pointerEvent->isDoubleClickEvent()) {
+        itemPrivate->handlePointerEvent(pointerEvent);
+        allowDoubleClick = !(pointerEvent->asPointerMouseEvent() && pointerEvent->isPressEvent() && pointerEvent->allPointsAccepted());
+    }
+    if (handlersOnly)
+        return;
+    if (pointerEvent->allPointsAccepted() && !pointerEvent->isReleaseEvent())
+        return;
+
+    // If all points are released and the item is not the grabber, it doesn't get the event.
+    // But if at least one point is still pressed, we might be in a potential gesture-takeover scenario.
+    if (pointerEvent->isReleaseEvent() && !pointerEvent->isUpdateEvent()
+            && !pointerEvent->exclusiveGrabbers().contains(item))
+        return;
 
     // TODO: unite this mouse point delivery with the synthetic mouse event below
-    if (auto event = pointerEvent->asPointerMouseEvent()) {
-        if (item->acceptedMouseButtons() & event->button()) {
+    auto event = pointerEvent->asPointerMouseEvent();
+    if (event && item->acceptedMouseButtons() & event->button()) {
             auto point = event->point(0);
             if (point->isAccepted())
-                return false;
-
+                return;
             // The only reason to already have a mouse grabber here is
             // synthetic events - flickable sends one when setPressDelay is used.
             auto oldMouseGrabber = q->mouseGrabberItem();
@@ -2330,7 +2474,7 @@ bool QQuickWindowPrivate::deliverMatchingPointsToItem(QQuickItem *item, QQuickPo
             Q_ASSERT(item->contains(localPos)); // transform is checked already
             QMouseEvent *me = event->asMouseEvent(localPos);
             me->accept();
-            q->sendEvent(item, me);
+            QCoreApplication::sendEvent(item, me);
             if (me->isAccepted()) {
                 auto mouseGrabber = q->mouseGrabberItem();
                 if (mouseGrabber && mouseGrabber != item && mouseGrabber != oldMouseGrabber) {
@@ -2340,33 +2484,25 @@ bool QQuickWindowPrivate::deliverMatchingPointsToItem(QQuickItem *item, QQuickPo
                 }
                 point->setAccepted(true);
             }
-            return me->isAccepted();
-        }
-        return false;
+        return;
     }
 
-    QQuickPointerTouchEvent *event = pointerEvent->asPointerTouchEvent();
-    if (!event)
-        return false;
+    QQuickPointerTouchEvent *ptEvent = pointerEvent->asPointerTouchEvent();
+    if (!ptEvent)
+        return;
 
-    QScopedPointer<QTouchEvent> touchEvent(event->touchEventForItem(item));
+    QScopedPointer<QTouchEvent> touchEvent(ptEvent->touchEventForItem(item));
     if (!touchEvent)
-        return false;
+        return;
 
-    qCDebug(DBG_TOUCH) << " - considering delivering " << touchEvent.data() << " to " << item;
+    qCDebug(DBG_TOUCH) << "considering delivering " << touchEvent.data() << " to " << item;
     bool eventAccepted = false;
 
-    // First check whether the parent wants to be a filter,
-    // and if the parent accepts the event we are done.
-    if (sendFilteredTouchEvent(item->parentItem(), item, event, hasFiltered)) {
-        // If the touch was accepted (regardless by whom or in what form),
-        // update acceptedNewPoints
-        qCDebug(DBG_TOUCH) << " - can't. intercepted " << touchEvent.data() << " to " << item->parentItem() << " instead of " << item;
-        for (auto point: qAsConst(touchEvent->touchPoints())) {
-            event->pointById(point.id())->setAccepted();
-        }
-        return true;
-    }
+    // If any parent filters the event, we're done.
+    // updateFilteringParentItems was called when the press occurred,
+    // and we assume that the filtering relationships don't change between press and release.
+    if (sendFilteredPointerEvent(pointerEvent, item))
+        return;
 
     // Deliver the touch event to the given item
     qCDebug(DBG_TOUCH) << " - actually delivering " << touchEvent.data() << " to " << item;
@@ -2374,36 +2510,34 @@ bool QQuickWindowPrivate::deliverMatchingPointsToItem(QQuickItem *item, QQuickPo
     eventAccepted = touchEvent->isAccepted();
 
     // If the touch event wasn't accepted, synthesize a mouse event and see if the item wants it.
-    QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
     if (!eventAccepted && (itemPrivate->acceptedMouseButtons() & Qt::LeftButton)) {
         //  send mouse event
-        if (deliverTouchAsMouse(item, event))
+        if (deliverTouchAsMouse(item, ptEvent))
             eventAccepted = true;
     }
 
     if (eventAccepted) {
         // If the touch was accepted (regardless by whom or in what form),
         // update accepted new points.
+        bool isPressOrRelease = pointerEvent->isPressEvent() || pointerEvent->isReleaseEvent();
         for (auto point: qAsConst(touchEvent->touchPoints())) {
-            auto pointerEventPoint = event->pointById(point.id());
+            auto pointerEventPoint = ptEvent->pointById(point.id());
             pointerEventPoint->setAccepted();
-            if (point.state() == Qt::TouchPointPressed)
-                pointerEventPoint->setGrabber(item);
+            if (isPressOrRelease)
+                pointerEventPoint->setGrabberItem(item);
         }
     } else {
         // But if the event was not accepted then we know this item
         // will not be interested in further updates for those touchpoint IDs either.
         for (auto point: qAsConst(touchEvent->touchPoints())) {
             if (point.state() == Qt::TouchPointPressed) {
-                if (event->pointById(point.id())->grabber() == item) {
-                    qCDebug(DBG_TOUCH_TARGET) << "TP" << point.id() << "disassociated";
-                    event->pointById(point.id())->setGrabber(nullptr);
+                if (ptEvent->pointById(point.id())->exclusiveGrabber() == item) {
+                    qCDebug(DBG_TOUCH_TARGET) << "TP" << hex << point.id() << "disassociated";
+                    ptEvent->pointById(point.id())->setGrabberItem(nullptr);
                 }
             }
         }
     }
-
-    return eventAccepted;
 }
 
 #if QT_CONFIG(draganddrop)
@@ -2578,38 +2712,86 @@ QQuickItem *QQuickWindowPrivate::findCursorItem(QQuickItem *item, const QPointF
 }
 #endif
 
-bool QQuickWindowPrivate::sendFilteredTouchEvent(QQuickItem *target, QQuickItem *item, QQuickPointerTouchEvent *event, QSet<QQuickItem *> *hasFiltered)
+void QQuickWindowPrivate::updateFilteringParentItems(const QVector<QQuickItem *> &targetItems)
 {
-    Q_Q(QQuickWindow);
+    if (Q_UNLIKELY(DBG_MOUSE_TARGET().isDebugEnabled())) {
+        // qDebug() << map(&objectName, targetItems) but done the hard way because C++ is still that primitive
+        QStringList targetNames;
+        for (QQuickItem *t : targetItems)
+            targetNames << (QLatin1String(t->metaObject()->className()) + QLatin1Char(' ') + t->objectName());
+        qCDebug(DBG_MOUSE_TARGET) << "finding potential filtering parents of" << targetNames;
+    }
+    filteringParentItems.clear();
+    for (QQuickItem *item : targetItems) {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+        bool acceptsTouchEvents = item->acceptTouchEvents();
+#else
+        // In versions prior to Qt 6, we can't trust item->acceptTouchEvents() here, because it defaults to true.
+        bool acceptsTouchEvents = false;
+#endif
+        QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(item);
+        // If the item neither handles events nor has handlers which do, then it will never be a receiver, so filtering is irrelevant.
+        if (!item->acceptedMouseButtons() && !acceptsTouchEvents &&
+                !(itemPriv->extra.isAllocated() && !itemPriv->extra->pointerHandlers.isEmpty()))
+            continue;
+        QQuickItem *parent = item->parentItem();
+        while (parent) {
+            if (parent->filtersChildMouseEvents()) {
+                bool foundParent = false;
+                for (const QPair<QQuickItem*,QQuickItem*> existingItemAndParent : filteringParentItems)
+                    if (existingItemAndParent.second == parent)
+                        foundParent = true;
+                if (!foundParent)
+                    filteringParentItems.append(QPair<QQuickItem*,QQuickItem*>(item, parent));
+            }
+            parent = parent->parentItem();
+        }
+    }
+}
 
-    if (!target)
+bool QQuickWindowPrivate::sendFilteredPointerEvent(QQuickPointerEvent *event, QQuickItem *receiver, QQuickItem **itemThatFiltered)
+{
+    if (!allowChildEventFiltering)
         return false;
-
-    bool filtered = false;
-
-    QQuickItemPrivate *targetPrivate = QQuickItemPrivate::get(target);
-    if (targetPrivate->filtersChildMouseEvents && !hasFiltered->contains(target)) {
-        hasFiltered->insert(target);
-        QScopedPointer<QTouchEvent> targetEvent(event->touchEventForItem(target, true));
-        if (targetEvent) {
-            if (target->childMouseEventFilter(item, targetEvent.data())) {
-                qCDebug(DBG_TOUCH) << " - first chance intercepted on childMouseEventFilter by " << target;
-                QVector<int> touchIds;
-                const int touchPointCount = targetEvent->touchPoints().size();
-                touchIds.reserve(touchPointCount);
-                for (int i = 0; i < touchPointCount; ++i)
-                    touchIds.append(targetEvent->touchPoints().at(i).id());
-                target->grabTouchPoints(touchIds);
-                if (q->mouseGrabberItem()) {
-                    q->mouseGrabberItem()->ungrabMouse();
-                    touchMouseId = -1;
-                    touchMouseDevice = nullptr;
-                }
-                filtered = true;
+    bool ret = false;
+    if (QQuickPointerMouseEvent *pme = event->asPointerMouseEvent()) {
+        for (QPair<QQuickItem *,QQuickItem *> itemAndParent : filteringParentItems) {
+            QQuickItem *item = receiver ? receiver : itemAndParent.first;
+            QQuickItem *filteringParent = itemAndParent.second;
+            if (item == filteringParent)
+                continue; // a filtering item never needs to filter for itself
+            QPointF localPos = item->mapFromScene(pme->point(0)->scenePos());
+            QMouseEvent *me = pme->asMouseEvent(localPos);
+            if (filteringParent->childMouseEventFilter(item, me)) {
+                if (itemThatFiltered) *itemThatFiltered = item;
+                ret = true;
             }
-
-            for (int i = 0; i < targetEvent->touchPoints().size(); ++i) {
-                const QTouchEvent::TouchPoint &tp = targetEvent->touchPoints().at(i);
+        }
+    } else if (QQuickPointerTouchEvent *pte = event->asPointerTouchEvent()) {
+        QVarLengthArray<QPair<QQuickPointerHandler *, QQuickEventPoint *>, 32> passiveGrabsToCancel;
+        for (QPair<QQuickItem *,QQuickItem *> itemAndParent : filteringParentItems) {
+            QQuickItem *item = receiver ? receiver : itemAndParent.first;
+            if (item != itemAndParent.first)
+                continue;
+            if (!item->acceptTouchEvents() && !item->acceptedMouseButtons())
+                continue; // if this item won't accept, parents don't need to filter the touch for it
+            QQuickItem *filteringParent = itemAndParent.second;
+            if (item == filteringParent)
+                continue; // a filtering item never needs to filter for itself
+            // get a touch event customized for delivery to filteringParent
+            QScopedPointer<QTouchEvent> filteringParentTouchEvent(pte->touchEventForItem(filteringParent, true));
+            if (!filteringParentTouchEvent)
+                continue; // all points are stationary, or no touchpoints inside that parent
+            if (filteringParent->childMouseEventFilter(item, filteringParentTouchEvent.data())) {
+                qCDebug(DBG_TOUCH) << "touch event intercepted by childMouseEventFilter of " << filteringParent;
+                for (auto point: qAsConst(filteringParentTouchEvent->touchPoints()))
+                    event->pointById(point.id())->setAccepted();
+                ret = true;
+                break;
+            }
+            // filteringParent didn't filter the touch event.  Give it a chance to filter a synthetic mouse event.
+            for (int i = 0; i < filteringParentTouchEvent->touchPoints().size(); ++i) {
+                const QTouchEvent::TouchPoint &tp = filteringParentTouchEvent->touchPoints().at(i);
 
                 QEvent::Type t;
                 switch (tp.state()) {
@@ -2629,29 +2811,29 @@ bool QQuickWindowPrivate::sendFilteredTouchEvent(QQuickItem *target, QQuickItem
                 bool touchMouseUnset = (touchMouseId == -1);
                 // Only deliver mouse event if it is the touchMouseId or it could become the touchMouseId
                 if (touchMouseUnset || touchMouseId == tp.id()) {
-                    // targetEvent is already transformed wrt local position, velocity, etc.
-
-                    // FIXME: remove asTouchEvent!!!
-                    QScopedPointer<QMouseEvent> mouseEvent(touchToMouseEvent(t, tp, event->asTouchEvent(), item, false));
+                    // convert filteringParentTouchEvent (which is already transformed wrt local position, velocity, etc.)
+                    // into a synthetic mouse event, and let childMouseEventFilter() have another chance with that
+                    QScopedPointer<QMouseEvent> mouseEvent(touchToMouseEvent(t, tp, filteringParentTouchEvent.data(), item, false));
                     // If a filtering item calls QQuickWindow::mouseGrabberItem(), it should
                     // report the touchpoint's grabber.  Whenever we send a synthetic mouse event,
                     // touchMouseId and touchMouseDevice must be set, even if it's only temporarily and isn't grabbed.
                     touchMouseId = tp.id();
                     touchMouseDevice = event->device();
-                    if (target->childMouseEventFilter(item, mouseEvent.data())) {
-                        qCDebug(DBG_TOUCH) << " - second chance intercepted on childMouseEventFilter by " << target;
+                    if (filteringParent->childMouseEventFilter(item, mouseEvent.data())) {
+                        qCDebug(DBG_TOUCH) << "touch event intercepted as synth mouse event by childMouseEventFilter of " << filteringParent;
                         if (t != QEvent::MouseButtonRelease) {
-                            qCDebug(DBG_TOUCH_TARGET) << "TP" << tp.id() << "->" << target;
-                            if (touchMouseUnset) {
-                                // the point was grabbed as a pure touch point before, now it will be treated as mouse
-                                // but the old receiver still needs to be informed
-                                if (auto oldGrabber = pointerEventInstance(touchMouseDevice)->pointById(tp.id())->grabber())
-                                    oldGrabber->touchUngrabEvent();
-                            }
+                            qCDebug(DBG_TOUCH_TARGET) << "TP (mouse)" << hex << tp.id() << "->" << filteringParent;
+                            pointerEventInstance(touchMouseDevice)->pointById(tp.id())->setGrabberItem(filteringParent);
                             touchMouseUnset = false; // We want to leave touchMouseId and touchMouseDevice set
-                            target->grabMouse();
+                            filteringParent->grabMouse();
+                            auto pointerEventPoint = pte->pointById(tp.id());
+                            for (auto handler : pointerEventPoint->passiveGrabbers()) {
+                                QPair<QQuickPointerHandler *, QQuickEventPoint *> grab(handler, pointerEventPoint);
+                                if (!passiveGrabsToCancel.contains(grab))
+                                    passiveGrabsToCancel.append(grab);
+                            }
                         }
-                        filtered = true;
+                        ret = true;
                     }
                     if (touchMouseUnset) {
                         // Now that we're done sending a synth mouse event, and it wasn't grabbed,
@@ -2659,14 +2841,16 @@ bool QQuickWindowPrivate::sendFilteredTouchEvent(QQuickItem *target, QQuickItem
                         touchMouseId = -1;
                         touchMouseDevice = nullptr;
                     }
-                    // Only one event can be filtered as a mouse event.
-                    break;
+                    // Only one touchpoint can be treated as a synthetic mouse, so after childMouseEventFilter
+                    // has been called once, we're done with this loop over the touchpoints.
+                     break;
                 }
             }
         }
+        for (auto grab : passiveGrabsToCancel)
+            grab.second->cancelPassiveGrab(grab.first);
     }
-
-    return sendFilteredTouchEvent(target->parentItem(), item, event, hasFiltered) || filtered;
+    return ret;
 }
 
 bool QQuickWindowPrivate::sendFilteredMouseEvent(QQuickItem *target, QQuickItem *item, QEvent *event, QSet<QQuickItem *> *hasFiltered)
diff --git a/src/quick/items/qquickwindow_p.h b/src/quick/items/qquickwindow_p.h
index b3ff5a2b35..14564a7f55 100644
--- a/src/quick/items/qquickwindow_p.h
+++ b/src/quick/items/qquickwindow_p.h
@@ -143,11 +143,12 @@ public:
     bool deliverTouchAsMouse(QQuickItem *item, QQuickPointerEvent *pointerEvent);
     void translateTouchEvent(QTouchEvent *touchEvent);
     void setMouseGrabber(QQuickItem *grabber);
-    void grabTouchPoints(QQuickItem *grabber, const QVector<int> &ids);
+    void grabTouchPoints(QObject *grabber, const QVector<int> &ids);
     void removeGrabber(QQuickItem *grabber, bool mouse = true, bool touch = true);
     static QMouseEvent *cloneMouseEvent(QMouseEvent *event, QPointF *transformedLocalPos = 0);
     void deliverMouseEvent(QQuickPointerMouseEvent *pointerEvent);
     bool sendFilteredMouseEvent(QQuickItem *, QQuickItem *, QEvent *, QSet<QQuickItem *> *);
+    bool sendFilteredPointerEvent(QQuickPointerEvent *event, QQuickItem *receiver, QQuickItem **itemThatFiltered = 0);
 #if QT_CONFIG(wheelevent)
     bool deliverWheelEvent(QQuickItem *, QWheelEvent *);
 #endif
@@ -171,13 +172,13 @@ public:
     void deliverPointerEvent(QQuickPointerEvent *);
     void deliverTouchEvent(QQuickPointerTouchEvent *);
     bool deliverTouchCancelEvent(QTouchEvent *);
-    bool deliverPressEvent(QQuickPointerEvent *, QSet<QQuickItem *> *);
-    bool deliverUpdatedTouchPoints(QQuickPointerTouchEvent *event, QSet<QQuickItem *> *hasFiltered);
-    bool deliverMatchingPointsToItem(QQuickItem *item, QQuickPointerEvent *pointerEvent, QSet<QQuickItem*> *filtered);
-    bool sendFilteredTouchEvent(QQuickItem *target, QQuickItem *item, QQuickPointerTouchEvent *event, QSet<QQuickItem*> *filtered);
+    bool deliverPressOrReleaseEvent(QQuickPointerEvent *, bool handlersOnly = false);
+    void deliverUpdatedTouchPoints(QQuickPointerTouchEvent *event);
+    void deliverMatchingPointsToItem(QQuickItem *item, QQuickPointerEvent *pointerEvent, bool handlersOnly = false);
 
-    QVector<QQuickItem *> pointerTargets(QQuickItem *, const QPointF &, bool checkMouseButtons) const;
+    QVector<QQuickItem *> pointerTargets(QQuickItem *, const QPointF &, bool checkMouseButtons, bool checkAcceptsTouch) const;
     QVector<QQuickItem *> mergePointerTargets(const QVector<QQuickItem *> &list1, const QVector<QQuickItem *> &list2) const;
+    void updateFilteringParentItems(const QVector<QQuickItem *> &targetItems);
 
     // hover delivery
     bool deliverHoverEvent(QQuickItem *, const QPointF &scenePos, const QPointF &lastScenePos, Qt::KeyboardModifiers modifiers, ulong timestamp, bool &accepted);
@@ -226,6 +227,7 @@ public:
     QList<QSGNode *> cleanupNodeList;
 
     QVector<QQuickItem *> itemsToPolish;
+    QVector<QPair<QQuickItem *,QQuickItem *> > filteringParentItems;  // item:parent pairs
 
     qreal devicePixelRatio;
     QMetaObject::Connection physicalDpiChangedConnection;
@@ -263,6 +265,9 @@ public:
     uint lastWheelEventAccepted : 1;
     bool componentCompleted : 1;
 
+    bool allowChildEventFiltering : 1;
+    bool allowDoubleClick : 1;
+
     Qt::FocusReason lastFocusReason;
 
     QOpenGLFramebufferObject *renderTarget;
@@ -290,6 +295,14 @@ public:
         return overThreshold;
     }
 
+    static bool dragOverThreshold(const QQuickEventPoint *point)
+    {
+        QPointF delta = point->scenePos() - point->scenePressPos();
+        return (QQuickWindowPrivate::dragOverThreshold(delta.x(), Qt::XAxis, point) ||
+                QQuickWindowPrivate::dragOverThreshold(delta.y(), Qt::YAxis, point));
+    }
+
+
     // data property
     static void data_append(QQmlListProperty<QObject> *, QObject *);
     static int data_count(QQmlListProperty<QObject> *);
diff --git a/src/quick/quick.pro b/src/quick/quick.pro
index eae9b09b2f..e9a8b84b2a 100644
--- a/src/quick/quick.pro
+++ b/src/quick/quick.pro
@@ -30,6 +30,7 @@ ANDROID_BUNDLED_FILES += \
 include(util/util.pri)
 include(scenegraph/scenegraph.pri)
 include(items/items.pri)
+include(handlers/handlers.pri)
 qtConfig(quick-designer): \
     include(designer/designer.pri)
 qtConfig(accessibility) {
diff --git a/tests/auto/qmltest/events/tst_touch.qml b/tests/auto/qmltest/events/tst_touch.qml
index 5b209a6d0b..fd603e5a71 100644
--- a/tests/auto/qmltest/events/tst_touch.qml
+++ b/tests/auto/qmltest/events/tst_touch.qml
@@ -35,6 +35,16 @@ MultiPointTouchArea {
     width: 100
     height: 100
 
+    // touchUpdatedSpy stores the QQuickTouchPoint, and in some cases
+    // MultiPointTouchArea can delete it out from under us.
+    // (test_simpleChain was failing because touchUpdatedSpy.signalArguments[0][0][0]
+    // ended up as an empty object somehow.)  If we declare
+    // all the touchpoints that this test will use, that won't happen.
+    touchPoints: [
+        TouchPoint { },
+        TouchPoint { }
+    ]
+
     SignalSpy {
         id: touchUpdatedSpy
         target: touchArea
diff --git a/tests/auto/qmltest/listview/BLACKLIST b/tests/auto/qmltest/listview/BLACKLIST
index ffb4f94e2c..62bf89128d 100644
--- a/tests/auto/qmltest/listview/BLACKLIST
+++ b/tests/auto/qmltest/listview/BLACKLIST
@@ -1,4 +1,3 @@
 # Blacklist for testing
 [ListView::test_listInteractiveCurrentIndexEnforce]
-linux
-osx-10.12
+*
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..d01bcf74ed
--- /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: tap.isPressed || 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..4aac89402b
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/flickableinterop/data/TapHandlerButton.qml
@@ -0,0 +1,106 @@
+/****************************************************************************
+**
+** 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.point.scenePressPosition.x - radius
+        y: tap.point.scenePressPosition.y - radius
+        opacity: 0.25
+        Component.onCompleted: {
+            // get on top of all the buttons
+            var par = root.parent;
+            while (par.parent)
+                par = par.parent;
+            parent = par;
+        }
+    }
+}
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..833fef0a81
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/flickableinterop/data/flickableWithHandlers.qml
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** 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 {
+                    objectName: "DragThreshold"
+                    label: "DragThreshold"
+                    gesturePolicy: TapHandler.DragThreshold
+                }
+                TapHandlerButton {
+                    objectName: "WithinBounds"
+                    label: "WithinBounds"
+                    gesturePolicy: TapHandler.WithinBounds
+                }
+                TapHandlerButton {
+                    objectName: "ReleaseWithinBounds"
+                    label: "ReleaseWithinBounds"
+                    gesturePolicy: TapHandler.ReleaseWithinBounds // the default
+                }
+            }
+        }
+    }
+}
+
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..c8fe6052fb
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/flickableinterop/tst_flickableinterop.cpp
@@ -0,0 +1,475 @@
+/****************************************************************************
+**
+** 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_data();
+    void touchTapButton();
+    void touchDragFlickableBehindButton_data();
+    void touchDragFlickableBehindButton();
+    void mouseClickButton_data();
+    void mouseClickButton();
+    void mouseDragFlickableBehindButton_data();
+    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_data()
+{
+    QTest::addColumn<QString>("buttonName");
+    QTest::newRow("DragThreshold") << QStringLiteral("DragThreshold");
+    QTest::newRow("WithinBounds") << QStringLiteral("WithinBounds");
+    QTest::newRow("ReleaseWithinBounds") << QStringLiteral("ReleaseWithinBounds");
+}
+
+void tst_FlickableInterop::touchTapButton()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QFETCH(QString, buttonName);
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>(buttonName);
+    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_data()
+{
+    QTest::addColumn<QString>("buttonName");
+    QTest::newRow("DragThreshold") << QStringLiteral("DragThreshold");
+    QTest::newRow("WithinBounds") << QStringLiteral("WithinBounds");
+    QTest::newRow("ReleaseWithinBounds") << QStringLiteral("ReleaseWithinBounds");
+}
+
+void tst_FlickableInterop::touchDragFlickableBehindButton()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QFETCH(QString, buttonName);
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>(buttonName);
+    QVERIFY(button);
+    QQuickFlickable *flickable = window->rootObject()->findChild<QQuickFlickable*>();
+    QVERIFY(flickable);
+    QSignalSpy tappedSpy(button, SIGNAL(tapped()));
+
+    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;
+    // Start dragging; eventually when the touchpoint goes beyond dragThreshold,
+    // Button is no longer pressed because Flickable steals the grab
+    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_data()
+{
+    QTest::addColumn<QString>("buttonName");
+    QTest::newRow("DragThreshold") << QStringLiteral("DragThreshold");
+    QTest::newRow("WithinBounds") << QStringLiteral("WithinBounds");
+    QTest::newRow("ReleaseWithinBounds") << QStringLiteral("ReleaseWithinBounds");
+}
+
+void tst_FlickableInterop::mouseClickButton()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QFETCH(QString, buttonName);
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>(buttonName);
+    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_data()
+{
+    QTest::addColumn<QString>("buttonName");
+    QTest::newRow("DragThreshold") << QStringLiteral("DragThreshold");
+    QTest::newRow("WithinBounds") << QStringLiteral("WithinBounds");
+    QTest::newRow("ReleaseWithinBounds") << QStringLiteral("ReleaseWithinBounds");
+}
+
+void tst_FlickableInterop::mouseDragFlickableBehindButton()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "flickableWithHandlers.qml");
+    QQuickView * window = windowPtr.data();
+
+    QFETCH(QString, buttonName);
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>(buttonName);
+    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"
+
diff --git a/tests/auto/quick/pointerhandlers/multipointtoucharea_interop/data/pinchDragMPTA.qml b/tests/auto/quick/pointerhandlers/multipointtoucharea_interop/data/pinchDragMPTA.qml
new file mode 100644
index 0000000000..d479882d38
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/multipointtoucharea_interop/data/pinchDragMPTA.qml
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** 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 {
+    width: 1024; height: 600
+    color: "beige"
+    objectName: "beige root"
+
+    Rectangle {
+        id: container
+        objectName: "container rect"
+        width: 600
+        height: 500
+        color: "black"
+        border.color: pinch3.active ? "red" : "black"
+        border.width: 3
+        antialiasing: true
+
+        MultiPointTouchArea {
+            id: mpta
+            anchors.fill: parent
+            //onGestureStarted: gesture.grab() // in case this is embedded in something that might steal
+            touchPoints: [
+                TouchPoint { property color color: "red" },
+                TouchPoint { property color color: "orange" },
+                TouchPoint { property color color: "lightsteelblue" },
+                TouchPoint { property color color: "green" }
+            ] }
+
+        Repeater {
+            model: 4
+
+            Item {
+                id: crosshairs
+                property TouchPoint touchPoint
+                x: touchPoint.x - width / 2
+                y: touchPoint.y - height / 2
+                width: 300; height: 300
+                visible: touchPoint.pressed
+                rotation: touchPoint.rotation
+
+                Rectangle {
+                    color: touchPoint.color
+                    anchors.centerIn: parent
+                    width: 2; height: parent.height
+                    antialiasing: true
+                }
+                Rectangle {
+                    color: touchPoint.color
+                    anchors.centerIn: parent
+                    width: parent.width; height: 2
+                    antialiasing: true
+                }
+                Component.onCompleted: touchPoint = mpta.touchPoints[index]
+            }
+        }
+
+        Item {
+            objectName: "pinch and drag"
+            anchors.fill: parent
+            // In order for PinchHandler to get a chance to take a passive grab, it has to get the touchpoints first.
+            // In order to get the touchpoints first, it has to be on top of the Z order: i.e. come last in paintOrderChildItems().
+            // This is the opposite situation as with filtersChildMouseEvents: e.g. PinchArea would have wanted to be the parent,
+            // if it even knew that trick (which it doesn't).
+            PinchHandler {
+                id: pinch3
+                objectName: "3-finger pinch"
+                target: container
+                requiredPointCount: 3
+                minimumScale: 0.1
+                maximumScale: 10
+            }
+            DragHandler {
+                id: dragHandler
+                objectName: "DragHandler"
+                target: container
+            }
+        }
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/multipointtoucharea_interop/multipointtoucharea_interop.pro b/tests/auto/quick/pointerhandlers/multipointtoucharea_interop/multipointtoucharea_interop.pro
new file mode 100644
index 0000000000..10d0ff8018
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/multipointtoucharea_interop/multipointtoucharea_interop.pro
@@ -0,0 +1,15 @@
+CONFIG += testcase
+
+TARGET = tst_multipointtoucharea_interop
+QT += core-private gui-private qml-private quick-private  testlib
+
+macos:CONFIG -= app_bundle
+
+SOURCES  += tst_multipointtoucharea_interop.cpp
+
+include (../../../shared/util.pri)
+include (../../shared/util.pri)
+
+TESTDATA = data/*
+
+OTHER_FILES += data/pinchDragMPTA.qml
diff --git a/tests/auto/quick/pointerhandlers/multipointtoucharea_interop/tst_multipointtoucharea_interop.cpp b/tests/auto/quick/pointerhandlers/multipointtoucharea_interop/tst_multipointtoucharea_interop.cpp
new file mode 100644
index 0000000000..09a3c36b6d
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/multipointtoucharea_interop/tst_multipointtoucharea_interop.cpp
@@ -0,0 +1,261 @@
+/****************************************************************************
+**
+** 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 <QtQml/qqmlengine.h>
+#include <QtQml/qqmlproperty.h>
+#include <QtQuick/private/qquickdraghandler_p.h>
+#include <QtQuick/private/qquickmultipointtoucharea_p.h>
+#include <QtQuick/private/qquickpinchhandler_p.h>
+#include <QtQuick/qquickitem.h>
+#include <QtQuick/qquickview.h>
+
+#include "../../../shared/util.h"
+#include "../../shared/viewtestutil.h"
+
+Q_LOGGING_CATEGORY(lcPointerTests, "qt.quick.pointer.tests")
+
+class tst_MptaInterop : public QQmlDataTest
+{
+    Q_OBJECT
+public:
+    tst_MptaInterop()
+      : touchDevice(QTest::createTouchDevice())
+      , touchPointerDevice(QQuickPointerDevice::touchDevice(touchDevice))
+    {}
+
+private slots:
+    void initTestCase();
+
+    void touchDrag();
+    void touchesThenPinch();
+
+private:
+    void createView(QScopedPointer<QQuickView> &window, const char *fileName);
+    QTouchDevice *touchDevice;
+    QQuickPointerDevice *touchPointerDevice;
+};
+
+void tst_MptaInterop::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_MptaInterop::initTestCase()
+{
+    // This test assumes that we don't get synthesized mouse events from QGuiApplication
+    qApp->setAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents, false);
+
+    QQmlDataTest::initTestCase();
+}
+
+void tst_MptaInterop::touchDrag()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "pinchDragMPTA.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickMultiPointTouchArea *mpta = window->rootObject()->findChild<QQuickMultiPointTouchArea*>();
+    QVERIFY(mpta);
+    QQuickPinchHandler *pinch = window->rootObject()->findChild<QQuickPinchHandler*>();
+    QVERIFY(pinch);
+    QQuickDragHandler *drag = window->rootObject()->findChild<QQuickDragHandler*>();
+    QVERIFY(drag);
+    QQmlListReference tp(mpta, "touchPoints");
+    QVERIFY(tp.at(3)); // the QML declares four touchpoints
+    QSignalSpy mptaPressedSpy(mpta, SIGNAL(pressed(QList<QObject*>)));
+    QSignalSpy mptaReleasedSpy(mpta, SIGNAL(released(QList<QObject*>)));
+    QTest::QTouchEventSequence touch = QTest::touchEvent(window, touchDevice);
+
+    // Press one touchpoint:
+    // DragHandler gets a passive grab
+    // PinchHandler declines, because it wants 3 touchpoints
+    // MPTA doesn't get a chance, because DragHandler accepted the single EventPoint
+    QPoint p1 = mpta->mapToScene(QPointF(20, 20)).toPoint();
+    touch.press(1, p1).commit();
+    QQuickTouchUtils::flush(window);
+    auto pointerEvent = QQuickWindowPrivate::get(window)->pointerEventInstance(touchPointerDevice);
+    QCOMPARE(tp.at(0)->property("pressed").toBool(), false);
+//    QCOMPARE(pointerEvent->point(0)->exclusiveGrabber(), mpta);
+
+    // Start moving
+    // DragHandler gets keeps monitoring, due to its passive grab,
+    // and eventually steals the exclusive grab from MPTA
+    int dragStoleGrab = 0;
+    for (int i = 0; i < 4; ++i) {
+        p1 += QPoint(dragThreshold / 2, 0);
+        touch.move(1, p1).commit();
+        QQuickTouchUtils::flush(window);
+        if (!dragStoleGrab && pointerEvent->point(0)->exclusiveGrabber() == drag)
+            dragStoleGrab = i;
+//        QCOMPARE(tp.at(0)->property("pressed").toBool(), !dragStoleGrab);
+    }
+    qCDebug(lcPointerTests, "DragHandler stole the grab after %d events", dragStoleGrab);
+    QVERIFY(dragStoleGrab > 1);
+
+    touch.release(1, p1).commit();
+    QQuickTouchUtils::flush(window);
+}
+
+// TODO touchesThenPinch_data with press/release sequences somehow: vectors of touchpoint IDs? or a string representation?
+void tst_MptaInterop::touchesThenPinch()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "pinchDragMPTA.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickMultiPointTouchArea *mpta = window->rootObject()->findChild<QQuickMultiPointTouchArea*>();
+    QVERIFY(mpta);
+    QQuickPinchHandler *pinch = window->rootObject()->findChild<QQuickPinchHandler*>();
+    QVERIFY(pinch);
+    QQuickDragHandler *drag = window->rootObject()->findChild<QQuickDragHandler*>();
+    QVERIFY(drag);
+    QQmlListReference tp(mpta, "touchPoints");
+    QVERIFY(tp.at(3)); // the QML declares four touchpoints
+    QSignalSpy mptaPressedSpy(mpta, SIGNAL(pressed(QList<QObject*>)));
+    QSignalSpy mptaReleasedSpy(mpta, SIGNAL(released(QList<QObject*>)));
+    QTest::QTouchEventSequence touch = QTest::touchEvent(window, touchDevice);
+    auto pointerEvent = QQuickWindowPrivate::get(window)->pointerEventInstance(touchPointerDevice);
+
+    // Press one touchpoint:
+    // DragHandler gets a passive grab
+    // PinchHandler declines, because it wants 3 touchpoints
+    // MPTA doesn't get a chance, because DragHandler accepted the single EventPoint
+    QPoint p1 = mpta->mapToScene(QPointF(20, 20)).toPoint();
+    touch.press(1, p1).commit();
+    QQuickTouchUtils::flush(window);
+    QTRY_COMPARE(pointerEvent->point(0)->exclusiveGrabber(), nullptr);
+    QTRY_COMPARE(pointerEvent->point(0)->passiveGrabbers().first(), drag);
+//    QTRY_VERIFY(tp.at(0)->property("pressed").toBool());
+
+    // Press a second touchpoint: MPTA grabs it
+    QPoint p2 = mpta->mapToScene(QPointF(200, 30)).toPoint();
+    touch.stationary(1).press(2, p2).commit();
+    QQuickTouchUtils::flush(window);
+    QVERIFY(tp.at(0)->property("pressed").toBool());
+    QTRY_VERIFY(tp.at(1)->property("pressed").toBool());
+    QCOMPARE(mptaPressedSpy.count(), 1);
+
+    // ATM it's required that when PinchHandler sees the third touchpoint,
+    // the pre-existing points must have moved far enough to exceed the drag threshold.
+    // If MPTA is allowed to grab that third point, then PinchHandler won't steal.
+    // TODO should we change that?  make sure that if PH has a passive grab, it always gets updated even though MPTA has the grab?
+    for (int i = 0; i < 2; ++i) {
+        p1 += QPoint(dragThreshold, dragThreshold);
+        p2 += QPoint(dragThreshold, dragThreshold);
+        touch.move(1, p1).move(2, p2).commit();
+    }
+
+    // Press a third touchpoint: PinchHandler grabs, MPTA doesn't
+    QPoint p3 = mpta->mapToScene(QPointF(110, 200)).toPoint();
+    touch.stationary(1).stationary(2).press(3, p3).commit();
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(tp.at(0)->property("pressed").toBool(), true);
+    QCOMPARE(tp.at(1)->property("pressed").toBool(), true);
+    QCOMPARE(tp.at(2)->property("pressed").toBool(), false);
+    QCOMPARE(mptaPressedSpy.count(), 1);
+    QTRY_COMPARE(pointerEvent->point(2)->exclusiveGrabber(), pinch);
+    QVERIFY(pinch->active());
+
+    // Move some more: PinchHandler reacts
+    for (int i = 0; i < 8; ++i) {
+        p1 += QPoint(4, 4);
+        p2 += QPoint(4, 4);
+        p3 += QPoint(-4, 4);
+        touch.move(1, p1).move(2, p2).move(3, p3).commit();
+//        QTRY_COMPARE(tp.at(0)->property("pressed").toBool(), false); // TODO fails; MPTA doesn't know it lost its grabs
+//        QCOMPARE(tp.at(1)->property("pressed").toBool(), false);
+//        QCOMPARE(tp.at(2)->property("pressed").toBool(), false);
+    }
+    qCDebug(lcPointerTests) << "scale" << pinch->scale() << "rot" << pinch->rotation();
+    QTRY_VERIFY(pinch->rotation() > 10);
+    QVERIFY(pinch->scale() > 1);
+
+    // Press one more point (pinkie finger)
+    QPoint p4 = mpta->mapToScene(QPointF(300, 200)).toPoint();
+    touch.stationary(1).stationary(2).stationary(3).press(4, p4).commit();
+    // MPTA grabs p4 (which is at index 3)
+//    QTRY_COMPARE(pointerEvent->point(3)->exclusiveGrabber(), mpta);
+    // PinchHandler wantsPointerEvent declines, because it wants exactly 3 touchpoints, and there are now 4.
+    // Move some more... MPTA reacts, in spite of not grabbing all the points
+    for (int i = 0; i < 8; ++i) {
+        p1 += QPoint(4, 4);
+        p2 += QPoint(4, 4);
+        p3 += QPoint(-4, 4);
+        p4 += QPoint(-4, -4);
+        touch.move(1, p1).move(2, p2).move(3, p3).move(4, p4).commit();
+//        QTRY_COMPARE(pointerEvent->point(0)->exclusiveGrabber(), nullptr);
+//        QCOMPARE(pointerEvent->point(1)->exclusiveGrabber(), nullptr);
+//        QCOMPARE(pointerEvent->point(2)->exclusiveGrabber(), nullptr);
+//        QCOMPARE(pointerEvent->point(3)->exclusiveGrabber(), mpta);
+        QCOMPARE(tp.at(0)->property("pressed").toBool(), true);
+        QCOMPARE(tp.at(1)->property("pressed").toBool(), true);
+//        QCOMPARE(tp.at(2)->property("pressed").toBool(), true);
+//        QCOMPARE(tp.at(3)->property("pressed").toBool(), true);
+    }
+
+    // Release the pinkie
+    touch.stationary(1).stationary(2).stationary(3).release(4, p4).commit();
+    // Move some more: PinchHander grabs again, and reacts
+    for (int i = 0; i < 8; ++i) {
+        p1 -= QPoint(4, 4);
+        p2 += QPoint(4, 4);
+        p3 -= QPoint(-4, 4);
+        touch.move(1, p1).move(2, p2).move(3, p3).commit();
+        QTRY_COMPARE(pointerEvent->point(0)->exclusiveGrabber(), pinch);
+    }
+
+    // Release the first finger
+    touch.stationary(2).stationary(3).release(1, p1).commit();
+    // Move some more: PinchHander isn't interested in a mere 2 points, and MPTA should react... but it doesn't (TODO?)
+    for (int i = 0; i < 8; ++i) {
+        p1 -= QPoint(4, 4);
+        p2 += QPoint(4, 4);
+        touch.move(1, p1).move(2, p2).commit();
+        QTest::qWait(100);
+    }
+
+    touch.release(1, p1).release(2, p2).release(3, p3).commit();
+    QQuickTouchUtils::flush(window);
+//    QTRY_COMPARE(mptaReleasedSpy.count(), 1); // all points at once
+}
+
+QTEST_MAIN(tst_MptaInterop)
+
+#include "tst_multipointtoucharea_interop.moc"
diff --git a/tests/auto/quick/pointerhandlers/pointerhandlers.pro b/tests/auto/quick/pointerhandlers/pointerhandlers.pro
new file mode 100644
index 0000000000..2492924944
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/pointerhandlers.pro
@@ -0,0 +1,11 @@
+TEMPLATE = subdirs
+
+qtConfig(private_tests) {
+    SUBDIRS += \
+        flickableinterop \
+        multipointtoucharea_interop \
+        qquickpointerhandler \
+        qquickdraghandler \
+        qquicktaphandler \
+}
+
diff --git a/tests/auto/quick/pointerhandlers/qquickdraghandler/data/DragAnywhereSlider.qml b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/DragAnywhereSlider.qml
new file mode 100644
index 0000000000..9b0ef81635
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/DragAnywhereSlider.qml
@@ -0,0 +1,138 @@
+/****************************************************************************
+**
+** 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
+    objectName: label
+    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
+    width: 140
+    height: 400
+
+    DragHandler {
+        id: dragHandler
+        objectName: label.text + " DragHandler"
+        target: knob
+        xAxis.enabled: false
+        yAxis.minimum: slot.y
+        yAxis.maximum: slot.height + slot.y - knob.height
+    }
+
+    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: tap.isPressed || tapFlash.running ? 1 : 0
+        FlashAnimation on visible {
+            id: tapFlash
+        }
+    }
+    Rectangle {
+        id: knob
+        objectName: "Slider Knob"
+        width: parent.width - 2
+        height: 30
+        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 }
+        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/qquickdraghandler/data/FlashAnimation.qml b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/FlashAnimation.qml
new file mode 100644
index 0000000000..2224276819
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickdraghandler/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 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.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/qquickdraghandler/data/Slider.qml b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/Slider.qml
new file mode 100644
index 0000000000..81c261fc7a
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/Slider.qml
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** 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
+    objectName: label
+    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
+    width: 140
+    height: 400
+
+    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: tap.isPressed || tapFlash.running ? 1 : 0
+        FlashAnimation on visible {
+            id: tapFlash
+        }
+    }
+    Rectangle {
+        id: knob
+        objectName: root.label + " Knob"
+        width: parent.width - 2
+        height: 30
+        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 }
+        function flash() { tapFlash.start() }
+        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/qquickdraghandler/data/draggables.qml b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/draggables.qml
new file mode 100644
index 0000000000..5ed9bd1523
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/draggables.qml
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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.8
+import Qt.labs.handlers 1.0
+
+Item {
+    id: root
+    objectName: "Draggables"
+    width: 640
+    height: 480
+
+    Repeater {
+        model: 2
+
+        Rectangle {
+            id: ball
+            objectName: "Ball " + index
+            color: dragHandler.active ? "blue" : "lightsteelblue"
+            width: 80; height: 80; x: 200 + index * 200; y: 200; radius: width / 2
+            onParentChanged: console.log(this + " parent " + parent)
+
+            DragHandler {
+                id: dragHandler
+                objectName: "DragHandler " + index
+            }
+
+            Text {
+                color: "white"
+                anchors.centerIn: parent
+                text: dragHandler.point.position.x.toFixed(1) + "," + dragHandler.point.position.y.toFixed(1)
+            }
+        }
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/qquickdraghandler/data/multipleSliders.qml b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/multipleSliders.qml
new file mode 100644
index 0000000000..bcb16f54cb
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/multipleSliders.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: 900
+    height: 850
+    objectName: "root"
+    color: "#222222"
+
+    Grid {
+        objectName: "grid"
+        anchors.fill: parent
+        spacing: 10
+        columns: 6
+        Repeater {
+            id: top
+            objectName: "top"
+            model: 6
+
+            delegate: Slider {
+                objectName: label
+                label: "Drag Knob " + index
+                width: 140
+            }
+        }
+        Repeater {
+            id: bottom
+            objectName: "bottom"
+            model: 6
+
+            delegate: DragAnywhereSlider {
+                objectName: label
+                label: "Drag Anywhere " + index
+                width: 140
+            }
+        }
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/qquickdraghandler/data/reparenting.qml b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/reparenting.qml
new file mode 100644
index 0000000000..3545badd86
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickdraghandler/data/reparenting.qml
@@ -0,0 +1,60 @@
+import QtQuick 2.8
+import Qt.labs.handlers 1.0
+
+Grid {
+    id: root
+    objectName: "root"
+    property bool reparentOnDrag: true
+    width: 200; height: 200
+    columns: 3
+    spacing: 10
+    Repeater {
+        model: 9
+        anchors.fill: parent
+        Item {
+            id: gridPlaceholder
+            objectName: "gridPlaceholder" + index
+            width: 60
+            height: 60
+            Rectangle {
+                id: icon
+                border.color: "black"
+                color: "beige"
+                radius: 3
+                width: 60
+                height: 60
+                onParentChanged :console.log("parent " + parent)
+                anchors {
+                    horizontalCenter: parent.horizontalCenter
+                    verticalCenter: parent.verticalCenter
+                }
+                DragHandler {
+                    id: dragArea
+                }
+                Text {
+                    anchors.centerIn: parent
+                    text: index + "@" + Math.round(icon.x) + "," + Math.round(icon.y)
+                    font.pointSize: 8
+                }
+                states: [
+                    State {
+                        when: dragArea.dragging
+                        AnchorChanges {
+                            target: icon
+                            anchors.horizontalCenter: undefined
+                            anchors.verticalCenter: undefined
+                        }
+                        ParentChange {
+                            target: root.reparentOnDrag ? icon : null
+                            parent: root
+                        }
+                        PropertyChanges {
+                            target: icon
+                            color: "yellow"
+                        }
+                    }
+                ]
+            }
+        }
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/qquickdraghandler/qquickdraghandler.pro b/tests/auto/quick/pointerhandlers/qquickdraghandler/qquickdraghandler.pro
new file mode 100644
index 0000000000..b50fe5ca6f
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickdraghandler/qquickdraghandler.pro
@@ -0,0 +1,15 @@
+CONFIG += testcase
+
+TARGET = tst_qquickdraghandler
+QT += core-private gui-private qml-private quick-private  testlib
+
+macos:CONFIG -= app_bundle
+
+SOURCES  += tst_qquickdraghandler.cpp
+
+include (../../../shared/util.pri)
+include (../../shared/util.pri)
+
+TESTDATA = data/*
+
+# OTHER_FILES += data/foo.qml
diff --git a/tests/auto/quick/pointerhandlers/qquickdraghandler/tst_qquickdraghandler.cpp b/tests/auto/quick/pointerhandlers/qquickdraghandler/tst_qquickdraghandler.cpp
new file mode 100644
index 0000000000..5b59911965
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickdraghandler/tst_qquickdraghandler.cpp
@@ -0,0 +1,405 @@
+/****************************************************************************
+**
+** 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 <QtQml/qqmlengine.h>
+#include <QtQml/qqmlproperty.h>
+#include <QtQuick/private/qquickdraghandler_p.h>
+#include <QtQuick/private/qquickrepeater_p.h>
+#include <QtQuick/private/qquicktaphandler_p.h>
+#include <QtQuick/qquickitem.h>
+#include <QtQuick/qquickview.h>
+
+#include "../../../shared/util.h"
+#include "../../shared/viewtestutil.h"
+
+Q_LOGGING_CATEGORY(lcPointerTests, "qt.quick.pointer.tests")
+
+class tst_DragHandler : public QQmlDataTest
+{
+    Q_OBJECT
+public:
+    tst_DragHandler()
+        :touchDevice(QTest::createTouchDevice())
+    {}
+
+private slots:
+    void initTestCase();
+
+    void defaultPropertyValues();
+    void touchDrag();
+    void mouseDrag();
+    void touchDragMulti();
+    void touchDragMultiSliders_data();
+    void touchDragMultiSliders();
+
+private:
+    void createView(QScopedPointer<QQuickView> &window, const char *fileName);
+    QTouchDevice *touchDevice;
+};
+
+void tst_DragHandler::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_DragHandler::initTestCase()
+{
+    // This test assumes that we don't get synthesized mouse events from QGuiApplication
+    qApp->setAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents, false);
+
+    QQmlDataTest::initTestCase();
+}
+
+void tst_DragHandler::defaultPropertyValues()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "draggables.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *ball = window->rootObject()->childItems().first();
+    QVERIFY(ball);
+    QQuickDragHandler *dragHandler = ball->findChild<QQuickDragHandler*>();
+    QVERIFY(dragHandler);
+
+    QCOMPARE(dragHandler->acceptedButtons(), Qt::LeftButton);
+    QCOMPARE(dragHandler->translation(), QPointF());
+    QCOMPARE(dragHandler->point().position(), QPointF());
+    QCOMPARE(dragHandler->point().scenePosition(), QPointF());
+    QCOMPARE(dragHandler->point().pressPosition(), QPointF());
+    QCOMPARE(dragHandler->point().scenePressPosition(), QPointF());
+    QCOMPARE(dragHandler->point().sceneGrabPosition(), QPointF());
+}
+
+void tst_DragHandler::touchDrag()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "draggables.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *ball = window->rootObject()->childItems().first();
+    QVERIFY(ball);
+    QQuickDragHandler *dragHandler = ball->findChild<QQuickDragHandler*>();
+    QVERIFY(dragHandler);
+
+    QSignalSpy translationChangedSpy(dragHandler, SIGNAL(translationChanged()));
+
+    QPointF ballCenter = ball->clipRect().center();
+    QPointF scenePressPos = ball->mapToScene(ballCenter);
+    QPoint p1 = scenePressPos.toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(!dragHandler->active());
+    QCOMPARE(dragHandler->point().position(), ballCenter);
+    QCOMPARE(dragHandler->point().pressPosition(), ballCenter);
+    QCOMPARE(dragHandler->point().scenePosition(), scenePressPos);
+    QCOMPARE(dragHandler->point().scenePressPosition(), scenePressPos);
+    p1 += QPoint(dragThreshold, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(!dragHandler->active());
+    p1 += QPoint(1, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(dragHandler->active());
+    QCOMPARE(translationChangedSpy.count(), 0);
+    QCOMPARE(dragHandler->translation().x(), 0.0);
+    QPointF sceneGrabPos = p1;
+    QCOMPARE(dragHandler->point().sceneGrabPosition(), sceneGrabPos);
+    p1 += QPoint(19, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(dragHandler->active());
+    QCOMPARE(dragHandler->point().position(), ballCenter);
+    QCOMPARE(dragHandler->point().pressPosition(), ballCenter);
+    QCOMPARE(dragHandler->point().scenePosition(), ball->mapToScene(ballCenter));
+    QCOMPARE(dragHandler->point().scenePressPosition(), scenePressPos);
+    QCOMPARE(dragHandler->point().sceneGrabPosition(), sceneGrabPos);
+    QCOMPARE(dragHandler->translation().x(), dragThreshold + 20.0);
+    QCOMPARE(dragHandler->translation().y(), 0.0);
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!dragHandler->active());
+    QCOMPARE(dragHandler->point().pressedButtons(), Qt::NoButton);
+    QCOMPARE(ball->mapToScene(ballCenter).toPoint(), p1);
+    QCOMPARE(translationChangedSpy.count(), 1);
+}
+
+void tst_DragHandler::mouseDrag()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "draggables.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *ball = window->rootObject()->childItems().first();
+    QVERIFY(ball);
+    QQuickDragHandler *dragHandler = ball->findChild<QQuickDragHandler*>();
+    QVERIFY(dragHandler);
+
+    QSignalSpy translationChangedSpy(dragHandler, SIGNAL(translationChanged()));
+
+    QPointF ballCenter = ball->clipRect().center();
+    QPointF scenePressPos = ball->mapToScene(ballCenter);
+    QPoint p1 = scenePressPos.toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QVERIFY(!dragHandler->active());
+    QCOMPARE(dragHandler->point().position(), ballCenter);
+    QCOMPARE(dragHandler->point().pressPosition(), ballCenter);
+    QCOMPARE(dragHandler->point().scenePosition(), scenePressPos);
+    QCOMPARE(dragHandler->point().scenePressPosition(), scenePressPos);
+    p1 += QPoint(dragThreshold, 0);
+    QTest::mouseMove(window, p1);
+    QVERIFY(!dragHandler->active());
+    p1 += QPoint(1, 0);
+    QTest::mouseMove(window, p1);
+    QTRY_VERIFY(dragHandler->active());
+    QCOMPARE(translationChangedSpy.count(), 0);
+    QCOMPARE(dragHandler->translation().x(), 0.0);
+    QPointF sceneGrabPos = p1;
+    QCOMPARE(dragHandler->point().sceneGrabPosition(), sceneGrabPos);
+    p1 += QPoint(19, 0);
+    QTest::mouseMove(window, p1);
+    QTRY_VERIFY(dragHandler->active());
+    QCOMPARE(dragHandler->point().position(), ballCenter);
+    QCOMPARE(dragHandler->point().pressPosition(), ballCenter);
+    QCOMPARE(dragHandler->point().scenePosition(), ball->mapToScene(ballCenter));
+    QCOMPARE(dragHandler->point().scenePressPosition(), scenePressPos);
+    QCOMPARE(dragHandler->point().sceneGrabPosition(), sceneGrabPos);
+    QCOMPARE(dragHandler->translation().x(), dragThreshold + 20.0);
+    QCOMPARE(dragHandler->translation().y(), 0.0);
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(!dragHandler->active());
+    QCOMPARE(dragHandler->point().pressedButtons(), Qt::NoButton);
+    QCOMPARE(ball->mapToScene(ballCenter).toPoint(), p1);
+    QCOMPARE(translationChangedSpy.count(), 1);
+}
+
+void tst_DragHandler::touchDragMulti()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "draggables.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *ball1 = window->rootObject()->childItems().first();
+    QVERIFY(ball1);
+    QQuickDragHandler *dragHandler1 = ball1->findChild<QQuickDragHandler*>();
+    QVERIFY(dragHandler1);
+    QSignalSpy translationChangedSpy1(dragHandler1, SIGNAL(translationChanged()));
+
+    QQuickItem *ball2 = window->rootObject()->childItems().at(1);
+    QVERIFY(ball2);
+    QQuickDragHandler *dragHandler2 = ball2->findChild<QQuickDragHandler*>();
+    QVERIFY(dragHandler2);
+    QSignalSpy translationChangedSpy2(dragHandler2, SIGNAL(translationChanged()));
+
+    QPointF ball1Center = ball1->clipRect().center();
+    QPointF scenePressPos1 = ball1->mapToScene(ball1Center);
+    QPoint p1 = scenePressPos1.toPoint();
+    QPointF ball2Center = ball2->clipRect().center();
+    QPointF scenePressPos2 = ball2->mapToScene(ball2Center);
+    QPoint p2 = scenePressPos2.toPoint();
+
+    QTest::touchEvent(window, touchDevice).press(1, p1, window).press(2, p2, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(!dragHandler1->active());
+    QCOMPARE(dragHandler1->point().position(), ball1Center);
+    QCOMPARE(dragHandler1->point().pressPosition(), ball1Center);
+    QCOMPARE(dragHandler1->point().scenePosition(), scenePressPos1);
+    QCOMPARE(dragHandler1->point().scenePressPosition(), scenePressPos1);
+    QVERIFY(!dragHandler2->active());
+    QCOMPARE(dragHandler2->point().position(), ball2Center);
+    QCOMPARE(dragHandler2->point().pressPosition(), ball2Center);
+    QCOMPARE(dragHandler2->point().scenePosition(), scenePressPos2);
+    QCOMPARE(dragHandler2->point().scenePressPosition(), scenePressPos2);
+    p1 += QPoint(dragThreshold, 0);
+    p2 += QPoint(0, dragThreshold);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window).move(2, p2, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(!dragHandler1->active());
+    p1 += QPoint(1, 0);
+    p2 += QPoint(0, 1);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window).move(2, p2, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(dragHandler1->active());
+    QVERIFY(dragHandler2->active());
+    QCOMPARE(translationChangedSpy1.count(), 0);
+    QCOMPARE(dragHandler1->translation().x(), 0.0);
+    QPointF sceneGrabPos1 = p1;
+    QPointF sceneGrabPos2 = p2;
+    QCOMPARE(dragHandler1->point().sceneGrabPosition(), sceneGrabPos1);
+    QCOMPARE(dragHandler2->point().sceneGrabPosition(), sceneGrabPos2);
+    p1 += QPoint(19, 0);
+    p2 += QPoint(0, 19);
+    QVERIFY(dragHandler2->active());
+    QCOMPARE(translationChangedSpy2.count(), 0);
+    QCOMPARE(dragHandler2->translation().x(), 0.0);
+    QCOMPARE(dragHandler2->point().sceneGrabPosition(), sceneGrabPos2);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window).move(2, p2, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(dragHandler1->active());
+    QVERIFY(dragHandler2->active());
+    QCOMPARE(dragHandler1->point().position(), ball1Center);
+    QCOMPARE(dragHandler1->point().pressPosition(), ball1Center);
+    QCOMPARE(dragHandler1->point().scenePosition(), ball1->mapToScene(ball1Center));
+    QCOMPARE(dragHandler1->point().scenePressPosition(), scenePressPos1);
+    QCOMPARE(dragHandler1->point().sceneGrabPosition(), sceneGrabPos1);
+    QCOMPARE(dragHandler1->translation().x(), dragThreshold + 20.0);
+    QCOMPARE(dragHandler1->translation().y(), 0.0);
+    QCOMPARE(dragHandler2->point().position(), ball2Center);
+    QCOMPARE(dragHandler2->point().pressPosition(), ball2Center);
+    QCOMPARE(dragHandler2->point().scenePosition(), ball2->mapToScene(ball2Center));
+    QCOMPARE(dragHandler2->point().scenePressPosition(), scenePressPos2);
+    QCOMPARE(dragHandler2->point().sceneGrabPosition(), sceneGrabPos2);
+    QCOMPARE(dragHandler2->translation().x(), 0.0);
+    QCOMPARE(dragHandler2->translation().y(), dragThreshold + 20.0);
+    QTest::touchEvent(window, touchDevice).release(1, p1, window).stationary(2);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!dragHandler1->active());
+    QVERIFY(dragHandler2->active());
+    QCOMPARE(dragHandler1->point().pressedButtons(), Qt::NoButton);
+    QCOMPARE(ball1->mapToScene(ball1Center).toPoint(), p1);
+    QCOMPARE(translationChangedSpy1.count(), 1);
+    QTest::touchEvent(window, touchDevice).release(2, p2, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!dragHandler2->active());
+    QCOMPARE(ball2->mapToScene(ball2Center).toPoint(), p2);
+    QCOMPARE(translationChangedSpy2.count(), 1);
+}
+
+void tst_DragHandler::touchDragMultiSliders_data()
+{
+    QTest::addColumn<int>("sliderRow");
+    QTest::addColumn<QVector<int> >("whichSliders");
+    QTest::addColumn<QVector<int> >("startingCenterOffsets");
+    QTest::addColumn<QVector<QVector2D> >("movements");
+
+    QTest::newRow("Drag Knob: start on the knobs, drag down") <<
+        0 << QVector<int> { 0, 1, 2 } << QVector<int> { 0, 0, 0 } << QVector<QVector2D> { {0, 60}, {0, 60}, {0, 60} };
+    QTest::newRow("Drag Knob: start on the knobs, drag diagonally downward") <<
+        0 << QVector<int> { 0, 1, 2 } << QVector<int> { 0, 0, 0 } << QVector<QVector2D> { {20, 40}, {20, 60}, {20, 80} };
+    // TOOD these fail
+//    QTest::newRow("Drag Anywhere: start on the knobs, drag down") <<
+//        1 << QVector<int> { 0, 1, 2 } << QVector<int> { 0, 0, 0 } << QVector<QVector2D> { {0, 60}, {0, 60}, {0, 60} };
+//    QTest::newRow("Drag Anywhere: start on the knobs, drag diagonally downward") <<
+//        1 << QVector<int> { 0, 1, 2 } << QVector<int> { 0, 0, 0 } << QVector<QVector2D> { {20, 40}, {20, 60}, {20, 80} };
+    // TODO these next two fail because the DragHandler grabs when a finger
+    // drags across it from outside, but should rather start only if it is pressed inside
+//    QTest::newRow("Drag Knob: start above the knobs, drag down") <<
+//        0 << QVector<int> { 0, 1, 2 } << QVector<int> { -30, -30, -30 } << QVector<QVector2D> { {0, 40}, {0, 60}, {0, 80} };
+//    QTest::newRow("Drag Knob: start above the knobs, drag diagonally downward") <<
+//        0 << QVector<int> { 0, 1, 2 } << QVector<int> { -30, -30, -30 } << QVector<QVector2D> { {20, 40}, {20, 60}, {20, 80} };
+    QTest::newRow("Drag Anywhere: start above the knobs, drag down") <<
+        1 << QVector<int> { 0, 1, 2 } << QVector<int> { -20, -30, -40 } << QVector<QVector2D> { {0, 60}, {0, 60}, {0, 60} };
+    QTest::newRow("Drag Anywhere: start above the knobs, drag diagonally downward") <<
+        1 << QVector<int> { 0, 1, 2 } << QVector<int> { -20, -30, -40 } << QVector<QVector2D> { {20, 40}, {20, 60}, {20, 80} };
+}
+
+void tst_DragHandler::touchDragMultiSliders()
+{
+    QFETCH(int, sliderRow);
+    QFETCH(QVector<int>, whichSliders);
+    QFETCH(QVector<int>, startingCenterOffsets);
+    QFETCH(QVector<QVector2D>, movements);
+    const int moveCount = 8;
+
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "multipleSliders.qml");
+    QQuickView * window = windowPtr.data();
+    QTest::QTouchEventSequence touch = QTest::touchEvent(window, touchDevice);
+
+    QQuickRepeater *rowRepeater = window->rootObject()->findChildren<QQuickRepeater *>()[sliderRow];
+    QVector<QQuickItem *> knobs;
+    QVector<QQuickDragHandler *> dragHandlers;
+    QVector<QQuickTapHandler *> tapHandlers;
+    QVector<QPointF> startPoints;
+    for (int sli : whichSliders) {
+        QQuickItem *slider = rowRepeater->itemAt(sli);
+        QVERIFY(slider);
+        dragHandlers << slider->findChild<QQuickDragHandler*>();
+        QVERIFY(dragHandlers[sli]);
+        tapHandlers << slider->findChild<QQuickTapHandler*>();
+        QVERIFY(tapHandlers[sli]);
+        knobs << tapHandlers[sli]->parentItem();
+        QPointF startPoint = knobs[sli]->mapToScene(knobs[sli]->clipRect().center());
+        startPoint.setY(startPoint.y() + startingCenterOffsets[sli]);
+        startPoints << startPoint;
+        qCDebug(lcPointerTests) << "row" << sliderRow << "slider" << sli << slider->objectName() <<
+            "start" << startingCenterOffsets[sli] << startPoints[sli];
+    }
+    QVector<QPointF> touchPoints = startPoints;
+
+    // Press
+    for (int sli : whichSliders)
+        touch.press(sli, touchPoints[sli].toPoint());
+    touch.commit();
+
+    // Moves
+    for (int m = 0; m < moveCount; ++m) {
+        for (int sli : whichSliders) {
+            QVector2D incr = movements[sli] / moveCount;
+            touchPoints[sli] += incr.toPointF();
+            touch.move(sli, touchPoints[sli].toPoint());
+        }
+        touch.commit();
+        QQuickTouchUtils::flush(window);
+    }
+
+    // Check that they moved to where they should: since the slider is constrained,
+    // only the y component should have an effect; knobs should not come out of their "grooves"
+    for (int sli : whichSliders) {
+        QPoint endPosition = knobs[sli]->mapToScene(knobs[sli]->clipRect().center()).toPoint();
+        QPoint expectedEndPosition(startPoints[sli].x(), startPoints[sli].y() + movements[sli].y());
+        if (sliderRow == 0 && qAbs(startingCenterOffsets[sli]) > knobs[sli]->height() / 2)
+            expectedEndPosition = startPoints[sli].toPoint();
+        qCDebug(lcPointerTests) << "slider " << knobs[sli]->objectName() << "started @" << startPoints[sli]
+            << "tried to move by" << movements[sli] << "ended up @" << endPosition << "expected" << expectedEndPosition;
+        QTRY_COMPARE(endPosition, expectedEndPosition);
+    }
+
+    // Release
+    for (int sli : whichSliders)
+        touch.release(sli, touchPoints[sli].toPoint());
+    touch.commit();
+}
+
+QTEST_MAIN(tst_DragHandler)
+
+#include "tst_qquickdraghandler.moc"
+
diff --git a/tests/auto/quick/pointerhandlers/qquickpointerhandler/data/singleitem.qml b/tests/auto/quick/pointerhandlers/qquickpointerhandler/data/singleitem.qml
new file mode 100644
index 0000000000..126cf3ff2b
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickpointerhandler/data/singleitem.qml
@@ -0,0 +1,28 @@
+import QtQuick 2.8
+import Qt.test 1.0
+
+Item {
+    id: root
+    objectName: "root Item"
+    width: 320
+    height: 480
+
+    Rectangle {
+        objectName: "eventItem's bounds"
+        anchors.fill: eventItem
+        color: "lightsteelblue"
+    }
+
+    EventItem {
+        id: eventItem
+        objectName: "eventItem1"
+        x: 5
+        y: 5
+        height: 30
+        width: 30
+
+        EventHandler {
+            objectName: "eventHandler"
+        }
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/qquickpointerhandler/qquickpointerhandler.pro b/tests/auto/quick/pointerhandlers/qquickpointerhandler/qquickpointerhandler.pro
new file mode 100644
index 0000000000..c386969206
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickpointerhandler/qquickpointerhandler.pro
@@ -0,0 +1,16 @@
+CONFIG += testcase
+
+TARGET = tst_qquickpointerhandler
+QT += core-private gui-private qml-private quick-private  testlib
+
+macos:CONFIG -= app_bundle
+
+SOURCES  += tst_qquickpointerhandler.cpp
+
+include (../../../shared/util.pri)
+include (../../shared/util.pri)
+
+TESTDATA = data/*
+
+# OTHER_FILES += data/foo.qml
+
diff --git a/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp b/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp
new file mode 100644
index 0000000000..bb4361255c
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp
@@ -0,0 +1,579 @@
+/****************************************************************************
+**
+** 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 <private/qdebug_p.h>
+#include <QtGui/qstylehints.h>
+#include <QtQuick/private/qquickpointerhandler_p.h>
+#include <QtQuick/qquickitem.h>
+#include <QtQuick/qquickview.h>
+
+#include "../../../shared/util.h"
+#include "../../shared/viewtestutil.h"
+
+Q_LOGGING_CATEGORY(lcPointerTests, "qt.quick.pointer.tests")
+
+class Event
+{
+    Q_GADGET
+public:
+    enum Destination {
+        FilterDestination,
+        MouseDestination,
+        TouchDestination,
+        HandlerDestination
+    };
+    Q_ENUM(Destination)
+
+    Event(Destination d, QEvent::Type t, Qt::TouchPointState s, int grabState, QPointF item, QPointF scene)
+        : destination(d), type(t), state(s), grabState(grabState), posWrtItem(item), posWrtScene(scene)
+    {}
+
+    Destination destination;
+    QEvent::Type type;                      // if this represents a QEvent that was received
+    Qt::TouchPointState state;              // if this represents an event (pointer, touch or mouse)
+    int grabState;                          // if this represents an onGrabChanged() notification (QQuickEventPoint::GrabState)
+    QPointF posWrtItem;
+    QPointF posWrtScene;
+};
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const class Event &event) {
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
+    dbg << "Event(";
+    QtDebugUtils::formatQEnum(dbg, event.destination);
+    dbg << ' ';
+    QtDebugUtils::formatQEnum(dbg, event.type);
+    dbg << ' ';
+    QtDebugUtils::formatQEnum(dbg, event.state);
+    if (event.grabState) {
+        dbg << ' ';
+        QtDebugUtils::formatQEnum(dbg, QQuickEventPoint::GrabState(event.grabState));
+    }
+    dbg << " @ ";
+    QtDebugUtils::formatQPoint(dbg, event.posWrtItem);
+    dbg << " S ";
+    QtDebugUtils::formatQPoint(dbg, event.posWrtScene);
+    dbg << ')';
+    return dbg;
+}
+#endif
+
+enum {
+    NoGrab = 0,
+};
+
+class EventItem : public QQuickItem
+{
+    Q_OBJECT
+public:
+    EventItem(QQuickItem *parent = 0)
+        : QQuickItem(parent), acceptPointer(false), grabPointer(false), acceptMouse(false), acceptTouch(false), filterTouch(false)
+    {}
+
+    inline int grabState(bool accept, Qt::TouchPointState state) {
+        return (accept && (state != Qt::TouchPointReleased)) ? (int)QQuickEventPoint::GrabExclusive : (int)NoGrab;
+    }
+
+    void touchEvent(QTouchEvent *event)
+    {
+        qCDebug(lcPointerTests) << event << "will accept?" << acceptTouch;
+        for (const QTouchEvent::TouchPoint &tp : event->touchPoints())
+            eventList.append(Event(Event::TouchDestination, event->type(), tp.state(), grabState(acceptTouch, tp.state()), tp.pos(), tp.scenePos()));
+        event->setAccepted(acceptTouch);
+    }
+    void mousePressEvent(QMouseEvent *event)
+    {
+        qCDebug(lcPointerTests) << event;
+        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointPressed, grabState(acceptMouse, Qt::TouchPointPressed), event->pos(), event->windowPos()));
+        event->setAccepted(acceptMouse);
+    }
+    void mouseMoveEvent(QMouseEvent *event)
+    {
+        qCDebug(lcPointerTests) << event;
+        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointMoved, grabState(acceptMouse, Qt::TouchPointMoved), event->pos(), event->windowPos()));
+        event->setAccepted(acceptMouse);
+    }
+    void mouseReleaseEvent(QMouseEvent *event)
+    {
+        qCDebug(lcPointerTests) << event;
+        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointReleased, grabState(acceptMouse, Qt::TouchPointReleased), event->pos(), event->windowPos()));
+        event->setAccepted(acceptMouse);
+    }
+    void mouseDoubleClickEvent(QMouseEvent *event)
+    {
+        qCDebug(lcPointerTests) << event;
+        eventList.append(Event(Event::MouseDestination, event->type(), Qt::TouchPointPressed, grabState(acceptMouse, Qt::TouchPointPressed), event->pos(), event->windowPos()));
+        event->setAccepted(acceptMouse);
+    }
+
+    void mouseUngrabEvent()
+    {
+        qCDebug(lcPointerTests);
+        eventList.append(Event(Event::MouseDestination, QEvent::UngrabMouse, Qt::TouchPointReleased, QQuickEventPoint::UngrabExclusive, QPoint(0,0), QPoint(0,0)));
+    }
+
+    bool event(QEvent *event)
+    {
+        qCDebug(lcPointerTests) << event;
+        return QQuickItem::event(event);
+    }
+
+    QList<Event> eventList;
+    bool acceptPointer;
+    bool grabPointer;
+    bool acceptMouse;
+    bool acceptTouch;
+    bool filterTouch; // when used as event filter
+
+    bool eventFilter(QObject *o, QEvent *event)
+    {
+        qCDebug(lcPointerTests) << event << o;
+        if (event->type() == QEvent::TouchBegin ||
+                event->type() == QEvent::TouchUpdate ||
+                event->type() == QEvent::TouchCancel ||
+                event->type() == QEvent::TouchEnd) {
+            QTouchEvent *touch = static_cast<QTouchEvent*>(event);
+            for (const QTouchEvent::TouchPoint &tp : touch->touchPoints())
+                eventList.append(Event(Event::FilterDestination, event->type(), tp.state(), QQuickEventPoint::GrabExclusive, tp.pos(), tp.scenePos()));
+            if (filterTouch)
+                event->accept();
+            return true;
+        }
+        return false;
+    }
+};
+
+#define QCOMPARE_EVENT(i, d, t, s, g) \
+    {\
+        const Event &event = eventItem1->eventList.at(i);\
+        QCOMPARE(event.destination, d);\
+        QCOMPARE(event.type, t);\
+        QCOMPARE(event.state, s);\
+        QCOMPARE(event.grabState, g);\
+    }\
+
+class EventHandler : public QQuickPointerHandler
+{
+    void handlePointerEventImpl(QQuickPointerEvent *event) override
+    {
+        QQuickPointerHandler::handlePointerEventImpl(event);
+        if (!enabled())
+            return;
+        EventItem *item = static_cast<EventItem *>(target());
+        qCDebug(lcPointerTests) << item->objectName() << event;
+        int c = event->pointCount();
+        for (int i = 0; i < c; ++i) {
+            QQuickEventPoint *point = event->point(i);
+            if (item->acceptPointer)
+                point->setAccepted(item->acceptPointer); // does NOT imply a grab
+            if (item->grabPointer)
+                setExclusiveGrab(point, true);
+            qCDebug(lcPointerTests) << "        " << i << ":" << point << "accepted?" << item->acceptPointer << "grabbed?" << (point->exclusiveGrabber() == this);
+            item->eventList.append(Event(Event::HandlerDestination, QEvent::Pointer,
+                static_cast<Qt::TouchPointState>(point->state()),
+                item->grabPointer ? (int)QQuickEventPoint::GrabExclusive : (int)NoGrab,
+                eventPos(point), point->scenePos()));
+        }
+    }
+
+    void onGrabChanged(QQuickPointerHandler *, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point) override
+    {
+        EventItem *item = static_cast<EventItem *>(target());
+        item->eventList.append(Event(Event::HandlerDestination, QEvent::None,
+            static_cast<Qt::TouchPointState>(point->state()), stateChange, eventPos(point), point->scenePos()));
+    }
+};
+
+class tst_PointerHandlers : public QQmlDataTest
+{
+    Q_OBJECT
+public:
+    tst_PointerHandlers()
+        :touchDevice(QTest::createTouchDevice())
+    {}
+
+private slots:
+    void initTestCase();
+
+    void touchEventDelivery();
+    void mouseEventDelivery();
+    void touchReleaseOutside_data();
+    void touchReleaseOutside();
+
+protected:
+    bool eventFilter(QObject *, QEvent *event)
+    {
+        Qt::TouchPointState tpState;
+        switch (event->type()) {
+        case QEvent::MouseButtonPress:
+            tpState = Qt::TouchPointPressed;
+            break;
+        case QEvent::MouseMove:
+            tpState = Qt::TouchPointMoved;
+            break;
+        case QEvent::MouseButtonRelease:
+            tpState = Qt::TouchPointReleased;
+            break;
+        default:
+            // So far we aren't recording filtered touch events here - they would be quite numerous in some cases
+            return false;
+        }
+        QMouseEvent *me = static_cast<QMouseEvent*>(event);
+        filteredEventList.append(Event(Event::FilterDestination, event->type(), tpState,
+                                       0, me->pos(), me->globalPos()));
+        return false;
+    }
+
+private:
+    void createView(QScopedPointer<QQuickView> &window, const char *fileName);
+    QTouchDevice *touchDevice;
+    QList<Event> filteredEventList;
+};
+
+void tst_PointerHandlers::createView(QScopedPointer<QQuickView> &window, const char *fileName)
+{
+    window.reset(new QQuickView);
+//    window->setGeometry(0,0,240,320);
+    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_PointerHandlers::initTestCase()
+{
+    // This test assumes that we don't get synthesized mouse events from QGuiApplication
+    qApp->setAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents, false);
+
+    QQmlDataTest::initTestCase();
+    qmlRegisterType<EventItem>("Qt.test", 1, 0, "EventItem");
+    qmlRegisterType<EventHandler>("Qt.test", 1, 0, "EventHandler");
+}
+
+void tst_PointerHandlers::touchEventDelivery()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "singleitem.qml");
+    QQuickView * window = windowPtr.data();
+
+    EventItem *eventItem1 = window->rootObject()->findChild<EventItem*>("eventItem1");
+    QVERIFY(eventItem1);
+
+    // Do not accept anything
+    QPoint p1 = QPoint(20, 20);
+    QTest::touchEvent(window, touchDevice).press(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_COMPARE(eventItem1->eventList.size(), 3);
+    QCOMPARE_EVENT(0, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointPressed, NoGrab);
+    QCOMPARE_EVENT(1, Event::TouchDestination, QEvent::TouchBegin, Qt::TouchPointPressed, NoGrab);
+    QCOMPARE_EVENT(2, Event::MouseDestination, QEvent::MouseButtonPress, Qt::TouchPointPressed, NoGrab);
+    p1 += QPoint(10, 0);
+    QTest::touchEvent(window, touchDevice).move(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 4);
+    QCOMPARE_EVENT(3, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointMoved, NoGrab);
+    QTest::touchEvent(window, touchDevice).release(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 5);
+    QCOMPARE_EVENT(4, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointReleased, NoGrab);
+    eventItem1->eventList.clear();
+
+    // Accept touch
+    eventItem1->acceptTouch = true;
+    p1 = QPoint(20, 20);
+    QTest::touchEvent(window, touchDevice).press(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 2);
+    QCOMPARE_EVENT(0, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointPressed, NoGrab);
+    QCOMPARE_EVENT(1, Event::TouchDestination, QEvent::TouchBegin, Qt::TouchPointPressed, QQuickEventPoint::GrabExclusive);
+    auto pointerEvent = QQuickWindowPrivate::get(window)->pointerEventInstance(QQuickPointerDevice::touchDevices().at(0));
+    QCOMPARE(pointerEvent->point(0)->exclusiveGrabber(), eventItem1);
+    p1 += QPoint(10, 0);
+    QTest::touchEvent(window, touchDevice).move(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 4);
+    QCOMPARE_EVENT(2, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointMoved, NoGrab);
+    QCOMPARE_EVENT(3, Event::TouchDestination, QEvent::TouchUpdate, Qt::TouchPointMoved, QQuickEventPoint::GrabExclusive);
+    QTest::touchEvent(window, touchDevice).release(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 6);
+    QCOMPARE_EVENT(4, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointReleased, NoGrab);
+    QCOMPARE_EVENT(5, Event::TouchDestination, QEvent::TouchEnd, Qt::TouchPointReleased, NoGrab);
+    eventItem1->eventList.clear();
+
+    // wait to avoid getting a double click event
+    QTest::qWait(qApp->styleHints()->mouseDoubleClickInterval() + 10);
+
+    // Accept mouse
+    eventItem1->acceptTouch = false;
+    eventItem1->acceptMouse = true;
+    eventItem1->setAcceptedMouseButtons(Qt::LeftButton);
+    p1 = QPoint(20, 20);
+    QTest::touchEvent(window, touchDevice).press(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 3);
+    QCOMPARE_EVENT(0, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointPressed, NoGrab);
+    QCOMPARE_EVENT(1, Event::TouchDestination, QEvent::TouchBegin, Qt::TouchPointPressed, NoGrab);
+    QCOMPARE_EVENT(2, Event::MouseDestination, QEvent::MouseButtonPress, Qt::TouchPointPressed, QQuickEventPoint::GrabExclusive);
+    QCOMPARE(window->mouseGrabberItem(), eventItem1);
+
+    QPointF localPos = eventItem1->mapFromScene(p1);
+    QPointF scenePos = p1; // item is at 0,0
+    QCOMPARE(eventItem1->eventList.at(1).posWrtItem, localPos);
+    QCOMPARE(eventItem1->eventList.at(1).posWrtScene, scenePos);
+    QCOMPARE(eventItem1->eventList.at(2).posWrtItem, localPos);
+    QCOMPARE(eventItem1->eventList.at(2).posWrtScene, scenePos);
+
+    p1 += QPoint(10, 0);
+    QTest::touchEvent(window, touchDevice).move(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 6);
+    QCOMPARE_EVENT(3, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointMoved, NoGrab);
+    QCOMPARE_EVENT(4, Event::TouchDestination, QEvent::TouchUpdate, Qt::TouchPointMoved, NoGrab);
+    QCOMPARE_EVENT(5, Event::MouseDestination, QEvent::MouseMove, Qt::TouchPointMoved, QQuickEventPoint::GrabExclusive);
+    QTest::touchEvent(window, touchDevice).release(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 10);
+    QCOMPARE_EVENT(6, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointReleased, NoGrab);
+    QCOMPARE_EVENT(7, Event::TouchDestination, QEvent::TouchEnd, Qt::TouchPointReleased, NoGrab);
+    QCOMPARE_EVENT(8, Event::MouseDestination, QEvent::MouseButtonRelease, Qt::TouchPointReleased, NoGrab);
+    QCOMPARE_EVENT(9, Event::MouseDestination, QEvent::UngrabMouse, Qt::TouchPointReleased, QQuickEventPoint::UngrabExclusive);
+    eventItem1->eventList.clear();
+
+    // wait to avoid getting a double click event
+    QTest::qWait(qApp->styleHints()->mouseDoubleClickInterval() + 10);
+
+    // Accept mouse buttons but not the touch event
+    eventItem1->acceptTouch = false;
+    eventItem1->acceptMouse = false;
+    eventItem1->setAcceptedMouseButtons(Qt::LeftButton);
+    p1 = QPoint(20, 20);
+    QTest::touchEvent(window, touchDevice).press(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 3);
+    QCOMPARE_EVENT(0, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointPressed, NoGrab);
+    QCOMPARE_EVENT(1, Event::TouchDestination, QEvent::TouchBegin, Qt::TouchPointPressed, NoGrab);
+    QCOMPARE_EVENT(2, Event::MouseDestination, QEvent::MouseButtonPress, Qt::TouchPointPressed, NoGrab);
+    QCOMPARE(pointerEvent->point(0)->exclusiveGrabber(), nullptr);
+    p1 += QPoint(10, 0);
+    QTest::touchEvent(window, touchDevice).move(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 4);
+    QTest::touchEvent(window, touchDevice).release(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 5);
+    eventItem1->eventList.clear();
+
+    // wait to avoid getting a double click event
+    QTest::qWait(qApp->styleHints()->mouseDoubleClickInterval() + 10);
+
+    // Accept touch
+    eventItem1->acceptTouch = true;
+    eventItem1->setAcceptedMouseButtons(Qt::LeftButton);
+    p1 = QPoint(20, 20);
+    QTest::touchEvent(window, touchDevice).press(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 2);
+    QCOMPARE_EVENT(0, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointPressed, NoGrab);
+    QCOMPARE_EVENT(1, Event::TouchDestination, QEvent::TouchBegin, Qt::TouchPointPressed, QQuickEventPoint::GrabExclusive);
+    p1 += QPoint(10, 0);
+    QTest::touchEvent(window, touchDevice).move(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 4);
+    QCOMPARE_EVENT(2, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointMoved, NoGrab);
+    QCOMPARE_EVENT(3, Event::TouchDestination, QEvent::TouchUpdate, Qt::TouchPointMoved, QQuickEventPoint::GrabExclusive);
+    QTest::touchEvent(window, touchDevice).release(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 6);
+    QCOMPARE_EVENT(4, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointReleased, NoGrab);
+    QCOMPARE_EVENT(5, Event::TouchDestination, QEvent::TouchEnd, Qt::TouchPointReleased, NoGrab);
+    eventItem1->eventList.clear();
+
+    // Accept pointer events
+    eventItem1->acceptPointer = true;
+    eventItem1->grabPointer = true;
+    p1 = QPoint(20, 20);
+    QTest::touchEvent(window, touchDevice).press(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 2);
+    QCOMPARE_EVENT(0, Event::HandlerDestination, QEvent::None, Qt::TouchPointPressed, QQuickEventPoint::GrabExclusive);
+    QCOMPARE_EVENT(1, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointPressed, QQuickEventPoint::GrabExclusive);
+    p1 += QPoint(10, 0);
+    QTest::touchEvent(window, touchDevice).move(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 3);
+    QCOMPARE_EVENT(2, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointMoved, QQuickEventPoint::GrabExclusive);
+    QTest::touchEvent(window, touchDevice).release(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(eventItem1->eventList.size(), 5);
+    qCDebug(lcPointerTests) << eventItem1->eventList;
+    QCOMPARE_EVENT(3, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointReleased, QQuickEventPoint::GrabExclusive);
+    QCOMPARE_EVENT(4, Event::HandlerDestination, QEvent::None, Qt::TouchPointReleased, QQuickEventPoint::UngrabExclusive);
+    eventItem1->eventList.clear();
+}
+
+void tst_PointerHandlers::mouseEventDelivery()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "singleitem.qml");
+    QQuickView * window = windowPtr.data();
+
+    EventItem *eventItem1 = window->rootObject()->findChild<EventItem*>("eventItem1");
+    QVERIFY(eventItem1);
+
+    // Do not accept anything
+    QPoint p1 = QPoint(20, 20);
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QCOMPARE(eventItem1->eventList.size(), 2);
+    p1 += QPoint(10, 0);
+    QTest::mouseMove(window, p1);
+    QCOMPARE(eventItem1->eventList.size(), 3);
+    QTest::mouseRelease(window, Qt::LeftButton);
+    QCOMPARE(eventItem1->eventList.size(), 3);
+    eventItem1->eventList.clear();
+
+    // wait to avoid getting a double click event
+    QTest::qWait(qApp->styleHints()->mouseDoubleClickInterval() + 10);
+
+    // Accept mouse
+    eventItem1->acceptTouch = false;
+    eventItem1->acceptMouse = true;
+    eventItem1->setAcceptedMouseButtons(Qt::LeftButton);
+    p1 = QPoint(20, 20);
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QCOMPARE(eventItem1->eventList.size(), 2);
+    QCOMPARE_EVENT(0, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointPressed, NoGrab);
+    QCOMPARE_EVENT(1, Event::MouseDestination, QEvent::MouseButtonPress, Qt::TouchPointPressed, QQuickEventPoint::GrabExclusive);
+    QCOMPARE(window->mouseGrabberItem(), eventItem1);
+
+    QPointF localPos = eventItem1->mapFromScene(p1);
+    QPointF scenePos = p1; // item is at 0,0
+    QCOMPARE(eventItem1->eventList.at(0).posWrtItem, localPos);
+    QCOMPARE(eventItem1->eventList.at(0).posWrtScene, scenePos);
+    QCOMPARE(eventItem1->eventList.at(1).posWrtItem, localPos);
+    QCOMPARE(eventItem1->eventList.at(1).posWrtScene, scenePos);
+
+    p1 += QPoint(10, 0);
+    QTest::mouseMove(window, p1);
+    QCOMPARE(eventItem1->eventList.size(), 3);
+    QCOMPARE_EVENT(2, Event::MouseDestination, QEvent::MouseMove, Qt::TouchPointMoved, QQuickEventPoint::GrabExclusive);
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QCOMPARE(eventItem1->eventList.size(), 5);
+    QCOMPARE_EVENT(3, Event::MouseDestination, QEvent::MouseButtonRelease, Qt::TouchPointReleased, NoGrab);
+    QCOMPARE_EVENT(4, Event::MouseDestination, QEvent::UngrabMouse, Qt::TouchPointReleased, QQuickEventPoint::UngrabExclusive);
+    eventItem1->eventList.clear();
+
+    // wait to avoid getting a double click event
+    QTest::qWait(qApp->styleHints()->mouseDoubleClickInterval() + 10);
+
+    // Grab pointer events
+    eventItem1->acceptMouse = false;
+    eventItem1->acceptPointer = true;
+    eventItem1->grabPointer = true;
+    p1 = QPoint(20, 20);
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_COMPARE(eventItem1->eventList.size(), 2);
+    QCOMPARE_EVENT(0, Event::HandlerDestination, QEvent::None, Qt::TouchPointPressed, QQuickEventPoint::GrabExclusive);
+    QCOMPARE_EVENT(1, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointPressed, QQuickEventPoint::GrabExclusive);
+    p1 += QPoint(10, 0);
+    QTest::mouseMove(window, p1);
+    QCOMPARE(eventItem1->eventList.size(), 3);
+    QCOMPARE_EVENT(2, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointMoved, QQuickEventPoint::GrabExclusive);
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QCOMPARE(eventItem1->eventList.size(), 5);
+    QCOMPARE_EVENT(3, Event::HandlerDestination, QEvent::Pointer, Qt::TouchPointReleased, QQuickEventPoint::GrabExclusive);
+    QCOMPARE_EVENT(4, Event::HandlerDestination, QEvent::None, Qt::TouchPointReleased, QQuickEventPoint::UngrabExclusive);
+    eventItem1->eventList.clear();
+}
+
+void tst_PointerHandlers::touchReleaseOutside_data()
+{
+    QTest::addColumn<bool>("acceptPointer");
+    QTest::addColumn<bool>("grabPointer");
+    QTest::addColumn<int>("eventCount");
+    QTest::addColumn<int>("endIndexToTest");
+    QTest::addColumn<int>("endDestination");    // Event::Destination
+    QTest::addColumn<int>("endType");           // QEvent::Type
+    QTest::addColumn<int>("endState");          // Qt::TouchPointState
+    QTest::addColumn<int>("endGrabState");      // Qt::TouchPointState
+
+    QTest::newRow("reject and ignore") << false << false << 6 << 5 << (int)Event::TouchDestination
+        << (int)QEvent::TouchEnd << (int)Qt::TouchPointReleased << (int)NoGrab;
+    QTest::newRow("reject and grab") << false << true << 5 << 4 << (int)Event::HandlerDestination
+        << (int)QEvent::None << (int)Qt::TouchPointReleased << (int)QQuickEventPoint::UngrabExclusive;
+    QTest::newRow("accept and ignore") << true << false << 1 << 0 << (int)Event::HandlerDestination
+        << (int)QEvent::Pointer << (int)Qt::TouchPointPressed << (int)NoGrab;
+    QTest::newRow("accept and grab") << true << true << 5 << 4 << (int)Event::HandlerDestination
+        << (int)QEvent::None << (int)Qt::TouchPointReleased << (int)QQuickEventPoint::UngrabExclusive;
+}
+
+void tst_PointerHandlers::touchReleaseOutside()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "singleitem.qml");
+    QQuickView * window = windowPtr.data();
+
+    QFETCH(bool, acceptPointer);
+    QFETCH(bool, grabPointer);
+    QFETCH(int, eventCount);
+    QFETCH(int, endIndexToTest);
+    QFETCH(int, endDestination);
+    QFETCH(int, endType);
+    QFETCH(int, endState);
+    QFETCH(int, endGrabState);
+
+    EventItem *eventItem1 = window->rootObject()->findChild<EventItem*>("eventItem1");
+    QVERIFY(eventItem1);
+
+    eventItem1->acceptTouch = true;
+    eventItem1->acceptPointer = acceptPointer;
+    eventItem1->grabPointer = grabPointer;
+
+    QPoint p1 = QPoint(20, 20);
+    QTest::touchEvent(window, touchDevice).press(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    p1.setX(eventItem1->mapToScene(eventItem1->clipRect().bottomRight()).x() + 10);
+    QTest::touchEvent(window, touchDevice).move(0, p1, window);
+    QTest::touchEvent(window, touchDevice).release(0, p1, window);
+    QQuickTouchUtils::flush(window);
+    qCDebug(lcPointerTests) << eventItem1->eventList;
+    QCOMPARE(eventItem1->eventList.size(), eventCount);
+    QCOMPARE_EVENT(endIndexToTest, endDestination, endType, endState, endGrabState);
+}
+
+QTEST_MAIN(tst_PointerHandlers)
+
+#include "tst_qquickpointerhandler.moc"
+
diff --git a/tests/auto/quick/pointerhandlers/qquicktaphandler/data/Button.qml b/tests/auto/quick/pointerhandlers/qquicktaphandler/data/Button.qml
new file mode 100644
index 0000000000..6203a6769d
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquicktaphandler/data/Button.qml
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** 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
+    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
+        color: "transparent"
+        border.width: 2; 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: "blue"
+        color: "transparent"
+        width: radius * 2
+        height: radius * 2
+        x: tap.point.scenePressPosition.x - radius
+        y: tap.point.scenePressPosition.y - radius
+        opacity: 0.25
+        Component.onCompleted: parent = root.parent
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/qquicktaphandler/data/FlashAnimation.qml b/tests/auto/quick/pointerhandlers/qquicktaphandler/data/FlashAnimation.qml
new file mode 100644
index 0000000000..2224276819
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquicktaphandler/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 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.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/qquicktaphandler/data/buttons.qml b/tests/auto/quick/pointerhandlers/qquicktaphandler/data/buttons.qml
new file mode 100644
index 0000000000..ca1aba71fb
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquicktaphandler/data/buttons.qml
@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** 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.0
+import Qt.labs.handlers 1.0
+
+Item {
+    width: 320
+    height: 240
+    Button {
+        objectName: "DragThreshold"
+        label: "DragThreshold"
+        x: 10; y: 10; width: parent.width - 20; height: 40
+        gesturePolicy: TapHandler.DragThreshold
+    }
+    Button {
+        objectName: "WithinBounds"
+        label: "WithinBounds"
+        x: 10; y: 60; width: parent.width - 20; height: 40
+        gesturePolicy: TapHandler.WithinBounds
+    }
+    Button {
+        objectName: "ReleaseWithinBounds"
+        label: "ReleaseWithinBounds"
+        x: 10; y: 110; width: parent.width - 20; height: 40
+        gesturePolicy: TapHandler.ReleaseWithinBounds
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/qquicktaphandler/qquicktaphandler.pro b/tests/auto/quick/pointerhandlers/qquicktaphandler/qquicktaphandler.pro
new file mode 100644
index 0000000000..b41a94b55e
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquicktaphandler/qquicktaphandler.pro
@@ -0,0 +1,16 @@
+CONFIG += testcase
+
+TARGET = tst_qquicktaphandler
+QT += core-private gui-private qml-private quick-private  testlib
+
+macos:CONFIG -= app_bundle
+
+SOURCES  += tst_qquicktaphandler.cpp
+
+include (../../../shared/util.pri)
+include (../../shared/util.pri)
+
+TESTDATA = data/*
+
+# OTHER_FILES += data/foo.qml
+
diff --git a/tests/auto/quick/pointerhandlers/qquicktaphandler/tst_qquicktaphandler.cpp b/tests/auto/quick/pointerhandlers/qquicktaphandler/tst_qquicktaphandler.cpp
new file mode 100644
index 0000000000..d7eda5e19c
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquicktaphandler/tst_qquicktaphandler.cpp
@@ -0,0 +1,591 @@
+/****************************************************************************
+**
+** 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/qquickpointerhandler_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_TapHandler : public QQmlDataTest
+{
+    Q_OBJECT
+public:
+    tst_TapHandler()
+        :touchDevice(QTest::createTouchDevice())
+    {}
+
+private slots:
+    void initTestCase();
+
+    void touchGesturePolicyDragThreshold();
+    void mouseGesturePolicyDragThreshold();
+    void touchGesturePolicyWithinBounds();
+    void mouseGesturePolicyWithinBounds();
+    void touchGesturePolicyReleaseWithinBounds();
+    void mouseGesturePolicyReleaseWithinBounds();
+    void touchMultiTap();
+    void mouseMultiTap();
+    void touchLongPress();
+    void mouseLongPress();
+    void buttonsMultiTouch();
+
+private:
+    void createView(QScopedPointer<QQuickView> &window, const char *fileName);
+    QTouchDevice *touchDevice;
+};
+
+void tst_TapHandler::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_TapHandler::initTestCase()
+{
+    // This test assumes that we don't get synthesized mouse events from QGuiApplication
+    qApp->setAttribute(Qt::AA_SynthesizeMouseForUnhandledTouchEvents, false);
+
+    QQmlDataTest::initTestCase();
+}
+
+void tst_TapHandler::touchGesturePolicyDragThreshold()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *buttonDragThreshold = window->rootObject()->findChild<QQuickItem*>("DragThreshold");
+    QVERIFY(buttonDragThreshold);
+    QSignalSpy dragThresholdTappedSpy(buttonDragThreshold, SIGNAL(tapped()));
+
+    // DragThreshold button stays pressed while touchpoint stays within dragThreshold, emits tapped on release
+    QPoint p1 = buttonDragThreshold->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonDragThreshold->property("pressed").toBool());
+    p1 += QPoint(dragThreshold, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(buttonDragThreshold->property("pressed").toBool());
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!buttonDragThreshold->property("pressed").toBool());
+    QCOMPARE(dragThresholdTappedSpy.count(), 1);
+
+    // DragThreshold button is no longer pressed if touchpoint goes beyond dragThreshold
+    dragThresholdTappedSpy.clear();
+    p1 = buttonDragThreshold->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonDragThreshold->property("pressed").toBool());
+    p1 += QPoint(dragThreshold, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(buttonDragThreshold->property("pressed").toBool());
+    p1 += QPoint(1, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!buttonDragThreshold->property("pressed").toBool());
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(!buttonDragThreshold->property("pressed").toBool());
+    QCOMPARE(dragThresholdTappedSpy.count(), 0);
+}
+
+void tst_TapHandler::mouseGesturePolicyDragThreshold()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *buttonDragThreshold = window->rootObject()->findChild<QQuickItem*>("DragThreshold");
+    QVERIFY(buttonDragThreshold);
+    QSignalSpy dragThresholdTappedSpy(buttonDragThreshold, SIGNAL(tapped()));
+
+    // DragThreshold button stays pressed while mouse stays within dragThreshold, emits tapped on release
+    QPoint p1 = buttonDragThreshold->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(buttonDragThreshold->property("pressed").toBool());
+    p1 += QPoint(dragThreshold, 0);
+    QTest::mouseMove(window, p1);
+    QVERIFY(buttonDragThreshold->property("pressed").toBool());
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(!buttonDragThreshold->property("pressed").toBool());
+    QTRY_COMPARE(dragThresholdTappedSpy.count(), 1);
+
+    // DragThreshold button is no longer pressed if mouse goes beyond dragThreshold
+    dragThresholdTappedSpy.clear();
+    p1 = buttonDragThreshold->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(buttonDragThreshold->property("pressed").toBool());
+    p1 += QPoint(dragThreshold, 0);
+    QTest::mouseMove(window, p1);
+    QVERIFY(buttonDragThreshold->property("pressed").toBool());
+    p1 += QPoint(1, 0);
+    QTest::mouseMove(window, p1);
+    QTRY_VERIFY(!buttonDragThreshold->property("pressed").toBool());
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QVERIFY(!buttonDragThreshold->property("pressed").toBool());
+    QCOMPARE(dragThresholdTappedSpy.count(), 0);
+}
+
+void tst_TapHandler::touchGesturePolicyWithinBounds()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *buttonWithinBounds = window->rootObject()->findChild<QQuickItem*>("WithinBounds");
+    QVERIFY(buttonWithinBounds);
+    QSignalSpy withinBoundsTappedSpy(buttonWithinBounds, SIGNAL(tapped()));
+
+    // WithinBounds button stays pressed while touchpoint stays within bounds, emits tapped on release
+    QPoint p1 = buttonWithinBounds->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonWithinBounds->property("pressed").toBool());
+    p1 += QPoint(50, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(buttonWithinBounds->property("pressed").toBool());
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!buttonWithinBounds->property("pressed").toBool());
+    QCOMPARE(withinBoundsTappedSpy.count(), 1);
+
+    // WithinBounds button is no longer pressed if touchpoint leaves bounds
+    withinBoundsTappedSpy.clear();
+    p1 = buttonWithinBounds->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonWithinBounds->property("pressed").toBool());
+    p1 += QPoint(0, 100);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!buttonWithinBounds->property("pressed").toBool());
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(!buttonWithinBounds->property("pressed").toBool());
+    QCOMPARE(withinBoundsTappedSpy.count(), 0);
+}
+
+void tst_TapHandler::mouseGesturePolicyWithinBounds()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *buttonWithinBounds = window->rootObject()->findChild<QQuickItem*>("WithinBounds");
+    QVERIFY(buttonWithinBounds);
+    QSignalSpy withinBoundsTappedSpy(buttonWithinBounds, SIGNAL(tapped()));
+
+    // WithinBounds button stays pressed while touchpoint stays within bounds, emits tapped on release
+    QPoint p1 = buttonWithinBounds->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(buttonWithinBounds->property("pressed").toBool());
+    p1 += QPoint(50, 0);
+    QTest::mouseMove(window, p1);
+    QVERIFY(buttonWithinBounds->property("pressed").toBool());
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(!buttonWithinBounds->property("pressed").toBool());
+    QCOMPARE(withinBoundsTappedSpy.count(), 1);
+
+    // WithinBounds button is no longer pressed if touchpoint leaves bounds
+    withinBoundsTappedSpy.clear();
+    p1 = buttonWithinBounds->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(buttonWithinBounds->property("pressed").toBool());
+    p1 += QPoint(0, 100);
+    QTest::mouseMove(window, p1);
+    QTRY_VERIFY(!buttonWithinBounds->property("pressed").toBool());
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QVERIFY(!buttonWithinBounds->property("pressed").toBool());
+    QCOMPARE(withinBoundsTappedSpy.count(), 0);
+}
+
+void tst_TapHandler::touchGesturePolicyReleaseWithinBounds()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *buttonReleaseWithinBounds = window->rootObject()->findChild<QQuickItem*>("ReleaseWithinBounds");
+    QVERIFY(buttonReleaseWithinBounds);
+    QSignalSpy releaseWithinBoundsTappedSpy(buttonReleaseWithinBounds, SIGNAL(tapped()));
+
+    // ReleaseWithinBounds button stays pressed while touchpoint wanders anywhere,
+    // then if it comes back within bounds, emits tapped on release
+    QPoint p1 = buttonReleaseWithinBounds->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    p1 += QPoint(50, 0);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    p1 += QPoint(250, 100);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    p1 = buttonReleaseWithinBounds->mapToScene(QPointF(25, 15)).toPoint();
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!buttonReleaseWithinBounds->property("pressed").toBool());
+    QCOMPARE(releaseWithinBoundsTappedSpy.count(), 1);
+
+    // ReleaseWithinBounds button does not emit tapped if released out of bounds
+    releaseWithinBoundsTappedSpy.clear();
+    p1 = buttonReleaseWithinBounds->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    p1 += QPoint(0, 100);
+    QTest::touchEvent(window, touchDevice).move(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!buttonReleaseWithinBounds->property("pressed").toBool());
+    QCOMPARE(releaseWithinBoundsTappedSpy.count(), 0);
+}
+
+void tst_TapHandler::mouseGesturePolicyReleaseWithinBounds()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *buttonReleaseWithinBounds = window->rootObject()->findChild<QQuickItem*>("ReleaseWithinBounds");
+    QVERIFY(buttonReleaseWithinBounds);
+    QSignalSpy releaseWithinBoundsTappedSpy(buttonReleaseWithinBounds, SIGNAL(tapped()));
+
+    // ReleaseWithinBounds button stays pressed while touchpoint wanders anywhere,
+    // then if it comes back within bounds, emits tapped on release
+    QPoint p1 = buttonReleaseWithinBounds->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    p1 += QPoint(50, 0);
+    QTest::mouseMove(window, p1);
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    p1 += QPoint(250, 100);
+    QTest::mouseMove(window, p1);
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    p1 = buttonReleaseWithinBounds->mapToScene(QPointF(25, 15)).toPoint();
+    QTest::mouseMove(window, p1);
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(!buttonReleaseWithinBounds->property("pressed").toBool());
+    QCOMPARE(releaseWithinBoundsTappedSpy.count(), 1);
+
+    // ReleaseWithinBounds button does not emit tapped if released out of bounds
+    releaseWithinBoundsTappedSpy.clear();
+    p1 = buttonReleaseWithinBounds->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    p1 += QPoint(0, 100);
+    QTest::mouseMove(window, p1);
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(!buttonReleaseWithinBounds->property("pressed").toBool());
+    QCOMPARE(releaseWithinBoundsTappedSpy.count(), 0);
+}
+
+void tst_TapHandler::touchMultiTap()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>("DragThreshold");
+    QVERIFY(button);
+    QSignalSpy tappedSpy(button, SIGNAL(tapped()));
+
+    // Tap once
+    QPoint p1 = button->mapToScene(QPointF(2, 2)).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);
+
+    // Tap again in exactly the same place (not likely with touch in the real world)
+    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(), 2);
+
+    // Tap a third time, nearby
+    p1 += QPoint(dragThreshold, dragThreshold);
+    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(), 3);
+
+    // Tap a fourth time, drifting farther away
+    p1 += QPoint(dragThreshold, dragThreshold);
+    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(), 4);
+}
+
+void tst_TapHandler::mouseMultiTap()
+{
+    const int dragThreshold = QGuiApplication::styleHints()->startDragDistance();
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>("DragThreshold");
+    QVERIFY(button);
+    QSignalSpy tappedSpy(button, SIGNAL(tapped()));
+
+    // Tap once
+    QPoint p1 = button->mapToScene(QPointF(2, 2)).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);
+
+    // Tap again in exactly the same place (not likely with touch in the real world)
+    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(), 2);
+
+    // Tap a third time, nearby
+    p1 += QPoint(dragThreshold, dragThreshold);
+    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(), 3);
+
+    // Tap a fourth time, drifting farther away
+    p1 += QPoint(dragThreshold, dragThreshold);
+    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(), 4);
+}
+
+void tst_TapHandler::touchLongPress()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>("DragThreshold");
+    QVERIFY(button);
+    QQuickTapHandler *tapHandler = button->findChild<QQuickTapHandler*>("DragThreshold");
+    QVERIFY(tapHandler);
+    QSignalSpy tappedSpy(button, SIGNAL(tapped()));
+    QSignalSpy longPressThresholdChangedSpy(tapHandler, SIGNAL(longPressThresholdChanged()));
+    QSignalSpy timeHeldSpy(tapHandler, SIGNAL(timeHeldChanged()));
+    QSignalSpy longPressedSpy(tapHandler, SIGNAL(longPressed()));
+
+    // Reduce the threshold so that we can get a long press quickly
+    tapHandler->setLongPressThreshold(0.5);
+    QCOMPARE(longPressThresholdChangedSpy.count(), 1);
+
+    // Press and hold
+    QPoint p1 = button->mapToScene(button->clipRect().center()).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(button->property("pressed").toBool());
+    QTRY_COMPARE(longPressedSpy.count(), 1);
+    timeHeldSpy.wait(); // the longer we hold it, the more this will occur
+    qDebug() << "held" << tapHandler->timeHeld() << "secs; timeHeld updated" << timeHeldSpy.count() << "times";
+    QVERIFY(timeHeldSpy.count() > 0);
+    QVERIFY(tapHandler->timeHeld() > 0.4); // Should be > 0.5 but slow CI and timer granularity can interfere
+
+    // Release and verify that tapped was not emitted
+    QTest::touchEvent(window, touchDevice).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!button->property("pressed").toBool());
+    QCOMPARE(tappedSpy.count(), 0);
+}
+
+void tst_TapHandler::mouseLongPress()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *button = window->rootObject()->findChild<QQuickItem*>("DragThreshold");
+    QVERIFY(button);
+    QQuickTapHandler *tapHandler = button->findChild<QQuickTapHandler*>("DragThreshold");
+    QVERIFY(tapHandler);
+    QSignalSpy tappedSpy(button, SIGNAL(tapped()));
+    QSignalSpy longPressThresholdChangedSpy(tapHandler, SIGNAL(longPressThresholdChanged()));
+    QSignalSpy timeHeldSpy(tapHandler, SIGNAL(timeHeldChanged()));
+    QSignalSpy longPressedSpy(tapHandler, SIGNAL(longPressed()));
+
+    // Reduce the threshold so that we can get a long press quickly
+    tapHandler->setLongPressThreshold(0.5);
+    QCOMPARE(longPressThresholdChangedSpy.count(), 1);
+
+    // Press and hold
+    QPoint p1 = button->mapToScene(button->clipRect().center()).toPoint();
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTRY_VERIFY(button->property("pressed").toBool());
+    QTRY_COMPARE(longPressedSpy.count(), 1);
+    timeHeldSpy.wait(); // the longer we hold it, the more this will occur
+    qDebug() << "held" << tapHandler->timeHeld() << "secs; timeHeld updated" << timeHeldSpy.count() << "times";
+    QVERIFY(timeHeldSpy.count() > 0);
+    QVERIFY(tapHandler->timeHeld() > 0.4); // Should be > 0.5 but slow CI and timer granularity can interfere
+
+    // Release and verify that tapped was not emitted
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, p1, 500);
+    QTRY_VERIFY(!button->property("pressed").toBool());
+    QCOMPARE(tappedSpy.count(), 0);
+}
+
+void tst_TapHandler::buttonsMultiTouch()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "buttons.qml");
+    QQuickView * window = windowPtr.data();
+
+    QQuickItem *buttonDragThreshold = window->rootObject()->findChild<QQuickItem*>("DragThreshold");
+    QVERIFY(buttonDragThreshold);
+    QSignalSpy dragThresholdTappedSpy(buttonDragThreshold, SIGNAL(tapped()));
+
+    QQuickItem *buttonWithinBounds = window->rootObject()->findChild<QQuickItem*>("WithinBounds");
+    QVERIFY(buttonWithinBounds);
+    QSignalSpy withinBoundsTappedSpy(buttonWithinBounds, SIGNAL(tapped()));
+
+    QQuickItem *buttonReleaseWithinBounds = window->rootObject()->findChild<QQuickItem*>("ReleaseWithinBounds");
+    QVERIFY(buttonReleaseWithinBounds);
+    QSignalSpy releaseWithinBoundsTappedSpy(buttonReleaseWithinBounds, SIGNAL(tapped()));
+
+    // can press multiple buttons at the same time
+    QPoint p1 = buttonDragThreshold->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonDragThreshold->property("pressed").toBool());
+    QPoint p2 = buttonWithinBounds->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).stationary(1).press(2, p2, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonWithinBounds->property("pressed").toBool());
+    QPoint p3 = buttonReleaseWithinBounds->mapToScene(QPointF(20, 20)).toPoint();
+    QTest::touchEvent(window, touchDevice).stationary(1).stationary(2).press(3, p3, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+
+    // can release top button and press again: others stay pressed the whole time
+    QTest::touchEvent(window, touchDevice).stationary(2).stationary(3).release(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!buttonDragThreshold->property("pressed").toBool());
+    QCOMPARE(dragThresholdTappedSpy.count(), 1);
+    QVERIFY(buttonWithinBounds->property("pressed").toBool());
+    QCOMPARE(withinBoundsTappedSpy.count(), 0);
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    QCOMPARE(releaseWithinBoundsTappedSpy.count(), 0);
+    QTest::touchEvent(window, touchDevice).stationary(2).stationary(3).press(1, p1, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonDragThreshold->property("pressed").toBool());
+    QVERIFY(buttonWithinBounds->property("pressed").toBool());
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+
+    // can release middle button and press again: others stay pressed the whole time
+    QTest::touchEvent(window, touchDevice).stationary(1).stationary(3).release(2, p2, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(!buttonWithinBounds->property("pressed").toBool());
+    QCOMPARE(withinBoundsTappedSpy.count(), 1);
+    QVERIFY(buttonDragThreshold->property("pressed").toBool());
+    QCOMPARE(dragThresholdTappedSpy.count(), 1);
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+    QCOMPARE(releaseWithinBoundsTappedSpy.count(), 0);
+    QTest::touchEvent(window, touchDevice).stationary(1).stationary(3).press(2, p2, window);
+    QQuickTouchUtils::flush(window);
+    QVERIFY(buttonDragThreshold->property("pressed").toBool());
+    QVERIFY(buttonWithinBounds->property("pressed").toBool());
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+
+    // can release bottom button and press again: others stay pressed the whole time
+    QTest::touchEvent(window, touchDevice).stationary(1).stationary(2).release(3, p3, window);
+    QQuickTouchUtils::flush(window);
+    QCOMPARE(releaseWithinBoundsTappedSpy.count(), 1);
+    QVERIFY(buttonWithinBounds->property("pressed").toBool());
+    QCOMPARE(withinBoundsTappedSpy.count(), 1);
+    QVERIFY(!buttonReleaseWithinBounds->property("pressed").toBool());
+    QCOMPARE(dragThresholdTappedSpy.count(), 1);
+    QTest::touchEvent(window, touchDevice).stationary(1).stationary(2).press(3, p3, window);
+    QQuickTouchUtils::flush(window);
+    QTRY_VERIFY(buttonDragThreshold->property("pressed").toBool());
+    QVERIFY(buttonWithinBounds->property("pressed").toBool());
+    QVERIFY(buttonReleaseWithinBounds->property("pressed").toBool());
+}
+
+QTEST_MAIN(tst_TapHandler)
+
+#include "tst_qquicktaphandler.moc"
+
diff --git a/tests/auto/quick/qquickflickable/data/nestedStopAtBounds.qml b/tests/auto/quick/qquickflickable/data/nestedStopAtBounds.qml
index 81187f3c2f..902920babc 100644
--- a/tests/auto/quick/qquickflickable/data/nestedStopAtBounds.qml
+++ b/tests/auto/quick/qquickflickable/data/nestedStopAtBounds.qml
@@ -18,6 +18,8 @@ Flickable {
         height: 300
 
         color: "yellow"
+        objectName: "yellowRect"
+
         Flickable {
             id: inner
             objectName: "innerFlickable"
@@ -30,6 +32,7 @@ Flickable {
             Rectangle {
                 anchors.fill: parent
                 anchors.margins: 100
+                objectName: "blueRect"
                 color: "blue"
             }
             MouseArea {
diff --git a/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp b/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp
index ef6e444580..0bb913d104 100644
--- a/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp
+++ b/tests/auto/quick/qquickflickable/tst_qquickflickable.cpp
@@ -63,7 +63,13 @@ public:
         , touchReleases(0)
         , ungrabs(0)
         , m_active(false)
-    { }
+    {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+        setAcceptTouchEvents(true);
+#else
+        setAcceptedMouseButtons(Qt::LeftButton); // not really, but we want touch events
+#endif
+    }
 
     QPointF pos() const { return m_pos; }
 
diff --git a/tests/auto/quick/qquickitem/tst_qquickitem.cpp b/tests/auto/quick/qquickitem/tst_qquickitem.cpp
index 10a3a0bfa8..f4434d9d3f 100644
--- a/tests/auto/quick/qquickitem/tst_qquickitem.cpp
+++ b/tests/auto/quick/qquickitem/tst_qquickitem.cpp
@@ -49,7 +49,12 @@ public:
         : QQuickItem(parent), focused(false), pressCount(0), releaseCount(0)
         , wheelCount(0), acceptIncomingTouchEvents(true)
         , touchEventReached(false), timestamp(0)
-        , lastWheelEventPos(0, 0), lastWheelEventGlobalPos(0, 0) {}
+        , lastWheelEventPos(0, 0), lastWheelEventGlobalPos(0, 0)
+    {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+        setAcceptTouchEvents(true);
+#endif
+    }
 
     bool focused;
     int pressCount;
diff --git a/tests/auto/quick/qquickwindow/tst_qquickwindow.cpp b/tests/auto/quick/qquickwindow/tst_qquickwindow.cpp
index 91d577fb6f..2133b4d2d3 100644
--- a/tests/auto/quick/qquickwindow/tst_qquickwindow.cpp
+++ b/tests/auto/quick/qquickwindow/tst_qquickwindow.cpp
@@ -37,6 +37,7 @@
 #include <QtQml/QQmlComponent>
 #include <QtQuick/private/qquickrectangle_p.h>
 #include <QtQuick/private/qquickloader_p.h>
+#include <QtQuick/private/qquickmousearea_p.h>
 #include "../../shared/util.h"
 #include "../shared/visualtestutil.h"
 #include "../shared/viewtestutil.h"
@@ -47,6 +48,8 @@
 #include <QOpenGLFunctions>
 #include <QSGRendererInterface>
 
+Q_LOGGING_CATEGORY(lcTests, "qt.quick.tests")
+
 struct TouchEventData {
     QEvent::Type type;
     QWidget *widget;
@@ -140,7 +143,7 @@ class TestTouchItem : public QQuickRectangle
 public:
     TestTouchItem(QQuickItem *parent = 0)
         : QQuickRectangle(parent), acceptTouchEvents(true), acceptMouseEvents(true),
-          mousePressId(0),
+          mousePressCount(0), mouseMoveCount(0),
           spinLoopWhenPressed(false), touchEventCount(0)
     {
         border()->setWidth(1);
@@ -159,9 +162,10 @@ public:
         lastMousePos = QPointF();
         lastMouseCapabilityFlags = 0;
         touchEventCount = 0;
+        mouseMoveCount = 0;
     }
 
-    static void clearMousePressCounter()
+    static void clearMouseEventCounters()
     {
         mousePressNum = mouseMoveNum = mouseReleaseNum = 0;
     }
@@ -174,7 +178,8 @@ public:
     bool acceptTouchEvents;
     bool acceptMouseEvents;
     TouchEventData lastEvent;
-    int mousePressId;
+    int mousePressCount;
+    int mouseMoveCount;
     bool spinLoopWhenPressed;
     int touchEventCount;
     QVector2D lastVelocity;
@@ -204,7 +209,7 @@ public:
             e->ignore();
             return;
         }
-        mousePressId = ++mousePressNum;
+        mousePressCount = ++mousePressNum;
         lastMousePos = e->pos();
         lastMouseCapabilityFlags = QGuiApplicationPrivate::mouseEventCaps(e);
     }
@@ -214,7 +219,7 @@ public:
             e->ignore();
             return;
         }
-        ++mouseMoveNum;
+        mouseMoveCount = ++mouseMoveNum;
         lastVelocityFromMouseMove = QGuiApplicationPrivate::mouseEventVelocity(e);
         lastMouseCapabilityFlags = QGuiApplicationPrivate::mouseEventCaps(e);
         lastMousePos = e->pos();
@@ -230,10 +235,19 @@ public:
         lastMouseCapabilityFlags = QGuiApplicationPrivate::mouseEventCaps(e);
     }
 
-    bool childMouseEventFilter(QQuickItem *, QEvent *event) {
-        // TODO Is it a bug if a QTouchEvent comes here?
-        if (event->type() == QEvent::MouseButtonPress)
-            mousePressId = ++mousePressNum;
+    bool childMouseEventFilter(QQuickItem *item, QEvent *e) {
+        qCDebug(lcTests) << objectName() << "filtering" << e << "ahead of delivery to" << item->metaObject()->className() << item->objectName();
+        switch (e->type()) {
+        case QEvent::MouseButtonPress:
+            mousePressCount = ++mousePressNum;
+            break;
+        case QEvent::MouseMove:
+            mouseMoveCount = ++mouseMoveNum;
+            break;
+        default:
+            break;
+        }
+
         return false;
     }
 
@@ -368,6 +382,7 @@ private slots:
 
     void testHoverChildMouseEventFilter();
     void testHoverTimestamp();
+    void test_circleMapItem();
 
     void pointerEventTypeAndPointCount();
 
@@ -507,7 +522,7 @@ void tst_qquickwindow::constantUpdatesOnWindow()
 
 void tst_qquickwindow::touchEvent_basic()
 {
-    TestTouchItem::clearMousePressCounter();
+    TestTouchItem::clearMouseEventCounters();
 
     QQuickWindow *window = new QQuickWindow;
     QScopedPointer<QQuickWindow> cleanup(window);
@@ -636,7 +651,7 @@ void tst_qquickwindow::touchEvent_basic()
 
 void tst_qquickwindow::touchEvent_propagation()
 {
-    TestTouchItem::clearMousePressCounter();
+    TestTouchItem::clearMouseEventCounters();
 
     QFETCH(bool, acceptTouchEvents);
     QFETCH(bool, acceptMouseEvents);
@@ -783,7 +798,7 @@ void tst_qquickwindow::touchEvent_propagation_data()
 
 void tst_qquickwindow::touchEvent_cancel()
 {
-    TestTouchItem::clearMousePressCounter();
+    TestTouchItem::clearMouseEventCounters();
 
     QQuickWindow *window = new QQuickWindow;
     QScopedPointer<QQuickWindow> cleanup(window);
@@ -817,7 +832,7 @@ void tst_qquickwindow::touchEvent_cancel()
 
 void tst_qquickwindow::touchEvent_reentrant()
 {
-    TestTouchItem::clearMousePressCounter();
+    TestTouchItem::clearMouseEventCounters();
 
     QQuickWindow *window = new QQuickWindow;
     QScopedPointer<QQuickWindow> cleanup(window);
@@ -856,7 +871,7 @@ void tst_qquickwindow::touchEvent_reentrant()
 
 void tst_qquickwindow::touchEvent_velocity()
 {
-    TestTouchItem::clearMousePressCounter();
+    TestTouchItem::clearMouseEventCounters();
 
     QQuickWindow *window = new QQuickWindow;
     QScopedPointer<QQuickWindow> cleanup(window);
@@ -982,7 +997,7 @@ void tst_qquickwindow::mouseFromTouch_basic()
     // should result in sending mouse events generated from the touch
     // with the new event propagation system.
 
-    TestTouchItem::clearMousePressCounter();
+    TestTouchItem::clearMouseEventCounters();
     QQuickWindow *window = new QQuickWindow;
     QScopedPointer<QQuickWindow> cleanup(window);
     window->resize(250, 250);
@@ -1071,7 +1086,7 @@ void tst_qquickwindow::clearWindow()
 
 void tst_qquickwindow::mouseFiltering()
 {
-    TestTouchItem::clearMousePressCounter();
+    TestTouchItem::clearMouseEventCounters();
 
     QQuickWindow *window = new QQuickWindow;
     QScopedPointer<QQuickWindow> cleanup(window);
@@ -1085,6 +1100,11 @@ void tst_qquickwindow::mouseFiltering()
     bottomItem->setObjectName("Bottom Item");
     bottomItem->setSize(QSizeF(150, 150));
 
+    TestTouchItem *siblingItem = new TestTouchItem(bottomItem);
+    siblingItem->setObjectName("Sibling of Middle Item");
+    siblingItem->setPosition(QPointF(90, 25));
+    siblingItem->setSize(QSizeF(150, 150));
+
     TestTouchItem *middleItem = new TestTouchItem(bottomItem);
     middleItem->setObjectName("Middle Item");
     middleItem->setPosition(QPointF(50, 50));
@@ -1104,9 +1124,41 @@ void tst_qquickwindow::mouseFiltering()
     // 1. middleItem filters event
     // 2. bottomItem filters event
     // 3. topItem receives event
-    QTRY_COMPARE(middleItem->mousePressId, 1);
-    QTRY_COMPARE(bottomItem->mousePressId, 2);
-    QTRY_COMPARE(topItem->mousePressId, 3);
+    QTRY_COMPARE(middleItem->mousePressCount, 1);
+    QTRY_COMPARE(bottomItem->mousePressCount, 2);
+    QTRY_COMPARE(topItem->mousePressCount, 3);
+    QCOMPARE(siblingItem->mousePressCount, 0);
+
+    QTest::mouseRelease(window, Qt::LeftButton, 0, pos);
+    topItem->clearMouseEventCounters();
+    middleItem->clearMouseEventCounters();
+    bottomItem->clearMouseEventCounters();
+    siblingItem->clearMouseEventCounters();
+
+    // Repeat, but this time have the top item accept the press
+    topItem->acceptMouseEvents = true;
+
+    QTest::mousePress(window, Qt::LeftButton, 0, pos);
+
+    // Mouse filtering propagates down the stack, so the
+    // correct order is
+    // 1. middleItem filters event
+    // 2. bottomItem filters event
+    // 3. topItem receives event
+    QTRY_COMPARE(middleItem->mousePressCount, 1);
+    QTRY_COMPARE(bottomItem->mousePressCount, 2);
+    QTRY_COMPARE(topItem->mousePressCount, 3);
+    QCOMPARE(siblingItem->mousePressCount, 0);
+
+    pos += QPoint(50, 50);
+    QTest::mouseMove(window, pos);
+
+    // The top item has grabbed, so the move goes there, but again
+    // all the ancestors can filter, even when the mouse is outside their bounds
+    QTRY_COMPARE(middleItem->mouseMoveCount, 1);
+    QTRY_COMPARE(bottomItem->mouseMoveCount, 2);
+    QTRY_COMPARE(topItem->mouseMoveCount, 3);
+    QCOMPARE(siblingItem->mouseMoveCount, 0);
 
     // clean up mouse press state for the next tests
     QTest::mouseRelease(window, Qt::LeftButton, 0, pos);
@@ -2503,6 +2555,84 @@ void tst_qquickwindow::testHoverTimestamp()
     QCOMPARE(hoverConsumer->hoverTimestamps.last(), 5UL);
 }
 
+class CircleItem : public QQuickRectangle
+{
+public:
+    CircleItem(QQuickItem *parent = 0) : QQuickRectangle(parent) { }
+
+    void setRadius(qreal radius) {
+        const qreal diameter = radius*2;
+        setWidth(diameter);
+        setHeight(diameter);
+    }
+
+    bool childMouseEventFilter(QQuickItem *item, QEvent *event) override
+    {
+        Q_UNUSED(item)
+        if (event->type() == QEvent::MouseButtonPress && !contains(static_cast<QMouseEvent*>(event)->pos())) {
+            // This is an evil hack: in case of items that are not rectangles, we never accept the event.
+            // Instead the events are now delivered to QDeclarativeGeoMapItemBase which doesn't to anything with them.
+            // The map below it still works since it filters events and steals the events at some point.
+            event->setAccepted(false);
+            return true;
+        }
+        return false;
+    }
+
+    virtual bool contains(const QPointF &pos) const override {
+        // returns true if the point is inside the the embedded circle inside the (square) rect
+        const float radius = (float)width()/2;
+        const QVector2D center(radius, radius);
+        const QVector2D dx = QVector2D(pos) - center;
+        const bool ret = dx.lengthSquared() < radius*radius;
+        return ret;
+    }
+};
+
+void tst_qquickwindow::test_circleMapItem()
+{
+    QQuickWindow window;
+
+    window.resize(250, 250);
+    window.setPosition(100, 100);
+    window.setTitle(QTest::currentTestFunction());
+
+    QQuickItem *root = window.contentItem();
+    QQuickMouseArea *mab = new QQuickMouseArea(root);
+    mab->setObjectName("Bottom MouseArea");
+    mab->setSize(QSizeF(100, 100));
+
+    CircleItem *topItem = new CircleItem(root);
+    topItem->setFiltersChildMouseEvents(true);
+    topItem->setColor(Qt::green);
+    topItem->setObjectName("Top Item");
+    topItem->setPosition(QPointF(30, 30));
+    topItem->setRadius(20);
+    QQuickMouseArea *mat = new QQuickMouseArea(topItem);
+    mat->setObjectName("Top Item/MouseArea");
+    mat->setSize(QSizeF(40, 40));
+
+    QSignalSpy bottomSpy(mab, SIGNAL(clicked(QQuickMouseEvent *)));
+    QSignalSpy topSpy(mat, SIGNAL(clicked(QQuickMouseEvent *)));
+
+    window.show();
+    QTest::qWaitForWindowExposed(&window);
+    QTest::qWait(1000);
+
+    QPoint pos(50, 50);
+    QTest::mouseClick(&window, Qt::LeftButton, Qt::KeyboardModifiers(), pos);
+
+    QCOMPARE(topSpy.count(), 1);
+    QCOMPARE(bottomSpy.count(), 0);
+
+    // Outside the "Circles" "input area", but on top of the bottomItem rectangle
+    pos = QPoint(66, 66);
+    QTest::mouseClick(&window, Qt::LeftButton, Qt::KeyboardModifiers(), pos);
+
+    QCOMPARE(bottomSpy.count(), 1);
+    QCOMPARE(topSpy.count(), 1);
+}
+
 void tst_qquickwindow::pointerEventTypeAndPointCount()
 {
     QPointF localPosition(33, 66);
diff --git a/tests/auto/quick/quick.pro b/tests/auto/quick/quick.pro
index 2ff606488c..9b7740646a 100644
--- a/tests/auto/quick/quick.pro
+++ b/tests/auto/quick/quick.pro
@@ -47,6 +47,7 @@ PRIVATETESTS += \
 !qtHaveModule(xmlpatterns): PRIVATETESTS -= qquickxmllistmodel
 
 QUICKTESTS =  \
+    pointerhandlers \
     qquickaccessible \
     qquickanchors \
     qquickanimatedimage \
diff --git a/tests/auto/quick/touchmouse/BLACKLIST b/tests/auto/quick/touchmouse/BLACKLIST
new file mode 100644
index 0000000000..ac0352d10b
--- /dev/null
+++ b/tests/auto/quick/touchmouse/BLACKLIST
@@ -0,0 +1,3 @@
+# QTBUG-40856 hover regression on pointerhandler branch: TODO fix before merging to dev
+[hoverEnabled]
+*
diff --git a/tests/auto/quick/touchmouse/tst_touchmouse.cpp b/tests/auto/quick/touchmouse/tst_touchmouse.cpp
index 39f2961927..646317078b 100644
--- a/tests/auto/quick/touchmouse/tst_touchmouse.cpp
+++ b/tests/auto/quick/touchmouse/tst_touchmouse.cpp
@@ -30,6 +30,7 @@
 #include <QtTest/QtTest>
 
 #include <QtGui/qstylehints.h>
+#include <private/qdebug_p.h>
 
 #include <QtQuick/qquickview.h>
 #include <QtQuick/qquickitem.h>
@@ -62,6 +63,21 @@ struct Event
     QList<QTouchEvent::TouchPoint> points;
 };
 
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const struct Event &event) {
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
+    dbg << "Event(";
+    QtDebugUtils::formatQEnum(dbg, event.type);
+    if (event.points.isEmpty())
+        dbg << " @ " << event.mousePos << " global " << event.mousePosGlobal;
+    else
+        dbg << ", " << event.points.count() << " touchpoints: " << event.points;
+    dbg << ')';
+    return dbg;
+}
+#endif
+
 class EventItem : public QQuickItem
 {
     Q_OBJECT
@@ -74,6 +90,9 @@ public:
         : QQuickItem(parent), touchUngrabCount(0), acceptMouse(false), acceptTouch(false), filterTouch(false), point0(-1)
     {
         setAcceptedMouseButtons(Qt::LeftButton);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+        setAcceptTouchEvents(true);
+#endif
     }
 
     void touchEvent(QTouchEvent *event)
@@ -572,7 +591,7 @@ void tst_TouchMouse::buttonOnFlickable()
     QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(window.data());
     QVERIFY(windowPriv->touchMouseId != -1);
     auto pointerEvent = windowPriv->pointerEventInstance(QQuickPointerDevice::touchDevices().at(0));
-    QCOMPARE(pointerEvent->point(0)->grabber(), eventItem1);
+    QCOMPARE(pointerEvent->point(0)->exclusiveGrabber(), eventItem1);
     QCOMPARE(window->mouseGrabberItem(), eventItem1);
 
     int dragDelta = -qApp->styleHints()->startDragDistance();
@@ -594,7 +613,7 @@ void tst_TouchMouse::buttonOnFlickable()
 
     QCOMPARE(window->mouseGrabberItem(), flickable);
     QVERIFY(windowPriv->touchMouseId != -1);
-    QCOMPARE(pointerEvent->point(0)->grabber(), flickable);
+    QCOMPARE(pointerEvent->point(0)->exclusiveGrabber(), flickable);
     QVERIFY(flickable->isMovingVertically());
 
     QTest::touchEvent(window.data(), device).release(0, p3, window.data());
@@ -633,7 +652,7 @@ void tst_TouchMouse::touchButtonOnFlickable()
     QQuickWindowPrivate *windowPriv = QQuickWindowPrivate::get(window.data());
     QVERIFY(windowPriv->touchMouseId == -1);
     auto pointerEvent = windowPriv->pointerEventInstance(QQuickPointerDevice::touchDevices().at(0));
-    QCOMPARE(pointerEvent->point(0)->grabber(), eventItem2);
+    QCOMPARE(pointerEvent->point(0)->grabberItem(), eventItem2);
     QCOMPARE(window->mouseGrabberItem(), nullptr);
 
     int dragDelta = qApp->styleHints()->startDragDistance() * -0.7;
@@ -654,7 +673,7 @@ void tst_TouchMouse::touchButtonOnFlickable()
     QCOMPARE(eventItem2->touchUngrabCount, 1);
     QCOMPARE(window->mouseGrabberItem(), flickable);
     QVERIFY(windowPriv->touchMouseId != -1);
-    QCOMPARE(pointerEvent->point(0)->grabber(), flickable);
+    QCOMPARE(pointerEvent->point(0)->grabberItem(), flickable);
     QVERIFY(flickable->isMovingVertically());
 
     QTest::touchEvent(window.data(), device).release(0, p3, window.data());
@@ -759,7 +778,7 @@ void tst_TouchMouse::buttonOnDelayedPressFlickable()
     QCOMPARE(window->mouseGrabberItem(), flickable);
     QVERIFY(windowPriv->touchMouseId != -1);
     auto pointerEvent = windowPriv->pointerEventInstance(QQuickPointerDevice::touchDevices().at(0));
-    QCOMPARE(pointerEvent->point(0)->grabber(), flickable);
+    QCOMPARE(pointerEvent->point(0)->grabberItem(), flickable);
 
     QTest::touchEvent(window.data(), device).release(0, p3, window.data());
     QQuickTouchUtils::flush(window.data());
diff --git a/tests/manual/pointer/content/FakeFlickable.qml b/tests/manual/pointer/content/FakeFlickable.qml
new file mode 100644
index 0000000000..55dafef82e
--- /dev/null
+++ b/tests/manual/pointer/content/FakeFlickable.qml
@@ -0,0 +1,122 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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.8
+import Qt.labs.handlers 1.0
+
+Item {
+    id: root
+    default property alias data: __contentItem.data
+    property alias velocity: anim.velocity
+    property alias contentX: __contentItem.x // sign is reversed compared to Flickable.contentX
+    property alias contentY: __contentItem.y // sign is reversed compared to Flickable.contentY
+    property alias contentWidth: __contentItem.width
+    property alias contentHeight: __contentItem.height
+    signal flickStarted
+    signal flickEnded
+
+    Item {
+        id: __contentItem
+        objectName: "__contentItem"
+        width: childrenRect.width
+        height: childrenRect.height
+
+        property real xlimit: root.width - __contentItem.width
+        property real ylimit: root.height - __contentItem.height
+
+        function returnToBounds() {
+            var startAnim = false
+            if (x > 0) {
+                returnToBoundsAnim.x = 0
+                startAnim = true
+            } else if (x < xlimit) {
+                returnToBoundsAnim.x = xlimit
+                startAnim = true
+            }
+            if (y > 0) {
+                returnToBoundsAnim.y = 0
+                startAnim = true
+            } else if (y < ylimit) {
+                returnToBoundsAnim.y = ylimit
+                startAnim = true
+            }
+            if (startAnim)
+                returnToBoundsAnim.start()
+        }
+
+        DragHandler {
+            id: dragHandler
+            onActiveChanged: if (!active) anim.restart(point.velocity)
+        }
+        MomentumAnimation {
+            id: anim
+            target: __contentItem
+            onStarted: root.flickStarted()
+            onStopped: {
+                __contentItem.returnToBounds()
+                root.flickEnded()
+            }
+        }
+        ParallelAnimation {
+            id: returnToBoundsAnim
+            property Item target: __contentItem
+            property int duration: 200
+            property real x: 0
+            property real y: 0
+
+            NumberAnimation {
+                id: xAnim
+                target: returnToBoundsAnim.target
+                property: "x"
+                to: returnToBoundsAnim.x
+                duration: returnToBoundsAnim.duration
+                easing.type: Easing.OutQuad
+            }
+            NumberAnimation {
+                id: yAnim
+                target: returnToBoundsAnim.target
+                property: "y"
+                to: returnToBoundsAnim.y
+                duration: returnToBoundsAnim.duration
+                easing.type: Easing.OutQuad
+            }
+        }
+    }
+}
diff --git a/tests/manual/pointer/content/FlashAnimation.qml b/tests/manual/pointer/content/FlashAnimation.qml
new file mode 100644
index 0000000000..b628255a3d
--- /dev/null
+++ b/tests/manual/pointer/content/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/manual/pointer/content/MomentumAnimation.qml b/tests/manual/pointer/content/MomentumAnimation.qml
new file mode 100644
index 0000000000..abd9ac9269
--- /dev/null
+++ b/tests/manual/pointer/content/MomentumAnimation.qml
@@ -0,0 +1,71 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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.8
+
+ParallelAnimation {
+    id: root
+    property Item target: null
+    property int duration: 500
+    property vector2d velocity: Qt.vector2d(0,0)
+
+    function restart(vel) {
+        stop()
+        velocity = vel
+        start()
+    }
+
+    NumberAnimation {
+        id: xAnim
+        target: root.target
+        property: "x"
+        to: target.x + velocity.x / duration * 100000
+        duration: root.duration
+        easing.type: Easing.OutQuad
+    }
+    NumberAnimation {
+        id: yAnim
+        target: root.target
+        property: "y"
+        to: target.y + velocity.y / duration * 100000
+        duration: root.duration
+        easing.type: Easing.OutQuad
+    }
+}
diff --git a/tests/manual/pointer/content/MouseAreaButton.qml b/tests/manual/pointer/content/MouseAreaButton.qml
new file mode 100644
index 0000000000..de1d972386
--- /dev/null
+++ b/tests/manual/pointer/content/MouseAreaButton.qml
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the examples 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.1
+import QtQuick.Window 2.1
+
+Item {
+    id: container
+
+    property alias text: buttonLabel.text
+    property alias label: buttonLabel
+    signal clicked
+    property alias containsMouse: mouseArea.containsMouse
+    property alias pressed: mouseArea.pressed
+    implicitHeight: Math.max(Screen.pixelDensity * 7, buttonLabel.implicitHeight * 1.2)
+    implicitWidth: Math.max(Screen.pixelDensity * 11, buttonLabel.implicitWidth * 1.3)
+    height: implicitHeight
+    width: implicitWidth
+
+    SystemPalette { id: palette }
+
+    Rectangle {
+        id: frame
+        anchors.fill: parent
+        color: palette.button
+        gradient: Gradient {
+            GradientStop { position: 0.0; color: mouseArea.pressed ? Qt.darker(palette.button, 1.3) : palette.button }
+            GradientStop { position: 1.0; color: Qt.darker(palette.button, 1.3) }
+        }
+        antialiasing: true
+        radius: height / 6
+        border.color: Qt.darker(palette.button, 1.5)
+        border.width: 1
+    }
+
+    MouseArea {
+        id: mouseArea
+        anchors.fill: parent
+        onClicked: container.clicked()
+        hoverEnabled: true
+    }
+
+    Text {
+        id: buttonLabel
+        text: container.text
+        color: palette.buttonText
+        anchors.centerIn: parent
+    }
+}
diff --git a/tests/manual/pointer/content/MouseAreaSlider.qml b/tests/manual/pointer/content/MouseAreaSlider.qml
new file mode 100644
index 0000000000..c34c528c7d
--- /dev/null
+++ b/tests/manual/pointer/content/MouseAreaSlider.qml
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** 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.7
+
+Item {
+    id: root
+    property int value: 50
+    property int maximumValue: 99
+    property alias label: label.text
+
+    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 {
+        // RectangularGlow is better, but that's a different module
+        id: glow
+        anchors.fill: knob
+        anchors.margins: -5
+        anchors.leftMargin: -2
+        anchors.horizontalCenterOffset: 1
+        radius: 5
+        color: "#4400FFFF"
+        opacity: ma.pressed ? 1 : 0
+    }
+    Image {
+        id: knob
+        source: "../resources/mixer-knob.png"
+        antialiasing: true
+        x: slot.x - width / 2 + slot.width / 2
+        height: root.width / 2
+        width: implicitWidth / implicitHeight * height
+        property bool programmatic: false
+        property real multiplier: root.maximumValue / (ma.drag.maximumY - ma.drag.minimumY)
+        onYChanged: if (!programmatic) root.value = root.maximumValue - (knob.y - ma.drag.minimumY) * multiplier
+        transformOrigin: Item.Center
+        function setValue(value) { knob.y = ma.drag.maximumY - value / knob.multiplier }
+        MouseArea {
+            id: ma
+            anchors.fill: parent
+            drag.target: parent
+            drag.minimumX: knob.x
+            drag.maximumX: knob.x
+            drag.minimumY: slot.y
+            drag.maximumY: slot.height + slot.y - knob.height
+        }
+    }
+
+    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
+    }
+
+    onHeightChanged: {
+        knob.programmatic = true
+        knob.setValue(root.value)
+        knob.programmatic = false
+    }
+}
diff --git a/tests/manual/pointer/content/MptaButton.qml b/tests/manual/pointer/content/MptaButton.qml
new file mode 100644
index 0000000000..836744822b
--- /dev/null
+++ b/tests/manual/pointer/content/MptaButton.qml
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the examples 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.7
+import QtQuick.Window 2.1
+
+Item {
+    id: container
+
+    property alias text: buttonLabel.text
+    property alias label: buttonLabel
+    signal clicked
+    property alias pressed: point.pressed
+    implicitHeight: Math.max(Screen.pixelDensity * 7, buttonLabel.implicitHeight * 1.2)
+    implicitWidth: Math.max(Screen.pixelDensity * 11, buttonLabel.implicitWidth * 1.3)
+    height: implicitHeight
+    width: implicitWidth
+
+    SystemPalette { id: palette }
+
+    Rectangle {
+        id: frame
+        anchors.fill: parent
+        color: palette.button
+        gradient: Gradient {
+            GradientStop { position: 0.0; color: container.pressed ? Qt.darker(palette.button, 1.3) : palette.button }
+            GradientStop { position: 1.0; color: Qt.darker(palette.button, 1.3) }
+        }
+        antialiasing: true
+        radius: height / 6
+        border.color: Qt.darker(palette.button, 1.5)
+        border.width: 1
+    }
+
+    MultiPointTouchArea {
+        id: mpta
+        anchors.fill: parent
+        touchPoints: [ TouchPoint {
+            id: point
+            onPressedChanged: if (!pressed) container.clicked()
+        } ]
+    }
+
+    Text {
+        id: buttonLabel
+        text: container.text
+        color: palette.buttonText
+        anchors.centerIn: parent
+    }
+}
diff --git a/tests/manual/pointer/content/MultiButton.qml b/tests/manual/pointer/content/MultiButton.qml
new file mode 100644
index 0000000000..4a737dc9b0
--- /dev/null
+++ b/tests/manual/pointer/content/MultiButton.qml
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** 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.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
+    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
+        onTapped: {
+            tapFlash.start()
+            root.tapped()
+        }
+    }
+
+    Text {
+        id: label
+        font.pointSize: 14
+        text: "Button"
+        anchors.centerIn: parent
+    }
+
+    Rectangle {
+        anchors.fill: parent
+        color: "transparent"
+        border.width: 2; radius: root.radius; antialiasing: true
+        opacity: tapFlash.running ? 1 : 0
+        FlashAnimation on visible {
+            id: tapFlash
+        }
+    }
+}
diff --git a/tests/manual/pointer/content/ScrollBar.qml b/tests/manual/pointer/content/ScrollBar.qml
new file mode 100644
index 0000000000..ef18ceb98f
--- /dev/null
+++ b/tests/manual/pointer/content/ScrollBar.qml
@@ -0,0 +1,160 @@
+/****************************************************************************
+**
+** 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.8
+import Qt.labs.handlers 1.0
+
+Rectangle {
+    id: root
+    property real contentHeight: 100
+    property FakeFlickable flick: null
+    property real position
+
+    onPositionChanged: if (flick && (drag.active || tap.active)) {
+        if (knob.state === "horizontal")
+            flick.contentX = position * knob.scrollDistance
+        else if (knob.state === "vertical")
+            flick.contentY = position * knob.scrollDistance
+    }
+
+    SystemPalette { id: palette }
+
+    color: palette.button
+    border.color: Qt.darker(palette.button, 1.5)
+    gradient: Gradient {
+        GradientStop { position: 0; color: Qt.darker(palette.button, 1.3) }
+        GradientStop { position: 1; color: palette.button }
+    }
+    antialiasing: true
+    radius: Math.min(width, height) / 6
+    width: 20
+    height: 20
+
+    TapHandler {
+        id: tap
+        onTapped: {
+            if (knob.state === "horizontal")
+                knob.x = position.x - knob.width / 2
+            else if (knob.state === "vertical")
+                knob.y = position.y - knob.height / 2
+        }
+    }
+
+    Rectangle {
+        id: knob
+        border.color: "black"
+        border.width: 1
+        gradient: Gradient {
+            GradientStop { position: 0; color: palette.button }
+            GradientStop { position: 1; color: Qt.darker(palette.button, 1.3) }
+        }
+        radius: 2
+        antialiasing: true
+        state: root.height > root.width ? "vertical" : root.height < root.width ? "horizontal" : ""
+        property real scrollDistance: 0
+        property real scrolledX: 0
+        property real scrolledY: 0
+        property real max: 0
+
+        Binding on x {
+            value: knob.scrolledX
+            when: !drag.active
+        }
+
+        Binding on y {
+            value: knob.scrolledY
+            when: !drag.active
+        }
+
+        states: [
+            // We will control the horizontal. We will control the vertical.
+            State {
+                name: "horizontal"
+                PropertyChanges {
+                    target: knob
+                    max: root.width - knob.width
+                    scrolledX: Math.min(max, Math.max(0, max * flick.contentX / (flick.width - flick.contentWidth)))
+                    scrolledY: 1
+                    scrollDistance: flick.width - flick.contentWidth
+                    width: flick.width * (flick.width / flick.contentWidth) - (height - anchors.margins) * 2
+                    height: root.height - 2
+                }
+                PropertyChanges {
+                    target: drag
+                    xAxis.minimum: 0
+                    xAxis.maximum: knob.max
+                    yAxis.minimum: 1
+                    yAxis.maximum: 1
+                }
+                PropertyChanges {
+                    target: root
+                    position: knob.x / drag.xAxis.maximum
+                }
+            },
+            State {
+                name: "vertical"
+                PropertyChanges {
+                    target: knob
+                    max: root.height - knob.height
+                    scrolledX: 1
+                    scrolledY: Math.min(max, Math.max(0, max * flick.contentY / (flick.height - flick.contentHeight)))
+                    scrollDistance: flick.height - flick.contentHeight
+                    width: root.width - 2
+                    height: root.width - 2
+                }
+                PropertyChanges {
+                    target: drag
+                    xAxis.minimum: 1
+                    xAxis.maximum: 1
+                    yAxis.minimum: 0
+                    yAxis.maximum: knob.max
+                }
+                PropertyChanges {
+                    target: root
+                    position: knob.y / drag.yAxis.maximum
+                }
+            }
+        ]
+
+        DragHandler {
+            id: drag
+        }
+    }
+}
diff --git a/tests/manual/pointer/content/Slider.qml b/tests/manual/pointer/content/Slider.qml
new file mode 100644
index 0000000000..809e4c5f1c
--- /dev/null
+++ b/tests/manual/pointer/content/Slider.qml
@@ -0,0 +1,135 @@
+/****************************************************************************
+**
+** 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.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
+
+    DragHandler {
+        id: dragHandler
+        objectName: label.text + " DragHandler"
+        target: knob
+        xAxis.enabled: false
+        yAxis.minimum: slot.y
+        yAxis.maximum: slot.height + slot.y - knob.height
+    }
+
+    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 {
+        // RectangularGlow is better, but that's a different module
+        id: glow
+        anchors.fill: knob
+        anchors.margins: -5
+        anchors.leftMargin: -2
+        anchors.horizontalCenterOffset: 1
+        radius: 5
+        color: "#4400FFFF"
+        opacity: tap.isPressed || tapFlash.running ? 1 : 0
+        FlashAnimation on visible {
+            id: tapFlash
+        }
+    }
+    Image {
+        id: knob
+        source: "../resources/mixer-knob.png"
+        antialiasing: true
+        x: slot.x - width / 2 + slot.width / 2
+        height: root.width / 2
+        width: implicitWidth / implicitHeight * height
+        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 }
+        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
+    }
+
+    onHeightChanged: {
+        knob.programmatic = true
+        knob.setValue(root.value)
+        knob.programmatic = false
+    }
+}
diff --git a/tests/manual/pointer/content/TapHandlerButton.qml b/tests/manual/pointer/content/TapHandlerButton.qml
new file mode 100644
index 0000000000..e40c539686
--- /dev/null
+++ b/tests/manual/pointer/content/TapHandlerButton.qml
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the examples 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.7
+import QtQuick.Window 2.1
+import Qt.labs.handlers 1.0
+
+Item {
+    id: container
+
+    property alias text: buttonLabel.text
+    property alias label: buttonLabel
+    signal clicked
+    property alias pressed: th.isPressed
+    implicitHeight: Math.max(Screen.pixelDensity * 7, buttonLabel.implicitHeight * 1.2)
+    implicitWidth: Math.max(Screen.pixelDensity * 11, buttonLabel.implicitWidth * 1.3)
+    height: implicitHeight
+    width: implicitWidth
+
+    SystemPalette { id: palette }
+
+    Rectangle {
+        id: frame
+        anchors.fill: parent
+        color: palette.button
+        gradient: Gradient {
+            GradientStop { position: 0.0; color: container.pressed ? Qt.darker(palette.button, 1.3) : palette.button }
+            GradientStop { position: 1.0; color: Qt.darker(palette.button, 1.3) }
+        }
+        antialiasing: true
+        radius: height / 6
+        border.color: Qt.darker(palette.button, 1.5)
+        border.width: 1
+    }
+
+    TapHandler {
+        id: th
+        onTapped: container.clicked()
+    }
+
+    Text {
+        id: buttonLabel
+        text: container.text
+        color: palette.buttonText
+        anchors.centerIn: parent
+    }
+}
diff --git a/tests/manual/pointer/fakeFlickable.qml b/tests/manual/pointer/fakeFlickable.qml
new file mode 100644
index 0000000000..0c6dbe4558
--- /dev/null
+++ b/tests/manual/pointer/fakeFlickable.qml
@@ -0,0 +1,117 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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.8
+import Qt.labs.handlers 1.0
+import "content"
+
+Rectangle {
+    color: "#444"
+    width: 480
+    height: 480
+
+    FakeFlickable {
+        id: ff
+        anchors.fill: parent
+        anchors.rightMargin: rightSB.width
+        Row {
+            Item {
+                width: 100
+                height: 400
+                Slider {
+                    id: slider
+                    label: "font size"
+                    anchors.fill: parent
+                    maximumValue: 36
+                    value: 14
+                }
+            }
+            Text {
+                id: text
+                color: "beige"
+                font.family: "mono"
+                font.pointSize: slider.value
+                onTextChanged: console.log("text geom " + width + "x" + height +
+                    ", parent " + parent + " geom " + parent.width + "x" + parent.height)
+            }
+        }
+
+
+        onFlickStarted: console.log("flick started with velocity " + velocity)
+        onFlickEnded: console.log("flick ended with velocity " + velocity)
+
+        Component.onCompleted: {
+            var request = new XMLHttpRequest()
+            request.open('GET', 'content/FakeFlickable.qml')
+            request.onreadystatechange = function(event) {
+                if (request.readyState === XMLHttpRequest.DONE)
+                    text.text = request.responseText
+            }
+            request.send()
+        }
+    }
+
+    ScrollBar {
+        id: rightSB
+        objectName: "rightSB"
+        flick: ff
+        height: parent.height - width
+        anchors.right: parent.right
+    }
+
+    ScrollBar {
+        id: bottomSB
+        objectName: "bottomSB"
+        flick: ff
+        width: parent.width - height
+        anchors.bottom: parent.bottom
+    }
+
+    Rectangle {
+        id: cornerCover
+        color: "lightgray"
+        width: rightSB.width
+        height: bottomSB.height
+        anchors {
+            right: parent.right
+            bottom: parent.bottom
+        }
+    }
+}
diff --git a/tests/manual/pointer/flickableWithHandlers.qml b/tests/manual/pointer/flickableWithHandlers.qml
new file mode 100644
index 0000000000..8225012591
--- /dev/null
+++ b/tests/manual/pointer/flickableWithHandlers.qml
@@ -0,0 +1,108 @@
+/****************************************************************************
+**
+** 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.7
+import Qt.labs.handlers 1.0
+import "qrc:/quick/shared/" as Examples
+import "content"
+
+Rectangle {
+    id: root
+    width: 400
+    height: 400
+    objectName: "root"
+    color: "#222222"
+
+    Flickable {
+        anchors.fill: parent
+        anchors.margins: 10
+        anchors.topMargin: 40
+        contentHeight: 600
+        contentWidth: 600
+        pressDelay: pressDelayCB.checked ? 1000 : 0
+
+        Column {
+            spacing: 6
+            Rectangle {
+                radius: 5
+                width: parent.width - 12
+                height: pressDelayCB.implicitHeight + 12
+                x: 6
+                color: "lightgray"
+                Examples.CheckBox {
+                    x: 6; y: 6
+                    id: pressDelayCB
+                    text: "press delay"
+                }
+            }
+
+
+            Row {
+                spacing: 6
+                Slider {
+                    label: "DragHandler"
+                    value: 49; width: 100; height: 400
+                }
+                MouseAreaSlider {
+                    label: "MouseArea"
+                    value: 49; width: 100; height: 400
+                }
+                Column {
+                    spacing: 6
+                    MouseAreaButton {
+                        text: "MouseArea"
+                    }
+                    MptaButton {
+                        text: "MultiPointTouchArea"
+                    }
+                    MptaButton {
+                        text: "MultiPointTouchArea"
+                    }
+                    TapHandlerButton {
+                        text: "TapHandler"
+                    }
+                    TapHandlerButton {
+                        text: "TapHandler"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/manual/pointer/flingAnimation.qml b/tests/manual/pointer/flingAnimation.qml
new file mode 100644
index 0000000000..d868fcc498
--- /dev/null
+++ b/tests/manual/pointer/flingAnimation.qml
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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.8
+import Qt.labs.handlers 1.0
+import "content"
+
+Rectangle {
+    id: root
+    width: 640
+    height: 480
+    color: "black"
+
+    Repeater {
+        model: 2
+
+        Image {
+            id: ball
+            objectName: "ball" + index
+            source: "resources/redball.png"
+            width: 80; height: 80; x: 200 + index * 200; y: 200
+
+            Text {
+                anchors.centerIn: parent
+                color: "white"
+                text: anim.velocity.x.toFixed(2) + "," + anim.velocity.y.toFixed(2)
+            }
+
+            MomentumAnimation { id: anim; target: ball }
+
+            DragHandler {
+                id: dragHandler
+                objectName: "dragHandler" + index
+                onActiveChanged: {
+                    if (!active)
+                        anim.restart(point.velocity)
+                }
+            }
+            Rectangle {
+                visible: dragHandler.active
+                anchors.fill: parent
+                anchors.margins: -5
+                radius: width / 2
+                opacity: 0.25
+            }
+        }
+    }
+}
diff --git a/tests/manual/pointer/joystick.qml b/tests/manual/pointer/joystick.qml
new file mode 100644
index 0000000000..bcc4564471
--- /dev/null
+++ b/tests/manual/pointer/joystick.qml
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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.8
+import Qt.labs.handlers 1.0
+
+Rectangle {
+    width: 480
+    height: 480
+    color: "black"
+
+    Image {
+        id: knob
+        source: "resources/redball.png"
+        anchors {
+            horizontalCenter: parent.horizontalCenter
+            verticalCenter: parent.verticalCenter
+        }
+        DragHandler {
+            id: dragHandler
+        }
+        states: [
+            State {
+                when: dragHandler.active
+                AnchorChanges {
+                    target: knob
+                    anchors.horizontalCenter: undefined
+                    anchors.verticalCenter: undefined
+                }
+            }
+        ]
+        transitions: [
+            Transition {
+                AnchorAnimation { easing.type: Easing.OutElastic }
+            }
+        ]
+    }
+}
diff --git a/tests/manual/pointer/main.cpp b/tests/manual/pointer/main.cpp
new file mode 100644
index 0000000000..7935b4072c
--- /dev/null
+++ b/tests/manual/pointer/main.cpp
@@ -0,0 +1,66 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://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$
+**
+****************************************************************************/
+#include <QGuiApplication>
+#include <QQmlApplicationEngine>
+#include <QQuickItem>
+#include <QQuickWindow>
+
+int main(int argc, char *argv[])
+{
+    QGuiApplication app(argc, argv);
+
+    QQmlApplicationEngine engine;
+    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
+    if (!app.arguments().isEmpty()) {
+        QQuickWindow * win = static_cast<QQuickWindow *>(engine.rootObjects().first());
+        auto lastArg = app.arguments().last();
+        if (lastArg.endsWith(QLatin1String(".qml"))) {
+            auto root = win->findChild<QQuickItem *>("LauncherList");
+            int showExampleIdx = -1;
+            for (int i = root->metaObject()->methodCount(); showExampleIdx < 0 && i >= 0; --i)
+                if (root->metaObject()->method(i).name() == QByteArray("showExample"))
+                    showExampleIdx = i;
+            QMetaMethod showExampleFn = root->metaObject()->method(showExampleIdx);
+            showExampleFn.invoke(root, Q_ARG(QVariant, QVariant(QLatin1String("../../") + lastArg)));
+        }
+    }
+
+    return app.exec();
+}
diff --git a/tests/manual/pointer/main.qml b/tests/manual/pointer/main.qml
new file mode 100644
index 0000000000..df34c7d4a3
--- /dev/null
+++ b/tests/manual/pointer/main.qml
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** 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.8
+import QtQuick.Window 2.2
+import "qrc:/quick/shared/" as Examples
+
+Window {
+    width: 800
+    height: 600
+    visible: true
+    Examples.LauncherList {
+        id: ll
+        objectName: "LauncherList"
+        anchors.fill: parent
+        Component.onCompleted: {
+            addExample("single point handler", "QQuickPointerSingleHandler: test properties copied from events", Qt.resolvedUrl("singlePointHandlerProperties.qml"))
+            addExample("joystick", "DragHandler: move one item inside another with any pointing device", Qt.resolvedUrl("joystick.qml"))
+            addExample("mixer", "mixing console", Qt.resolvedUrl("mixer.qml"))
+            addExample("pinch", "PinchHandler: scale, rotate and drag", Qt.resolvedUrl("pinchHandler.qml"))
+            addExample("map", "scale and pan", Qt.resolvedUrl("map.qml"))
+            addExample("custom map", "scale and pan", Qt.resolvedUrl("map2.qml"))
+            addExample("fling animation", "DragHandler: after dragging, use an animation to simulate momentum", Qt.resolvedUrl("flingAnimation.qml"))
+            addExample("fake Flickable", "implementation of a simplified Flickable using only Items, DragHandler and MomentumAnimation", Qt.resolvedUrl("fakeFlickable.qml"))
+            addExample("photo surface", "re-implementation of the existing photo surface demo using Handlers", Qt.resolvedUrl("photosurface.qml"))
+            addExample("tap", "TapHandler: device-agnostic tap/click detection for buttons", Qt.resolvedUrl("tapHandler.qml"))
+            addExample("multibuttons", "TapHandler: gesturePolicy (99 red balloons)", Qt.resolvedUrl("multibuttons.qml"))
+            addExample("flickable with Handlers", "Flickable with buttons, sliders etc. implemented in various ways", Qt.resolvedUrl("flickableWithHandlers.qml"))
+        }
+    }
+}
diff --git a/tests/manual/pointer/map.qml b/tests/manual/pointer/map.qml
new file mode 100644
index 0000000000..e1ca889064
--- /dev/null
+++ b/tests/manual/pointer/map.qml
@@ -0,0 +1,74 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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.8
+import Qt.labs.handlers 1.0
+
+Item {
+    width: 640
+    height: 480
+
+    Rectangle {
+        id: map
+        color: "aqua"
+        x: (parent.width - width) / 2
+        y: (parent.height - height) / 2
+        width: image.implicitWidth
+        height: image.implicitHeight
+
+        Image {
+            id: image
+            anchors.centerIn: parent
+            fillMode: Image.PreserveAspectFit
+            source: "resources/map.svgz"
+        }
+    }
+
+    PinchHandler {
+        id: pinch
+        target: map
+        minimumScale: 0.1
+        maximumScale: 10
+    }
+
+    DragHandler {
+        target: map
+    }
+}
diff --git a/tests/manual/pointer/map2.qml b/tests/manual/pointer/map2.qml
new file mode 100644
index 0000000000..fcd144bd7f
--- /dev/null
+++ b/tests/manual/pointer/map2.qml
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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.8
+import Qt.labs.handlers 1.0
+
+Item {
+    width: 640
+    height: 480
+
+    Rectangle {
+        id: map
+        color: "aqua"
+        x: (parent.width - width) / 2
+        y: (parent.height - height) / 2
+        width: image.implicitWidth
+        height: image.implicitHeight
+        property point center : Qt.point(x + map.width/2, y + map.height/2)
+
+        function setCenter(xx, yy) {
+            map.x = xx - map.width/2
+            map.y = yy - map.height/2
+        }
+
+
+        Image {
+            id: image
+            anchors.centerIn: parent
+            fillMode: Image.PreserveAspectFit
+            source: "resources/map.svgz"
+        }
+    }
+
+    PinchHandler {
+        id: pinch
+        target: map
+        minimumScale: 0.1
+        maximumScale: 10
+    }
+
+    DragHandler {
+        property point startDrag
+        target: null
+        onActiveChanged: {
+            if (active)
+                startDrag = map.center
+        }
+
+        onTranslationChanged: {
+            if (!target)
+                map.setCenter(startDrag.x + translation.x, startDrag.y + translation.y)
+        }
+    }
+}
diff --git a/tests/manual/pointer/mixer.qml b/tests/manual/pointer/mixer.qml
new file mode 100644
index 0000000000..84ad975340
--- /dev/null
+++ b/tests/manual/pointer/mixer.qml
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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.8
+import Qt.labs.handlers 1.0
+import "content"
+
+Rectangle {
+    id: root
+    width: 1280
+    height: 960
+    objectName: "root"
+    color: "#222222"
+
+    ListView {
+        id: list
+        objectName: "listView"
+        anchors.fill: parent
+        anchors.margins: 10
+        orientation: Qt.Horizontal
+
+        model: 20
+
+        delegate: Item {
+            objectName: "delegateItem" + index
+            width: 154
+            height: list.height
+
+            Slider {
+                anchors.fill: parent
+                label: "Channel " + (index + 1)
+            }
+        }
+    }
+}
diff --git a/tests/manual/pointer/multibuttons.qml b/tests/manual/pointer/multibuttons.qml
new file mode 100644
index 0000000000..748ec87c86
--- /dev/null
+++ b/tests/manual/pointer/multibuttons.qml
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** 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
+import QtQuick.Particles 2.0
+import QtQuick.Layouts 1.0
+import Qt.labs.handlers 1.0
+import "content"
+
+Item {
+    width: 800
+    height: 800
+    ColumnLayout {
+        anchors.right: parent.right
+        spacing: 20
+        Text { text: "protagonist"; font.pointSize: 12 }
+        MultiButton {
+            id: balloonsButton
+            label: "Launch Balloons"
+            Layout.fillWidth: true
+            gesturePolicy: TapHandler.WithinBounds
+        }
+        Text { text: "the goons"; font.pointSize: 12 }
+        MultiButton {
+            id: missilesButton
+            label: "Launch Missile"
+            Layout.fillWidth: true
+            gesturePolicy: TapHandler.ReleaseWithinBounds
+            onTapped: missileEmitter.burst(1)
+        }
+        MultiButton {
+            id: fightersButton
+            label: "Launch Fighters"
+            Layout.fillWidth: true
+            gesturePolicy: TapHandler.DragThreshold
+        }
+    }
+    ParticleSystem {
+        anchors.bottom: parent.bottom
+        anchors.left: parent.left
+        anchors.leftMargin: 150
+        ImageParticle { source: "resources/balloon.png" }
+        Emitter { anchors.bottom: parent.bottom; enabled: balloonsButton.pressed; lifeSpan: 5000; size: 64
+            maximumEmitted: 99
+            emitRate: 50; velocity: PointDirection { x: 10; y: -150; yVariation: 30; xVariation: 50 } } }
+    ParticleSystem {
+        anchors.verticalCenter: parent.verticalCenter
+        anchors.right: parent.right
+        ImageParticle { source: "resources/fighter.png" }
+        Emitter { anchors.bottom: parent.bottom; enabled: fightersButton.pressed; lifeSpan: 15000; size: 204
+            emitRate: 3; velocity: PointDirection { x: -1000; y: -250; yVariation: 150; xVariation: 50 } } }
+    ParticleSystem {
+        anchors.bottom: parent.bottom
+        anchors.right: parent.right
+        anchors.rightMargin: 100
+        ImageParticle { source: "resources/missile.png"; autoRotation: true; rotation: 90 }
+        Emitter { id: missileEmitter; anchors.bottom: parent.bottom; lifeSpan: 5000; size: 128;
+            emitRate: 0; velocity: PointDirection { x: -200; y: -350; yVariation: 200; xVariation: 100 } } }
+}
diff --git a/tests/manual/pointer/photosurface.qml b/tests/manual/pointer/photosurface.qml
new file mode 100644
index 0000000000..a2e8b2aede
--- /dev/null
+++ b/tests/manual/pointer/photosurface.qml
@@ -0,0 +1,175 @@
+/****************************************************************************
+**
+** 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.8
+import QtQuick.Dialogs 1.0
+import Qt.labs.folderlistmodel 1.0
+import Qt.labs.handlers 1.0
+import "content"
+
+Rectangle {
+    id: root
+    visible: true
+    width: 1024; height: 600
+    color: "black"
+    property int highestZ: 0
+    property real defaultSize: 200
+    property real surfaceViewportRatio: 1.5
+
+    FileDialog {
+        id: fileDialog
+        title: "Choose a folder with some images"
+        selectFolder: true
+        onAccepted: folderModel.folder = fileUrl + "/"
+    }
+    Shortcut {
+        id: openShortcut
+        sequence: StandardKey.Open
+        onActivated: fileDialog.open()
+    }
+
+    FakeFlickable {
+        id: flick
+        anchors.fill: parent
+        contentWidth: width * 2
+        contentHeight: height * 2
+        Repeater {
+            model: FolderListModel {
+                id: folderModel
+                folder: "resources/"
+                objectName: "folderModel"
+                showDirs: false
+                nameFilters: ["*.png", "*.jpg", "*.gif"]
+            }
+            Rectangle {
+                id: photoFrame
+                objectName: "frame-" + fileName
+                width: image.width * (1 + 0.10 * image.height / image.width)
+                height: image.height * 1.10
+                scale: defaultSize / Math.max(image.sourceSize.width, image.sourceSize.height)
+                Behavior on scale { NumberAnimation { duration: 200 } }
+                Behavior on x { NumberAnimation { duration: 200 } }
+                Behavior on y { NumberAnimation { duration: 200 } }
+                border.color: pinchHandler.active || dragHandler.active ? "red" : "black"
+                border.width: 2
+                smooth: true
+                antialiasing: true
+                Component.onCompleted: {
+                    x = Math.random() * root.width - width / 2
+                    y = Math.random() * root.height - height / 2
+                    rotation = Math.random() * 13 - 6
+                }
+                Image {
+                    id: image
+                    anchors.centerIn: parent
+                    fillMode: Image.PreserveAspectFit
+                    source: folderModel.folder + fileName
+                    antialiasing: true
+                }
+
+                MomentumAnimation { id: anim; target: photoFrame }
+
+                DragHandler {
+                    id: dragHandler
+                    onActiveChanged: {
+                        if (!active)
+                            anim.restart(point.velocity)
+                    }
+                }
+
+                PinchHandler {
+                    id: pinchHandler
+                    minimumRotation: -360
+                    maximumRotation: 360
+                    minimumScale: 0.1
+                    maximumScale: 10
+                    property real zRestore: 0
+                }
+            }
+        }
+    }
+
+    Rectangle {
+        id: verticalScrollDecorator
+        anchors.right: parent.right
+        anchors.margins: 2
+        color: "cyan"
+        border.color: "black"
+        border.width: 1
+        width: 5
+        radius: 2
+        antialiasing: true
+        height: flick.height * (flick.height / flick.contentHeight) - (width - anchors.margins) * 2
+        y:  -flick.contentY * (flick.height / flick.contentHeight)
+        NumberAnimation on opacity { id: vfade; to: 0; duration: 500 }
+        onYChanged: { opacity = 1.0; fadeTimer.restart() }
+    }
+
+    Rectangle {
+        id: horizontalScrollDecorator
+        anchors.bottom: parent.bottom
+        anchors.margins: 2
+        color: "cyan"
+        border.color: "black"
+        border.width: 1
+        height: 5
+        radius: 2
+        antialiasing: true
+        width: flick.width * (flick.width / flick.contentWidth) - (height - anchors.margins) * 2
+        x:  -flick.contentX * (flick.width / flick.contentWidth)
+        NumberAnimation on opacity { id: hfade; to: 0; duration: 500 }
+        onXChanged: { opacity = 1.0; fadeTimer.restart() }
+    }
+
+    Timer { id: fadeTimer; interval: 1000; onTriggered: { hfade.start(); vfade.start() } }
+
+    Text {
+        anchors.bottom: parent.bottom
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.margins: 10
+        color: "darkgrey"
+        wrapMode: Text.WordWrap
+        font.pointSize: 8
+        text: "Press " + openShortcut.nativeText + " to choose a different image folder\n" +
+              "On a touchscreen: use two fingers to zoom and rotate, one finger to drag\n" +
+              "With a mouse: drag normally"
+    }
+}
diff --git a/tests/manual/pointer/pinchDragFlingMPTA.qml b/tests/manual/pointer/pinchDragFlingMPTA.qml
new file mode 100644
index 0000000000..6446a17873
--- /dev/null
+++ b/tests/manual/pointer/pinchDragFlingMPTA.qml
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** 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.8
+import Qt.labs.handlers 1.0
+import "content"
+
+Rectangle {
+    width: 1024; height: 600
+    color: "beige"
+    objectName: "beige root"
+
+    function getTransformationDetails(item, pinchhandler) {
+        return "scale:" + pinchhandler.scale.toFixed(2)
+                + " rotation:" + pinchhandler.rotation.toFixed(2)
+                + " translation:" + "(" + pinchhandler.translation.x.toFixed(2) + "," + pinchhandler.translation.y.toFixed(2) + ")"
+    }
+
+    Rectangle {
+        id: container
+        objectName: "container rect"
+        width: 600
+        height: 500
+        color: pinch3.active ? "red" : "black"
+        antialiasing: true
+        Loader {
+            source: "../touch/mpta-crosshairs.qml"
+            anchors.fill: parent
+            anchors.margins: 2
+        }
+        Item {
+            anchors.fill: parent
+            // In order for PinchHandler to get a chance to take a passive grab, it has to get the touchpoints first.
+            // In order to get the touchpoints first, it has to be on top of the Z order: i.e. come last in paintOrderChildItems().
+            // This is the opposite situation as with filtersChildMouseEvents: e.g. PinchArea would have wanted to be the parent,
+            // if it even knew that trick (which it doesn't).
+            PinchHandler {
+                id: pinch3
+                objectName: "3-finger pinch"
+                target: container
+                requiredPointCount: 3
+                minimumScale: 0.1
+                maximumScale: 10
+                onActiveChanged: if (!active) fling.restart(centroidVelocity)
+            }
+            DragHandler {
+                id: dragHandler
+                objectName: "DragHandler"
+                target: container
+                acceptedModifiers: Qt.MetaModifier
+                onActiveChanged: if (!active) fling.restart(point.velocity)
+            }
+        }
+        MomentumAnimation { id: fling; target: container }
+    }
+    Text {
+        anchors.bottom: parent.bottom
+        text: pinch3.active ? getTransformationDetails(container, pinch3) : "Pinch with 3 fingers to scale, rotate and translate"
+    }
+}
diff --git a/tests/manual/pointer/pinchHandler.qml b/tests/manual/pointer/pinchHandler.qml
new file mode 100644
index 0000000000..71cdd98e4f
--- /dev/null
+++ b/tests/manual/pointer/pinchHandler.qml
@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 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.8
+import Qt.labs.handlers 1.0
+import "content"
+
+Rectangle {
+    width: 1024; height: 600
+    color: "#eee"
+
+    function getTransformationDetails(item, pinchhandler) {
+        return "\n\npinch.scale:" + pinchhandler.scale.toFixed(2)
+        + "\npinch.rotation:" + pinchhandler.rotation.toFixed(2)
+        + "\npinch.translation:" + "(" + pinchhandler.translation.x.toFixed(2) + "," + pinchhandler.translation.y.toFixed(2) + ")"
+        + "\nrect.scale: " + item.scale.toFixed(2)
+        + "\nrect.rotation: " + item.rotation.toFixed(2)
+        + "\nrect.position: " + "(" + item.x.toFixed(2) + "," + item.y.toFixed(2) + ")"
+    }
+
+    Rectangle {
+        // Purpose of this item is just to make sure the rectangles are transformed into
+        // a coordinate system that is different from the scene coordinate system.
+        anchors.fill: parent
+        anchors.margins: 50
+        color: "#ffe0e0e0"
+
+        Rectangle {
+            id: rect2
+            width: 400
+            height: 300
+            color: "lightsteelblue"
+            antialiasing: true
+            x: 100
+            y: 200
+            rotation: 30
+            transformOrigin: Item.TopRight
+            border.width: pinch2.active ? 2 : 0
+            border.color: pinch2.active ? "red" : "transparent"
+
+            Text {
+                anchors.centerIn: parent
+                text: "Pinch with 2 fingers to scale, rotate and translate"
+                    + getTransformationDetails(rect2, pinch2)
+            }
+
+            PinchHandler {
+                id: pinch2
+                objectName: "2-finger pinch"
+                minimumRotation: -45
+                maximumRotation: 45
+                minimumScale: 0.5
+                maximumScale: 3
+                minimumX: 0
+                maximumX: 600
+                pointDistanceThreshold: 0
+                // acceptedModifiers: Qt.ControlModifier
+            }
+        }
+
+        Rectangle {
+            id: rect3
+            x: 500
+            width: 400
+            height: 300
+            color: "wheat"
+            antialiasing: true
+            border.width: (dragHandler.active || pinch3.active) ? 2 : 0
+            border.color: border.width > 0 ? "red" : "transparent"
+
+            Text {
+                anchors.centerIn: parent
+                text: "Pinch with 3 fingers to scale, rotate and translate\nDrag with 1 finger"
+                    + getTransformationDetails(rect3, pinch3)
+            }
+            DragHandler {
+                id: dragHandler
+                objectName: "DragHandler"
+            }
+
+            PinchHandler {
+                id: pinch3
+                objectName: "3-finger pinch"
+                requiredPointCount: 3
+                minimumScale: 0.1
+                maximumScale: 10
+                onActiveChanged: {
+                    if (!active)
+                        anim.restart(centroidVelocity)
+                }
+            }
+
+            MomentumAnimation { id: anim; target: rect3 }
+        }
+    }
+    Rectangle {
+        id: centroidIndicator
+        property QtObject pincher: pinch2.active ? pinch2 : pinch3
+        x: pincher.centroid.x - radius
+        y: pincher.centroid.y - radius
+        z: 1
+        visible: pincher.active
+        radius: width / 2
+        width: 10
+        height: width
+        color: "red"
+    }
+}
diff --git a/tests/manual/pointer/pointer.pro b/tests/manual/pointer/pointer.pro
new file mode 100644
index 0000000000..3705d41df0
--- /dev/null
+++ b/tests/manual/pointer/pointer.pro
@@ -0,0 +1,7 @@
+TEMPLATE = app
+
+QT += qml quick
+
+SOURCES += main.cpp
+
+RESOURCES += qml.qrc ../../../examples/quick/shared/quick_shared.qrc
diff --git a/tests/manual/pointer/qml.qrc b/tests/manual/pointer/qml.qrc
new file mode 100644
index 0000000000..68937a8c4a
--- /dev/null
+++ b/tests/manual/pointer/qml.qrc
@@ -0,0 +1,39 @@
+<RCC>
+    <qresource prefix="/">
+        <file>flingAnimation.qml</file>
+        <file>main.qml</file>
+        <file>fakeFlickable.qml</file>
+        <file>flickableWithHandlers.qml</file>
+        <file>joystick.qml</file>
+        <file>map.qml</file>
+        <file>mixer.qml</file>
+        <file>multibuttons.qml</file>
+        <file>photosurface.qml</file>
+        <file>pinchHandler.qml</file>
+        <file>singlePointHandlerProperties.qml</file>
+        <file>tapHandler.qml</file>
+        <file>content/FakeFlickable.qml</file>
+        <file>content/FlashAnimation.qml</file>
+        <file>content/MomentumAnimation.qml</file>
+        <file>content/MouseAreaButton.qml</file>
+        <file>content/MouseAreaSlider.qml</file>
+        <file>content/MptaButton.qml</file>
+        <file>content/MultiButton.qml</file>
+        <file>content/ScrollBar.qml</file>
+        <file>content/Slider.qml</file>
+        <file>content/TapHandlerButton.qml</file>
+        <file>resources/arrowhead.png</file>
+        <file>resources/balloon.png</file>
+        <file>resources/fighter.png</file>
+        <file>resources/grabbing-location.svg</file>
+        <file>resources/map.svgz</file>
+        <file>resources/missile.png</file>
+        <file>resources/mixer-knob.png</file>
+        <file>resources/mouse.png</file>
+        <file>resources/mouse_left.png</file>
+        <file>resources/mouse_middle.png</file>
+        <file>resources/mouse_right.png</file>
+        <file>resources/redball.png</file>
+        <file>map2.qml</file>
+    </qresource>
+</RCC>
diff --git a/tests/manual/pointer/resources/arrowhead.png b/tests/manual/pointer/resources/arrowhead.png
new file mode 100644
index 0000000000..7719bc6d6a
--- /dev/null
+++ b/tests/manual/pointer/resources/arrowhead.png
diff --git a/tests/manual/pointer/resources/balloon.png b/tests/manual/pointer/resources/balloon.png
new file mode 100644
index 0000000000..6476facc49
--- /dev/null
+++ b/tests/manual/pointer/resources/balloon.png
diff --git a/tests/manual/pointer/resources/fighter.png b/tests/manual/pointer/resources/fighter.png
new file mode 100644
index 0000000000..2acee43cba
--- /dev/null
+++ b/tests/manual/pointer/resources/fighter.png
diff --git a/tests/manual/pointer/resources/grabbing-location.svg b/tests/manual/pointer/resources/grabbing-location.svg
new file mode 100644
index 0000000000..c26881e9ba
--- /dev/null
+++ b/tests/manual/pointer/resources/grabbing-location.svg
@@ -0,0 +1 @@
+<svg width="3408" height="3124"><path d="M1517 1562c0-126-93-229-208-229s-208 102-208 229c0 126 93 229 208 229s208-102 208-229zm123-172c-58-206-221-365-424-412l-270 531H380l203-223 219-241 346-380c42 14 82 32 121 54 232 128 402 375 449 671h-77zm-551-933c448 123 782 546 802 1055h1517C3386 673 2787 0 2050 0H696L0 1367h120l826-938 146 25c-1 1-2 2-3 4zm551 1277c-58 206-221 365-424 412l-270-531H380l203 223 219 241 346 380c42-14 82-32 121-54 232-128 402-375 449-671h-77zm-548 936l-146 25-826-938H0l696 1367h1354c737 0 1337-673 1358-1512H1891c-19 509-354 933-802 1055 1 1 2 2 3 4z" fill="#ee832b"/></svg>
diff --git a/tests/manual/pointer/resources/map.svgz b/tests/manual/pointer/resources/map.svgz
new file mode 100644
index 0000000000..64d509c106
--- /dev/null
+++ b/tests/manual/pointer/resources/map.svgz
diff --git a/tests/manual/pointer/resources/missile.png b/tests/manual/pointer/resources/missile.png
new file mode 100644
index 0000000000..72c02d1fb9
--- /dev/null
+++ b/tests/manual/pointer/resources/missile.png
diff --git a/tests/manual/pointer/resources/mixer-knob.png b/tests/manual/pointer/resources/mixer-knob.png
new file mode 100644
index 0000000000..b7d42ee3bd
--- /dev/null
+++ b/tests/manual/pointer/resources/mixer-knob.png
diff --git a/tests/manual/pointer/resources/mouse.png b/tests/manual/pointer/resources/mouse.png
new file mode 100644
index 0000000000..268946df0a
--- /dev/null
+++ b/tests/manual/pointer/resources/mouse.png
diff --git a/tests/manual/pointer/resources/mouse_left.png b/tests/manual/pointer/resources/mouse_left.png
new file mode 100644
index 0000000000..9292301b47
--- /dev/null
+++ b/tests/manual/pointer/resources/mouse_left.png
diff --git a/tests/manual/pointer/resources/mouse_middle.png b/tests/manual/pointer/resources/mouse_middle.png
new file mode 100644
index 0000000000..064e8b9c16
--- /dev/null
+++ b/tests/manual/pointer/resources/mouse_middle.png
diff --git a/tests/manual/pointer/resources/mouse_right.png b/tests/manual/pointer/resources/mouse_right.png
new file mode 100644
index 0000000000..cab1a36ba6
--- /dev/null
+++ b/tests/manual/pointer/resources/mouse_right.png
diff --git a/tests/manual/pointer/resources/redball.png b/tests/manual/pointer/resources/redball.png
new file mode 100644
index 0000000000..68d2e1d638
--- /dev/null
+++ b/tests/manual/pointer/resources/redball.png
diff --git a/tests/manual/pointer/singlePointHandlerProperties.qml b/tests/manual/pointer/singlePointHandlerProperties.qml
new file mode 100644
index 0000000000..f91094ee9e
--- /dev/null
+++ b/tests/manual/pointer/singlePointHandlerProperties.qml
@@ -0,0 +1,163 @@
+/****************************************************************************
+**
+** 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.9
+import Qt.labs.handlers 1.0
+
+Rectangle {
+    id: root
+    width: 480
+    height: 480
+    color: "black"
+
+    Item {
+        id: crosshairs
+        x: dragHandler.point.position.x - width / 2
+        y: dragHandler.point.position.y - height / 2
+        width: parent.width / 2; height: parent.height / 2
+        visible: dragHandler.active
+        rotation: dragHandler.point.rotation
+
+        Rectangle {
+            color: "goldenrod"
+            anchors.centerIn: parent
+            width: 2; height: parent.height
+            antialiasing: true
+        }
+        Rectangle {
+            color: "goldenrod"
+            anchors.centerIn: parent
+            width: parent.width; height: 2
+            antialiasing: true
+        }
+        Rectangle {
+            color: "goldenrod"
+            width: Math.max(2, 50 * dragHandler.point.pressure)
+            height: width
+            radius: width / 2
+            anchors.centerIn: parent
+            antialiasing: true
+            Rectangle {
+                y: -40
+                anchors.horizontalCenter: parent.horizontalCenter
+                color: "lightsteelblue"
+                implicitWidth: label.implicitWidth
+                implicitHeight: label.implicitHeight
+                Text {
+                    id: label
+                    text: 'id: ' + dragHandler.point.id.toString(16) + " uid: " + dragHandler.point.uniqueId.numericId +
+                        '\npos: (' + dragHandler.point.position.x.toFixed(2) + ', ' + dragHandler.point.position.y.toFixed(2) + ')'
+                }
+            }
+        }
+        Rectangle {
+            color: "transparent"
+            border.color: "white"
+            antialiasing: true
+            width: dragHandler.point.ellipseDiameters.width
+            height: dragHandler.point.ellipseDiameters.height
+            radius: Math.min(width / 2, height / 2)
+            anchors.centerIn: parent
+        }
+    }
+    Rectangle {
+        id: velocityVector
+        visible: width > 0
+        width: dragHandler.point.velocity.length() * 100
+        height: 2
+        x: dragHandler.point.position.x
+        y: dragHandler.point.position.y
+        rotation: Math.atan2(dragHandler.point.velocity.y, dragHandler.point.velocity.x) * 180 / Math.PI
+        transformOrigin: Item.BottomLeft
+        antialiasing: true
+
+        Image {
+            source: "resources/arrowhead.png"
+            anchors.right: parent.right
+            anchors.verticalCenter: parent.verticalCenter
+            width: 16
+            height: 12
+            antialiasing: true
+        }
+    }
+
+    Component {
+        id: grabbingLocationIndicator
+        Image {
+            source: "resources/grabbing-location.svg"
+            sourceSize.width: 32
+            sourceSize.height: 32
+        }
+    }
+
+    Component {
+        id: mouseButtonIndicator
+        Image {
+            property int buttons
+            source: "resources/mouse.png"
+            Image {
+                source: "resources/mouse_left.png"
+                visible: buttons & Qt.LeftButton
+            }
+            Image {
+                source: "resources/mouse_middle.png"
+                visible: buttons & Qt.MidButton
+            }
+            Image {
+                source: "resources/mouse_right.png"
+                visible: buttons & Qt.RightButton
+            }
+        }
+    }
+
+    DragHandler {
+        id: dragHandler
+        target: null
+        onGrabChanged: if (active) {    // 'point' is an implicit parameter referencing to a QQuickEventPoint instance
+            console.log("grabbed " + point.pointId + " @ " + point.sceneGrabPos)
+            grabbingLocationIndicator.createObject(root, {"x": point.sceneGrabPos.x, "y": point.sceneGrabPos.y - 16})
+        }
+        onPointChanged: {
+            // Here, 'point' is referring to the property of the DragHandler
+            if (point.pressedButtons)
+                mouseButtonIndicator.createObject(root, {"x": point.pressPosition.x - 44, "y": point.pressPosition.y - 64, "buttons": point.pressedButtons})
+        }
+    }
+}
diff --git a/tests/manual/pointer/tapHandler.qml b/tests/manual/pointer/tapHandler.qml
new file mode 100644
index 0000000000..5dac99a899
--- /dev/null
+++ b/tests/manual/pointer/tapHandler.qml
@@ -0,0 +1,190 @@
+/****************************************************************************
+**
+** 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.8
+import Qt.labs.handlers 1.0
+import "qrc:/quick/shared/" as Examples
+
+Item {
+    width: 480
+    height: 320
+
+    Rectangle {
+        id: rect
+        anchors.fill: parent; anchors.margins: 40
+        border.width: 3; border.color: "transparent"
+        color: handler.isPressed ? "lightsteelblue" : "darkgrey"
+
+        TapHandler {
+            id: handler
+            acceptedButtons: (leftAllowedCB.checked ? Qt.LeftButton : Qt.NoButton) |
+                             (middleAllowedCB.checked ? Qt.MiddleButton : Qt.NoButton) |
+                             (rightAllowedCB.checked ? Qt.RightButton : Qt.NoButton)
+            gesturePolicy: (policyDragThresholdCB.checked ? TapHandler.DragThreshold :
+                            policyWithinBoundsCB.checked ? TapHandler.WithinBounds :
+                            TapHandler.ReleaseWithinBounds)
+
+            onCanceled: {
+                console.log("canceled @ " + point.position)
+                borderBlink.blinkColor = "red"
+                borderBlink.start()
+            }
+            onTapped: { // 'point' is an implicit parameter referencing to a QQuickEventPoint instance
+                console.log("tapped @ " + point.pos + " button(s) " + point.event.button + " tapCount " + tapCount)
+                if (tapCount > 1) {
+                    tapCountLabel.text = tapCount
+                    flashAnimation.start()
+                } else {
+                    borderBlink.start()
+                }
+            }
+            onLongPressed: longPressFeedback.createObject(rect,
+                {"x": point.position.x, "y": point.position.y,
+                 "text": Math.round(handler.timeHeld).toFixed(3) + " sec",
+                 "color": borderBlink.blinkColor})
+        }
+
+        Text {
+            id: tapCountLabel
+            anchors.centerIn: parent
+            font.pixelSize: 72
+            font.weight: Font.Black
+            SequentialAnimation {
+                id: flashAnimation
+                PropertyAction { target: tapCountLabel; property: "visible"; value: true }
+                PropertyAction { target: tapCountLabel; property: "opacity"; value: 1.0 }
+                PropertyAction { target: tapCountLabel; property: "scale"; value: 1.0 }
+                ParallelAnimation {
+                    NumberAnimation {
+                        target: tapCountLabel
+                        property: "opacity"
+                        to: 0
+                        duration: 500
+                    }
+                    NumberAnimation {
+                        target: tapCountLabel
+                        property: "scale"
+                        to: 1.5
+                        duration: 500
+                    }
+                }
+            }
+        }
+
+        Rectangle {
+            id: expandingCircle
+            radius: handler.timeHeld * 100
+            visible: radius > 0 && handler.isPressed
+            border.width: 3
+            border.color: borderBlink.blinkColor
+            color: "transparent"
+            width: radius * 2
+            height: radius * 2
+            x: handler.point.pressPosition.x - radius
+            y: handler.point.pressPosition.y - radius
+            opacity: 0.25
+        }
+
+        Component {
+            id: longPressFeedback
+            Text { }
+        }
+
+        SequentialAnimation {
+            id: borderBlink
+            property color blinkColor: (function(pbtns) {
+                switch (pbtns) {
+                case Qt.MiddleButton: return "orange";
+                case Qt.RightButton:  return "magenta";
+                default:              return "green";
+                }
+            })(handler.point.pressedButtons)
+            loops: 3
+            ScriptAction { script: rect.border.color = borderBlink.blinkColor }
+            PauseAnimation { duration: 100 }
+            ScriptAction { script: rect.border.color = "transparent" }
+            PauseAnimation { duration: 100 }
+        }
+    }
+
+    Row {
+        spacing: 6
+        Text { text: "accepted mouse clicks:"; anchors.verticalCenter: leftAllowedCB.verticalCenter }
+        Examples.CheckBox {
+            id: leftAllowedCB
+            checked: true
+            text: "left click"
+        }
+        Examples.CheckBox {
+            id: middleAllowedCB
+            text: "middle click"
+        }
+        Examples.CheckBox {
+            id: rightAllowedCB
+            text: "right click"
+        }
+        Text { text: "      gesture policy:"; anchors.verticalCenter: leftAllowedCB.verticalCenter }
+        Examples.CheckBox {
+            id: policyDragThresholdCB
+            text: "drag threshold"
+            onCheckedChanged: if (checked) {
+                policyWithinBoundsCB.checked = false;
+                policyReleaseWithinBoundsCB.checked = false;
+            }
+        }
+        Examples.CheckBox {
+            id: policyWithinBoundsCB
+            text: "within bounds"
+            onCheckedChanged: if (checked) {
+                policyDragThresholdCB.checked = false;
+                policyReleaseWithinBoundsCB.checked = false;
+            }
+        }
+        Examples.CheckBox {
+            id: policyReleaseWithinBoundsCB
+            checked: true
+            text: "release within bounds"
+            onCheckedChanged: if (checked) {
+                policyDragThresholdCB.checked = false;
+                policyWithinBoundsCB.checked = false;
+            }
+        }
+    }
+}
diff --git a/tests/manual/pointer/tapWithModifiers.qml b/tests/manual/pointer/tapWithModifiers.qml
new file mode 100644
index 0000000000..9a6977da1c
--- /dev/null
+++ b/tests/manual/pointer/tapWithModifiers.qml
@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** 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.8
+import Qt.labs.handlers 1.0
+
+Item {
+    width: 200
+    height: 200
+    TapHandler {
+        acceptedModifiers: Qt.ControlModifier
+        onTapped: console.log("control-tapped")
+    }
+    TapHandler {
+        acceptedModifiers: Qt.NoModifier
+        onTapped: console.log("tapped with no modifiers")
+    }
+    TapHandler {
+        onTapped: console.log("tapped with modifiers " + point.event.modifiers)
+    }
+}
diff --git a/tests/manual/touch/mpta-crosshairs.qml b/tests/manual/touch/mpta-crosshairs.qml
index d1dbd0f188..efea16029b 100644
--- a/tests/manual/touch/mpta-crosshairs.qml
+++ b/tests/manual/touch/mpta-crosshairs.qml
@@ -50,6 +50,7 @@ Rectangle {
     MultiPointTouchArea {
         id: mpta
         anchors.fill: parent
+        //onGestureStarted: gesture.grab() // in case this is embedded in something that might steal
         touchPoints: [
             TouchPoint { property color color: "red" },
             TouchPoint { property color color: "orange" },