Merge lp:~dandrader/unity8/ddaImprovements into lp:unity8

[Daniel d'Andrada]

DirectionalDragArea: improvements & API grooming

-Simplified DirectionalDragArea gesture recognition
 * The widening angle property was dropped. Didn't really work
   as in real life swipes might start up in very different directions
   before finally turning to the final overall direction. That's specially
   bad when you have to conclude the recognition in a short amount
   of time so that you can still play animations to follow the user's finger
 * minSpeed as well. Went for a simpler way of expressing and evaluating it
   which is having maxTime and maxDistance.

-EdgeDragArea got absorbed by DirectionalDragArea

-Privatized all gesture recognition parameters.

-Privatized DirectionalDragArea.status property. All apps need is
 DirectionalDragArea.dragging. Modified qml code using DDA accordingly.

-Modified DirectionalDragArea.dragging semantics a bit. It goes to true only
 once a gesture is recognized

-Moved code that smooths out touch movement into DirectionalDragArea so all users
 get it for free.

-Cleaned up DirectionalDragArea.h of all implementation details, getting it ready
 to be moved out of unity8, into the SDK.

-Removed DirectionalDragArea.tapped() signal as it doesn't belong to it.

-Fine-tuned gesture recognition parameters and made them based on physical size.

-Added tests with input from real gestures to catch those annoying
  false-negatives and false-positives introduced by badly set recognition parameters

-Improved debug output

-UnownedTouchEvents are no longer sent to interim owners

-Fixed issue when TouchGate got disabled while holding an active touch

-Made "make tryDirectionalDragArea" and "make tryDragHandle" work with mouse again.

Fixes bug 1417920.
The way parameters are currently set in EdgeDragArea, a gesture gets recognized regardless of its direction, it only have to be dragged far enough.

* Are there any related MPs required for this MP to build/function as expected? Please list.
No.
* Did you perform an exploratory manual test run of your code change and any related functionality?
Yes.
* Did you make sure that your branch does not contain spurious tags?
Yes.
* If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
Not applicable.
* If you changed the UI, has there been a design review?
Not applicable.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1705
http://jenkins.qa.ubuntu.com/job/unity8-ci/5511/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2090/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/674/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/676/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/676/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2088/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5511/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1706
http://jenkins.qa.ubuntu.com/job/unity8-ci/5512/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2093
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/675
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/677
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/677
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/1843
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2091
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2091/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19366

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5512/rebuild

review: Needs Fixing (continuous-integration)

[Michał Sawicz (saviq)]

Failed QML tests:
    qmltestrunner.Launcher::test_clickFlick
    qmltestrunner.PhoneStage::test_shortFlick
    qmltestrunner.ShellWithPin::test_shortLeftEdgeSwipeMakesLauncherStayVisible

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> Failed QML tests:
> qmltestrunner.Launcher::test_clickFlick
> qmltestrunner.PhoneStage::test_shortFlick
> qmltestrunner.ShellWithPin::test_shortLeftEdgeSwipeMakesLauncherStayVisible

Fixed.

[Michał Sawicz (saviq)]

review: Abstain

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1707
http://jenkins.qa.ubuntu.com/job/unity8-ci/5517/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2105/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/680
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/682
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/682
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/1853/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2103
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2103/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19388

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5517/rebuild

review: Needs Fixing (continuous-integration)

[Albert Astals Cid (aacid)]

This does not actually fix the linked bug right?

Any way to test this change?

review: Needs Information

[Daniel d'Andrada (dandrader)]

> This does not actually fix the linked bug right?
>
> Any way to test this change?

It does, but you have to make Launcher's EdgeDragArea cover the whole launcher in order to notice it.

=== modified file 'qml/Launcher/Launcher.qml'
--- qml/Launcher/Launcher.qml 2015-03-12 13:04:36 +0000
+++ qml/Launcher/Launcher.qml 2015-04-07 12:19:02 +0000
@@ -280,7 +280,7 @@ Item {

         enabled: root.available
         x: -root.x // so if launcher is adjusted relative to screen, we stay put (like tutorial does when teasing)
- width: root.dragAreaWidth
+ width: root.panelWidth
         height: root.height

         onTouchXChanged: {

Apply diff the diff above to trunk and try to scroll the launcher icons. It won't work.

Then merge this branch and try again. It will work.

And check that all DDAs still work normally
  - show and hide indicators panel
  - right-edge drag to show the spread
  - left-edge drag to show launcher
  - horizontal drag to dismiss the greeter
  - bottom edge drag to show the "manage dash" UI.

[Albert Astals Cid (aacid)]

Can you confirm that doing http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2103/artifact/work/output/*zip*/output.zip + width: root.panelWidth in /usr/share/unity8/Launcher/Launcher.qml in the phone it works for you?

I just tried and it still closes when i swipe vertically over an open Launcher.

review: Needs Information

[Daniel d'Andrada (dandrader)]

On 07/04/15 11:08, Albert Astals Cid wrote:
> Review: Needs Information
>
> Can you confirm that doing http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2103/artifact/work/output/*zip*/output.zip + width: root.panelWidth in /usr/share/unity8/Launcher/Launcher.qml in the phone it works for you?
>
> I just tried and it still closes when i swipe vertically over an open Launcher.

Sorry, this is the full patch:

"""
=== modified file 'qml/Launcher/Launcher.qml'
--- qml/Launcher/Launcher.qml 2015-03-12 13:04:36 +0000
+++ qml/Launcher/Launcher.qml 2015-04-07 15:13:15 +0000
@@ -280,7 +280,7 @@ Item {

         enabled: root.available
         x: -root.x // so if launcher is adjusted relative to screen, we
stay put (like tutorial does when teasing)
- width: root.dragAreaWidth
+ width: root.panelWidth
         height: root.height

         onTouchXChanged: {
@@ -306,8 +306,9 @@ Item {
                     if (distance > minimizeDistance) {
                         root.dash();
                     }
- } else {
- root.switchToNextState("")
+ } else if (root.state === "") {
+ // didn't drag far enough. rollback
+ root.switchToNextState("");
                 }
             }
         }
"""

And you don't have to do it on the phone. Doing it in "make tryShell" is
enough. Apply this patch in trunk and you won't be able to scroll the
launcher as the DDA in front of it is recognizing even those vertical
swiped. Apply it on top of ddaImprovements branch and you will see you
can scroll launcher icons just fine as the DDA rejects vertical drags.

[Albert Astals Cid (aacid)]

Hmmm, the code looks ok, can't see anything wrong, but i think some parameter changes need some tweaking, with the old code i can show the launcher with a small drag and it'll show the margin of the launcher and very few of the icons, with this i need to do a bigger drag and it'll in consequence show more part of the launcher.

On the other hand not sure this is problematic either. Can you try it yourself and see what you think?

review: Needs Information

[Daniel d'Andrada (dandrader)]

On 08/04/15 08:18, Albert Astals Cid wrote:
> Review: Needs Information
>
> Hmmm, the code looks ok, can't see anything wrong, but i think some parameter changes need some tweaking, with the old code i can show the launcher with a small drag and it'll show the margin of the launcher and very few of the icons, with this i need to do a bigger drag and it'll in consequence show more part of the launcher.
>
> On the other hand not sure this is problematic either. Can you try it yourself and see what you think?
I get what you mean. But this is not relevant as you only do those very
short drags when you're testing the edge drag feature, ie when you're
checking how much drag it needs to kick in etc. In real usage no one
would do a very short edge drag expose the launcher just a little bit. :)

In any case I reduced the distance threshold a bit so that the gesture
kicks in a bit sooner, if that makes you feel better. :) But it does
help smoothing out the very beginning of the right edge drag (to show
the spread) as it is not animated like the left edge one. It just jumps
to the current drag position instead of animating towards it. Which
makes the larger drag threshold noticeable. But that's an issue with the
"show the spread with right-edge gesture" qml code, not with DDA per se.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1708
http://jenkins.qa.ubuntu.com/job/unity8-ci/5525/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2150
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/688
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/690
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/690
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/1894
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2148
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2148/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19489

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5525/rebuild

review: Needs Fixing (continuous-integration)

[Albert Astals Cid (aacid)]

Approving since code looks good and the behaviour change is acceptable to me but i'd like someone else to give it a try on the phone before top approving.

 * Did you perform an exploratory manual test run of the code change and any related functionality?
Yes

 * Did CI run pass?
known autopilot fixed elsewhere

 * Did you make sure that the branch does not contain spurious tags?
Yes

review: Approve

[Daniel d'Andrada (dandrader)]

right-edge animation start is now smooth as silk

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1709
http://jenkins.qa.ubuntu.com/job/unity8-ci/5527/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2167
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/690
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/692
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/692
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/1908
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2165
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2165/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19514

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5527/rebuild

review: Needs Fixing (continuous-integration)

[Michał Sawicz (saviq)]

Broken tests again:
    qmltestrunner.PhoneStage::test_enterSpread
    qmltestrunner.Tutorial::test_bottomShortDrag
    qmltestrunner.Tutorial::test_walkthrough

[Daniel d'Andrada (dandrader)]

On 09/04/15 15:35, Michał Sawicz wrote:
> Broken tests again:
> qmltestrunner.PhoneStage::test_enterSpread
> qmltestrunner.Tutorial::test_bottomShortDrag
> qmltestrunner.Tutorial::test_walkthrough
Fixed

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1710
http://jenkins.qa.ubuntu.com/job/unity8-ci/5528/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2170
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/691
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/693
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/693
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/1913
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2168
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2168/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19524

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5528/rebuild

review: Approve (continuous-integration)

[Michael Zanetti (mzanetti)]

> right-edge animation start is now smooth as silk

If this would just be unity8, I'd be totally happy with it (Except that you're missing TabletStage.qml). But given that the DDA should be an upstream component, I'm hesitant to make all the app developers do that magic as you added in the Phone stage. They won't, and as a result we'll have the jumpiness every time an app uses the DDA.

[Daniel d'Andrada (dandrader)]

>> right-edge animation start is now smooth as silk
> If this would just be unity8, I'd be totally happy with it (Except that you're missing TabletStage.qml). But given that the DDA should be an upstream component, I'm hesitant to make all the app developers do that magic as you added in the Phone stage. They won't, and as a result we'll have the jumpiness every time an app uses the DDA.

Ok, you asked for it: Put all the DDA improvements into this branch.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1711
http://jenkins.qa.ubuntu.com/job/unity8-ci/5536/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2190/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/699/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/701/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/701/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2188/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5536/rebuild

review: Needs Fixing (continuous-integration)

[lp:~dandrader/unity8/ddaImprovements]

1712. By Daniel d'Andrada on 2015-04-13

Fix whitespace issues

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1712
http://jenkins.qa.ubuntu.com/job/unity8-ci/5538/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2194/console
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/701
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/703
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/703
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/1929/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2192
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2192/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19568

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5538/rebuild

review: Needs Fixing (continuous-integration)

[Michael Zanetti (mzanetti)]

2838- if (status !== DirectionalDragArea.Recognized || launcher.state == "visible")
2839+ if (!dragging || launcher.state == "visible")

This seems to make the launcher jump a little... also design wants to see the launcher's shadow immediately when you touch the edge.

My suggestion would be a "pressed" property in the DirectionalDragArea that could be used for that.

[lp:~dandrader/unity8/ddaImprovements]

1713. By Daniel d'Andrada on 2015-04-15

Fix UnityTestCase.removeTimeConstraintsFromDirectionalDragAreas()

1714. By Daniel d'Andrada on 2015-04-15

Fix tst_Shell::test_leftEdgeDragFullscreen

1715. By Daniel d'Andrada on 2015-04-15

fix shell tests

1716. By Daniel d'Andrada on 2015-04-15

Added DirectionalDragArea.pressed property

1717. By Daniel d'Andrada on 2015-04-15

Fix tst_ShellWithPin

1718. By Daniel d'Andrada on 2015-04-15

Tweak launcher animation

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1715
http://jenkins.qa.ubuntu.com/job/unity8-ci/5554/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2267/console
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/717
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/719
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/719
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/1991/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2265
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2265/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19677

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5554/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1718
http://jenkins.qa.ubuntu.com/job/unity8-ci/5555/
Executed test runs:
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-vivid-touch/2268
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-vivid/718
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-amd64-ci/720
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-vivid-i386-ci/720
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-runner-vivid-mako/1992
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2266
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-vivid-armhf/2266/artifact/work/output/*zip*/output.zip
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19682

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/5555/rebuild

review: Needs Fixing (continuous-integration)

[Daniel d'Andrada (dandrader)]

> 2838- if (status !== DirectionalDragArea.Recognized ||
> launcher.state == "visible")
> 2839+ if (!dragging || launcher.state == "visible")
>
> This seems to make the launcher jump a little... also design wants to see the
> launcher's shadow immediately when you touch the edge.
>
> My suggestion would be a "pressed" property in the DirectionalDragArea that
> could be used for that.

Added the pressed property. It's needed in the Greeter.
Made Launcher use it although I don't think it makes a difference. What did solve Launcher's jumpiness was making it use DDA.distance instead of DDA.touchX, since the former starts from 0 whereas the latter starts from the X position from the the drag started (eg: touchStartPos.x())

[Daniel d'Andrada (dandrader)]

qmltests are also passing now.

[Albert Astals Cid (aacid)]

Had another look at this and for what my manual testing and looking and the code says it's fine, next time i would really appreciate if you do not rebase everything into a single commit since it makes reviewing the changes from the last time i did a review much harder since basically i have to look at it all.

Leaving top un-approved to let others have a look.

 * Did you perform an exploratory manual test run of the code change and any related functionality?
Yes

 * Did CI run pass?
Yes, to the extend it passes everywhere else

 * Did you make sure that the branch does not contain spurious tags?
Yes

review: Approve

[Michael Zanetti (mzanetti)]

Ack. My concerns have been addressed. If Albert is fine with it now, so am I.

review: Approve

=== modified file 'libs/UbuntuGestures/CMakeLists.txt'
--- libs/UbuntuGestures/CMakeLists.txt	2014-10-01 13:20:32 +0000
+++ libs/UbuntuGestures/CMakeLists.txt	2015-04-15 20:21:35 +0000
@@ -5,6 +5,7 @@
     CandidateInactivityTimer.cpp
     DebugHelpers.cpp
     Timer.cpp
+    TimeSource.cpp
     TouchOwnershipEvent.cpp
     TouchRegistry.cpp
     UnownedTouchEvent.cpp

=== modified file 'libs/UbuntuGestures/CandidateInactivityTimer.h'
--- libs/UbuntuGestures/CandidateInactivityTimer.h	2014-10-01 13:20:32 +0000
+++ libs/UbuntuGestures/CandidateInactivityTimer.h	2015-04-15 20:21:35 +0000
@@ -32,7 +32,7 @@
                              AbstractTimerFactory &timerFactory,
                              QObject *parent = nullptr);
 
-    const int durationMs = 350;
+    const int durationMs = 1000;
 
 Q_SIGNALS:
     void candidateDefaulted(int touchId, QQuickItem *candidate);

=== renamed file 'plugins/Ubuntu/Gestures/TimeSource.cpp' => 'libs/UbuntuGestures/TimeSource.cpp'
=== renamed file 'plugins/Ubuntu/Gestures/TimeSource.h' => 'libs/UbuntuGestures/TimeSource.h'
--- plugins/Ubuntu/Gestures/TimeSource.h	2014-10-01 13:20:32 +0000
+++ libs/UbuntuGestures/TimeSource.h	2015-04-15 20:21:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 - Canonical Ltd.
+ * Copyright (C) 2013,2015 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License, as
@@ -21,14 +21,14 @@
 #ifndef UBUNTUGESTURES_TIMESOURCE_H
 #define UBUNTUGESTURES_TIMESOURCE_H
 
-#include "UbuntuGesturesQmlGlobal.h"
+#include "UbuntuGesturesGlobal.h"
 #include <QSharedPointer>
 
 namespace UbuntuGestures {
 /*
     Interface for a time source.
  */
-class UBUNTUGESTURESQML_EXPORT TimeSource {
+class UBUNTUGESTURES_EXPORT TimeSource {
 public:
     virtual ~TimeSource() {}
     /* Returns the current time in milliseconds since some reference time in the past. */
@@ -40,7 +40,7 @@
     Implementation of a time source
  */
 class RealTimeSourcePrivate;
-class RealTimeSource : public TimeSource {
+class UBUNTUGESTURES_EXPORT RealTimeSource : public TimeSource {
 public:
     RealTimeSource();
     virtual ~RealTimeSource();
@@ -49,6 +49,16 @@
     RealTimeSourcePrivate *d;
 };
 
+/*
+    A fake time source, useful for tests
+ */
+class FakeTimeSource : public TimeSource {
+public:
+    FakeTimeSource() { m_msecsSinceReference = 0; }
+    qint64 msecsSinceReference() override { return m_msecsSinceReference; }
+    qint64 m_msecsSinceReference;
+};
+
 } // namespace UbuntuGestures
 
 #endif // UBUNTUGESTURES_TIMESOURCE_H

=== modified file 'libs/UbuntuGestures/Timer.cpp'
--- libs/UbuntuGestures/Timer.cpp	2014-10-01 13:20:32 +0000
+++ libs/UbuntuGestures/Timer.cpp	2015-04-15 20:21:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-2015 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -58,11 +58,34 @@
 
 /////////////////////////////////// FakeTimer //////////////////////////////////
 
-FakeTimer::FakeTimer(QObject *parent)
+FakeTimer::FakeTimer(const SharedTimeSource &timeSource, QObject *parent)
     : UbuntuGestures::AbstractTimer(parent)
     , m_interval(0)
     , m_singleShot(false)
-{
+    , m_timeSource(timeSource)
+{
+}
+
+void FakeTimer::update()
+{
+    if (!isRunning()) {
+        return;
+    }
+
+    if (m_nextTimeoutTime <= m_timeSource->msecsSinceReference()) {
+        if (isSingleShot()) {
+            stop();
+        } else {
+            m_nextTimeoutTime += interval();
+        }
+        Q_EMIT timeout();
+    }
+}
+
+void FakeTimer::start()
+{
+    AbstractTimer::start();
+    m_nextTimeoutTime = m_timeSource->msecsSinceReference() + (qint64)interval();
 }
 
 int FakeTimer::interval() const
@@ -87,23 +110,53 @@
 
 /////////////////////////////////// FakeTimerFactory //////////////////////////////////
 
+FakeTimerFactory::FakeTimerFactory()
+{
+    m_timeSource.reset(new FakeTimeSource);
+}
+
+FakeTimerFactory::~FakeTimerFactory()
+{
+    for (int i = 0; i < timers.count(); ++i) {
+        FakeTimer *timer = timers[i].data();
+        if (timer) {
+            delete timer;
+        }
+    }
+}
+
+void FakeTimerFactory::updateTime(qint64 targetTime)
+{
+    qint64 minTimeoutTime = targetTime;
+
+    for (int i = 0; i < timers.count(); ++i) {
+        FakeTimer *timer = timers[i].data();
+        if (timer && timer->isRunning() && timer->nextTimeoutTime() < minTimeoutTime) {
+            minTimeoutTime = timer->nextTimeoutTime();
+        }
+    }
+
+    m_timeSource->m_msecsSinceReference = minTimeoutTime;
+
+    for (int i = 0; i < timers.count(); ++i) {
+        FakeTimer *timer = timers[i].data();
+        if (timer) {
+            timer->update();
+        }
+    }
+
+    if (m_timeSource->msecsSinceReference() < targetTime) {
+        updateTime(targetTime);
+    }
+}
+
 AbstractTimer *FakeTimerFactory::createTimer(QObject *parent)
 {
-    FakeTimer *fakeTimer = new FakeTimer(parent);
+    FakeTimer *fakeTimer = new FakeTimer(m_timeSource, parent);
 
     timers.append(fakeTimer);
 
     return fakeTimer;
 }
 
-void FakeTimerFactory::makeRunningTimersTimeout()
-{
-    for (int i = 0; i < timers.count(); ++i) {
-        FakeTimer *timer = timers[i].data();
-        if (timer && timer->isRunning()) {
-            timer->emitTimeout();
-        }
-    }
-}
-
 } // namespace UbuntuGestures

=== modified file 'libs/UbuntuGestures/Timer.h'
--- libs/UbuntuGestures/Timer.h	2014-10-01 13:20:32 +0000
+++ libs/UbuntuGestures/Timer.h	2015-04-15 20:21:35 +0000
@@ -18,6 +18,7 @@
 #define UBUNTUGESTURES_TIMER_H
 
 #include "UbuntuGesturesGlobal.h"
+#include "TimeSource.h"
 
 #include <QObject>
 #include <QPointer>
@@ -66,17 +67,21 @@
 {
     Q_OBJECT
 public:
-    FakeTimer(QObject *parent = nullptr);
+    FakeTimer(const SharedTimeSource &timeSource, QObject *parent = nullptr);
 
-    virtual void emitTimeout() { Q_EMIT timeout(); }
+    void update();
+    qint64 nextTimeoutTime() const { return m_nextTimeoutTime; }
 
     int interval() const override;
     void setInterval(int msecs) override;
+    void start() override;
     bool isSingleShot() const override;
     void setSingleShot(bool value) override;
 private:
     int m_interval;
     bool m_singleShot;
+    SharedTimeSource m_timeSource;
+    qint64 m_nextTimeoutTime;
 };
 
 class UBUNTUGESTURES_EXPORT AbstractTimerFactory
@@ -95,9 +100,16 @@
 class UBUNTUGESTURES_EXPORT FakeTimerFactory : public AbstractTimerFactory
 {
 public:
+    FakeTimerFactory();
+    virtual ~FakeTimerFactory();
+
+    void updateTime(qint64 msecsSinceReference);
+    QSharedPointer<TimeSource> timeSource() { return m_timeSource; }
+
     AbstractTimer *createTimer(QObject *parent = nullptr) override;
-    void makeRunningTimersTimeout();
     QList<QPointer<FakeTimer>> timers;
+private:
+    QSharedPointer<FakeTimeSource> m_timeSource;
 };
 
 } // namespace UbuntuGestures

=== modified file 'libs/UbuntuGestures/TouchRegistry.cpp'
--- libs/UbuntuGestures/TouchRegistry.cpp	2014-10-01 13:20:32 +0000
+++ libs/UbuntuGestures/TouchRegistry.cpp	2015-04-15 20:21:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-2015 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -95,10 +95,6 @@
     //       for each point and there should not be many active points at any given moment.
     //       But having three nested for-loops does scare.
 
-    // TODO: Don't send it to the object that is already receiving the regular event
-    // because QQuickWindow is sending it to him (i.e., he's the touch owner from Qt's point of view)
-    // Problem is, we cannnot easily get this information.
-
     const QList<QTouchEvent::TouchPoint> &updatedTouchPoints = event->touchPoints();
 
     // Maps an item to the touches in this event he should be informed about.
@@ -118,7 +114,9 @@
                     for (int i = 0; i < touchInfo->candidates.count(); ++i) {
                         CandidateInfo &candidate = touchInfo->candidates[i];
                         Q_ASSERT(!candidate.item.isNull());
-                        touchIdsForItems[candidate.item.data()].append(touchInfo->id);
+                        if (candidate.state != CandidateInfo::InterimOwner) {
+                            touchIdsForItems[candidate.item.data()].append(touchInfo->id);
+                        }
                     }
                 }
 
@@ -260,7 +258,7 @@
     // TODO: Check if candidate already exists
 
     CandidateInfo candidateInfo;
-    candidateInfo.undecided = true;
+    candidateInfo.state = CandidateInfo::Undecided;
     candidateInfo.item = candidate;
     candidateInfo.inactivityTimer = new CandidateInactivityTimer(id, candidate,
                                                                  *m_timerFactory,
@@ -301,8 +299,8 @@
     for (int i = 0; i < touchInfo->candidates.count() && indexRemoved == -1; ++i) {
         CandidateInfo &candidateInfo = touchInfo->candidates[i];
         if (candidateInfo.item == candidate) {
-            Q_ASSERT(i > 0 || candidateInfo.undecided);
-            if (i == 0 && !candidateInfo.undecided) {
+            Q_ASSERT(i > 0 || candidateInfo.state == CandidateInfo::Undecided);
+            if (i == 0 && candidateInfo.state != CandidateInfo::Undecided) {
                 qCritical("TouchRegistry: touch owner is being removed.");
             }
             delete candidateInfo.inactivityTimer;
@@ -340,7 +338,7 @@
     for (int i = 0; i < touchInfo->candidates.count(); ++i) {
         CandidateInfo &candidateInfo = touchInfo->candidates[i];
         if (candidateInfo.item == candidate) {
-            candidateInfo.undecided = false;
+            candidateInfo.state = CandidateInfo::Requested;
             delete candidateInfo.inactivityTimer;
             candidateInfo.inactivityTimer = nullptr;
             candidateIndex = i;
@@ -351,7 +349,7 @@
     // add it as a candidate if not present yet
     if (candidateIndex < 0) {
         CandidateInfo candidateInfo;
-        candidateInfo.undecided = false;
+        candidateInfo.state = CandidateInfo::InterimOwner;
         candidateInfo.item = candidate;
         candidateInfo.inactivityTimer = nullptr;
         touchInfo->candidates.append(candidateInfo);
@@ -407,8 +405,8 @@
     for (int i = 0; i < touchInfo->candidates.count() && rejectedCandidateIndex == -1; ++i) {
         CandidateInfo &candidateInfo = touchInfo->candidates[i];
         if (candidateInfo.item == candidate) {
-            Q_ASSERT(i > 0 || candidateInfo.undecided);
-            if (i == 0 && !candidateInfo.undecided) {
+            Q_ASSERT(i > 0 || candidateInfo.state == CandidateInfo::Undecided);
+            if (i == 0 && candidateInfo.state != CandidateInfo::Undecided) {
                 qCritical() << "TouchRegistry: Can't reject item (" << (void*)candidate
                     << ") as it already owns touch" << id;
                 return;
@@ -467,7 +465,7 @@
 
 bool TouchRegistry::TouchInfo::isOwned() const
 {
-    return !candidates.isEmpty() && !candidates.first().undecided;
+    return !candidates.isEmpty() && candidates.first().state != CandidateInfo::Undecided;
 }
 
 bool TouchRegistry::TouchInfo::ended() const

=== modified file 'libs/UbuntuGestures/TouchRegistry.h'
--- libs/UbuntuGestures/TouchRegistry.h	2014-10-02 12:47:07 +0000
+++ libs/UbuntuGestures/TouchRegistry.h	2015-04-15 20:21:35 +0000
@@ -79,9 +79,11 @@
   If an item wants ownership over touches as soon as he receives the TouchBegin for them, his step 1
   would be instead:
         TouchRegistry::instance()->requestTouchOwnership(touchId, this);
-        return true;
-  He would then be notified once ownership has been granted to him, from which point onwards he could
-  safely assume other TouchRegistry users wouldn't snatch this touch away from him.
+        touchEvent->accept();
+  He won't get any UnownedTouchEvent for that touch as he is already the interim owner (ie, QQuickWindow
+  will keep sending touch updates to him already). Eventually he will be notified once ownership has
+  been granted to him (from TouchRegistry perspective), from which point onwards he could safely assume
+  other TouchRegistry users wouldn't snatch this touch away from him.
 
   Items oblivious to TouchRegistry will lose their touch points without warning, just like in plain Qt.
 
@@ -132,7 +134,19 @@
 private:
     class CandidateInfo {
     public:
-        bool undecided;
+        enum {
+            // A candidate owner that doesn't yet know for sure whether he wants the touch point
+            // (gesture recognition is stilll going on)
+            Undecided = 0,
+            // A candidate owner that wants the touch but hasn't been granted it yet,
+            // most likely because there's an undecided candidate with higher priority
+            Requested = 1,
+            // An item that is the interim owner of the touch, receiving QTouchEvents of it
+            // from QQuickWindow. Ie, it's the actual touch owner from Qt's point of view.
+            // It wants to keep its touch ownership but hasn't been granted it by TouchRegistry
+            // yet because of undecided candidates higher up.
+            InterimOwner = 2
+        } state;
         // TODO: Prune candidates that become null and resolve ownership accordingly.
         QPointer<QQuickItem> item;
         QPointer<UbuntuGestures::CandidateInactivityTimer> inactivityTimer;

=== modified file 'plugins/Ubuntu/Gestures/CMakeLists.txt'
--- plugins/Ubuntu/Gestures/CMakeLists.txt	2014-10-17 11:01:53 +0000
+++ plugins/Ubuntu/Gestures/CMakeLists.txt	2015-04-15 20:21:35 +0000
@@ -4,10 +4,10 @@
 set(UbuntuGesturesQml_SOURCES
     plugin.cpp
     AxisVelocityCalculator.cpp
+    Damper.cpp
     Direction.cpp
     DirectionalDragArea.cpp
     PressedOutsideNotifier.cpp
-    TimeSource.cpp
     TouchDispatcher.cpp
     TouchGate.cpp
 )

=== added file 'plugins/Ubuntu/Gestures/Damper.cpp'
--- plugins/Ubuntu/Gestures/Damper.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Gestures/Damper.cpp	2015-04-15 20:21:35 +0000
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Damper.h"
+#include <QDebug>
+
+QDebug operator<<(QDebug dbg, const DampedPointF &p)
+{
+    dbg.nospace() << "(" << p.x() << ", " << p.y() << ")";
+    return dbg.space();
+}

=== modified file 'plugins/Ubuntu/Gestures/Damper.h'
--- plugins/Ubuntu/Gestures/Damper.h	2013-08-06 13:18:34 +0000
+++ plugins/Ubuntu/Gestures/Damper.h	2015-04-15 20:21:35 +0000
@@ -84,4 +84,6 @@
     Damper<qreal> m_y;
 };
 
+QDebug operator<<(QDebug dbg, const DampedPointF &p);
+
 #endif // UBUNTU_GESTURES_DAMPER_H

=== modified file 'plugins/Ubuntu/Gestures/DirectionalDragArea.cpp'
--- plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2014-12-09 11:00:37 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2015-04-15 20:21:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 Canonical, Ltd.
+ * Copyright (C) 2013-2015 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,6 +21,7 @@
 
 #include <QQuickWindow>
 #include <QtCore/qmath.h>
+#include <QScreen>
 #include <QDebug>
 
 #pragma GCC diagnostic push
@@ -33,6 +34,8 @@
 #include "TouchRegistry.h"
 #include "UnownedTouchEvent.h"
 
+#include "DirectionalDragArea_p.h"
+
 using namespace UbuntuGestures;
 
 #if DIRECTIONALDRAGAREA_DEBUG
@@ -40,11 +43,11 @@
 #include "DebugHelpers.h"
 
 namespace {
-const char *statusToString(DirectionalDragArea::Status status)
+const char *statusToString(DirectionalDragAreaPrivate::Status status)
 {
-    if (status == DirectionalDragArea::WaitingForTouch) {
+    if (status == DirectionalDragAreaPrivate::WaitingForTouch) {
         return "WaitingForTouch";
-    } else if (status == DirectionalDragArea::Undecided) {
+    } else if (status == DirectionalDragAreaPrivate::Undecided) {
         return "Undecided";
     } else {
         return "Recognized";
@@ -56,205 +59,168 @@
 #define ddaDebug(params) ((void)0)
 #endif // DIRECTIONALDRAGAREA_DEBUG
 
-
 DirectionalDragArea::DirectionalDragArea(QQuickItem *parent)
     : QQuickItem(parent)
-    , m_status(WaitingForTouch)
-    , m_sceneDistance(0)
-    , m_touchId(-1)
-    , m_direction(Direction::Rightwards)
-    , m_wideningAngle(0)
-    , m_wideningFactor(0)
-    , m_distanceThreshold(0)
-    , m_distanceThresholdSquared(0.)
-    , m_minSpeed(0)
-    , m_maxSilenceTime(200)
-    , m_silenceTime(0)
-    , m_compositionTime(60)
-    , m_numSamplesOnLastSpeedCheck(0)
-    , m_recognitionTimer(0)
-    , m_velocityCalculator(0)
-    , m_timeSource(new RealTimeSource)
-    , m_activeTouches(m_timeSource)
+    , d(new DirectionalDragAreaPrivate(this))
 {
-    setRecognitionTimer(new Timer(this));
-    m_recognitionTimer->setInterval(60);
-    m_recognitionTimer->setSingleShot(false);
-
-    m_velocityCalculator = new AxisVelocityCalculator(this);
-
-    connect(this, &QQuickItem::enabledChanged, this, &DirectionalDragArea::giveUpIfDisabledOrInvisible);
-    connect(this, &QQuickItem::visibleChanged, this, &DirectionalDragArea::giveUpIfDisabledOrInvisible);
+    d->setRecognitionTimer(new Timer(this));
+    d->recognitionTimer->setInterval(d->maxTime);
+    d->recognitionTimer->setSingleShot(true);
+
+    connect(this, &QQuickItem::enabledChanged, d, &DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible);
+    connect(this, &QQuickItem::visibleChanged, d, &DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible);
 }
 
 Direction::Type DirectionalDragArea::direction() const
 {
-    return m_direction;
+    return d->direction;
 }
 
 void DirectionalDragArea::setDirection(Direction::Type direction)
 {
-    if (direction != m_direction) {
-        m_direction = direction;
-        Q_EMIT directionChanged(m_direction);
-    }
-}
-
-void DirectionalDragArea::setMaxDeviation(qreal value)
-{
-    if (m_dampedScenePos.maxDelta() != value) {
-        m_dampedScenePos.setMaxDelta(value);
-        Q_EMIT maxDeviationChanged(value);
-    }
-}
-
-qreal DirectionalDragArea::wideningAngle() const
-{
-    return m_wideningAngle;
-}
-
-void DirectionalDragArea::setWideningAngle(qreal angle)
-{
-    if (angle == m_wideningAngle)
-        return;
-
-    m_wideningAngle = angle;
-
-    // wideningFactor = pow(cosine(angle), 2)
-    {
-        qreal angleRadians = angle * M_PI / 180.0;
-        m_wideningFactor = qCos(angleRadians);
-        m_wideningFactor = m_wideningFactor * m_wideningFactor;
-    }
-
-    Q_EMIT wideningAngleChanged(angle);
-}
-
-void DirectionalDragArea::setDistanceThreshold(qreal value)
-{
-    if (m_distanceThreshold != value) {
-        m_distanceThreshold = value;
-        m_distanceThresholdSquared = m_distanceThreshold * m_distanceThreshold;
-        Q_EMIT distanceThresholdChanged(value);
-    }
-}
-
-void DirectionalDragArea::setMinSpeed(qreal value)
-{
-    if (m_minSpeed != value) {
-        m_minSpeed = value;
-        Q_EMIT minSpeedChanged(value);
-    }
-}
-
-void DirectionalDragArea::setMaxSilenceTime(int value)
-{
-    if (m_maxSilenceTime != value) {
-        m_maxSilenceTime = value;
-        Q_EMIT maxSilenceTimeChanged(value);
-    }
-}
-
-void DirectionalDragArea::setCompositionTime(int value)
-{
-    if (m_compositionTime != value) {
-        m_compositionTime = value;
-        Q_EMIT compositionTimeChanged(value);
-    }
-}
-
-void DirectionalDragArea::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)
+    if (direction != d->direction) {
+        d->direction = direction;
+        Q_EMIT directionChanged(d->direction);
+    }
+}
+
+void DirectionalDragAreaPrivate::setDistanceThreshold(qreal value)
+{
+    if (distanceThreshold != value) {
+        distanceThreshold = value;
+        distanceThresholdSquared = distanceThreshold * distanceThreshold;
+    }
+}
+
+void DirectionalDragAreaPrivate::setMaxTime(int value)
+{
+    if (maxTime != value) {
+        maxTime = value;
+        recognitionTimer->setInterval(maxTime);
+    }
+}
+
+void DirectionalDragAreaPrivate::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)
 {
     int interval = 0;
     bool timerWasRunning = false;
     bool wasSingleShot = false;
 
     // can be null when called from the constructor
-    if (m_recognitionTimer) {
-        interval = m_recognitionTimer->interval();
-        timerWasRunning = m_recognitionTimer->isRunning();
-        if (m_recognitionTimer->parent() == this) {
-            delete m_recognitionTimer;
+    if (recognitionTimer) {
+        interval = recognitionTimer->interval();
+        timerWasRunning = recognitionTimer->isRunning();
+        if (recognitionTimer->parent() == this) {
+            delete recognitionTimer;
         }
     }
 
-    m_recognitionTimer = timer;
+    recognitionTimer = timer;
     timer->setInterval(interval);
     timer->setSingleShot(wasSingleShot);
     connect(timer, &UbuntuGestures::AbstractTimer::timeout,
-            this, &DirectionalDragArea::checkSpeed);
+            this, &DirectionalDragAreaPrivate::rejectGesture);
     if (timerWasRunning) {
-        m_recognitionTimer->start();
+        recognitionTimer->start();
     }
 }
 
-void DirectionalDragArea::setTimeSource(const SharedTimeSource &timeSource)
+void DirectionalDragAreaPrivate::setTimeSource(const SharedTimeSource &timeSource)
 {
-    m_timeSource = timeSource;
-    m_velocityCalculator->setTimeSource(timeSource);
-    m_activeTouches.m_timeSource = timeSource;
+    this->timeSource = timeSource;
+    activeTouches.m_timeSource = timeSource;
 }
 
 qreal DirectionalDragArea::distance() const
 {
-    if (Direction::isHorizontal(m_direction)) {
-        return m_previousPos.x() - m_startPos.x();
+    if (Direction::isHorizontal(d->direction)) {
+        return d->publicPos.x() - d->startPos.x();
     } else {
-        return m_previousPos.y() - m_startPos.y();
+        return d->publicPos.y() - d->startPos.y();
     }
 }
 
-void DirectionalDragArea::updateSceneDistance()
+void DirectionalDragAreaPrivate::updateSceneDistance()
 {
-    QPointF totalMovement = m_previousScenePos - m_startScenePos;
-    m_sceneDistance = projectOntoDirectionVector(totalMovement);
+    QPointF totalMovement = publicScenePos - startScenePos;
+    sceneDistance = projectOntoDirectionVector(totalMovement);
 }
 
 qreal DirectionalDragArea::sceneDistance() const
 {
-    return m_sceneDistance;
+    return d->sceneDistance;
 }
 
 qreal DirectionalDragArea::touchX() const
 {
-    return m_previousPos.x();
+    return d->publicPos.x();
 }
 
 qreal DirectionalDragArea::touchY() const
 {
-    return m_previousPos.y();
+    return d->publicPos.y();
 }
 
 qreal DirectionalDragArea::touchSceneX() const
 {
-    return m_previousScenePos.x();
+    return d->publicScenePos.x();
 }
 
 qreal DirectionalDragArea::touchSceneY() const
 {
-    return m_previousScenePos.y();
+    return d->publicScenePos.y();
+}
+
+bool DirectionalDragArea::dragging() const
+{
+    return d->status == DirectionalDragAreaPrivate::Recognized;
+}
+
+bool DirectionalDragArea::pressed() const
+{
+    return d->status != DirectionalDragAreaPrivate::WaitingForTouch;
+}
+
+bool DirectionalDragArea::immediateRecognition() const
+{
+    return d->immediateRecognition;
+}
+
+void DirectionalDragArea::setImmediateRecognition(bool enabled)
+{
+    if (d->immediateRecognition != enabled) {
+        d->immediateRecognition = enabled;
+        Q_EMIT immediateRecognitionChanged(enabled);
+    }
+}
+
+void DirectionalDragArea::removeTimeConstraints()
+{
+    d->setMaxTime(60 * 60 * 1000);
+    d->compositionTime = 0;
+    ddaDebug("removed time constraints");
 }
 
 bool DirectionalDragArea::event(QEvent *event)
 {
     if (event->type() == TouchOwnershipEvent::touchOwnershipEventType()) {
-        touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(event));
+        d->touchOwnershipEvent(static_cast<TouchOwnershipEvent *>(event));
         return true;
     } else if (event->type() == UnownedTouchEvent::unownedTouchEventType()) {
-        unownedTouchEvent(static_cast<UnownedTouchEvent *>(event));
+        d->unownedTouchEvent(static_cast<UnownedTouchEvent *>(event));
         return true;
     } else {
         return QQuickItem::event(event);
     }
 }
 
-void DirectionalDragArea::touchOwnershipEvent(TouchOwnershipEvent *event)
+void DirectionalDragAreaPrivate::touchOwnershipEvent(TouchOwnershipEvent *event)
 {
     if (event->gained()) {
         QVector<int> ids;
         ids.append(event->touchId());
         ddaDebug("grabbing touch");
-        grabTouchPoints(ids);
+        q->grabTouchPoints(ids);
 
         // Work around for Qt bug. If we grab a touch that is being used for mouse pointer
         // emulation it will cause the emulation logic to go nuts.
@@ -262,35 +228,35 @@
         //
         // The fix for this bug has landed in Qt 5.4 (https://codereview.qt-project.org/96887)
         // TODO: Remove this workaround once we start using Qt 5.4
-        if (window()) {
-            QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(window());
-            if (windowPrivate->touchMouseId == event->touchId() && window()->mouseGrabberItem()) {
+        if (q->window()) {
+            QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(q->window());
+            if (windowPrivate->touchMouseId == event->touchId() && q->window()->mouseGrabberItem()) {
                 ddaDebug("removing mouse grabber");
-                window()->mouseGrabberItem()->ungrabMouse();
+                q->window()->mouseGrabberItem()->ungrabMouse();
             }
         }
     } else {
         // We still wanna know when it ends for keeping the composition time window up-to-date
-        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
+        TouchRegistry::instance()->addTouchWatcher(touchId, q);
 
         setStatus(WaitingForTouch);
     }
 }
 
-void DirectionalDragArea::unownedTouchEvent(UnownedTouchEvent *unownedTouchEvent)
+void DirectionalDragAreaPrivate::unownedTouchEvent(UnownedTouchEvent *unownedTouchEvent)
 {
     QTouchEvent *event = unownedTouchEvent->touchEvent();
 
     Q_ASSERT(!event->touchPointStates().testFlag(Qt::TouchPointPressed));
 
-    ddaDebug("Unowned " << m_timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
+    ddaDebug("Unowned " << timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
 
-    switch (m_status) {
+    switch (status) {
         case WaitingForTouch:
             // do nothing
             break;
         case Undecided:
-            Q_ASSERT(isEnabled() && isVisible());
+            Q_ASSERT(q->isEnabled() && q->isVisible());
             unownedTouchEvent_undecided(unownedTouchEvent);
             break;
         default: // Recognized:
@@ -298,18 +264,18 @@
             break;
     }
 
-    m_activeTouches.update(event);
+    activeTouches.update(event);
 }
 
-void DirectionalDragArea::unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent)
+void DirectionalDragAreaPrivate::unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent)
 {
     const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(unownedTouchEvent->touchEvent());
     if (!touchPoint) {
-        qCritical() << "DirectionalDragArea[status=Undecided]: touch " << m_touchId
+        qCritical() << "DirectionalDragArea[status=Undecided]: touch " << touchId
             << "missing from UnownedTouchEvent without first reaching state Qt::TouchPointReleased. "
                "Considering it as released.";
 
-        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
         setStatus(WaitingForTouch);
         return;
     }
@@ -319,48 +285,42 @@
     if (touchPoint->state() == Qt::TouchPointReleased) {
         // touch has ended before recognition concluded
         ddaDebug("Touch has ended before recognition concluded");
-        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
-        emitSignalIfTapped();
-        setStatus(WaitingForTouch);
-        return;
-    }
-
-    m_previousDampedScenePos.setX(m_dampedScenePos.x());
-    m_previousDampedScenePos.setY(m_dampedScenePos.y());
-    m_dampedScenePos.update(touchScenePos);
-    updateVelocityCalculator(touchScenePos);
-
-    if (!pointInsideAllowedArea()) {
-        ddaDebug("Rejecting gesture because touch point is outside allowed area.");
-        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
-        // We still wanna know when it ends for keeping the composition time window up-to-date
-        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
-        setStatus(WaitingForTouch);
-        return;
-    }
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
+        setStatus(WaitingForTouch);
+        return;
+    }
+
+    previousDampedScenePos.setX(dampedScenePos.x());
+    previousDampedScenePos.setY(dampedScenePos.y());
+    dampedScenePos.update(touchScenePos);
 
     if (!movingInRightDirection()) {
         ddaDebug("Rejecting gesture because touch point is moving in the wrong direction.");
-        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
         // We still wanna know when it ends for keeping the composition time window up-to-date
-        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
+        TouchRegistry::instance()->addTouchWatcher(touchId, q);
         setStatus(WaitingForTouch);
         return;
     }
 
-    setPreviousPos(touchPoint->pos());
-    setPreviousScenePos(touchScenePos);
-
     if (isWithinTouchCompositionWindow()) {
         // There's still time for some new touch to appear and ruin our party as it would be combined
-        // with our m_touchId one and therefore deny the possibility of a single-finger gesture.
+        // with our touchId one and therefore deny the possibility of a single-finger gesture.
         ddaDebug("Sill within composition window. Let's wait more.");
         return;
     }
 
-    if (movedFarEnough(touchScenePos)) {
-        TouchRegistry::instance()->requestTouchOwnership(m_touchId, this);
+    if (movedFarEnoughAlongGestureAxis()) {
+        TouchRegistry::instance()->requestTouchOwnership(touchId, q);
         setStatus(Recognized);
+        setPublicPos(touchPoint->pos());
+        setPublicScenePos(touchScenePos);
+    } else if (isPastMaxDistance()) {
+        ddaDebug("Rejecting gesture because it went farther than maxDistance without getting recognized.");
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
+        // We still wanna know when it ends for keeping the composition time window up-to-date
+        TouchRegistry::instance()->addTouchWatcher(touchId, q);
+        setStatus(WaitingForTouch);
     } else {
         ddaDebug("Didn't move far enough yet. Let's wait more.");
     }
@@ -371,29 +331,29 @@
     // TODO: Consider when more than one touch starts in the same event (although it's not possible
     //       with Mir's android-input). Have to track them all. Consider it a plus/bonus.
 
-    ddaDebug(m_timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
+    ddaDebug(d->timeSource->msecsSinceReference() << " " << qPrintable(touchEventToString(event)));
 
     if (!isEnabled() || !isVisible()) {
         QQuickItem::touchEvent(event);
         return;
     }
 
-    switch (m_status) {
-        case WaitingForTouch:
-            touchEvent_absent(event);
+    switch (d->status) {
+        case DirectionalDragAreaPrivate::WaitingForTouch:
+            d->touchEvent_absent(event);
             break;
-        case Undecided:
-            touchEvent_undecided(event);
+        case DirectionalDragAreaPrivate::Undecided:
+            d->touchEvent_undecided(event);
             break;
         default: // Recognized:
-            touchEvent_recognized(event);
+            d->touchEvent_recognized(event);
             break;
     }
 
-    m_activeTouches.update(event);
+    d->activeTouches.update(event);
 }
 
-void DirectionalDragArea::touchEvent_absent(QTouchEvent *event)
+void DirectionalDragAreaPrivate::touchEvent_absent(QTouchEvent *event)
 {
     // TODO: accept/reject is for the whole event, not per touch id. See how that affects us.
 
@@ -423,36 +383,40 @@
                 allGood = false;
             } else {
                 // that's our candidate
-                m_touchId = touchPoint.id();
                 newTouchPoint = &touchPoint;
             }
         }
     }
 
     if (allGood) {
+        allGood = sanityCheckRecognitionProperties();
+        if (!allGood) {
+            qWarning("DirectionalDragArea: recognition properties are wrongly set. Gesture recognition"
+                " is impossible");
+        }
+    }
+
+    if (allGood) {
         Q_ASSERT(newTouchPoint);
 
-        m_startPos = newTouchPoint->pos();
-        m_startScenePos = newTouchPoint->scenePos();
-        m_touchId = newTouchPoint->id();
-        m_dampedScenePos.reset(m_startScenePos);
-        m_velocityCalculator->setTrackedPosition(0.);
-        m_velocityCalculator->reset();
-        m_numSamplesOnLastSpeedCheck = 0;
-        m_silenceTime = 0;
-        setPreviousPos(m_startPos);
-        setPreviousScenePos(m_startScenePos);
+        startPos = newTouchPoint->pos();
+        startScenePos = newTouchPoint->scenePos();
+        touchId = newTouchPoint->id();
+        dampedScenePos.reset(startScenePos);
+        setPublicPos(startPos);
+
+        setPublicScenePos(startScenePos);
         updateSceneDirectionVector();
 
         if (recognitionIsDisabled()) {
             // Behave like a dumb TouchArea
             ddaDebug("Gesture recognition is disabled. Requesting touch ownership immediately.");
-            TouchRegistry::instance()->requestTouchOwnership(m_touchId, this);
+            TouchRegistry::instance()->requestTouchOwnership(touchId, q);
             setStatus(Recognized);
             event->accept();
         } else {
             // just monitor the touch points for now.
-            TouchRegistry::instance()->addCandidateOwnerForTouch(m_touchId, this);
+            TouchRegistry::instance()->addCandidateOwnerForTouch(touchId, q);
 
             setStatus(Undecided);
             // Let the item below have it. We will monitor it and grab it later if a gesture
@@ -465,12 +429,11 @@
     }
 }
 
-void DirectionalDragArea::touchEvent_undecided(QTouchEvent *event)
+void DirectionalDragAreaPrivate::touchEvent_undecided(QTouchEvent *event)
 {
-    Q_ASSERT(event->type() == QEvent::TouchBegin);
     Q_ASSERT(fetchTargetTouchPoint(event) == nullptr);
 
-    // We're not interested in new touch points. We already have our candidate (m_touchId).
+    // We're not interested in new touch points. We already have our candidate (touchId).
     // But we do want to know when those new touches end for keeping the composition time
     // window up-to-date
     event->ignore();
@@ -480,63 +443,60 @@
         // multi-finger drags are not accepted
         ddaDebug("Multi-finger drags are not accepted");
 
-        TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
         // We still wanna know when it ends for keeping the composition time window up-to-date
-        TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
+        TouchRegistry::instance()->addTouchWatcher(touchId, q);
 
         setStatus(WaitingForTouch);
     }
 }
 
-void DirectionalDragArea::touchEvent_recognized(QTouchEvent *event)
+void DirectionalDragAreaPrivate::touchEvent_recognized(QTouchEvent *event)
 {
     const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);
 
     if (!touchPoint) {
-        qCritical() << "DirectionalDragArea[status=Recognized]: touch " << m_touchId
+        qCritical() << "DirectionalDragArea[status=Recognized]: touch " << touchId
             << "missing from QTouchEvent without first reaching state Qt::TouchPointReleased. "
                "Considering it as released.";
         setStatus(WaitingForTouch);
     } else {
-        setPreviousPos(touchPoint->pos());
-        setPreviousScenePos(touchPoint->scenePos());
+        setPublicPos(touchPoint->pos());
+        setPublicScenePos(touchPoint->scenePos());
 
         if (touchPoint->state() == Qt::TouchPointReleased) {
-            emitSignalIfTapped();
             setStatus(WaitingForTouch);
         }
     }
 }
 
-void DirectionalDragArea::watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints)
+void DirectionalDragAreaPrivate::watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints)
 {
     for (int i = 0; i < touchPoints.count(); ++i) {
         const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
         if (touchPoint.state() == Qt::TouchPointPressed) {
-            TouchRegistry::instance()->addTouchWatcher(touchPoint.id(), this);
+            TouchRegistry::instance()->addTouchWatcher(touchPoint.id(), q);
         }
     }
 }
 
-bool DirectionalDragArea::recognitionIsDisabled() const
-{
-    return distanceThreshold() <= 0 && compositionTime() <= 0;
-}
-
-void DirectionalDragArea::emitSignalIfTapped()
-{
-    qint64 touchDuration = m_timeSource->msecsSinceReference() - m_activeTouches.touchStartTime(m_touchId);
-    if (touchDuration <= maxTapDuration()) {
-        Q_EMIT tapped();
-    }
-}
-
-const QTouchEvent::TouchPoint *DirectionalDragArea::fetchTargetTouchPoint(QTouchEvent *event)
+bool DirectionalDragAreaPrivate::recognitionIsDisabled() const
+{
+    return immediateRecognition || (distanceThreshold <= 0 && compositionTime <= 0);
+}
+
+bool DirectionalDragAreaPrivate::sanityCheckRecognitionProperties()
+{
+    return recognitionIsDisabled()
+        || (distanceThreshold < maxDistance && compositionTime < maxTime);
+}
+
+const QTouchEvent::TouchPoint *DirectionalDragAreaPrivate::fetchTargetTouchPoint(QTouchEvent *event)
 {
     const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
     const QTouchEvent::TouchPoint *touchPoint = 0;
     for (int i = 0; i < touchPoints.size(); ++i) {
-        if (touchPoints.at(i).id() == m_touchId) {
+        if (touchPoints.at(i).id() == touchId) {
             touchPoint = &touchPoints.at(i);
             break;
         }
@@ -544,39 +504,13 @@
     return touchPoint;
 }
 
-bool DirectionalDragArea::pointInsideAllowedArea() const
-{
-    // NB: Using squared values to avoid computing the square root to find
-    // the length totalMovement
-
-    QPointF totalMovement(m_dampedScenePos.x() - m_startScenePos.x(),
-                          m_dampedScenePos.y() - m_startScenePos.y());
-
-    qreal squaredTotalMovSize = totalMovement.x() * totalMovement.x() +
-                                totalMovement.y() * totalMovement.y();
-
-    if (squaredTotalMovSize == 0.) {
-        // didn't move
-        return true;
-    }
-
-    qreal projectedMovement = projectOntoDirectionVector(totalMovement);
-
-
-    qreal cosineAngleSquared = (projectedMovement * projectedMovement) / squaredTotalMovSize;
-
-    // Same as:
-    // angle_between_movement_vector_and_gesture_direction_vector <= widening_angle
-    return cosineAngleSquared >= m_wideningFactor;
-}
-
-bool DirectionalDragArea::movingInRightDirection() const
-{
-    if (m_direction == Direction::Horizontal) {
+bool DirectionalDragAreaPrivate::movingInRightDirection() const
+{
+    if (direction == Direction::Horizontal) {
         return true;
     } else {
-        QPointF movementVector(m_dampedScenePos.x() - m_previousDampedScenePos.x(),
-                               m_dampedScenePos.y() - m_previousDampedScenePos.y());
+        QPointF movementVector(dampedScenePos.x() - previousDampedScenePos.x(),
+                               dampedScenePos.y() - previousDampedScenePos.y());
 
         qreal scalarProjection = projectOntoDirectionVector(movementVector);
 
@@ -584,96 +518,95 @@
     }
 }
 
-bool DirectionalDragArea::movedFarEnough(const QPointF &point) const
+bool DirectionalDragAreaPrivate::movedFarEnoughAlongGestureAxis() const
 {
-    if (m_distanceThreshold <= 0.) {
+    if (distanceThreshold <= 0.) {
         // distance threshold check is disabled
         return true;
     } else {
-        QPointF totalMovement(point.x() - m_startScenePos.x(),
-                              point.y() - m_startScenePos.y());
-
-        qreal squaredTotalMovSize = totalMovement.x() * totalMovement.x() +
-                                    totalMovement.y() * totalMovement.y();
-
-        return squaredTotalMovSize > m_distanceThresholdSquared;
-    }
-}
-
-void DirectionalDragArea::checkSpeed()
-{
-    Q_ASSERT(m_status == Undecided);
-
-    if (m_velocityCalculator->numSamples() >= AxisVelocityCalculator::MIN_SAMPLES_NEEDED) {
-        qreal speed = qFabs(m_velocityCalculator->calculate());
-        qreal minSpeedMsecs = m_minSpeed / 1000.0;
-
-        if (speed < minSpeedMsecs) {
-            ddaDebug("Rejecting gesture because it's below minimum speed.");
-            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
-            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
-            setStatus(WaitingForTouch);
-        }
-    }
-
-    if (m_velocityCalculator->numSamples() == m_numSamplesOnLastSpeedCheck) {
-        m_silenceTime += m_recognitionTimer->interval();
-
-        if (m_silenceTime > m_maxSilenceTime) {
-            ddaDebug("Rejecting gesture because its silence time has been exceeded.");
-            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
-            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
-            setStatus(WaitingForTouch);
-        }
-    } else {
-        m_silenceTime = 0;
-    }
-    m_numSamplesOnLastSpeedCheck = m_velocityCalculator->numSamples();
-}
-
-void DirectionalDragArea::giveUpIfDisabledOrInvisible()
-{
-    if (!isEnabled() || !isVisible()) {
-        if (m_status == Undecided) {
-            TouchRegistry::instance()->removeCandidateOwnerForTouch(m_touchId, this);
+        QPointF totalMovement(dampedScenePos.x() - startScenePos.x(),
+                              dampedScenePos.y() - startScenePos.y());
+
+        qreal scalarProjection = projectOntoDirectionVector(totalMovement);
+
+        ddaDebug(" movedFarEnoughAlongGestureAxis: scalarProjection=" << scalarProjection
+            << ", distanceThreshold=" << distanceThreshold);
+
+        if (direction == Direction::Horizontal) {
+            return qAbs(scalarProjection) > distanceThreshold;
+        } else {
+            return scalarProjection > distanceThreshold;
+        }
+    }
+}
+
+bool DirectionalDragAreaPrivate::isPastMaxDistance() const
+{
+    QPointF totalMovement(dampedScenePos.x() - startScenePos.x(),
+                          dampedScenePos.y() - startScenePos.y());
+
+    qreal squaredDistance = totalMovement.x()*totalMovement.x() + totalMovement.y()*totalMovement.y();
+    return squaredDistance > maxDistance*maxDistance;
+}
+
+void DirectionalDragAreaPrivate::giveUpIfDisabledOrInvisible()
+{
+    if (!q->isEnabled() || !q->isVisible()) {
+        if (status == Undecided) {
+            TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
             // We still wanna know when it ends for keeping the composition time window up-to-date
-            TouchRegistry::instance()->addTouchWatcher(m_touchId, this);
+            TouchRegistry::instance()->addTouchWatcher(touchId, q);
         }
 
-        if (m_status != WaitingForTouch) {
+        if (status != WaitingForTouch) {
             ddaDebug("Resetting status because got disabled or made invisible");
             setStatus(WaitingForTouch);
         }
     }
 }
 
-void DirectionalDragArea::setStatus(DirectionalDragArea::Status newStatus)
-{
-    if (newStatus == m_status)
+void DirectionalDragAreaPrivate::rejectGesture()
+{
+    if (status == Undecided) {
+        ddaDebug("Rejecting gesture because it's taking too long to drag beyond the threshold.");
+
+        TouchRegistry::instance()->removeCandidateOwnerForTouch(touchId, q);
+        // We still wanna know when it ends for keeping the composition time window up-to-date
+        TouchRegistry::instance()->addTouchWatcher(touchId, q);
+
+        setStatus(WaitingForTouch);
+    }
+}
+
+void DirectionalDragAreaPrivate::setStatus(Status newStatus)
+{
+    if (newStatus == status)
         return;
 
-    DirectionalDragArea::Status oldStatus = m_status;
+    Status oldStatus = status;
 
     if (oldStatus == Undecided) {
-        m_recognitionTimer->stop();
+        recognitionTimer->stop();
     }
 
-    m_status = newStatus;
-    Q_EMIT statusChanged(m_status);
+    status = newStatus;
+    Q_EMIT statusChanged(status);
 
     ddaDebug(statusToString(oldStatus) << " -> " << statusToString(newStatus));
 
     switch (newStatus) {
         case WaitingForTouch:
-            Q_EMIT draggingChanged(false);
+            if (oldStatus == Recognized) {
+                Q_EMIT q->draggingChanged(false);
+            }
+            Q_EMIT q->pressedChanged(false);
             break;
         case Undecided:
-            m_recognitionTimer->start();
-            Q_EMIT draggingChanged(true);
+            recognitionTimer->start();
+            Q_EMIT q->pressedChanged(true);
             break;
         case Recognized:
-            if (oldStatus == WaitingForTouch)
-                Q_EMIT draggingChanged(true);
+            Q_EMIT q->draggingChanged(true);
             break;
         default:
             // no-op
@@ -681,77 +614,126 @@
     }
 }
 
-void DirectionalDragArea::setPreviousPos(const QPointF &point)
+void DirectionalDragAreaPrivate::setPublicPos(const QPointF &point)
 {
-    bool xChanged = m_previousPos.x() != point.x();
-    bool yChanged = m_previousPos.y() != point.y();
-
-    m_previousPos = point;
+    bool xChanged = publicPos.x() != point.x();
+    bool yChanged = publicPos.y() != point.y();
+
+    // Public position should not get updated while the gesture is still being recognized
+    // (ie, Undecided status).
+    Q_ASSERT(status == WaitingForTouch || status == Recognized);
+
+    if (status == Recognized && !recognitionIsDisabled()) {
+        // When the gesture finally gets recognized, the finger will likely be
+        // reasonably far from the edge. If we made the contentX immediately
+        // follow the finger position it would be visually unpleasant as it
+        // would appear right next to the user's finger out of nowhere (ie,
+        // it would jump). Instead, we make contentX go towards the user's
+        // finger in several steps. ie., in an animated way.
+        QPointF delta = point - publicPos;
+        // the trick is not to go all the way (1.0) as it would cause a sudden jump
+        publicPos.rx() += 0.4 * delta.x();
+        publicPos.ry() += 0.4 * delta.y();
+    } else {
+        // no smoothing when initializing or if gesture recognition was immediate as there will
+        // be no jump.
+        publicPos = point;
+    }
 
     if (xChanged) {
-        Q_EMIT touchXChanged(point.x());
-        if (Direction::isHorizontal(m_direction))
-            Q_EMIT distanceChanged(distance());
+        Q_EMIT q->touchXChanged(publicPos.x());
+        if (Direction::isHorizontal(direction))
+            Q_EMIT q->distanceChanged(q->distance());
     }
 
     if (yChanged) {
-        Q_EMIT touchYChanged(point.y());
-        if (Direction::isVertical(m_direction))
-            Q_EMIT distanceChanged(distance());
+        Q_EMIT q->touchYChanged(publicPos.y());
+        if (Direction::isVertical(direction))
+            Q_EMIT q->distanceChanged(q->distance());
     }
 }
 
-void DirectionalDragArea::setPreviousScenePos(const QPointF &point)
+void DirectionalDragAreaPrivate::setPublicScenePos(const QPointF &point)
 {
-    bool xChanged = m_previousScenePos.x() != point.x();
-    bool yChanged = m_previousScenePos.y() != point.y();
+    bool xChanged = publicScenePos.x() != point.x();
+    bool yChanged = publicScenePos.y() != point.y();
 
     if (!xChanged && !yChanged)
         return;
 
-    qreal oldSceneDistance = sceneDistance();
-    m_previousScenePos = point;
+    // Public position should not get updated while the gesture is still being recognized
+    // (ie, Undecided status).
+    Q_ASSERT(status == WaitingForTouch || status == Recognized);
+
+    qreal oldSceneDistance = sceneDistance;
+
+    if (status == Recognized && !recognitionIsDisabled()) {
+        // When the gesture finally gets recognized, the finger will likely be
+        // reasonably far from the edge. If we made the contentX immediately
+        // follow the finger position it would be visually unpleasant as it
+        // would appear right next to the user's finger out of nowhere (ie,
+        // it would jump). Instead, we make contentX go towards the user's
+        // finger in several steps. ie., in an animated way.
+        QPointF delta = point - publicScenePos;
+        // the trick is not to go all the way (1.0) as it would cause a sudden jump
+        publicScenePos.rx() += 0.4 * delta.x();
+        publicScenePos.ry() += 0.4 * delta.y();
+    } else {
+        // no smoothing when initializing or if gesture recognition was immediate as there will
+        // be no jump.
+        publicScenePos = point;
+    }
+
     updateSceneDistance();
 
-    if (oldSceneDistance != sceneDistance()) {
-        Q_EMIT sceneDistanceChanged(sceneDistance());
+    if (oldSceneDistance != sceneDistance) {
+        Q_EMIT q->sceneDistanceChanged(sceneDistance);
     }
 
     if (xChanged) {
-        Q_EMIT touchSceneXChanged(point.x());
+        Q_EMIT q->touchSceneXChanged(publicScenePos.x());
     }
 
     if (yChanged) {
-        Q_EMIT touchSceneYChanged(point.y());
+        Q_EMIT q->touchSceneYChanged(publicScenePos.y());
     }
 }
 
-void DirectionalDragArea::updateVelocityCalculator(const QPointF &scenePos)
-{
-    QPointF totalSceneMovement = scenePos - m_startScenePos;
-
-    qreal scalarProjection = projectOntoDirectionVector(totalSceneMovement);
-
-    m_velocityCalculator->setTrackedPosition(scalarProjection);
-}
-
-bool DirectionalDragArea::isWithinTouchCompositionWindow()
+bool DirectionalDragAreaPrivate::isWithinTouchCompositionWindow()
 {
     return
-        compositionTime() > 0 &&
-        !m_activeTouches.isEmpty() &&
-        m_timeSource->msecsSinceReference() <=
-            m_activeTouches.mostRecentStartTime() + (qint64)compositionTime();
+        compositionTime > 0 &&
+        !activeTouches.isEmpty() &&
+        timeSource->msecsSinceReference() <=
+            activeTouches.mostRecentStartTime() + (qint64)compositionTime;
+}
+
+void DirectionalDragArea::itemChange(ItemChange change, const ItemChangeData &value)
+{
+    if (change == QQuickItem::ItemSceneChange) {
+        if (value.window != nullptr) {
+            // TODO: Handle window->screen() changes (ie window changing screens)
+            qreal pixelsPerMm = value.window->screen()->physicalDotsPerInch() / 25.4;
+            d->setPixelsPerMm(pixelsPerMm);
+        }
+    }
+}
+
+void DirectionalDragAreaPrivate::setPixelsPerMm(qreal pixelsPerMm)
+{
+    dampedScenePos.setMaxDelta(1. * pixelsPerMm);
+    setDistanceThreshold(4. * pixelsPerMm);
+    maxDistance = 10. * pixelsPerMm;
 }
 
 //**************************  ActiveTouchesInfo **************************
 
-DirectionalDragArea::ActiveTouchesInfo::ActiveTouchesInfo(const SharedTimeSource &timeSource)
+ActiveTouchesInfo::ActiveTouchesInfo(const SharedTimeSource &timeSource)
     : m_timeSource(timeSource)
 {
 }
 
-void DirectionalDragArea::ActiveTouchesInfo::update(QTouchEvent *event)
+void ActiveTouchesInfo::update(QTouchEvent *event)
 {
     if (!(event->touchPointStates() & (Qt::TouchPointPressed | Qt::TouchPointReleased))) {
         // nothing to update
@@ -773,7 +755,7 @@
 }
 
 #if ACTIVETOUCHESINFO_DEBUG
-QString DirectionalDragArea::ActiveTouchesInfo::toString()
+QString ActiveTouchesInfo::toString()
 {
     QString string = "(";
 
@@ -791,7 +773,7 @@
 }
 #endif // ACTIVETOUCHESINFO_DEBUG
 
-void DirectionalDragArea::ActiveTouchesInfo::addTouchPoint(int touchId)
+void ActiveTouchesInfo::addTouchPoint(int touchId)
 {
     ActiveTouchInfo &activeTouchInfo = m_touchInfoPool.getEmptySlot();
     activeTouchInfo.id = touchId;
@@ -802,7 +784,7 @@
     #endif
 }
 
-qint64 DirectionalDragArea::ActiveTouchesInfo::touchStartTime(int touchId)
+qint64 ActiveTouchesInfo::touchStartTime(int touchId)
 {
     qint64 result = -1;
 
@@ -819,7 +801,7 @@
     return result;
 }
 
-void DirectionalDragArea::ActiveTouchesInfo::removeTouchPoint(int touchId)
+void ActiveTouchesInfo::removeTouchPoint(int touchId)
 {
     m_touchInfoPool.forEach([&](Pool<ActiveTouchInfo>::Iterator &touchInfo) {
         if (touchId == touchInfo->id) {
@@ -835,7 +817,7 @@
     #endif
 }
 
-qint64 DirectionalDragArea::ActiveTouchesInfo::mostRecentStartTime()
+qint64 ActiveTouchesInfo::mostRecentStartTime()
 {
     Q_ASSERT(!m_touchInfoPool.isEmpty());
 
@@ -851,11 +833,11 @@
     return highestStartTime;
 }
 
-void DirectionalDragArea::updateSceneDirectionVector()
+void DirectionalDragAreaPrivate::updateSceneDirectionVector()
 {
     QPointF localOrigin(0., 0.);
     QPointF localDirection;
-    switch (m_direction) {
+    switch (direction) {
         case Direction::Upwards:
             localDirection.rx() = 0.;
             localDirection.ry() = -1.;
@@ -873,14 +855,31 @@
             localDirection.ry() = 0.;
             break;
     }
-    QPointF sceneOrigin = mapToScene(localOrigin);
-    QPointF sceneDirection = mapToScene(localDirection);
-    m_sceneDirectionVector = sceneDirection - sceneOrigin;
-}
-
-qreal DirectionalDragArea::projectOntoDirectionVector(const QPointF &sceneVector) const
-{
-    // same as dot product as m_sceneDirectionVector is a unit vector
-    return  sceneVector.x() * m_sceneDirectionVector.x() +
-            sceneVector.y() * m_sceneDirectionVector.y();
+    QPointF sceneOrigin = q->mapToScene(localOrigin);
+    QPointF sceneDirection = q->mapToScene(localDirection);
+    sceneDirectionVector = sceneDirection - sceneOrigin;
+}
+
+qreal DirectionalDragAreaPrivate::projectOntoDirectionVector(const QPointF &sceneVector) const
+{
+    // same as dot product as sceneDirectionVector is a unit vector
+    return  sceneVector.x() * sceneDirectionVector.x() +
+            sceneVector.y() * sceneDirectionVector.y();
+}
+
+DirectionalDragAreaPrivate::DirectionalDragAreaPrivate(DirectionalDragArea *q)
+    : q(q)
+    , status(WaitingForTouch)
+    , sceneDistance(0)
+    , touchId(-1)
+    , direction(Direction::Rightwards)
+    , distanceThreshold(0)
+    , distanceThresholdSquared(0.)
+    , maxTime(400)
+    , compositionTime(60)
+    , immediateRecognition(false)
+    , recognitionTimer(nullptr)
+    , timeSource(new RealTimeSource)
+    , activeTouches(timeSource)
+{
 }

=== modified file 'plugins/Ubuntu/Gestures/DirectionalDragArea.h'
--- plugins/Ubuntu/Gestures/DirectionalDragArea.h	2014-10-01 13:20:32 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.h	2015-04-15 20:21:35 +0000
@@ -18,7 +18,6 @@
 #define DIRECTIONAL_DRAG_AREA_H
 
 #include <QtQuick/QQuickItem>
-#include "AxisVelocityCalculator.h"
 #include "UbuntuGesturesQmlGlobal.h"
 #include "Damper.h"
 #include "Direction.h"
@@ -29,6 +28,7 @@
 
 class TouchOwnershipEvent;
 class UnownedTouchEvent;
+class DirectionalDragAreaPrivate;
 
 /*
  An area that detects axis-aligned single-finger drag gestures
@@ -61,95 +61,31 @@
     Q_PROPERTY(qreal touchSceneX READ touchSceneX NOTIFY touchSceneXChanged)
     Q_PROPERTY(qreal touchSceneY READ touchSceneY NOTIFY touchSceneYChanged)
 
-    // The current status of the directional drag gesture area.
-    Q_PROPERTY(Status status READ status NOTIFY statusChanged)
-
     // Whether a drag gesture is taking place
-    // This will be true as long as status is Undecided or Recognized
-    // When a gesture gets rejected, dragging turns to false.
     Q_PROPERTY(bool dragging READ dragging NOTIFY draggingChanged)
 
-    /////
-    // stuff that will be set in stone at some point
-
-    // How far the touch point can move away from its expected position before
-    // it causes a rejection in the gesture recognition. This is to compensate
-    // for both noise in the touch input signal and for the natural irregularities
-    // in the finger movement.
-    // Proper value is likely device-specific.
-    Q_PROPERTY(qreal maxDeviation READ maxDeviation WRITE setMaxDeviation NOTIFY maxDeviationChanged)
-
-    // Widening angle, in degrees
-    // It's roughly the maximum angle a touch point can make relative to the
-    // axis defined by the compoment's direction for it to be recognized as a
-    // directional drag.
-    Q_PROPERTY(qreal wideningAngle READ wideningAngle WRITE setWideningAngle
-               NOTIFY wideningAngleChanged)
-
-    // How far a touch point has to move from its initial position in order for
-    // it to be recognized as a directional drag.
-    Q_PROPERTY(qreal distanceThreshold READ distanceThreshold WRITE setDistanceThreshold
-               NOTIFY distanceThresholdChanged)
-
-    // Minimum speed a gesture needs to have in order to be recognized as a
-    // directional drag.
-    // In pixels per second
-    Q_PROPERTY(qreal minSpeed READ minSpeed WRITE setMinSpeed NOTIFY minSpeedChanged)
-
-    // A gesture will be rejected if more than maxSilenceTime milliseconds has
-    // passed since we last got an input event from it (during Undecided state).
-    //
-    // Silence (i.e., lack of new input events) doesn't necessarily mean that the user's
-    // finger is still (zero drag speed). In some cases the finger might be moving but
-    // the driver's high noise filtering might cause those silence periods, specially
-    // in the moments succeeding a press (talking about Galaxy Nexus here).
-    Q_PROPERTY(int maxSilenceTime READ maxSilenceTime
-                                  WRITE setMaxSilenceTime
-                                  NOTIFY maxSilenceTimeChanged)
-
-    //
-    /////
-
-    // Maximum time (in milliseconds) after the start of a given touch point where
-    // subsequent touch starts are grouped with the first one into an N-touches gesture
-    // (e.g. a two-fingers tap or drag).
-    Q_PROPERTY(int compositionTime READ compositionTime
-                                   WRITE setCompositionTime
-                                   NOTIFY compositionTimeChanged)
+    // Whether the drag area is pressed.
+    Q_PROPERTY(bool pressed READ pressed NOTIFY pressedChanged)
+
+    // Whether a gesture should be Recognized as soon a touch lands on the area.
+    // With this property enabled it will work pretty much like a MultiPointTouchArea,
+    // just with a different API.
+    //
+    // It's false by default. In most cases you will not want that enabled.
+    Q_PROPERTY(bool immediateRecognition
+            READ immediateRecognition
+            WRITE setImmediateRecognition
+            NOTIFY immediateRecognitionChanged)
 
     Q_ENUMS(Direction)
-    Q_ENUMS(Status)
 public:
     DirectionalDragArea(QQuickItem *parent = 0);
 
     Direction::Type direction() const;
     void setDirection(Direction::Type);
 
-    // Describes the state of the directional drag gesture.
-    enum Status {
-        // Waiting for a new touch point to land on this area. No gesture is being processed
-        // or tracked.
-        WaitingForTouch,
-
-        // A touch point has landed on this area but it's not know yet whether it is
-        // performing a drag in the correct direction.
-        // If it's decided that the touch point is not performing a directional drag gesture,
-        // it will be rejected/ignored and status will return to WaitingForTouch.
-        Undecided, //Recognizing,
-
-        // There's a touch point in this area and it performed a drag in the correct
-        // direction.
-        //
-        // Once recognized, the gesture state will move back to WaitingForTouch only once
-        // that touch point ends. The gesture will remain in the Recognized state even if
-        // the touch point starts moving in other directions or halts.
-        Recognized,
-    };
-    Status status() const { return m_status; }
-
     qreal distance() const;
     qreal sceneDistance() const;
-    void updateSceneDistance();
 
     qreal touchX() const;
     qreal touchY() const;
@@ -157,152 +93,43 @@
     qreal touchSceneX() const;
     qreal touchSceneY() const;
 
-    bool dragging() const { return (m_status == Undecided) || (m_status == Recognized); }
-
-    qreal maxDeviation() const { return m_dampedScenePos.maxDelta(); }
-    void setMaxDeviation(qreal value);
-
-    qreal wideningAngle() const;
-    void setWideningAngle(qreal value);
-
-    qreal distanceThreshold() const { return m_distanceThreshold; }
-    void setDistanceThreshold(qreal value);
-
-    qreal minSpeed() const { return m_minSpeed; }
-    void setMinSpeed(qreal value);
-
-    int maxSilenceTime() const { return m_maxSilenceTime; }
-    void setMaxSilenceTime(int value);
-
-    int compositionTime() const { return m_compositionTime; }
-    void setCompositionTime(int value);
-
-    // Replaces the existing Timer with the given one.
-    //
-    // Useful for providing a fake timer when testing.
-    void setRecognitionTimer(UbuntuGestures::AbstractTimer *timer);
-
-    // Useful for testing, where a fake time source can be supplied
-    void setTimeSource(const UbuntuGestures::SharedTimeSource &timeSource);
+    bool dragging() const;
+
+    bool pressed() const;
+
+    bool immediateRecognition() const;
+    void setImmediateRecognition(bool enabled);
 
     bool event(QEvent *e) override;
 
-    // Maximum time, in milliseconds, between a press and a release, for a touch
-    // sequence to be considered a tap.
-    int maxTapDuration() const { return 300; }
+    /*
+      In qmltests, sequences of touch events are sent all at once, unlike in "real life".
+      Also qmltests might run really slowly, e.g. when run from inside virtual machines.
+      Thus to remove a variable that qmltests cannot really control, namely time, this
+      function removes all constraints that are sensible to elapsed time.
+
+      This effectively makes the DirectionalDragArea easier to fool.
+     */
+    Q_INVOKABLE void removeTimeConstraints();
 
 Q_SIGNALS:
     void directionChanged(Direction::Type direction);
-    void statusChanged(Status value);
     void draggingChanged(bool value);
+    void pressedChanged(bool value);
     void distanceChanged(qreal value);
     void sceneDistanceChanged(qreal value);
-    void maxDeviationChanged(qreal value);
-    void wideningAngleChanged(qreal value);
-    void distanceThresholdChanged(qreal value);
-    void minSpeedChanged(qreal value);
-    void maxSilenceTimeChanged(int value);
-    void compositionTimeChanged(int value);
     void touchXChanged(qreal value);
     void touchYChanged(qreal value);
     void touchSceneXChanged(qreal value);
     void touchSceneYChanged(qreal value);
-
-    // TODO: I would rather not have such signal as it has nothing to do with drag gestures.
-    // Remove when no longer used or move its implementation to the QML code that uses it
-    // See maxTapDuration()
-    void tapped();
+    void immediateRecognitionChanged(bool value);
 
 protected:
     virtual void touchEvent(QTouchEvent *event);
-
-private Q_SLOTS:
-    void checkSpeed();
-    void giveUpIfDisabledOrInvisible();
-
-private:
-    void touchEvent_absent(QTouchEvent *event);
-    void touchEvent_undecided(QTouchEvent *event);
-    void touchEvent_recognized(QTouchEvent *event);
-    bool pointInsideAllowedArea() const;
-    bool movingInRightDirection() const;
-    bool movedFarEnough(const QPointF &point) const;
-    const QTouchEvent::TouchPoint *fetchTargetTouchPoint(QTouchEvent *event);
-    void setStatus(Status newStatus);
-    void setPreviousPos(const QPointF &point);
-    void setPreviousScenePos(const QPointF &point);
-    void updateVelocityCalculator(const QPointF &point);
-    bool isWithinTouchCompositionWindow();
-    void updateSceneDirectionVector();
-    // returns the scalar projection between the given vector (in scene coordinates)
-    // and m_sceneDirectionVector
-    qreal projectOntoDirectionVector(const QPointF &sceneVector) const;
-    void touchOwnershipEvent(TouchOwnershipEvent *event);
-    void unownedTouchEvent(UnownedTouchEvent *event);
-    void unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent);
-    void watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints);
-    bool recognitionIsDisabled() const;
-    void emitSignalIfTapped();
-
-    Status m_status;
-
-    QPointF m_startPos;
-    QPointF m_startScenePos;
-    QPointF m_previousPos;
-    QPointF m_previousScenePos;
-    qreal m_sceneDistance;
-    int m_touchId;
-
-    // A movement damper is used in some of the gesture recognition calculations
-    // to get rid of noise or small oscillations in the touch position.
-    DampedPointF m_dampedScenePos;
-    QPointF m_previousDampedScenePos;
-
-    // Unit vector in scene coordinates describing the direction of the gesture recognition
-    QPointF m_sceneDirectionVector;
-
-    Direction::Type m_direction;
-    qreal m_wideningAngle; // in degrees
-    qreal m_wideningFactor; // it's pow(cosine(m_wideningAngle), 2)
-    qreal m_distanceThreshold;
-    qreal m_distanceThresholdSquared; // it's pow(m_distanceThreshold, 2)
-    qreal m_minSpeed;
-    int m_maxSilenceTime; // in milliseconds
-    int m_silenceTime; // in milliseconds
-    int m_compositionTime; // in milliseconds
-    int m_numSamplesOnLastSpeedCheck;
-    UbuntuGestures::AbstractTimer *m_recognitionTimer;
-    AxisVelocityCalculator *m_velocityCalculator;
-
-    UbuntuGestures::SharedTimeSource m_timeSource;
-
-    // Information about an active touch point
-    struct ActiveTouchInfo {
-        ActiveTouchInfo() : id(-1), startTime(-1) {}
-        bool isValid() const { return id != -1; }
-        void reset() { id = -1; }
-        int id;
-        qint64 startTime;
-    };
-    class ActiveTouchesInfo {
-    public:
-        ActiveTouchesInfo(const UbuntuGestures::SharedTimeSource &timeSource);
-        void update(QTouchEvent *event);
-        qint64 touchStartTime(int id);
-        bool isEmpty() const { return m_touchInfoPool.isEmpty(); }
-        qint64 mostRecentStartTime();
-        UbuntuGestures::SharedTimeSource m_timeSource;
-    private:
-        void addTouchPoint(int touchId);
-        void removeTouchPoint(int touchId);
-        #if ACTIVETOUCHESINFO_DEBUG
-        QString toString();
-        #endif
-
-        Pool<ActiveTouchInfo> m_touchInfoPool;
-    } m_activeTouches;
-
-    friend class tst_DirectionalDragArea;
+    virtual void itemChange(ItemChange change, const ItemChangeData &value);
+
+public: // so tests can access it
+    DirectionalDragAreaPrivate *d;
 };
 
 #endif // DIRECTIONAL_DRAG_AREA_H

=== added file 'plugins/Ubuntu/Gestures/DirectionalDragArea_p.h'
--- plugins/Ubuntu/Gestures/DirectionalDragArea_p.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea_p.h	2015-04-15 20:21:35 +0000
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef DIRECTIONAL_DRAG_AREA_PRIV_H
+#define DIRECTIONAL_DRAG_AREA_PRIV_H
+
+// Information about an active touch point
+struct UBUNTUGESTURESQML_EXPORT ActiveTouchInfo {
+    ActiveTouchInfo() : id(-1), startTime(-1) {}
+    bool isValid() const { return id != -1; }
+    void reset() { id = -1; }
+    int id;
+    qint64 startTime;
+};
+class UBUNTUGESTURESQML_EXPORT ActiveTouchesInfo {
+public:
+    ActiveTouchesInfo(const UbuntuGestures::SharedTimeSource &timeSource);
+    void update(QTouchEvent *event);
+    qint64 touchStartTime(int id);
+    bool isEmpty() const { return m_touchInfoPool.isEmpty(); }
+    qint64 mostRecentStartTime();
+    UbuntuGestures::SharedTimeSource m_timeSource;
+private:
+    void addTouchPoint(int touchId);
+    void removeTouchPoint(int touchId);
+    #if ACTIVETOUCHESINFO_DEBUG
+    QString toString();
+    #endif
+
+    Pool<ActiveTouchInfo> m_touchInfoPool;
+};
+
+class UBUNTUGESTURESQML_EXPORT DirectionalDragAreaPrivate : public QObject {
+    Q_OBJECT
+
+    Q_ENUMS(Status)
+public:
+    DirectionalDragAreaPrivate(DirectionalDragArea *q);
+
+public Q_SLOTS:
+    void giveUpIfDisabledOrInvisible();
+    void rejectGesture();
+
+public:
+    // Describes the state of the directional drag gesture.
+    enum Status {
+        // Waiting for a new touch point to land on this area. No gesture is being processed
+        // or tracked.
+        WaitingForTouch,
+
+        // A touch point has landed on this area but it's not know yet whether it is
+        // performing a drag in the correct direction.
+        // If it's decided that the touch point is not performing a directional drag gesture,
+        // it will be rejected/ignored and status will return to WaitingForTouch.
+        Undecided, //Recognizing,
+
+        // There's a touch point in this area and it performed a drag in the correct
+        // direction.
+        //
+        // Once recognized, the gesture state will move back to WaitingForTouch only once
+        // that touch point ends. The gesture will remain in the Recognized state even if
+        // the touch point starts moving in other directions or halts.
+        Recognized,
+    };
+
+    void touchEvent_absent(QTouchEvent *event);
+    void touchEvent_undecided(QTouchEvent *event);
+    void touchEvent_recognized(QTouchEvent *event);
+    bool movingInRightDirection() const;
+    bool movedFarEnoughAlongGestureAxis() const;
+    bool isPastMaxDistance() const;
+    const QTouchEvent::TouchPoint *fetchTargetTouchPoint(QTouchEvent *event);
+    void setStatus(Status newStatus);
+    void setPublicPos(const QPointF &point);
+    void setPublicScenePos(const QPointF &point);
+    bool isWithinTouchCompositionWindow();
+    void updateSceneDirectionVector();
+    // returns the scalar projection between the given vector (in scene coordinates)
+    // and m_sceneDirectionVector
+    qreal projectOntoDirectionVector(const QPointF &sceneVector) const;
+    void touchOwnershipEvent(TouchOwnershipEvent *event);
+    void unownedTouchEvent(UnownedTouchEvent *event);
+    void unownedTouchEvent_undecided(UnownedTouchEvent *unownedTouchEvent);
+    void watchPressedTouchPoints(const QList<QTouchEvent::TouchPoint> &touchPoints);
+    bool recognitionIsDisabled() const;
+    bool sanityCheckRecognitionProperties();
+    void updateSceneDistance();
+    void setMaxTime(int value);
+    void setDistanceThreshold(qreal value);
+    void setPixelsPerMm(qreal pixelsPerMm);
+    QString objectName() const { return q->objectName(); }
+
+    // Replaces the existing Timer with the given one.
+    //
+    // Useful for providing a fake timer when testing.
+    void setRecognitionTimer(UbuntuGestures::AbstractTimer *timer);
+
+    // Useful for testing, where a fake time source can be supplied
+    void setTimeSource(const UbuntuGestures::SharedTimeSource &timeSource);
+
+    DirectionalDragArea *q;
+
+    // The current status of the directional drag gesture area.
+    Status status;
+
+    QPointF startPos;
+    QPointF startScenePos;
+    qreal sceneDistance;
+    int touchId;
+
+    // The touch position exposed in the public API.
+    // It only starts to move once the gesture gets recognized.
+    QPointF publicPos;
+    QPointF publicScenePos;
+
+    // A movement damper is used in some of the gesture recognition calculations
+    // to get rid of noise or small oscillations in the touch position.
+    DampedPointF dampedScenePos;
+    QPointF previousDampedScenePos;
+
+    // Unit vector in scene coordinates describing the direction of the gesture recognition
+    QPointF sceneDirectionVector;
+
+    Direction::Type direction;
+
+    // How far a touch point has to move from its initial position along the gesture axis in order
+    // for it to be recognized as a directional drag.
+    qreal distanceThreshold;
+    qreal distanceThresholdSquared; // it's pow(distanceThreshold, 2)
+
+    // Maximum time (in milliseconds) the gesture can take to go beyond the distance threshold
+    int maxTime;
+
+    // Maximum distance the gesture can go without crossing the axis-aligned distance threshold
+    qreal maxDistance;
+
+    // Maximum time (in milliseconds) after the start of a given touch point where
+    // subsequent touch starts are grouped with the first one into an N-touches gesture
+    // (e.g. a two-fingers tap or drag).
+    int compositionTime;
+
+    bool immediateRecognition;
+
+    UbuntuGestures::AbstractTimer *recognitionTimer;
+
+    UbuntuGestures::SharedTimeSource timeSource;
+
+    ActiveTouchesInfo activeTouches;
+
+Q_SIGNALS:
+    void statusChanged(Status value);
+};
+
+#endif // DIRECTIONAL_DRAG_AREA_PRIV_H

=== modified file 'plugins/Ubuntu/Gestures/TouchDispatcher.cpp'
--- plugins/Ubuntu/Gestures/TouchDispatcher.cpp	2014-11-03 15:21:46 +0000
+++ plugins/Ubuntu/Gestures/TouchDispatcher.cpp	2015-04-15 20:21:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-2015 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -28,8 +28,11 @@
 #define TOUCHDISPATCHER_DEBUG 0
 
 #if TOUCHDISPATCHER_DEBUG
+#define ugDebug(params) qDebug().nospace() << "[TouchDispatcher(" << this << ")] " << params
 #include <DebugHelpers.h>
-#endif
+#else // TOUCHDISPATCHER_DEBUG
+#define ugDebug(params) ((void)0)
+#endif // TOUCHDISPATCHER_DEBUG
 
 TouchDispatcher::TouchDispatcher()
     : m_status(NoActiveTouch)
@@ -44,13 +47,12 @@
         m_targetItem = target;
         if (m_status != NoActiveTouch) {
             qWarning("[TouchDispatcher] Changing target item in the middle of a touch stream");
-            m_status = TargetRejectedTouches;
+            setStatus(TargetRejectedTouches);
         }
     }
 }
 
-void TouchDispatcher::dispatch(QEvent::Type eventType,
-                               QTouchDevice *device,
+void TouchDispatcher::dispatch(QTouchDevice *device,
                                Qt::KeyboardModifiers modifiers,
                                const QList<QTouchEvent::TouchPoint> &touchPoints,
                                QWindow *window,
@@ -61,6 +63,8 @@
         return;
     }
 
+    QEvent::Type eventType = resolveEventType(touchPoints);
+
     if (eventType == QEvent::TouchBegin) {
         dispatchTouchBegin(device, modifiers, touchPoints, window, timestamp);
 
@@ -72,15 +76,13 @@
             dispatchAsMouse(device, modifiers, touchPoints, timestamp);
         } else {
             Q_ASSERT(m_status == TargetRejectedTouches);
-            #if TOUCHDISPATCHER_DEBUG
-            qDebug() << "[TouchDispatcher] Not dispatching touch event to" << m_targetItem.data()
-                << "because it already rejected the touch stream.";
-            #endif
+            ugDebug("Not dispatching touch event to " << m_targetItem.data()
+                << "because it already rejected the touch stream.");
             // Do nothing
         }
 
         if (eventType == QEvent::TouchEnd) {
-            m_status = NoActiveTouch;
+            setStatus(NoActiveTouch);
             m_touchMouseId = -1;
         }
 
@@ -103,10 +105,7 @@
     QQuickItem *targetItem = m_targetItem.data();
 
     if (!targetItem->isEnabled() || !targetItem->isVisible()) {
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] Cannot dispatch touch event to" << targetItem
-            << "because it's disabled or invisible.";
-        #endif
+        ugDebug("Cannot dispatch touch event to " << targetItem << " because it's disabled or invisible.");
         return;
     }
 
@@ -118,62 +117,46 @@
             createQTouchEvent(QEvent::TouchBegin, device, modifiers, targetTouchPoints, window, timestamp));
 
 
-    #if TOUCHDISPATCHER_DEBUG
-    qDebug() << "[TouchDispatcher] dispatching" << qPrintable(touchEventToString(touchEvent.data()))
-            << "to" << targetItem;
-    #endif
+    ugDebug("dispatching " << qPrintable(touchEventToString(touchEvent.data()))
+            << " to " << targetItem);
     QCoreApplication::sendEvent(targetItem, touchEvent.data());
 
 
     if (touchEvent->isAccepted()) {
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] Item accepted the touch event.";
-        #endif
-        m_status = DeliveringTouchEvents;
+        ugDebug("Item accepted the touch event.");
+        setStatus(DeliveringTouchEvents);
     } else if (targetItem->acceptedMouseButtons() & Qt::LeftButton) {
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] Item rejected the touch event. Trying a QMouseEvent";
-        #endif
+        ugDebug("Item rejected the touch event. Trying a QMouseEvent");
         // NB: Arbitrarily chose the first touch point to emulate the mouse pointer
         QScopedPointer<QMouseEvent> mouseEvent(
                 touchToMouseEvent(QEvent::MouseButtonPress, targetTouchPoints.at(0), timestamp,
                                   modifiers, false /* transformNeeded */));
         Q_ASSERT(targetTouchPoints.at(0).state() == Qt::TouchPointPressed);
 
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(mouseEvent.data()))
-                << "to" << m_targetItem.data();
-        #endif
+        ugDebug("dispatching " << qPrintable(mouseEventToString(mouseEvent.data()))
+                << " to " << m_targetItem.data());
         QCoreApplication::sendEvent(targetItem, mouseEvent.data());
         if (mouseEvent->isAccepted()) {
-            #if TOUCHDISPATCHER_DEBUG
-            qDebug() << "[TouchDispatcher] Item accepted the QMouseEvent.";
-            #endif
-            m_status = DeliveringMouseEvents;
+            ugDebug("Item accepted the QMouseEvent.");
+            setStatus(DeliveringMouseEvents);
             m_touchMouseId = targetTouchPoints.at(0).id();
 
             if (checkIfDoubleClicked(timestamp)) {
                 QScopedPointer<QMouseEvent> doubleClickEvent(
                         touchToMouseEvent(QEvent::MouseButtonDblClick, targetTouchPoints.at(0), timestamp,
                                           modifiers, false /* transformNeeded */));
-                #if TOUCHDISPATCHER_DEBUG
-                qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(doubleClickEvent.data()))
-                        << "to" << m_targetItem.data();
-                #endif
+                ugDebug("dispatching " << qPrintable(mouseEventToString(doubleClickEvent.data()))
+                        << " to " << m_targetItem.data());
                 QCoreApplication::sendEvent(targetItem, doubleClickEvent.data());
             }
 
         } else {
-            #if TOUCHDISPATCHER_DEBUG
-            qDebug() << "[TouchDispatcher] Item rejected the QMouseEvent.";
-            #endif
-            m_status = TargetRejectedTouches;
+            ugDebug("Item rejected the QMouseEvent.");
+            setStatus(TargetRejectedTouches);
         }
     } else {
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] Item rejected the touch event and does not accept mouse buttons.";
-        #endif
-        m_status = TargetRejectedTouches;
+        ugDebug("Item rejected the touch event and does not accept mouse buttons.");
+        setStatus(TargetRejectedTouches);
     }
 }
 
@@ -194,10 +177,8 @@
             createQTouchEvent(eventType, device, modifiers, targetTouchPoints, window, timestamp));
 
 
-    #if TOUCHDISPATCHER_DEBUG
-    qDebug() << "[TouchDispatcher] dispatching" << qPrintable(touchEventToString(eventForTargetItem.data()))
-            << "to" << targetItem;
-    #endif
+    ugDebug("dispatching " << qPrintable(touchEventToString(eventForTargetItem.data()))
+            << " to " << targetItem);
     QCoreApplication::sendEvent(targetItem, eventForTargetItem.data());
 }
 
@@ -254,10 +235,8 @@
         QScopedPointer<QMouseEvent> mouseEvent(touchToMouseEvent(eventType, *touchMouse, timestamp, modifiers,
                     true /* transformNeeded */));
 
-        #if TOUCHDISPATCHER_DEBUG
-        qDebug() << "[TouchDispatcher] dispatching" << qPrintable(mouseEventToString(mouseEvent.data()))
-                << "to" << m_targetItem.data();
-        #endif
+        ugDebug("dispatching " << qPrintable(mouseEventToString(mouseEvent.data()))
+                << " to " << m_targetItem.data());
         QCoreApplication::sendEvent(m_targetItem.data(), mouseEvent.data());
     }
 }
@@ -365,3 +344,59 @@
 
     return doubleClicked;
 }
+
+void TouchDispatcher::setStatus(Status status)
+{
+    if (status != m_status) {
+        #if TOUCHDISPATCHER_DEBUG
+        switch (status) {
+        case NoActiveTouch:
+            ugDebug("status = NoActiveTouch");
+            break;
+        case DeliveringTouchEvents:
+            ugDebug("status = DeliveringTouchEvents");
+            break;
+        case DeliveringMouseEvents:
+            ugDebug("status = DeliveringMouseEvents");
+            break;
+        case TargetRejectedTouches:
+            ugDebug("status = TargetRejectedTouches");
+            break;
+        default:
+            ugDebug("status = " << status);
+            break;
+        }
+        #endif
+        m_status = status;
+    }
+}
+
+void TouchDispatcher::reset()
+{
+    setStatus(NoActiveTouch);
+    m_touchMouseId = -1;
+    m_touchMousePressTimestamp =0;
+}
+
+QEvent::Type TouchDispatcher::resolveEventType(const QList<QTouchEvent::TouchPoint> &touchPoints)
+{
+    QEvent::Type eventType;
+
+    Qt::TouchPointStates eventStates = 0;
+    for (int i = 0; i < touchPoints.count(); i++)
+        eventStates |= touchPoints[i].state();
+
+    switch (eventStates) {
+        case Qt::TouchPointPressed:
+            eventType = QEvent::TouchBegin;
+            break;
+        case Qt::TouchPointReleased:
+            eventType = QEvent::TouchEnd;
+            break;
+        default:
+            eventType = QEvent::TouchUpdate;
+            break;
+    }
+
+    return eventType;
+}

=== modified file 'plugins/Ubuntu/Gestures/TouchDispatcher.h'
--- plugins/Ubuntu/Gestures/TouchDispatcher.h	2014-11-03 15:21:46 +0000
+++ plugins/Ubuntu/Gestures/TouchDispatcher.h	2015-04-15 20:21:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-2015 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -36,12 +36,20 @@
     void setTargetItem(QQuickItem *target);
     QQuickItem *targetItem() { return m_targetItem; }
 
-    void dispatch(QEvent::Type eventType,
-            QTouchDevice *device,
+    void dispatch(QTouchDevice *device,
             Qt::KeyboardModifiers modifiers,
             const QList<QTouchEvent::TouchPoint> &touchPoints,
             QWindow *window,
             ulong timestamp);
+
+    void reset();
+
+    enum Status {
+        NoActiveTouch,
+        DeliveringTouchEvents,
+        DeliveringMouseEvents,
+        TargetRejectedTouches
+    };
 private:
     void dispatchTouchBegin(
             QTouchDevice *device,
@@ -73,14 +81,13 @@
 
     bool checkIfDoubleClicked(ulong newPressEventTimestamp);
 
+    void setStatus(Status status);
+
+    static QEvent::Type resolveEventType(const QList<QTouchEvent::TouchPoint> &touchPoints);
+
     QPointer<QQuickItem> m_targetItem;
 
-    enum {
-        NoActiveTouch,
-        DeliveringTouchEvents,
-        DeliveringMouseEvents,
-        TargetRejectedTouches
-    } m_status;
+    Status m_status;
 
     int m_touchMouseId;
     ulong m_touchMousePressTimestamp;

=== modified file 'plugins/Ubuntu/Gestures/TouchGate.cpp'
--- plugins/Ubuntu/Gestures/TouchGate.cpp	2015-03-12 13:52:35 +0000
+++ plugins/Ubuntu/Gestures/TouchGate.cpp	2015-04-15 20:21:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-2015 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,8 +23,18 @@
 #include <TouchRegistry.h>
 
 #if TOUCHGATE_DEBUG
+#define ugDebug(params) qDebug().nospace() << "[TouchGate(" << (void*)this << ")] " << params
 #include <DebugHelpers.h>
-#endif
+#else // TOUCHGATE_DEBUG
+#define ugDebug(params) ((void)0)
+#endif // TOUCHGATE_DEBUG
+
+TouchGate::TouchGate(QQuickItem *parent)
+    : QQuickItem(parent)
+{
+    connect(this, &QQuickItem::enabledChanged,
+            this, &TouchGate::onEnabledChanged);
+}
 
 bool TouchGate::event(QEvent *e)
 {
@@ -38,13 +48,12 @@
 
 void TouchGate::touchEvent(QTouchEvent *event)
 {
-    #if TOUCHGATE_DEBUG
-    qDebug() << "[TouchGate] got touch event" << qPrintable(touchEventToString(event));
-    #endif
+    ugDebug("got touch event" << qPrintable(touchEventToString(event)));
     event->accept();
 
     const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
-    bool goodToGo = true;
+    QList<QTouchEvent::TouchPoint> validTouchPoints;
+    bool ownsAllTouches = true;
     for (int i = 0; i < touchPoints.count(); ++i) {
         const QTouchEvent::TouchPoint &touchPoint = touchPoints[i];
 
@@ -55,31 +64,41 @@
             TouchRegistry::instance()->requestTouchOwnership(touchPoint.id(), this);
         }
 
-        goodToGo &= m_touchInfoMap.contains(touchPoint.id())
-            && m_touchInfoMap[touchPoint.id()].ownership == OwnershipGranted;
-
-        if (touchPoint.state() == Qt::TouchPointReleased && m_touchInfoMap.contains(touchPoint.id())) {
-            m_touchInfoMap[touchPoint.id()].ended = true;
+        if (m_touchInfoMap.contains(touchPoint.id())) {
+            validTouchPoints.append(touchPoint);
+
+            ownsAllTouches &= m_touchInfoMap[touchPoint.id()].ownership == OwnershipGranted;
+
+            if (touchPoint.state() == Qt::TouchPointReleased) {
+                m_touchInfoMap[touchPoint.id()].ended = true;
+            }
         }
 
     }
 
-    if (goodToGo) {
+    if (validTouchPoints.isEmpty()) {
+        // nothing to do.
+        return;
+    }
+
+    if (ownsAllTouches) {
         if (m_storedEvents.isEmpty()) {
             // let it pass through
-            dispatchTouchEventToTarget(event);
+            removeTouchInfoForEndedTouches(validTouchPoints);
+            m_dispatcher.dispatch(event->device(), event->modifiers(), validTouchPoints,
+                    event->window(), event->timestamp());
         } else {
             // Retain the event to ensure TouchGate dispatches them in order.
             // Otherwise the current event would come before the stored ones, which are older.
-            #if TOUCHGATE_DEBUG
-            qDebug("[TouchGate] Storing event because thouches %s are still pending ownership.",
-                qPrintable(oldestPendingTouchIdsString()));
-            #endif
-            storeTouchEvent(event);
+            ugDebug("Storing event because thouches " << qPrintable(oldestPendingTouchIdsString())
+                    << " are still pending ownership.");
+            storeTouchEvent(event->device(), event->modifiers(), validTouchPoints,
+                    event->window(), event->timestamp());
         }
     } else {
         // Retain events that have unowned touches
-        storeTouchEvent(event);
+        storeTouchEvent(event->device(), event->modifiers(), validTouchPoints,
+                event->window(), event->timestamp());
     }
 }
 
@@ -88,24 +107,23 @@
     // TODO: Optimization: batch those actions as TouchOwnershipEvents
     //       might come one right after the other.
 
-    Q_ASSERT(m_touchInfoMap.contains(event->touchId()));
-
-    TouchInfo &touchInfo = m_touchInfoMap[event->touchId()];
-
-    if (event->gained()) {
-        #if TOUCHGATE_DEBUG
-        qDebug() << "[TouchGate] Got ownership of touch " << event->touchId();
-        #endif
-        touchInfo.ownership = OwnershipGranted;
+    if (m_touchInfoMap.contains(event->touchId())) {
+        TouchInfo &touchInfo = m_touchInfoMap[event->touchId()];
+
+        if (event->gained()) {
+            ugDebug("Got ownership of touch " << event->touchId());
+            touchInfo.ownership = OwnershipGranted;
+        } else {
+            ugDebug("Lost ownership of touch " << event->touchId());
+            m_touchInfoMap.remove(event->touchId());
+            removeTouchFromStoredEvents(event->touchId());
+        }
+
+        dispatchFullyOwnedEvents();
     } else {
-        #if TOUCHGATE_DEBUG
-        qDebug() << "[TouchGate] Lost ownership of touch " << event->touchId();
-        #endif
-        m_touchInfoMap.remove(event->touchId());
-        removeTouchFromStoredEvents(event->touchId());
+        // Ignore it. It probably happened because the TouchGate got disabled
+        // between the time it requested ownership and the time it got it.
     }
-
-    dispatchFullyOwnedEvents();
 }
 
 bool TouchGate::isTouchPointOwned(int touchId) const
@@ -113,14 +131,15 @@
     return m_touchInfoMap[touchId].ownership == OwnershipGranted;
 }
 
-void TouchGate::storeTouchEvent(const QTouchEvent *event)
+void TouchGate::storeTouchEvent(QTouchDevice *device,
+            Qt::KeyboardModifiers modifiers,
+            const QList<QTouchEvent::TouchPoint> &touchPoints,
+            QWindow *window,
+            ulong timestamp)
 {
-    #if TOUCHGATE_DEBUG
-    qDebug() << "[TouchGate] Storing" << qPrintable(touchEventToString(event));
-    #endif
-
-    TouchEvent clonedEvent(event);
-    m_storedEvents.append(std::move(clonedEvent));
+    ugDebug("Storing" << touchPoints);
+    TouchEvent event(device, modifiers, touchPoints, window, timestamp);
+    m_storedEvents.append(std::move(event));
 }
 
 void TouchGate::removeTouchFromStoredEvents(int touchId)
@@ -193,25 +212,13 @@
 void TouchGate::dispatchTouchEventToTarget(const TouchEvent &event)
 {
     removeTouchInfoForEndedTouches(event.touchPoints);
-    m_dispatcher.dispatch(event.eventType,
-            event.device,
+    m_dispatcher.dispatch(event.device,
             event.modifiers,
             event.touchPoints,
             event.window,
             event.timestamp);
 }
 
-void TouchGate::dispatchTouchEventToTarget(QTouchEvent* event)
-{
-    removeTouchInfoForEndedTouches(event->touchPoints());
-    m_dispatcher.dispatch(event->type(),
-            event->device(),
-            event->modifiers(),
-            event->touchPoints(),
-            event->window(),
-            event->timestamp());
-}
-
 void TouchGate::removeTouchInfoForEndedTouches(const QList<QTouchEvent::TouchPoint> &touchPoints)
 {
     for (int i = 0; i < touchPoints.size(); ++i) {\
@@ -226,14 +233,31 @@
     }
 }
 
-TouchGate::TouchEvent::TouchEvent(const QTouchEvent *event)
-    : eventType(event->type())
-    , device(event->device())
-    , modifiers(event->modifiers())
-    , touchPoints(event->touchPoints())
-    , target(qobject_cast<QQuickItem*>(event->target()))
-    , window(event->window())
-    , timestamp(event->timestamp())
+void TouchGate::onEnabledChanged()
+{
+    ugDebug(" enabled = " << isEnabled());
+    if (!isEnabled()) {
+        reset();
+    }
+}
+
+void TouchGate::reset()
+{
+    m_storedEvents.clear();
+    m_touchInfoMap.clear();
+    m_dispatcher.reset();
+}
+
+TouchGate::TouchEvent::TouchEvent(QTouchDevice *device,
+            Qt::KeyboardModifiers modifiers,
+            const QList<QTouchEvent::TouchPoint> &touchPoints,
+            QWindow *window,
+            ulong timestamp)
+    : device(device)
+    , modifiers(modifiers)
+    , touchPoints(touchPoints)
+    , window(window)
+    , timestamp(timestamp)
 {
 }
 

=== modified file 'plugins/Ubuntu/Gestures/TouchGate.h'
--- plugins/Ubuntu/Gestures/TouchGate.h	2015-03-12 13:52:35 +0000
+++ plugins/Ubuntu/Gestures/TouchGate.h	2015-04-15 20:21:35 +0000
@@ -45,6 +45,8 @@
     Q_PROPERTY(QQuickItem* targetItem READ targetItem WRITE setTargetItem NOTIFY targetItemChanged)
 
 public:
+    TouchGate(QQuickItem *parent = nullptr);
+
     bool event(QEvent *e) override;
 
     QQuickItem *targetItem() { return m_dispatcher.targetItem(); }
@@ -55,31 +57,42 @@
 
 protected:
     void touchEvent(QTouchEvent *event) override;
+
+private Q_SLOTS:
+    void onEnabledChanged();
+
 private:
+    void reset();
+
     class TouchEvent {
     public:
-        TouchEvent(const QTouchEvent *event);
+        TouchEvent(QTouchDevice *device,
+            Qt::KeyboardModifiers modifiers,
+            const QList<QTouchEvent::TouchPoint> &touchPoints,
+            QWindow *window,
+            ulong timestamp);
 
         bool removeTouch(int touchId);
 
-        QEvent::Type eventType;
         QTouchDevice *device;
         Qt::KeyboardModifiers modifiers;
         QList<QTouchEvent::TouchPoint> touchPoints;
-        QQuickItem *target;
         QWindow *window;
         ulong timestamp;
     };
 
     void touchOwnershipEvent(TouchOwnershipEvent *event);
     bool isTouchPointOwned(int touchId) const;
-    void storeTouchEvent(const QTouchEvent *event);
+    void storeTouchEvent(QTouchDevice *device,
+            Qt::KeyboardModifiers modifiers,
+            const QList<QTouchEvent::TouchPoint> &touchPoints,
+            QWindow *window,
+            ulong timestamp);
     void removeTouchFromStoredEvents(int touchId);
     void dispatchFullyOwnedEvents();
     bool eventIsFullyOwned(const TouchEvent &event) const;
 
     void dispatchTouchEventToTarget(const TouchEvent &event);
-    void dispatchTouchEventToTarget(QTouchEvent* event);
 
     void removeTouchInfoForEndedTouches(const QList<QTouchEvent::TouchPoint> &touchPoints);
 

=== modified file 'qml/Components/DragHandle.qml'
--- qml/Components/DragHandle.qml	2014-12-05 17:06:36 +0000
+++ qml/Components/DragHandle.qml	2015-04-15 20:21:35 +0000
@@ -43,16 +43,8 @@
   }
 
  */
-EdgeDragArea {
+DirectionalDragArea {
     id: dragArea
-    objectName: "dragHandle"
-
-    // Disable gesture recognition by default when hinting is used as
-    // it conflicts with the hinting idea.
-    distanceThreshold: hintDisplacement > 0 ? 0 : defaultDistanceThreshold
-    maxSilenceTime: hintDisplacement > 0 ? 60*60*1000 : defaultMaxSilenceTime
-    maxDeviation: hintDisplacement > 0 ? 999999 : defaultMaxDeviation
-    compositionTime: hintDisplacement > 0 ? 0 : defaultCompositionTime
 
     property bool stretch: false
 
@@ -68,6 +60,9 @@
     }
 
     property real hintDisplacement: 0
+
+    immediateRecognition: hintDisplacement > 0
+
     property var overrideStartValue: undefined
     SmoothedAnimation {
         id: hintingAnimation
@@ -98,7 +93,6 @@
     // Private stuff
     QtObject {
         id: d
-        property var previousStatus: DirectionalDragArea.WaitingForTouch
         property real startValue
         property real minValue: {
             if (direction == Direction.Horizontal) {
@@ -183,7 +177,7 @@
     }
 
     onDistanceChanged: {
-        if (status === DirectionalDragArea.Recognized) {
+        if (dragging) {
             // don't go the whole distance in order to smooth out the movement
             var step = distance * 0.3;
 
@@ -193,31 +187,22 @@
         }
     }
 
-    onStatusChanged: {
-        if (status === DirectionalDragArea.WaitingForTouch) {
+    onDraggingChanged: {
+        if (dragging) {
+            dragEvaluator.reset();
+            if (overrideStartValue !== undefined) {
+                d.startValue = overrideStartValue;
+            } else {
+                d.startValue = parent[d.targetProp];
+            }
+
+            if (hintDisplacement > 0) {
+                hintingAnimation.targetValue = d.startValue;
+                hintingAnimation.start();
+            }
+        } else {
             hintingAnimation.stop();
-            if (d.previousStatus === DirectionalDragArea.Recognized) {
-                d.onFinishedRecognizedGesture();
-            } else /* d.previousStatus === DirectionalDragArea.Undecided */ {
-                // Gesture was rejected.
-                d.rollbackDrag();
-            }
-        } else /* Undecided || Recognized */ {
-            if (d.previousStatus === DirectionalDragArea.WaitingForTouch) {
-                dragEvaluator.reset();
-                if (overrideStartValue !== undefined) {
-                    d.startValue = overrideStartValue;
-                } else {
-                    d.startValue = parent[d.targetProp];
-                }
-
-                if (hintDisplacement > 0) {
-                    hintingAnimation.targetValue = d.startValue;
-                    hintingAnimation.start();
-                }
-            }
+            d.onFinishedRecognizedGesture();
         }
-
-        d.previousStatus = status;
     }
 }

=== removed file 'qml/Components/EdgeDragArea.qml'
--- qml/Components/EdgeDragArea.qml	2014-10-01 13:20:32 +0000
+++ qml/Components/EdgeDragArea.qml	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2013 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-import QtQuick 2.0
-import Ubuntu.Components 0.1
-import Ubuntu.Gestures 0.1
-
-/*
- A DirectionalDragArea wrapper that provides some well-chosen defaults
- for its gesture recognition parameters.
-*/
-DirectionalDragArea {
-
-    // TODO: Re-evaluate those or even the recognition heuristics itself once
-    // we have gesture cancelling/forwarding in place.
-    //
-    // The idea here is that it's better having lax rules than false negatives.
-    // False negatives are very frustrating to the user.
-    maxDeviation: defaultMaxDeviation
-    wideningAngle: defaultWideningAngle
-    distanceThreshold: defaultDistanceThreshold
-    minSpeed: defaultMinSpeed
-    maxSilenceTime: defaultMaxSilenceTime
-    compositionTime: defaultCompositionTime
-
-    readonly property real defaultMaxDeviation: units.gu(3)
-    readonly property real defaultWideningAngle: 50
-    readonly property real defaultDistanceThreshold: units.gu(1.5)
-    // some people were getting false negatives with it enabled.
-    readonly property real defaultMinSpeed: units.gu(0)
-    readonly property int defaultMaxSilenceTime: 200
-    readonly property int defaultCompositionTime: 60
-}

=== modified file 'qml/Dash/Dash.qml'
--- qml/Dash/Dash.qml	2015-04-09 14:00:37 +0000
+++ qml/Dash/Dash.qml	2015-04-15 20:21:35 +0000
@@ -153,7 +153,7 @@
         // (as expected) but would also cause the dash content flickable to move a bit, because
         // that flickable was getting the touch events while overviewDragHandle was still undecided
         // about whether that touch was indeed performing a directional drag gesture.
-        forceNonInteractive: overviewDragHandle.status != DirectionalDragArea.WaitingForTouch
+        forceNonInteractive: overviewDragHandle.dragging
 
         enabled: bottomEdgeController.progress == 0
     }
@@ -330,7 +330,7 @@
         }
     }
 
-    EdgeDragArea {
+    DirectionalDragArea {
         id: overviewDragHandle
         objectName: "overviewDragHandle"
         z: 1
@@ -346,21 +346,14 @@
         height: units.gu(2)
 
         onSceneDistanceChanged: {
-            if (status == DirectionalDragArea.Recognized) {
+            if (dragging) {
                 bottomEdgeController.enableAnimation = false;
                 bottomEdgeController.progress = Math.max(0, Math.min(1, sceneDistance / fullMovement));
             }
         }
 
-        property int previousStatus: -1
-        property int currentStatus: DirectionalDragArea.WaitingForTouch
-
-        onStatusChanged: {
-            previousStatus = currentStatus;
-            currentStatus = status;
-
-            if (status == DirectionalDragArea.WaitingForTouch &&
-                    previousStatus == DirectionalDragArea.Recognized) {
+        onDraggingChanged: {
+            if (!dragging) {
                 bottomEdgeController.enableAnimation = true;
                 bottomEdgeController.progress = (bottomEdgeController.progress > 0.2)  ? 1 : 0;
             }

=== modified file 'qml/Greeter/CoverPage.qml'
--- qml/Greeter/CoverPage.qml	2015-02-17 15:54:17 +0000
+++ qml/Greeter/CoverPage.qml	2015-04-15 20:21:35 +0000
@@ -129,13 +129,14 @@
 
     DragHandle {
         id: dragHandle
+        objectName: "coverPageDragHandle"
         anchors.fill: parent
         anchors.leftMargin: root.dragHandleLeftMargin
         enabled: root.draggable
         direction: Direction.Horizontal
 
-        onDraggingChanged: {
-            if (dragging) {
+        onPressedChanged: {
+            if (pressed) {
                 root.tease();
                 showLabelAnimation.start();
             }

=== modified file 'qml/Launcher/Launcher.qml'
--- qml/Launcher/Launcher.qml	2015-03-12 13:04:36 +0000
+++ qml/Launcher/Launcher.qml	2015-04-15 20:21:35 +0000
@@ -210,7 +210,7 @@
             bottom: parent.bottom
         }
         x: -width
-        visible: root.x > 0 || x > -width || dragArea.status === DirectionalDragArea.Undecided
+        visible: root.x > 0 || x > -width || dragArea.pressed
         model: LauncherModel
 
         property bool animate: true
@@ -272,7 +272,7 @@
         }
     }
 
-    EdgeDragArea {
+    DirectionalDragArea {
         id: dragArea
         objectName: "launcherDragArea"
 
@@ -283,20 +283,11 @@
         width: root.dragAreaWidth
         height: root.height
 
-        onTouchXChanged: {
-            if (status !== DirectionalDragArea.Recognized || launcher.state == "visible")
+        onDistanceChanged: {
+            if (!dragging || launcher.state == "visible")
                 return;
 
-            // When the gesture finally gets recognized, the finger will likely be
-            // reasonably far from the edge. If we made the panel immediately
-            // follow the finger position it would be visually unpleasant as it
-            // would appear right next to the user's finger out of nowhere.
-            // Instead, we make the panel go towards the user's finger in several
-            // steps. ie., in an animated way.
-            var targetPanelX = Math.min(0, touchX - panel.width) - root.x
-            var delta = targetPanelX - panel.x
-            // the trick is not to go all the way (1.0) as it would cause a sudden jump
-            panel.x += 0.4 * delta
+            panel.x = -panel.width + Math.min(Math.max(0, distance), panel.width);
         }
 
         onDraggingChanged: {
@@ -306,7 +297,8 @@
                     if (distance > minimizeDistance) {
                         root.dash();
                     }
-                } else {
+                } else if (root.state === "") {
+                    // didn't drag far enough. rollback
                     root.switchToNextState("")
                 }
             }

=== modified file 'qml/Panel/IndicatorsMenu.qml'
--- qml/Panel/IndicatorsMenu.qml	2015-04-02 15:29:10 +0000
+++ qml/Panel/IndicatorsMenu.qml	2015-04-15 20:21:35 +0000
@@ -186,9 +186,18 @@
         enabled: !root.shown && root.available
         autoCompleteDragThreshold: maxTotalDragDistance / 2
         stretch: true
-        distanceThreshold: enableHint ? 0 : minimizedPanelHeight
 
-        onTapped: showTapped(Qt.point(touchSceneX, touchSceneY));
+        onPressedChanged: {
+            if (pressed) {
+                touchPressTime = new Date().getTime();
+            } else {
+                var touchReleaseTime = new Date().getTime();
+                if (touchReleaseTime - touchPressTime <= 300) {
+                    root.showTapped(Qt.point(touchSceneX, touchSceneY));
+                }
+            }
+        }
+        property var touchPressTime
 
         // using hint regulates minimum to hint displacement, but in fullscreen mode, we need to do it manually.
         overrideStartValue: enableHint ? minimizedPanelHeight : expandedPanelHeight + handle.height
@@ -204,6 +213,7 @@
 
     DragHandle {
         id: __hideDragHandle
+        objectName: "hideDragHandle"
         anchors.fill: handle
         direction: Direction.Upwards
         enabled: root.shown && root.available

=== modified file 'qml/Stages/PhoneStage.qml'
--- qml/Stages/PhoneStage.qml	2015-02-18 18:29:03 +0000
+++ qml/Stages/PhoneStage.qml	2015-04-15 20:21:35 +0000
@@ -146,14 +146,13 @@
         id: spreadView
         objectName: "spreadView"
         anchors.fill: parent
-        interactive: (spreadDragArea.status == DirectionalDragArea.Recognized || phase > 1)
-                     && draggedDelegateCount === 0
+        interactive: (spreadDragArea.dragging || phase > 1) && draggedDelegateCount === 0
         contentWidth: spreadRow.width - shift
         contentX: -shift
 
         // This indicates when the spreadView is active. That means, all the animations
         // are activated and tiles need to line up for the spread.
-        readonly property bool active: shiftedContentX > 0 || spreadDragArea.status === DirectionalDragArea.Recognized || !root.focusFirstApp
+        readonly property bool active: shiftedContentX > 0 || spreadDragArea.dragging || !root.focusFirstApp
 
         // The flickable needs to fill the screen in order to get touch events all over.
         // However, we don't want to the user to be able to scroll back all the way. For
@@ -450,7 +449,7 @@
         }
     }
 
-    EdgeDragArea {
+    DirectionalDragArea {
         id: spreadDragArea
         objectName: "spreadDragArea"
         direction: Direction.Leftwards
@@ -462,59 +461,50 @@
         property var gesturePoints: new Array()
 
         onTouchXChanged: {
-            if (!dragging) {
-                // Initial touch. Let's reset the spreadView to the starting position.
-                spreadView.phase = 0;
-                spreadView.contentX = -spreadView.shift;
-            }
-            if (dragging && status == DirectionalDragArea.Recognized) {
+            if (dragging) {
                 // Gesture recognized. Let's move the spreadView with the finger
                 var dragX = Math.min(touchX + width, width); // Prevent dragging rightwards
                 dragX = -dragX + spreadDragArea.width - spreadView.shift;
                 // Don't allow dragging further than the animation crossing with phase2's animation
                 var maxMovement =  spreadView.width * spreadView.positionMarker4 - spreadView.shift;
+
                 spreadView.contentX = Math.min(dragX, maxMovement);
+            } else {
+                // Initial touch. Let's reset the spreadView to the starting position.
+                spreadView.phase = 0;
+                spreadView.contentX = -spreadView.shift;
             }
+
             gesturePoints.push(touchX);
         }
 
-        property int previousStatus: -1
-        property int currentStatus: DirectionalDragArea.WaitingForTouch
-
-        onStatusChanged: {
-            previousStatus = currentStatus;
-            currentStatus = status;
-        }
-
         onDraggingChanged: {
             if (dragging) {
                 // A potential edge-drag gesture has started. Start recording it
                 gesturePoints = [];
-                return;
-            }
-
-            // Ok. The user released. Find out if it was a one-way movement.
-            var oneWayFlick = true;
-            var smallestX = spreadDragArea.width;
-            for (var i = 0; i < gesturePoints.length; i++) {
-                if (gesturePoints[i] >= smallestX) {
-                    oneWayFlick = false;
-                    break;
-                }
-                smallestX = gesturePoints[i];
-            }
-            gesturePoints = [];
-
-            if (previousStatus == DirectionalDragArea.Recognized &&
-                oneWayFlick && spreadView.shiftedContentX > units.gu(2) &&
-                    spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
-                // If it was a short one-way movement, do the Alt+Tab switch
-                // no matter if we didn't cross positionMarker1 yet.
-                spreadView.snapTo(1);
-            } else if (!dragging) {
-                // otherwise snap to the closest snap position we can find
-                // (might be back to start, to app 1 or to spread)
-                spreadView.snap();
+            } else {
+                // Ok. The user released. Find out if it was a one-way movement.
+                var oneWayFlick = true;
+                var smallestX = spreadDragArea.width;
+                for (var i = 0; i < gesturePoints.length; i++) {
+                    if (gesturePoints[i] >= smallestX) {
+                        oneWayFlick = false;
+                        break;
+                    }
+                    smallestX = gesturePoints[i];
+                }
+                gesturePoints = [];
+
+                if (oneWayFlick && spreadView.shiftedContentX > units.gu(2) &&
+                        spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
+                    // If it was a short one-way movement, do the Alt+Tab switch
+                    // no matter if we didn't cross positionMarker1 yet.
+                    spreadView.snapTo(1);
+                } else if (!dragging) {
+                    // otherwise snap to the closest snap position we can find
+                    // (might be back to start, to app 1 or to spread)
+                    spreadView.snap();
+                }
             }
         }
     }

=== modified file 'qml/Stages/TabletStage.qml'
--- qml/Stages/TabletStage.qml	2015-02-02 16:28:03 +0000
+++ qml/Stages/TabletStage.qml	2015-04-15 20:21:35 +0000
@@ -170,8 +170,7 @@
     Flickable {
         id: spreadView
         anchors.fill: parent
-        interactive: (spreadDragArea.status == DirectionalDragArea.Recognized || phase > 1)
-                     && draggedDelegateCount === 0
+        interactive: (spreadDragArea.dragging || phase > 1) && draggedDelegateCount === 0
         contentWidth: spreadRow.width - shift
         contentX: -shift
 
@@ -598,7 +597,7 @@
         }
     }
 
-    EdgeDragArea {
+    DirectionalDragArea {
         id: spreadDragArea
         anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
         width: root.dragAreaWidth
@@ -624,26 +623,25 @@
             if (dragging) {
                 // Gesture recognized. Start recording this gesture
                 gesturePoints = [];
-                return;
-            }
-
-            // Ok. The user released. Find out if it was a one-way movement.
-            var oneWayFlick = priv.evaluateOneWayFlick(gesturePoints);
-            gesturePoints = [];
-
-            if (oneWayFlick && spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
-                // If it was a short one-way movement, do the Alt+Tab switch
-                // no matter if we didn't cross positionMarker1 yet.
-                spreadView.snapTo(spreadView.nextInStack);
-            } else if (!dragging) {
-                if (spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker1) {
-                    spreadView.snap();
-                } else if (spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker2) {
+            } else {
+                // Ok. The user released. Find out if it was a one-way movement.
+                var oneWayFlick = priv.evaluateOneWayFlick(gesturePoints);
+                gesturePoints = [];
+
+                if (oneWayFlick && spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
+                    // If it was a short one-way movement, do the Alt+Tab switch
+                    // no matter if we didn't cross positionMarker1 yet.
                     spreadView.snapTo(spreadView.nextInStack);
                 } else {
-                    // otherwise snap to the closest snap position we can find
-                    // (might be back to start, to app 1 or to spread)
-                    spreadView.snap();
+                    if (spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker1) {
+                        spreadView.snap();
+                    } else if (spreadView.shiftedContentX < spreadView.width * spreadView.positionMarker2) {
+                        spreadView.snapTo(spreadView.nextInStack);
+                    } else {
+                        // otherwise snap to the closest snap position we can find
+                        // (might be back to start, to app 1 or to spread)
+                        spreadView.snap();
+                    }
                 }
             }
         }

=== modified file 'qml/Tutorial/TutorialBottom.qml'
--- qml/Tutorial/TutorialBottom.qml	2015-02-01 22:39:25 +0000
+++ qml/Tutorial/TutorialBottom.qml	2015-04-15 20:21:35 +0000
@@ -73,7 +73,7 @@
         ]
     }
 
-    EdgeDragArea {
+    DirectionalDragArea {
         id: dragArea
         direction: Direction.Upwards
         anchors {

=== modified file 'tests/libs/UbuntuGestures/tst_TouchRegistry.cpp'
--- tests/libs/UbuntuGestures/tst_TouchRegistry.cpp	2014-10-01 13:20:32 +0000
+++ tests/libs/UbuntuGestures/tst_TouchRegistry.cpp	2015-04-15 20:21:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-2015 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -66,6 +66,7 @@
     void candidatesAndWatchers_2();
     void rejectingTouchfterItsEnd();
     void removeOldUndecidedCandidates();
+    void interimOwnerWontGetUnownedTouchEvents();
 };
 
 void tst_TouchRegistry::requestWithNoCandidates()
@@ -742,7 +743,7 @@
 
     // Simulate that enough time has passed to cause the CandidateInactivityTimer to timeout,
     // making TouchRegistry consider that undecidedCantidate defaulted.
-    fakeTimerFactory->makeRunningTimersTimeout();
+    fakeTimerFactory->updateTime(10000);
 
     QVERIFY(undecidedCandidate.ownedTouches.isEmpty());
     QVERIFY(undecidedCandidate.lostTouches.contains(0));
@@ -752,6 +753,71 @@
     delete touchRegistry;
 }
 
+/*
+    An item that calls requestTouchOwnership() without first having called addCandidateOwnerForTouch()
+    is assumed to be the interim owner of the touch point, thus there's no point in sending
+    UnownedTouchEvents to him as he already gets proper QTouchEvents from QQuickWindow because
+    he didn't ignore the first QTouchEvent with that touch point.
+ */
+void tst_TouchRegistry::interimOwnerWontGetUnownedTouchEvents()
+{
+    FakeTimerFactory *fakeTimerFactory = new FakeTimerFactory;
+    TouchRegistry *touchRegistry = new TouchRegistry(nullptr, fakeTimerFactory);
+
+    DummyCandidate undecidedCandidate;
+    undecidedCandidate.setObjectName("undecided");
+
+    DummyCandidate interimOwner;
+    interimOwner.setObjectName("interimOwner");
+
+    {
+        QList<QTouchEvent::TouchPoint> touchPoints;
+        touchPoints.append(QTouchEvent::TouchPoint(0));
+        touchPoints[0].setState(Qt::TouchPointPressed);
+        QTouchEvent touchEvent(QEvent::TouchBegin,
+                               0 /* device */,
+                               Qt::NoModifier,
+                               Qt::TouchPointPressed,
+                               touchPoints);
+        touchRegistry->update(&touchEvent);
+    }
+
+    touchRegistry->addCandidateOwnerForTouch(0, &undecidedCandidate);
+    touchRegistry->requestTouchOwnership(0, &interimOwner);
+
+    {
+        QList<QTouchEvent::TouchPoint> touchPoints;
+        touchPoints.append(QTouchEvent::TouchPoint(0));
+        touchPoints[0].setState(Qt::TouchPointMoved);
+        QTouchEvent touchEvent(QEvent::TouchUpdate,
+                               0 /* device */,
+                               Qt::NoModifier,
+                               Qt::TouchPointMoved,
+                               touchPoints);
+        touchRegistry->update(&touchEvent);
+    }
+
+    QCOMPARE(undecidedCandidate.unownedTouchEvents.count(), 1);
+    QCOMPARE(interimOwner.unownedTouchEvents.count(), 0);
+
+    {
+        QList<QTouchEvent::TouchPoint> touchPoints;
+        touchPoints.append(QTouchEvent::TouchPoint(0));
+        touchPoints[0].setState(Qt::TouchPointMoved);
+        QTouchEvent touchEvent(QEvent::TouchUpdate,
+                               0 /* device */,
+                               Qt::NoModifier,
+                               Qt::TouchPointMoved,
+                               touchPoints);
+        touchRegistry->update(&touchEvent);
+    }
+
+    QCOMPARE(undecidedCandidate.unownedTouchEvents.count(), 2);
+    QCOMPARE(interimOwner.unownedTouchEvents.count(), 0);
+
+    delete touchRegistry;
+}
+
 ////////////// TouchMemento //////////
 
 TouchMemento::TouchMemento(const QTouchEvent *touchEvent)

=== modified file 'tests/plugins/Ubuntu/Gestures/CMakeLists.txt'
--- tests/plugins/Ubuntu/Gestures/CMakeLists.txt	2014-10-17 11:01:53 +0000
+++ tests/plugins/Ubuntu/Gestures/CMakeLists.txt	2015-04-15 20:21:35 +0000
@@ -19,6 +19,7 @@
 )
 
 add_definitions(-DUBUNTU_GESTURES_PLUGIN_DIR="${CMAKE_BINARY_DIR}/plugins")
+add_definitions(-DTESTS_UTILS_MODULES_DIR="${CMAKE_BINARY_DIR}/tests/utils/modules")
 
 macro(add_gesture_ui_test CLASSNAME)
     add_executable(${CLASSNAME}TestExec tst_${CLASSNAME}.cpp GestureTest.cpp)
@@ -26,7 +27,8 @@
     target_link_libraries(${CLASSNAME}TestExec UbuntuGesturesQml UbuntuGestures)
 
     add_binary_qml_test(${CLASSNAME} ${CMAKE_BINARY_DIR}/plugins/Ubuntu/Gestures UbuntuGesturesTestQmlFiles "")
-    add_manual_qml_test(. ${CLASSNAME} IMPORT_PATHS ${CMAKE_BINARY_DIR}/plugins)
+    add_manual_qml_test(. ${CLASSNAME} IMPORT_PATHS ${CMAKE_BINARY_DIR}/plugins
+                                                    ${CMAKE_BINARY_DIR}/tests/utils/modules)
 endmacro(add_gesture_ui_test)
 
 macro(add_gesture_test CLASSNAME)

=== modified file 'tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml'
--- tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml	2014-02-11 20:21:24 +0000
+++ tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml	2015-04-15 20:21:35 +0000
@@ -37,8 +37,8 @@
 
     Rectangle {
         id: dragAreaRect
-        color: "yellow"
-        opacity: 0.0
+        opacity: dragArea.dragging ? 0.5 : 0.0
+        color: "green"
         anchors.fill: dragArea
     }
 
@@ -49,24 +49,10 @@
         height: units.gu(5)
 
         direction: Direction.Downwards
-        maxDeviation: units.gu(2)
-        wideningAngle: 10
-        distanceThreshold: units.gu(4)
 
-        onStatusChanged: {
-            switch (status) {
-                case DirectionalDragArea.WaitingForTouch:
-                    dragAreaRect.opacity = 0.0
-                    break;
-                case DirectionalDragArea.Undecided:
-                    dragAreaRect.color = "yellow"
-                    dragAreaRect.opacity = 0.3
-                    launcher.y = Qt.binding(launcher.followDragArea)
-                    break;
-                default: // DirectionalDragArea.Recognized:
-                    dragAreaRect.color = "green"
-                    dragAreaRect.opacity = 0.5
-                    break;
+        onDraggingChanged: {
+            if (dragging) {
+                launcher.y = Qt.binding(launcher.followDragArea)
             }
         }
 

=== modified file 'tests/plugins/Ubuntu/Gestures/GestureTest.cpp'
--- tests/plugins/Ubuntu/Gestures/GestureTest.cpp	2014-11-03 15:21:46 +0000
+++ tests/plugins/Ubuntu/Gestures/GestureTest.cpp	2015-04-15 20:21:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013,2015 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,8 +21,11 @@
 #include <QQuickView>
 #include <QtTest>
 
+#include <Timer.h>
 #include <TouchRegistry.h>
 
+using namespace UbuntuGestures;
+
 GestureTest::GestureTest(const QString &qmlFilename)
     : QObject(), m_device(nullptr), m_view(nullptr), m_qmlFilename(qmlFilename)
 {
@@ -40,14 +43,17 @@
 void GestureTest::init()
 {
     m_view = new QQuickView;
-    m_view->setResizeMode(QQuickView::SizeViewToRootObject);
+    m_view->setResizeMode(QQuickView::SizeRootObjectToView);
     m_view->engine()->addImportPath(QStringLiteral(UBUNTU_GESTURES_PLUGIN_DIR));
+    m_view->engine()->addImportPath(QStringLiteral(TESTS_UTILS_MODULES_DIR));
     m_view->setSource(QUrl::fromLocalFile(m_qmlFilename));
     m_view->show();
     QVERIFY(QTest::qWaitForWindowExposed(m_view));
     QVERIFY(m_view->rootObject() != 0);
 
-    m_touchRegistry = new TouchRegistry;
+    m_fakeTimerFactory = new FakeTimerFactory;
+
+    m_touchRegistry = new TouchRegistry(nullptr, m_fakeTimerFactory);
     m_view->installEventFilter(m_touchRegistry);
 
     qApp->processEvents();
@@ -59,6 +65,10 @@
     delete m_touchRegistry;
     m_touchRegistry = nullptr;
 
+    // TouchRegistry will take down the timer factory along with him
+    // delete m_fakeTimerFactory;
+    m_fakeTimerFactory = nullptr;
+
     delete m_view;
     m_view = nullptr;
 }

=== modified file 'tests/plugins/Ubuntu/Gestures/GestureTest.h'
--- tests/plugins/Ubuntu/Gestures/GestureTest.h	2014-11-03 15:21:46 +0000
+++ tests/plugins/Ubuntu/Gestures/GestureTest.h	2015-04-15 20:21:35 +0000
@@ -23,6 +23,9 @@
 class QQuickView;
 class QTouchDevice;
 
+namespace UbuntuGestures {
+    class FakeTimerFactory;
+}
 class TouchRegistry;
 
 // C++ std lib
@@ -81,6 +84,7 @@
     QTouchDevice *m_device;
     QQuickView *m_view;
     TouchRegistry *m_touchRegistry;
+    UbuntuGestures::FakeTimerFactory *m_fakeTimerFactory;
     QString m_qmlFilename;
 };
 

=== modified file 'tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml'
--- tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml	2014-02-11 20:21:24 +0000
+++ tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml	2015-04-15 20:21:35 +0000
@@ -21,7 +21,7 @@
 Item {
     id: root
 
-    function reset() { launcher.x = root.width }
+    function reset() { launcher.x = Qt.binding(function(){return root.width;}); }
 
     Rectangle {
         id: launcher
@@ -41,7 +41,8 @@
 
     Rectangle {
         id: dragAreaRect
-        opacity: 0.0
+        opacity: dragArea.dragging ? 0.5 : 0.0
+        color: "green"
         anchors.fill: dragArea
     }
 
@@ -52,24 +53,10 @@
         width: units.gu(5)
 
         direction: Direction.Leftwards
-        maxDeviation: units.gu(2)
-        wideningAngle: 10
-        distanceThreshold: units.gu(4)
 
-        onStatusChanged: {
-            switch (status) {
-                case DirectionalDragArea.WaitingForTouch:
-                    dragAreaRect.opacity = 0.0
-                    break;
-                case DirectionalDragArea.Undecided:
-                    dragAreaRect.color = "yellow"
-                    dragAreaRect.opacity = 0.3
-                    launcher.x = Qt.binding(launcher.followDragArea)
-                    break;
-                default: //case DirectionalDragArea.Recognized:
-                    dragAreaRect.color = "green"
-                    dragAreaRect.opacity = 0.5
-                    break;
+        onDraggingChanged: {
+            if (dragging) {
+                launcher.x = Qt.binding(launcher.followDragArea)
             }
         }
 

=== modified file 'tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml'
--- tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml	2014-10-01 13:20:32 +0000
+++ tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml	2015-04-15 20:21:35 +0000
@@ -38,7 +38,8 @@
 
     Rectangle {
         id: dragAreaRect
-        opacity: 0.0
+        opacity: dragArea.dragging ? 0.5 : 0.0
+        color: "green"
         anchors.fill: dragArea
     }
 
@@ -52,25 +53,10 @@
         width: units.gu(5)
 
         direction: Direction.Rightwards
-        maxDeviation: units.gu(2)
-        wideningAngle: 10
-        distanceThreshold: units.gu(4)
-        minSpeed: 50
 
-        onStatusChanged: {
-            switch (status) {
-                case DirectionalDragArea.WaitingForTouch:
-                    dragAreaRect.opacity = 0.0
-                    break;
-                case DirectionalDragArea.Undecided:
-                    dragAreaRect.color = "yellow"
-                    dragAreaRect.opacity = 0.3
-                    launcher.x = Qt.binding(launcher.followDragArea)
-                    break;
-                default: //case DirectionalDragArea.Recognized:
-                    dragAreaRect.color = "green"
-                    dragAreaRect.opacity = 0.5
-                    break;
+        onDraggingChanged: {
+            if (dragging) {
+                launcher.x = Qt.binding(launcher.followDragArea)
             }
         }
 

=== modified file 'tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml'
--- tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml	2014-02-11 20:21:24 +0000
+++ tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml	2015-04-15 20:21:35 +0000
@@ -21,7 +21,7 @@
 Item {
     id: root
 
-    function reset() { launcher.y = root.height }
+    function reset() { launcher.y = Qt.binding(function(){return root.height;}); }
 
     Rectangle {
         id: launcher
@@ -41,7 +41,8 @@
 
     Rectangle {
         id: dragAreaRect
-        opacity: 0.0
+        opacity: dragArea.dragging ? 0.5 : 0.0
+        color: "green"
         anchors.fill: dragArea
     }
 
@@ -52,24 +53,10 @@
         height: units.gu(5)
 
         direction: Direction.Upwards
-        maxDeviation: units.gu(2)
-        wideningAngle: 10
-        distanceThreshold: units.gu(4)
 
-        onStatusChanged: {
-            switch (status) {
-                case DirectionalDragArea.WaitingForTouch:
-                    dragAreaRect.opacity = 0.0
-                    break;
-                case DirectionalDragArea.Undecided:
-                    dragAreaRect.color = "yellow"
-                    dragAreaRect.opacity = 0.3
-                    launcher.y = Qt.binding(launcher.followDragArea)
-                    break;
-                default: //case DirectionalDragArea.Recognized:
-                    dragAreaRect.color = "green"
-                    dragAreaRect.opacity = 0.5
-                    break;
+        onDraggingChanged: {
+            if (dragging) {
+                launcher.y = Qt.binding(launcher.followDragArea)
             }
         }
 

=== modified file 'tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp'
--- tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp	2015-02-18 13:51:39 +0000
+++ tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp	2015-04-15 20:21:35 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 Canonical, Ltd.
+ * Copyright (C) 2013-2015 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,51 +20,38 @@
 #include <QtQml/QQmlEngine>
 #include <QPointer>
 #include <private/qquickmousearea_p.h>
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
-    #include <private/qquickwindow_p.h>
-#endif
+#include <private/qquickwindow_p.h>
 
 
 #include <DirectionalDragArea.h>
+#include <DirectionalDragArea_p.h>
 #include <TouchRegistry.h>
 
 #include "GestureTest.h"
 
 using namespace UbuntuGestures;
 
-
-class ComplexFakeTimer : public FakeTimer
-{
+// Because QSignalSpy(directionalDragArea, SIGNAL(DirectionalDragArea::Status)) simply
+// doesn't work
+class StatusSpy : public QObject {
     Q_OBJECT
 public:
-    ComplexFakeTimer(const SharedTimeSource &timeSource, QObject *parent = 0)
-        : FakeTimer(parent),
-          m_timeSource(timeSource)
-    {}
-
-    void start() override {
-        AbstractTimer::start();
-        m_nextTimeoutTime = m_timeSource->msecsSinceReference() + (qint64)interval();
-    }
-
-    void emitTimeout() {
-        m_nextTimeoutTime += interval();
-        Q_EMIT timeout();
-    }
-
-    qint64 nextTimeoutTime() const { return m_nextTimeoutTime; }
+    StatusSpy(DirectionalDragArea *edgeDragArea) {
+        m_recognized = false;
+        connect(edgeDragArea->d, &DirectionalDragAreaPrivate::statusChanged,
+                this, &StatusSpy::onStatusChanged);
+    }
+    bool recognized() {
+        return m_recognized;
+    }
+
+private Q_SLOTS:
+    void onStatusChanged(DirectionalDragAreaPrivate::Status status) {
+        m_recognized |= status == DirectionalDragAreaPrivate::Recognized;
+    }
 
 private:
-    SharedTimeSource m_timeSource;
-    qint64 m_nextTimeoutTime;
-};
-
-class FakeTimeSource : public UbuntuGestures::TimeSource
-{
-public:
-    FakeTimeSource() { m_msecsSinceReference = 0; }
-    virtual qint64 msecsSinceReference() {return m_msecsSinceReference;}
-    qint64 m_msecsSinceReference;
+    bool m_recognized;
 };
 
 /*
@@ -98,15 +85,9 @@
     tst_DirectionalDragArea();
 private Q_SLOTS:
     void init(); // called right before each and every test function is executed
-    void cleanup(); // called right after each and every test function is executed
 
-    void edgeDrag();
-    void edgeDrag_data();
     void dragWithShortDirectionChange();
-    void minSpeed();
-    void minSpeed_data();
     void recognitionTimerUsage();
-    void maxSilenceTime();
     void sceneXAndX();
     void sceneYAndY();
     void twoFingerTap();
@@ -122,14 +103,24 @@
     void immediateRecognitionWhenConstraintsDisabled();
     void withdrawTouchOwnershipCandidacyIfDisabledDuringRecognition();
     void withdrawTouchOwnershipCandidacyIfDisabledDuringRecognition_data();
-    void tappedSignal();
-    void tappedSignal_data();
     void gettingTouchOwnershipMakesMouseAreaBehindGetCanceled();
+    void interleavedTouches();
+    void makoRightEdgeDrag();
+    void makoRightEdgeDrag_verticalDownwards();
+    void makoLeftEdgeDrag_slowStart();
+    void makoLeftEdgeDrag_movesSlightlyBackwardsOnStart();
 
 private:
+    // QTest::touchEvent takes QPoint instead of QPointF and I don't want to
+    // lose precision due to rounding.
+    // Besides, those helper functions lead to more compact code.
+    void sendTouchPress(qint64 timestamp, int id, QPointF pos);
+    void sendTouchUpdate(qint64 timestamp, int id, QPointF pos);
+    void sendTouchRelease(qint64 timestamp, int id, QPointF pos);
+    void sendTouch(qint64 timestamp, int id, QPointF pos,
+            Qt::TouchPointState pointState, QEvent::Type eventType);
+
     void passTime(qint64 timeSpanMs);
-    ComplexFakeTimer *fakeTimer;
-    QSharedPointer<FakeTimeSource> fakeTimeSource;
 };
 
 tst_DirectionalDragArea::tst_DirectionalDragArea()
@@ -148,36 +139,49 @@
     m_view->resize(m_view->rootObject()->width(), m_view->rootObject()->height());
     QTRY_COMPARE(m_view->width(), (int)m_view->rootObject()->width());
     QTRY_COMPARE(m_view->height(), (int)m_view->rootObject()->height());
-
-    fakeTimeSource.reset(new FakeTimeSource);
-    fakeTimer = new ComplexFakeTimer(fakeTimeSource);
-}
-
-void tst_DirectionalDragArea::cleanup()
-{
-    delete fakeTimer;
-    fakeTimer = 0;
-
-    fakeTimeSource.reset();
-
-    GestureTest::cleanup();
+}
+
+void tst_DirectionalDragArea::sendTouchPress(qint64 timestamp, int id, QPointF pos)
+{
+    sendTouch(timestamp, id, pos, Qt::TouchPointPressed, QEvent::TouchBegin);
+}
+
+void tst_DirectionalDragArea::sendTouchUpdate(qint64 timestamp, int id, QPointF pos)
+{
+    sendTouch(timestamp, id, pos, Qt::TouchPointMoved, QEvent::TouchUpdate);
+}
+
+void tst_DirectionalDragArea::sendTouchRelease(qint64 timestamp, int id, QPointF pos)
+{
+    sendTouch(timestamp, id, pos, Qt::TouchPointReleased, QEvent::TouchEnd);
+}
+
+void tst_DirectionalDragArea::sendTouch(qint64 timestamp, int id, QPointF pos,
+                                 Qt::TouchPointState pointState, QEvent::Type eventType)
+{
+    m_fakeTimerFactory->updateTime(timestamp);
+
+    QTouchEvent::TouchPoint point;
+
+    point.setState(pointState);
+    point.setId(id);
+    point.setScenePos(pos);
+    point.setPos(pos);
+
+    QList<QTouchEvent::TouchPoint> points;
+    points << point;
+
+    QTouchEvent touchEvent(eventType, m_device, Qt::NoModifier, Qt::TouchPointPressed, points);
+    QCoreApplication::sendEvent(m_view, &touchEvent);
+
+    QQuickWindowPrivate *windowPrivate = QQuickWindowPrivate::get(m_view);
+    windowPrivate->flushDelayedTouchEvent();
 }
 
 void tst_DirectionalDragArea::passTime(qint64 timeSpanMs)
 {
-    qint64 finalTime = fakeTimeSource->m_msecsSinceReference + timeSpanMs;
-
-    if (fakeTimer->isRunning() && finalTime >= fakeTimer->nextTimeoutTime()) {
-        fakeTimeSource->m_msecsSinceReference = fakeTimer->nextTimeoutTime();
-        fakeTimer->emitTimeout();
-
-        qint64 timeSpanRemainder = finalTime - fakeTimeSource->m_msecsSinceReference;
-        if (timeSpanRemainder > 0) {
-            passTime(timeSpanRemainder);
-        }
-    } else {
-        fakeTimeSource->m_msecsSinceReference = finalTime;
-    }
+    qint64 finalTime = m_fakeTimerFactory->timeSource()->msecsSinceReference() + timeSpanMs;
+    m_fakeTimerFactory->updateTime(finalTime);
 }
 
 namespace {
@@ -186,147 +190,6 @@
     QPointF localCenter(edgeDragArea->width() / 2., edgeDragArea->height() / 2.);
     return edgeDragArea->mapToScene(localCenter);
 }
-
-QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea,
-                                 qreal wideningAngleMultiplier)
-{
-    qreal angleRadians = edgeDragArea->wideningAngle() * wideningAngleMultiplier
-        * M_PI / 180.0;
-
-    qreal angleCos = qCos(angleRadians);
-    qreal angleSin = qSin(angleRadians);
-
-    switch (edgeDragArea->direction()) {
-        case Direction::Upwards:
-            return QPointF(angleSin, -angleCos);
-        case Direction::Downwards:
-            return QPointF(angleSin, angleCos);
-        case Direction::Leftwards:
-            return QPointF(-angleCos, angleSin);
-        default: // Direction::Rightwards:
-            return QPointF(angleCos, angleSin);
-    }
-}
-
-QPointF createTouchDeviation(DirectionalDragArea *edgeDragArea)
-{
-    qreal deviation = edgeDragArea->maxDeviation() * 0.8;
-
-    if (Direction::isHorizontal(edgeDragArea->direction())) {
-        return QPointF(0, deviation);
-    } else {
-        return QPointF(deviation, 0);
-    }
-}
-}
-
-void tst_DirectionalDragArea::edgeDrag()
-{
-    QFETCH(QString, dragAreaObjectName);
-    QFETCH(qreal, wideningAngleMultiplier);
-    QFETCH(qreal, dragDistanceFactor);
-    QFETCH(bool, expectGestureRecognition);
-
-    DirectionalDragArea *edgeDragArea =
-        m_view->rootObject()->findChild<DirectionalDragArea*>(dragAreaObjectName);
-    QVERIFY(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
-
-    QSignalSpy draggingSpy(edgeDragArea, SIGNAL(draggingChanged(bool)));
-
-    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
-    QPointF touchPoint = initialTouchPos;
-
-    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*dragDistanceFactor;
-    QPointF dragDirectionVector = calculateDirectionVector(edgeDragArea,
-                                                           wideningAngleMultiplier);
-    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
-    QPointF touchMovement = dragDirectionVector * movementStepDistance;
-    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
-    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
-
-    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
-
-    QCOMPARE(draggingSpy.count(), 1);
-    QCOMPARE(edgeDragArea->dragging(), true);
-
-    if (wideningAngleMultiplier > 0) {
-        // go close to the border of the valid area for this touch point
-        // in order to make it easier to leave it by dragging at an angle
-        // slightly bigger than the widening angle
-        touchPoint += createTouchDeviation(edgeDragArea);
-        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
-    }
-
-    for (int i = 0; i < totalMovementSteps; ++i) {
-        touchPoint += touchMovement;
-        passTime(movementTimeStepMs);
-        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
-    }
-
-    if (expectGestureRecognition)
-        QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
-
-    if (edgeDragArea->status() == DirectionalDragArea::WaitingForTouch) {
-        QCOMPARE(edgeDragArea->dragging(), false);
-        QCOMPARE(draggingSpy.count(), 2);
-    }
-
-    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
-
-    QCOMPARE(draggingSpy.count(), 2);
-    QCOMPARE(edgeDragArea->dragging(), false);
-}
-
-void tst_DirectionalDragArea::edgeDrag_data()
-{
-    QTest::addColumn<QString>("dragAreaObjectName");
-    QTest::addColumn<qreal>("wideningAngleMultiplier");
-    QTest::addColumn<qreal>("dragDistanceFactor");
-    QTest::addColumn<bool>("expectGestureRecognition");
-
-    QTest::newRow("rightwards, tiny drag")
-        << "hpDragArea" << 0.0 << 0.2 << false;
-
-    QTest::newRow("rightwards, straight drag")
-        << "hpDragArea" << 0.0 << 3.0 << true;
-
-    QTest::newRow("rightwards, diagonal drag")
-        << "hpDragArea" << 0.9 << 3.0 << true;
-
-    QTest::newRow("rightwards, overly diagonal drag")
-        << "hpDragArea" << 2.0 << 3.0 << false;
-
-    QTest::newRow("leftwards, tiny drag")
-        << "hnDragArea" << 0.0 << 0.2 << false;
-
-    QTest::newRow("leftwards, straight drag")
-        << "hnDragArea" << 0.0 << 3.0 << true;
-
-    QTest::newRow("leftwards, diagonal drag")
-        << "hnDragArea" << 0.9 << 3.0 << true;
-
-    QTest::newRow("downwards, tiny drag")
-        << "vpDragArea" << 0.0 << 0.2 << false;
-
-    QTest::newRow("downwards, straight drag")
-        << "vpDragArea" << 0.0 << 3.0 << true;
-
-    QTest::newRow("downwards, diagonal drag")
-        << "vpDragArea" << 0.9 << 3.0 << true;
-
-    QTest::newRow("upwards, tiny drag")
-        << "vnDragArea" << 0.0 << 0.2 << false;
-
-    QTest::newRow("upwards, straight drag")
-        << "vnDragArea" << 0.0 << 3.0 << true;
-
-    QTest::newRow("upwards, diagonal drag")
-        << "vnDragArea" << 0.9 << 3.0 << true;
-
-    QTest::newRow("upwards, overly diagonal drag")
-        << "vnDragArea" << 2.0 << 3.0 << false;
 }
 
 /*
@@ -339,17 +202,17 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     QVERIFY(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
-    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0;
+    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0;
     QPointF dragDirectionVector(1.0, 0.0);
-    qreal touchStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
-    // make sure we are above minimum speed
-    int touchStepTimeMs = (touchStepDistance / (edgeDragArea->minSpeed() * 5.0f)) * 1000.0f;
+    qreal touchStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
+    // make sure we are above maximum time
+    int touchStepTimeMs = edgeDragArea->d->maxTime / 20. ;
     QPointF touchMovement = dragDirectionVector * touchStepDistance;
 
     QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
@@ -373,66 +236,14 @@
         passTime(touchStepTimeMs);
         QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
     } while ((touchPoint - initialTouchPos).manhattanLength() < desiredDragDistance
-            || fakeTimeSource->m_msecsSinceReference < (edgeDragArea->compositionTime() * 1.5f));
+            || m_fakeTimerFactory->timeSource()->msecsSinceReference() < (edgeDragArea->d->compositionTime * 1.5f));
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
 
     QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
 }
 
 /*
-   Checks that a gesture will be rejected if it's slower than minSpeed while
-   status is Undecided.
- */
-void tst_DirectionalDragArea::minSpeed()
-{
-    QFETCH(qreal, minSpeed);
-    QFETCH(qreal, speed);
-    QFETCH(int, expectedStatusAfterSpeedCheck);
-
-    DirectionalDragArea *edgeDragArea =
-        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
-    QVERIFY(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
-
-    // A really long, unattainable, number. We don't want it getting recognized before
-    // the speed checks we want have been performed
-    edgeDragArea->setDistanceThreshold(500000);
-
-    edgeDragArea->setMinSpeed(minSpeed);
-
-    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
-    QPointF touchPoint = initialTouchPos;
-
-    QPointF dragDirectionVector(1.0, 0.0);
-    qint64 timeStepMsecs = 10;
-    qreal distanceStep = (speed / 1000.0f) * timeStepMsecs;
-    QPointF touchMovement = dragDirectionVector * distanceStep;
-
-    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
-
-    // Move for a while to ensure our speed check is performed a couple of times
-    for (int i=0; i < 20; ++i) {
-        touchPoint += touchMovement;
-        passTime(timeStepMsecs);
-        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
-    }
-
-    QCOMPARE((int)edgeDragArea->status(), expectedStatusAfterSpeedCheck);
-}
-
-void tst_DirectionalDragArea::minSpeed_data()
-{
-    QTest::addColumn<qreal>("minSpeed");
-    QTest::addColumn<qreal>("speed");
-    QTest::addColumn<int>("expectedStatusAfterSpeedCheck");
-
-    QTest::newRow("slower than minSpeed") << 100.0 << 50.0 << (int)DirectionalDragArea::WaitingForTouch;
-    QTest::newRow("faster than minSpeed") << 100.0 << 150.0 << (int)DirectionalDragArea::Undecided;
-}
-
-/*
     Checks that the recognition timer is started and stopped appropriately.
     I.e., check that it's running only while gesture recognition is taking place
     (status == Undecided)
@@ -442,11 +253,9 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     QVERIFY(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
-
-    // don't let it interfere with our test
-    edgeDragArea->setMinSpeed(0.0);
+    AbstractTimer *fakeTimer = m_fakeTimerFactory->createTimer();
+    edgeDragArea->d->setRecognitionTimer(fakeTimer);
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     int timeStepMs = 5; // some arbitrary small value.
 
@@ -454,63 +263,32 @@
     QPointF touchPoint = initialTouchPos;
 
     QPointF dragDirectionVector(1.0, 0.0);
-    QPointF touchMovement = dragDirectionVector * (edgeDragArea->distanceThreshold() * 0.2f);
+    QPointF touchMovement = dragDirectionVector * (edgeDragArea->d->distanceThreshold * 0.2f);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
     QVERIFY(!fakeTimer->isRunning());
 
     QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
     QVERIFY(fakeTimer->isRunning());
 
     // Move beyond distance threshold and composition time to ensure recognition
-    while (fakeTimeSource->m_msecsSinceReference <= edgeDragArea->compositionTime() ||
-           (touchPoint - initialTouchPos).manhattanLength() <= edgeDragArea->distanceThreshold()) {
+    while (m_fakeTimerFactory->timeSource()->msecsSinceReference() <= edgeDragArea->d->compositionTime ||
+           (touchPoint - initialTouchPos).manhattanLength() <= edgeDragArea->d->distanceThreshold) {
 
-        QCOMPARE(edgeDragArea->status() == DirectionalDragArea::Undecided, fakeTimer->isRunning());
+        QCOMPARE(edgeDragArea->d->status == DirectionalDragAreaPrivate::Undecided, fakeTimer->isRunning());
 
         touchPoint += touchMovement;
         passTime(timeStepMs);
         QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
     }
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
     QVERIFY(!fakeTimer->isRunning());
 }
 
 /*
-    A gesture should be rejected if too much time has passed without any new input
-    events from it.
- */
-void tst_DirectionalDragArea::maxSilenceTime()
-{
-    DirectionalDragArea *edgeDragArea =
-        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
-    QVERIFY(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
-
-    // Make sure this property is not disabled
-    edgeDragArea->setMaxSilenceTime(100);
-
-    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
-    QPointF touchPoint = initialTouchPos;
-
-    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
-
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
-    QVERIFY(fakeTimer->isRunning());
-
-    // Force timer to timeout until after maxSilenceTime has been reached
-    while (fakeTimeSource->m_msecsSinceReference < edgeDragArea->maxSilenceTime()) {
-        passTime(fakeTimer->interval());
-    }
-
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
-}
-
-/*
   Checks that it informs the X coordinate of the touch point in local and scene coordinates
   correctly.
  */
@@ -519,18 +297,19 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");
     QVERIFY(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
+    edgeDragArea->setImmediateRecognition(true);
 
     QPointF touchScenePos(m_view->width() - (edgeDragArea->width()/2.0f), m_view->height()/2.0f);
 
-    QTest::touchEvent(m_view, m_device).press(0, touchScenePos.toPoint());
+    sendTouchPress(0 /* timestamp */, 0 /* id */, touchScenePos);
 
     QSignalSpy touchXSpy(edgeDragArea, SIGNAL(touchXChanged(qreal)));
     QSignalSpy touchSceneXSpy(edgeDragArea, SIGNAL(touchSceneXChanged(qreal)));
 
     touchScenePos.rx() = m_view->width() / 2;
-    QTest::touchEvent(m_view, m_device).move(0, touchScenePos.toPoint());
+    sendTouchUpdate(50 /* timestamp */, 0 /* id */, touchScenePos);
 
     QCOMPARE(touchXSpy.count(), 1);
     QCOMPARE(touchSceneXSpy.count(), 1);
@@ -547,18 +326,19 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("vnDragArea");
     QVERIFY(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
+    edgeDragArea->setImmediateRecognition(true);
 
     QPointF touchScenePos(m_view->width()/2.0f, m_view->height() - (edgeDragArea->height()/2.0f));
 
-    QTest::touchEvent(m_view, m_device).press(0, touchScenePos.toPoint());
+    sendTouchPress(0 /* timestamp */, 0 /* id */, touchScenePos);
 
     QSignalSpy touchYSpy(edgeDragArea, SIGNAL(touchYChanged(qreal)));
     QSignalSpy touchSceneYSpy(edgeDragArea, SIGNAL(touchSceneYChanged(qreal)));
 
     touchScenePos.ry() = m_view->height() / 2;
-    QTest::touchEvent(m_view, m_device).move(0, touchScenePos.toPoint());
+    sendTouchUpdate(50 /* timestamp */, 0 /* id */, touchScenePos);
 
     QCOMPARE(touchYSpy.count(), 1);
     QCOMPARE(touchSceneYSpy.count(), 1);
@@ -577,8 +357,8 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     QVERIFY(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     // Make touches evenly spaced along the edgeDragArea
     QPoint touchAPos(edgeDragArea->width()/2.0f, m_view->height()*0.33f);
@@ -592,7 +372,7 @@
     QTest::touchEvent(m_view, m_device)
         .press(0, touchAPos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
 
     passTime(timeStepMsecs);
     QTest::touchEvent(m_view, m_device)
@@ -601,20 +381,20 @@
 
     // A second touch point appeared during recognition, reject immediately as this
     // can't be a single-touch gesture anymore.
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
     passTime(timeStepMsecs);
     QTest::touchEvent(m_view, m_device)
         .release(0, touchAPos)
         .move(1, touchBPos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
     passTime(timeStepMsecs);
     QTest::touchEvent(m_view, m_device)
         .release(1, touchBPos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
     // Perform the second two-finger tap
 
@@ -622,27 +402,27 @@
     QTest::touchEvent(m_view, m_device)
         .press(0, touchAPos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
 
     passTime(timeStepMsecs);
     QTest::touchEvent(m_view, m_device)
         .move(0, touchAPos)
         .press(1, touchBPos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
     passTime(timeStepMsecs);
     QTest::touchEvent(m_view, m_device)
         .release(0, touchAPos)
         .move(1, touchBPos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
     passTime(timeStepMsecs);
     QTest::touchEvent(m_view, m_device)
         .release(1, touchBPos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 }
 
 /*
@@ -659,25 +439,25 @@
     DirectionalDragArea *edgeDragArea =
         rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");
     Q_ASSERT(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
-    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
+    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
     QPointF dragDirectionVector(1.0f, 0.0f);
 
-    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
+    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
     QPointF touchMovement = dragDirectionVector * movementStepDistance;
     int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
-    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
+    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
     QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
 
     // Move it far ahead along the direction of the gesture
     // rightwardsLauncher is a parent of our DirectionalDragArea. So moving it will move our DDA
-    rightwardsLauncher->setX(rightwardsLauncher->x() + edgeDragArea->distanceThreshold() * 5.0f);
+    rightwardsLauncher->setX(rightwardsLauncher->x() + edgeDragArea->d->distanceThreshold * 5.0f);
 
     for (int i = 0; i < totalMovementSteps; ++i) {
         touchPoint += touchMovement;
@@ -685,7 +465,7 @@
         QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
     }
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
 
     QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
 }
@@ -699,8 +479,8 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     Q_ASSERT(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     // Make touches evenly spaced along the edgeDragArea
     QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()*0.33f);
@@ -708,26 +488,26 @@
 
     QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
 
     // leave it lying around for some time
-    passTime(qMax(edgeDragArea->maxSilenceTime(), edgeDragArea->compositionTime()) * 10);
-
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
-
-    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
+    passTime(edgeDragArea->d->maxTime * 10);
+
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
+
+    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
     QPointF dragDirectionVector(1.0f, 0.0f);
 
-    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
+    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
     QPointF touchMovement = dragDirectionVector * movementStepDistance;
     int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
-    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
+    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
     QTest::touchEvent(m_view, m_device)
         .move(0, touch0Pos)
         .press(1, touch1Pos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
 
     for (int i = 0; i < totalMovementSteps; ++i) {
         touch1Pos += touchMovement.toPoint();
@@ -737,13 +517,13 @@
             .move(1, touch1Pos);
     }
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
 
     QTest::touchEvent(m_view, m_device)
         .move(0, touch0Pos)
         .release(1, touch1Pos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 }
 
 /*
@@ -762,19 +542,19 @@
     DirectionalDragArea *edgeDragArea =
         rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");
     Q_ASSERT(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
-    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
+    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
     QPointF dragDirectionVector(0.0f, 1.0f);
 
-    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
+    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
     QPointF touchMovement = dragDirectionVector * movementStepDistance;
     int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
-    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
+    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
     QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
 
@@ -784,7 +564,7 @@
         QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
     }
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
 
     QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
 }
@@ -802,31 +582,30 @@
     DirectionalDragArea *edgeDragArea =
         rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");
     Q_ASSERT(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
+
+    // to disable the position smoothing so that we can more easily check sceneDistance values
+    edgeDragArea->setImmediateRecognition(true);
 
     QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
-    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
+    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
 
-    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
+    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
     QPointF touchMovement = dragDirectionVector * movementStepDistance;
     int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
-    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
-
-    QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
-    QQuickWindowPrivate *wp = QQuickWindowPrivate::get(m_view);
-#endif
+    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
+
+    qint64 timestamp = 0;
+
+    sendTouchPress(timestamp, 0, touchPoint);
+
     for (int i = 0; i < totalMovementSteps; ++i) {
         touchPoint += touchMovement;
-        passTime(movementTimeStepMs);
-        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
-        wp->flushDelayedTouchEvent();
-#endif
+        timestamp += movementTimeStepMs;
+        sendTouchUpdate(timestamp, 0, touchPoint);
     }
 
     qreal actualDragDistance = ((qreal)totalMovementSteps) * movementStepDistance;
@@ -836,7 +615,8 @@
     // NB: qFuzzyCompare(), used internally by QCOMPARE(), is broken.
     QVERIFY(qAbs(edgeDragArea->sceneDistance() - actualDragDistance) < 0.001);
 
-    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
+    timestamp += movementTimeStepMs;
+    sendTouchRelease(timestamp, 0, touchPoint);
 }
 
 void tst_DirectionalDragArea::sceneDistance_data()
@@ -860,18 +640,18 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     Q_ASSERT(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     QPointF touchPoint = calculateInitialTouchPos(edgeDragArea);
 
-    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
+    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2.0f;
     QPointF dragDirectionVector(1., 0.); // horizontal positive
 
-    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
+    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
     QPointF touchMovement = dragDirectionVector * movementStepDistance;
     int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
-    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
+    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
     QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
 
@@ -881,13 +661,13 @@
         QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
     }
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
     QCOMPARE(edgeDragArea->dragging(), true);
 
     // disable the dragArea while it's being dragged.
     edgeDragArea->setEnabled(false);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
     QCOMPARE(edgeDragArea->dragging(), false);
 
     QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
@@ -898,15 +678,14 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     Q_ASSERT(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     // Disable some constraints we're not interested in
-    edgeDragArea->setMaxSilenceTime(60 * 1000);
-    edgeDragArea->setMinSpeed(0);
+    edgeDragArea->d->setMaxTime(60 * 1000);
 
     // And ensure others have the values we want
-    edgeDragArea->setCompositionTime(60);
+    edgeDragArea->d->compositionTime = 60;
 
     // Put an item right behind edgeDragArea to receive the touches ignored by it
     DummyItem *dummyItem = new DummyItem;
@@ -923,10 +702,10 @@
 
     QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
 
     // We are now going to be way beyond compositionTime
-    passTime(edgeDragArea->compositionTime()*3);
+    passTime(edgeDragArea->d->compositionTime*3);
 
     QTest::touchEvent(m_view, m_device)
         .move(0, touch0Pos)
@@ -948,7 +727,7 @@
         .move(0, touch0Pos)
         .move(1, touch1Pos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
 
     passTime(5);
 
@@ -956,7 +735,7 @@
         .release(0, touch0Pos)
         .move(1, touch1Pos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
     passTime(5);
 
@@ -964,7 +743,7 @@
         .release(1, touch1Pos);
 
     // Shouldn't be keepping info about touches that no longer exist or interest us
-    QVERIFY(edgeDragArea->m_activeTouches.isEmpty());
+    QVERIFY(edgeDragArea->d->activeTouches.isEmpty());
 
     delete dummyItem;
 }
@@ -974,12 +753,11 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     Q_ASSERT(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     // Disable some constraints we're not interested in
-    edgeDragArea->setMaxSilenceTime(60 * 1000);
-    edgeDragArea->setMinSpeed(0);
+    edgeDragArea->d->setMaxTime(60 * 1000);
 
     // Put an item right in front of edgeDragArea
     DummyItem *dummyItem = new DummyItem(edgeDragArea->parentItem());
@@ -998,11 +776,11 @@
 
     QTest::touchEvent(m_view, m_device).press(0, touchPos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
 
     m_touchRegistry->requestTouchOwnership(0, dummyItem);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
     dummyItem->grabTouchPoints({0});
     dummyItem->touchEventHandler = [&](QTouchEvent *event) { event->accept(); };
@@ -1010,9 +788,9 @@
     passTime(5);
     QTest::touchEvent(m_view, m_device).release(0, touchPos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
-    QVERIFY(edgeDragArea->m_activeTouches.isEmpty());
+    QVERIFY(edgeDragArea->d->activeTouches.isEmpty());
 }
 
 void tst_DirectionalDragArea::threeFingerDrag()
@@ -1020,15 +798,14 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     Q_ASSERT(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     // Disable some constraints we're not interested in
-    edgeDragArea->setMaxSilenceTime(60 * 1000);
-    edgeDragArea->setMinSpeed(0);
+    edgeDragArea->d->setMaxTime(60 * 1000);
 
     // And ensure others have the values we want
-    edgeDragArea->setCompositionTime(60);
+    edgeDragArea->d->compositionTime = 60;
 
     // Make touches evenly spaced along the edgeDragArea
     QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()*0.25f);
@@ -1038,14 +815,14 @@
     QTest::touchEvent(m_view, m_device)
         .press(0, touch0Pos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
 
     passTime(5);
     QTest::touchEvent(m_view, m_device)
         .move(0, touch0Pos)
         .press(1, touch1Pos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
     passTime(5);
     QTest::touchEvent(m_view, m_device)
@@ -1053,7 +830,7 @@
         .move(1, touch1Pos)
         .press(2, touch2Pos);
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
     passTime(10);
     QTest::touchEvent(m_view, m_device)
@@ -1077,7 +854,7 @@
         .release(0, touch0Pos);
 
     // Shouldn't be keepping info about touches that no longer exist or interest us
-    QVERIFY(edgeDragArea->m_activeTouches.isEmpty());
+    QVERIFY(edgeDragArea->d->activeTouches.isEmpty());
 }
 
 /*
@@ -1090,12 +867,12 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     Q_ASSERT(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     // Disable the minimum amount of constraints to ensure immediate recognition
-    edgeDragArea->setDistanceThreshold(0);
-    edgeDragArea->setCompositionTime(0);
+    edgeDragArea->d->setDistanceThreshold(0);
+    edgeDragArea->d->compositionTime = 0;
 
     // Put an item right behind edgeDragArea to receive the touches ignored by it
     DummyItem *dummyItem = new DummyItem;
@@ -1111,7 +888,7 @@
     QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
 
     // check for immediate recognition
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
 
     // and therefore it should have immediately grabbed the touch point,
     // not letting it leak to items behind him.
@@ -1123,19 +900,19 @@
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     Q_ASSERT(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     QPointF touchPoint = calculateInitialTouchPos(edgeDragArea);
 
     // Move less than the minimum needed for the drag gesture recognition
-    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*0.5f;
+    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 0.5f;
     QPointF dragDirectionVector(1., 0.); // horizontal positive
 
-    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
+    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
     QPointF touchMovement = dragDirectionVector * movementStepDistance;
     int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
-    int movementTimeStepMs = (edgeDragArea->compositionTime() * 0.8f) / totalMovementSteps;
+    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 0.8f) / totalMovementSteps;
 
     QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
 
@@ -1145,14 +922,14 @@
         QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
     }
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
 
     // edgeDragArea should be an undecided candidate
     {
         auto touchInfo = m_touchRegistry->findTouchInfo(0);
         QCOMPARE(touchInfo->candidates.size(), 1);
         QCOMPARE(touchInfo->candidates.at(0).item.data(), edgeDragArea);
-        QCOMPARE(touchInfo->candidates.at(0).undecided, true);
+        QCOMPARE(touchInfo->candidates.at(0).state, TouchRegistry::CandidateInfo::Undecided);
     }
 
     // disable the dragArea while it's still recognizing a possible drag gesture.
@@ -1169,7 +946,7 @@
         QCOMPARE(touchInfo->candidates.size(), 0);
     }
 
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
 
     QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
 }
@@ -1182,47 +959,13 @@
     QTest::newRow("invisible") << false;
 }
 
-void tst_DirectionalDragArea::tappedSignal()
-{
-    DirectionalDragArea *edgeDragArea =
-        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
-    QVERIFY(edgeDragArea != 0);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
-
-    QFETCH(bool, immediateGestureRecognition);
-    if (immediateGestureRecognition) {
-        // Disable the minimum amount of constraints to ensure immediate recognition
-        edgeDragArea->setDistanceThreshold(0);
-        edgeDragArea->setCompositionTime(0);
-    }
-
-    QPoint touch0Pos(edgeDragArea->width()/2.0f, m_view->height()/2.0f);
-
-    QSignalSpy tappedSpy(edgeDragArea, SIGNAL(tapped()));
-
-    QTest::touchEvent(m_view, m_device).press(0, touch0Pos);
-    passTime(edgeDragArea->maxTapDuration() / 2);
-    QTest::touchEvent(m_view, m_device).release(0, touch0Pos);
-
-    QCOMPARE(tappedSpy.count(), 1);
-}
-
-void tst_DirectionalDragArea::tappedSignal_data()
-{
-    QTest::addColumn<bool>("immediateGestureRecognition");
-
-    QTest::newRow("immediate gesture recognition") << true;
-    QTest::newRow("default gesture recognition") << false;
-}
-
 void tst_DirectionalDragArea::gettingTouchOwnershipMakesMouseAreaBehindGetCanceled()
 {
     DirectionalDragArea *edgeDragArea =
         m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
     QVERIFY(edgeDragArea != nullptr);
-    edgeDragArea->setRecognitionTimer(fakeTimer);
-    edgeDragArea->setTimeSource(fakeTimeSource);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
 
     QQuickMouseArea *mouseArea =
         m_view->rootObject()->findChild<QQuickMouseArea*>("mouseArea");
@@ -1233,12 +976,12 @@
     QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
-    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2;
+    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2;
     QPointF dragDirectionVector(1.0f, 0.0f); // rightwards
-    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
+    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
     QPointF touchMovement = dragDirectionVector * movementStepDistance;
     int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
-    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
+    int movementTimeStepMs = (edgeDragArea->d->compositionTime * 1.5f) / totalMovementSteps;
 
     QCOMPARE(mouseArea->pressed(), false);
 
@@ -1259,13 +1002,305 @@
     // As the DirectionalDragArea recognizes the gesture, it grabs the touch from the MouseArea,
     // which should make the MouseArea get a cancelation event, which will then cause it to
     // reset its state (going back to "unpressed"/"released").
-    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
     QCOMPARE(mouseArea->pressed(), false);
     QCOMPARE(mouseAreaSpy.canceledCount, 1);
 
     QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
 }
 
+void tst_DirectionalDragArea::interleavedTouches()
+{
+    DirectionalDragArea *edgeDragArea =
+        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
+    QVERIFY(edgeDragArea != 0);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
+
+    QPointF touch0 = edgeDragArea->mapToScene(
+            QPointF(edgeDragArea->width()*0.5, edgeDragArea->height()*0.3));
+
+    qreal desiredDragDistance = edgeDragArea->d->distanceThreshold * 2;
+    QPointF dragDirectionVector(1.0f, 0.0f); // rightwards
+    qreal movementStepDistance = edgeDragArea->d->distanceThreshold * 0.1f;
+    QPointF touchMovement = dragDirectionVector * movementStepDistance;
+    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
+    int movementTimeStepMs = (edgeDragArea->d->maxTime * 0.4f) / totalMovementSteps;
+
+    QTest::touchEvent(m_view, m_device).press(0, touch0.toPoint());
+    for (int i = 0; i < totalMovementSteps; ++i) {
+        touch0 += touchMovement;
+        passTime(movementTimeStepMs);
+        QTest::touchEvent(m_view, m_device).move(0, touch0.toPoint());
+    }
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
+
+    QPointF touch1 = edgeDragArea->mapToScene(
+            QPointF(edgeDragArea->width()*0.5, edgeDragArea->height()*0.6));
+
+    QTest::touchEvent(m_view, m_device)
+        .move(0, touch0.toPoint())
+        .press(1, touch1.toPoint());
+
+    touch1 += touchMovement;
+    passTime(movementTimeStepMs);
+    QTest::touchEvent(m_view, m_device)
+        .move(0, touch0.toPoint())
+        .move(1, touch1.toPoint());
+
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Recognized);
+
+    QTest::touchEvent(m_view, m_device)
+        .release(0, touch0.toPoint())
+        .move(1, touch1.toPoint());
+
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
+
+    touch1 += touchMovement;
+    passTime(movementTimeStepMs);
+    QTest::touchEvent(m_view, m_device)
+        .move(1, touch1.toPoint());
+
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
+
+    QPointF touch2 = edgeDragArea->mapToScene(
+            QPointF(edgeDragArea->width()*0.5, edgeDragArea->height()*0.9));
+
+    passTime(edgeDragArea->d->compositionTime + movementTimeStepMs);
+    QTest::touchEvent(m_view, m_device)
+        .move(1, touch1.toPoint())
+        .press(2, touch2.toPoint());
+
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::Undecided);
+    QCOMPARE(edgeDragArea->d->touchId, 2);
+
+    touch2 += touchMovement;
+    passTime(movementTimeStepMs);
+    QTest::touchEvent(m_view, m_device)
+        .move(1, touch1.toPoint())
+        .move(2, touch2.toPoint());
+
+    touch1 += touchMovement;
+    passTime(movementTimeStepMs);
+    QTest::touchEvent(m_view, m_device)
+        .move(1, touch1.toPoint())
+        .move(2, touch2.toPoint());
+
+    passTime(movementTimeStepMs);
+    QTest::touchEvent(m_view, m_device)
+        .release(1, touch1.toPoint())
+        .move(2, touch2.toPoint());
+
+    passTime(movementTimeStepMs);
+    QTest::touchEvent(m_view, m_device)
+        .release(2, touch2.toPoint());
+
+    QCOMPARE((int)edgeDragArea->d->status, (int)DirectionalDragAreaPrivate::WaitingForTouch);
+}
+
+/*
+  A valid right-edge drag performed on mako
+ */
+void tst_DirectionalDragArea::makoRightEdgeDrag()
+{
+    m_view->resize(768, 1280);
+    QTest::qWait(300);
+
+    DirectionalDragArea *edgeDragArea =
+        m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");
+    QVERIFY(edgeDragArea != nullptr);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
+
+    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
+
+    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
+
+    sendTouchPress(319744, 0, QPointF(767.001, 719.719));
+    sendTouchUpdate(319765, 0, QPointF(765.744,729.973));
+    sendTouchUpdate(319784, 0, QPointF(740.879,752.182));
+    sendTouchUpdate(319803, 0, QPointF(689.698,795.795));
+    sendTouchUpdate(319826, 0, QPointF(616.978,856.212));
+    sendTouchUpdate(319845, 0, QPointF(558.769,906.157));
+    sendTouchUpdate(319859, 0, QPointF(513.219,945.266));
+    sendTouchUpdate(319878, 0, QPointF(481.31,975.496));
+    sendTouchUpdate(319902, 0, QPointF(460.016,997.439));
+    sendTouchUpdate(319920, 0, QPointF(449.761,1008.6));
+    sendTouchUpdate(319929, 0, QPointF(445.891,1012.42));
+    sendTouchUpdate(319947, 0, QPointF(444.884,1013.93));
+    sendTouchUpdate(319965, 0, QPointF(444.461,1014.35));
+    sendTouchUpdate(320057, 0, QPointF(444.71,1013.56));
+    sendTouchUpdate(320138, 0, QPointF(445.434,1013.6));
+    sendTouchUpdate(320154, 0, QPointF(446.338,1012.98));
+    sendTouchUpdate(320171, 0, QPointF(447.232,1012.08));
+    sendTouchRelease(320171, 0, QPointF(447.232,1012.08));
+
+    QCOMPARE(statusSpy->recognized(), true);
+
+    delete statusSpy;
+}
+
+/*
+   A vertical, downwards swipe performed on mako near its right edge.
+
+   The DirectionalDragArea on the right edge must not recognize this
+   gesture.
+ */
+void tst_DirectionalDragArea::makoRightEdgeDrag_verticalDownwards()
+{
+    m_view->resize(768, 1280);
+    QTest::qWait(300);
+
+    DirectionalDragArea *edgeDragArea =
+        m_view->rootObject()->findChild<DirectionalDragArea*>("hnDragArea");
+    QVERIFY(edgeDragArea != nullptr);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
+
+    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
+
+    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
+
+    sendTouchPress(12012445, 26, QPointF(767.001,461.82));
+    sendTouchUpdate(12012472, 26, QPointF(767.001,462.569));
+    sendTouchUpdate(12012528, 26, QPointF(767.001,463.334));
+    sendTouchUpdate(12012546, 26, QPointF(767.001,466.856));
+    sendTouchUpdate(12012571, 26, QPointF(767.001,473.291));
+    sendTouchUpdate(12012587, 26, QPointF(767.001,487.31));
+    sendTouchUpdate(12012604, 26, QPointF(765.364,507.521));
+    sendTouchUpdate(12012618, 26, QPointF(765.364,507.521));
+    sendTouchUpdate(12012627, 26, QPointF(762.642,534.317));
+    sendTouchUpdate(12012655, 26, QPointF(760.846,573.406));
+    sendTouchUpdate(12012667, 26, QPointF(759.838,625.295));
+    sendTouchUpdate(12012675, 26, QPointF(758.875,703.207));
+    sendTouchUpdate(12012696, 26, QPointF(761.52,777.015));
+    sendTouchUpdate(12012713, 26, QPointF(765.659,835.591));
+    sendTouchUpdate(12012731, 26, QPointF(766.778,883.206));
+    sendTouchUpdate(12012748, 26, QPointF(767.001,922.937));
+    sendTouchUpdate(12012779, 26, QPointF(767.001,967.558));
+    sendTouchUpdate(12012798, 26, QPointF(767.001,1006.12));
+    sendTouchUpdate(12012809, 26, QPointF(767.001,1033.1));
+    sendTouchRelease(12012810, 26, QPointF(767.001,1033.1));
+
+    QCOMPARE(statusSpy->recognized(), false);
+
+    delete statusSpy;
+}
+
+/*
+   A valid left-edge drag performed on mako. This one starts a bit slow than speeds up
+ */
+void tst_DirectionalDragArea::makoLeftEdgeDrag_slowStart()
+{
+    m_view->resize(768, 1280);
+    QTest::qWait(300);
+
+    DirectionalDragArea *edgeDragArea =
+        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
+    QVERIFY(edgeDragArea != nullptr);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
+
+    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
+
+    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
+
+    sendTouchPress(4002267, 77, QPointF(0,885.154));
+    sendTouchUpdate(4002275, 77, QPointF(0,886.214));
+    sendTouchUpdate(4002311, 77, QPointF(1.09568,887.75));
+    sendTouchUpdate(4002329, 77, QPointF(3.53647,890.191));
+    sendTouchUpdate(4002347, 77, QPointF(7.87434,892.879));
+    sendTouchUpdate(4002366, 77, QPointF(12.3036,895.075));
+    sendTouchUpdate(4002384, 77, QPointF(15.8885,896.849));
+    sendTouchUpdate(4002406, 77, QPointF(18.4504,897.88));
+    sendTouchUpdate(4002420, 77, QPointF(20.2429,898.149));
+    sendTouchUpdate(4002439, 77, QPointF(20.9945,898.149));
+    sendTouchUpdate(4002457, 77, QPointF(21.8819,898.149));
+    sendTouchUpdate(4002480, 77, QPointF(22.7454,897.389));
+    sendTouchUpdate(4002493, 77, QPointF(23.5456,896.589));
+    sendTouchUpdate(4002511, 77, QPointF(24.5435,895.031));
+    sendTouchUpdate(4002529, 77, QPointF(25.4271,892.32));
+    sendTouchUpdate(4002548, 77, QPointF(26.3145,889.658));
+    sendTouchUpdate(4002566, 77, QPointF(27.2004,886.999));
+    sendTouchUpdate(4002584, 77, QPointF(28.035,885.048));
+    sendTouchUpdate(4002603, 77, QPointF(29.9684,883.167));
+    sendTouchUpdate(4002620, 77, QPointF(33.3591,881.403));
+    sendTouchUpdate(4002639, 77, QPointF(44.1017,879.642));
+    sendTouchUpdate(4002657, 77, QPointF(64.828,878.502));
+    sendTouchUpdate(4002675, 77, QPointF(87.9486,878.157));
+    sendTouchUpdate(4002693, 77, QPointF(112.96,877.742));
+    sendTouchUpdate(4002711, 77, QPointF(138.903,877.157));
+    sendTouchUpdate(4002729, 77, QPointF(163.204,877.157));
+    sendTouchUpdate(4002747, 77, QPointF(182.127,877.157));
+    sendTouchUpdate(4002765, 77, QPointF(194.478,877.657));
+    sendTouchUpdate(4002785, 77, QPointF(201.474,878.508));
+    sendTouchUpdate(4002803, 77, QPointF(204.855,879.401));
+    sendTouchUpdate(4002822, 77, QPointF(206.616,880.281));
+    sendTouchUpdate(4002839, 77, QPointF(207.115,880.906));
+    sendTouchUpdate(4002894, 77, QPointF(206.865,881.184));
+    sendTouchUpdate(4002912, 77, QPointF(206.865,882.143));
+    sendTouchUpdate(4002930, 77, QPointF(206.865,883.106));
+    sendTouchUpdate(4002949, 77, QPointF(206.526,883.994));
+    sendTouchUpdate(4002967, 77, QPointF(205.866,884.88));
+    sendTouchUpdate(4002985, 77, QPointF(205.866,885.766));
+    sendTouchUpdate(4003005, 77, QPointF(205.866,886.654));
+    sendTouchUpdate(4003021, 77, QPointF(205.366,887.537));
+    sendTouchUpdate(4003039, 77, QPointF(204.592,888.428));
+    sendTouchUpdate(4003050, 77, QPointF(204.367,888.653));
+    sendTouchRelease(4003050, 77, QPointF(204.367,888.653));
+
+    QCOMPARE(statusSpy->recognized(), true);
+
+    delete statusSpy;
+}
+
+void tst_DirectionalDragArea::makoLeftEdgeDrag_movesSlightlyBackwardsOnStart()
+{
+    m_view->resize(768, 1280);
+    QTest::qWait(300);
+
+    DirectionalDragArea *edgeDragArea =
+        m_view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
+    QVERIFY(edgeDragArea != nullptr);
+    edgeDragArea->d->setRecognitionTimer(m_fakeTimerFactory->createTimer());
+    edgeDragArea->d->setTimeSource(m_fakeTimerFactory->timeSource());
+
+    edgeDragArea->d->setPixelsPerMm(320.0 /*mako ppi*/ * 0.03937 /* inches per mm*/);
+
+    StatusSpy *statusSpy = new StatusSpy(edgeDragArea);
+
+    sendTouchPress(41097, 24, QPointF(13.9909,827.177));
+    sendTouchUpdate(41120, 24, QPointF(19.2375,825.677));
+    sendTouchUpdate(41138, 24, QPointF(18.4057,826.177));
+    sendTouchUpdate(41161, 24, QPointF(20.1067,825.867));
+    sendTouchUpdate(41177, 24, QPointF(21.8869,824.977));
+    sendTouchUpdate(41193, 24, QPointF(24.7603,823.494));
+    sendTouchUpdate(41211, 24, QPointF(28.3889,821.725));
+    sendTouchUpdate(41229, 24, QPointF(32.2909,819.955));
+    sendTouchUpdate(41247, 24, QPointF(38.2251,817.431));
+    sendTouchUpdate(41266, 24, QPointF(52.4182,814.223));
+    sendTouchUpdate(41284, 24, QPointF(85.8465,809.483));
+    sendTouchUpdate(41302, 24, QPointF(126.091,802.741));
+    sendTouchUpdate(41320, 24, QPointF(153.171,797.977));
+    sendTouchUpdate(41338, 24, QPointF(170.565,795.077));
+    sendTouchUpdate(41356, 24, QPointF(178.685,794.101));
+    sendTouchUpdate(41375, 24, QPointF(183.706,793.225));