Unity 8

Merge lp:~dandrader/unity8/drag-crash-1228336 into lp:unity8

drag-crash-1228336
Merge into trunk

Proposed by Daniel d'Andrada on 2013-10-22

Status:

Merged

Approved by:

Albert Astals Cid on 2013-11-05

Approved revision:

500

Merged at revision:

507

Proposed branch:

lp:~dandrader/unity8/drag-crash-1228336

Merge into:

lp:unity8

Diff against target:

2073 lines (+923/-335)

21 files modified

Components/DragHandle.qml (+21/-22)
Components/EdgeDragArea.qml (+12/-4)
Components/Stage.qml (+8/-7)
plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp (+9/-18)
plugins/Ubuntu/Gestures/AxisVelocityCalculator.h (+9/-16)
plugins/Ubuntu/Gestures/CMakeLists.txt (+1/-0)
plugins/Ubuntu/Gestures/DirectionalDragArea.cpp (+315/-79)
plugins/Ubuntu/Gestures/DirectionalDragArea.h (+50/-13)
plugins/Ubuntu/Gestures/TimeSource.cpp (+49/-0)
plugins/Ubuntu/Gestures/TimeSource.h (+54/-0)
tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml (+2/-10)
tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml (+5/-13)
tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml (+3/-10)
tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml (+5/-13)
tests/plugins/Ubuntu/Gestures/edgeDragExample.qml (+7/-1)
tests/plugins/Ubuntu/Gestures/tst_AxisVelocityCalculator.cpp (+3/-3)
tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp (+297/-108)
tests/qmltests/Components/tst_DragHandle.cpp (+4/-5)
tests/qmltests/Panel/tst_Panel.qml (+0/-1)
tests/qmltests/tst_Shell.qml (+35/-12)
tests/utils/modules/Unity/Test/UnityTestCase.qml (+34/-0)

To merge this branch:

bzr merge lp:~dandrader/unity8/drag-crash-1228336

Undecided

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Approve on 2013-11-05
Albert Astals Cid (community)		2013-10-22	Approve on 2013-11-05
Michael Zanetti (community)		2013-10-22	Approve on 2013-10-23
Review via email: mp+192183@code.launchpad.net

Commit message

Improve DirectionalDragArea

- Removed Rejected status, simplifying state machine
- Added compositionTime property. Multi-finger scenarios are better handled now.
- Refactored TimeSource in Ubuntu.Gestures plugin
- Added an easy way to debug DirectionalDragArea by having switchable debug prints
- Updated tests to also simulate the passage of time
- Use touch point scene coordinates for gesture recognition so that moving the
DirectionalDragArea (as in a hinting DragHandle) won't affect it

Description of the change

Make sure you have a fresh lp:qtubuntu (that includes revision 191) when testing.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-10-22:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1472/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-10-22:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1476/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2013-10-23:

381 + #if DIRECTIONALDRAGAREA_DEBUG
382 + qDebug() << "[DDA]" << m_timeSource->msecsSinceReference()
383 + << qPrintable(touchEventToString(event));
384 + #endif

I'd prefer using qCDebug instead of this. However, qCDebug will only be released with Qt 5.2. Maybe we should get this in for now with a TODO and add a task for cleaning up debug's once we have 5.2?

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-10-23:

> 381 + #if DIRECTIONALDRAGAREA_DEBUG
> 382 + qDebug() << "[DDA]" << m_timeSource->msecsSinceReference()
> 383 + << qPrintable(touchEventToString(event));
> 384 + #endif
>
> I'd prefer using qCDebug instead of this. However, qCDebug will only be
> released with Qt 5.2. Maybe we should get this in for now with a TODO and add
> a task for cleaning up debug's once we have 5.2?

done.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-10-23:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1477/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2013-10-23:

This looks really good. The crashes are definitely gone.

=======
can we const & all occurances of "SharedTimeSource timeSource" in method arguments?

=======
715 + // Estimate of the maximum number of active touches we might reach.
716 + // Not a problem if it ends up being an underestimate as this is just
717 + // an optimization.
718 + reserve(10);

If it's just an optimization, shouldn't we rather go for 3 or something that is more realistic? I think it happens max once a year that I touch the screen with all 10 fingers.

review: Needs Information

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-10-23:

> This looks really good. The crashes are definitely gone.
>
> =======
> can we const & all occurances of "SharedTimeSource timeSource" in method
> arguments?
>
> =======
> 715 + // Estimate of the maximum number of active touches we might reach.
> 716 + // Not a problem if it ends up being an underestimate as this is
> just
> 717 + // an optimization.
> 718 + reserve(10);
>
> If it's just an optimization, shouldn't we rather go for 3 or something that
> is more realistic? I think it happens max once a year that I touch the screen
> with all 10 fingers.

Done.

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2013-10-23:

looks good to me now.

review: Approve

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-04:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1549/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Albert Astals Cid (aacid) wrote on 2013-11-04:

do you think we can make it so removeTimeConstraintsFromDirectionalDragAreas is invoked on the shell for all the tests?

review: Needs Information

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-11-04:

> do you think we can make it so removeTimeConstraintsFromDirectionalDragAreas
> is invoked on the shell for all the tests?

The only way I can think of is having only UnityTestCase defining initTestCase() and them doing a s/initTestCase/someOtherInitName in all instances of UnityTestCase.

So UnityTestCase would have

function initTestCase() {
someOtherInitName();
removeTimeConstraintsFromDirectionalDragAreas(foo);
}

But that still has the problem that I need access to the root item so that I can iterate through it. But maybe that can be done through some C++ code...

So all things considered, I think the current approach is the better one.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-04:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1556/rebuild

review: Needs Fixing (continuous-integration)

lp:~dandrader/unity8/drag-crash-1228336 updated on 2013-11-04

498. By Daniel d'Andrada on 2013-11-04: Reorder things a bit

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-04:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1559/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-04:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1560/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-05:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1562/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Albert Astals Cid (aacid) wrote on 2013-11-05:

Can't we do Component.onCompleted on the UnityTestCase + recursion on parent until it's null to find the root?

review: Needs Information

lp:~dandrader/unity8/drag-crash-1228336 updated on 2013-11-05

499. By Daniel d'Andrada on 2013-11-05: Clean up tests. Following Albert's suggestion.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2013-11-05:

> Can't we do Component.onCompleted on the UnityTestCase + recursion on parent
> until it's null to find the root?

Good idea. It works. Done it.

Now let's just hope Jenkins agrees with us.

lp:~dandrader/unity8/drag-crash-1228336 updated on 2013-11-05

500. By Daniel d'Andrada on 2013-11-05: Trying to make tst_Shell.initTestCase() less hacky and more robust

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-05:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1564/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Albert Astals Cid (aacid) wrote on 2013-11-05:

Looks good :-)

review: Approve

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-05:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1569/rebuild

review: Approve (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-05:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1571/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-05:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1573/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2013-11-05:

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/unity8-ci/1575/rebuild

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Daniel d'Andrada

Mohammad Rakibul Hasan

Unity Team

 === modified file 'Components/DragHandle.qml'
 --- Components/DragHandle.qml	2013-10-11 11:41:27 +0000
 +++ Components/DragHandle.qml	2013-11-05 10:55:36 +0000
@@ -48,9 +48,12 @@
      id: dragArea
      objectName: "dragHandle"
--    // Disable gesture detection by default when hinting is used.
--    // It doesn't make sense to have both.
--    distanceThreshold: hintDisplacement > 0 ? 0 : units.gu(1.5)
++    // Disable most of the gesture recognition parameters by default when hinting is used as
++    // it conflicts with the hinting idea.
++    // The only part we keep in this situation is that it must be a single-finger gesture.
++    distanceThreshold: hintDisplacement > 0 ? 0 : defaultDistanceThreshold
++    maxSilenceTime: hintDisplacement > 0 ? 60*60*1000 : defaultMaxSilenceTime
++    maxDeviation: hintDisplacement > 0 ? 999999 : defaultMaxDeviation
      property bool stretch: false
@@ -181,29 +184,25 @@
+         }
+     }
--    onDraggingChanged: {
--        if (dragging) {
--            if (hintDisplacement > 0) {
--                hintingAnimation.targetValue = d.startValue;
--                hintingAnimation.start();
--            }
--        } else {
--            hintingAnimation.stop();
--        }
--    }
--
      onStatusChanged: {
          if (status === DirectionalDragArea.WaitingForTouch) {
++            hintingAnimation.stop();
              if (d.previousStatus === DirectionalDragArea.Recognized) {
                  d.onFinishedRecognizedGesture();
--            }
--            d.startValue = parent[d.targetProp];
--        }
--
--        if (d.previousStatus === DirectionalDragArea.WaitingForTouch ||
--                d.previousStatus === undefined) {
--            dragEvaluator.reset();
--            d.startValue = parent[d.targetProp];
++            } else /* d.previousStatus === DirectionalDragArea.Undecided */ {
++                // Gesture was rejected.
++                d.rollbackDrag();
++            }
++        } else /* Undecided || Recognized */ {
++            if (d.previousStatus === DirectionalDragArea.WaitingForTouch ||
++                    d.previousStatus === undefined) {
++                dragEvaluator.reset();
++                d.startValue = parent[d.targetProp];
++            }
++            if (hintDisplacement > 0) {
++                hintingAnimation.targetValue = d.startValue;
++                hintingAnimation.start();
++            }
+         }
          d.previousStatus = status;
 === modified file 'Components/EdgeDragArea.qml'
 --- Components/EdgeDragArea.qml	2013-06-28 19:32:16 +0000
 +++ Components/EdgeDragArea.qml	2013-11-05 10:55:36 +0000
@@ -29,8 +29,16 @@
      //
      // The idea here is that it's better having lax rules than false negatives.
      // False negatives are very frustrating to the user.
--    maxDeviation: units.gu(3)
--    wideningAngle: 50
--    distanceThreshold: units.gu(1.5)
--    minSpeed: units.gu(0) // some people were getting false negatives with it enabled.
++    maxDeviation: defaultMaxDeviation
++    wideningAngle: defaultWideningAngle
++    distanceThreshold: defaultDistanceThreshold
++    minSpeed: defaultMinSpeed
++    maxSilenceTime: defaultMaxSilenceTime
++
++    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
+ }
 === modified file 'Components/Stage.qml'
 --- Components/Stage.qml	2013-10-11 10:24:30 +0000
 +++ Components/Stage.qml	2013-11-05 10:55:36 +0000
@@ -482,19 +482,20 @@
              switchToApplicationAnimationController.progress += 0.4 * delta
+         }
--        property bool gotRejected: false
++        property int lastStatus: -1
          onStatusChanged: {
              if (status == DirectionalDragArea.Undecided) {
--                gotRejected = false
                  onUndecided();
--            } else if (status == DirectionalDragArea.Rejected) {
--                switchToApplicationAnimationController.completeToBeginningWithSignal();
--                gotRejected = true;
              } else if (status == DirectionalDragArea.WaitingForTouch) {
--                if (!gotRejected)
--                    onGestureEnded()
++                if (lastStatus == DirectionalDragArea.Undecided) {
++                    // got rejected
++                    switchToApplicationAnimationController.completeToBeginningWithSignal();
++                } else {
++                    onGestureEnded();
++                }
+             }
++            lastStatus = status;
+         }
          function onUndecided() {
 === modified file 'plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp'
 --- plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp	2013-06-26 16:27:04 +0000
 +++ plugins/Ubuntu/Gestures/AxisVelocityCalculator.cpp	2013-11-05 10:55:36 +0000
@@ -21,25 +21,19 @@
  #include "AxisVelocityCalculator.h"
  #include <QtCore/QElapsedTimer>
--class RealTimeSource : public UbuntuGestures::TimeSource {
--public:
--    RealTimeSource()
--        : UbuntuGestures::TimeSource() {
--        m_timer.start();
--    }
--    virtual qint64 msecsSinceReference() {
--        return m_timer.elapsed();
--    }
--private:
--    QElapsedTimer m_timer;
--};
++using namespace UbuntuGestures;
  AxisVelocityCalculator::AxisVelocityCalculator(QObject *parent)
++    : AxisVelocityCalculator(SharedTimeSource(new RealTimeSource), parent)
++{
++}
++
++AxisVelocityCalculator::AxisVelocityCalculator(const SharedTimeSource &timeSource,
++                                               QObject *parent)
      : QObject(parent)
--    , m_timeSource(new RealTimeSource)
++    , m_timeSource(timeSource)
      , m_trackedPosition(0.0)
+ {
--    m_timeSource->setParent(this);
      reset();
+ }
@@ -142,11 +136,8 @@
+     }
+ }
--void AxisVelocityCalculator::setTimeSource(UbuntuGestures::TimeSource *timeSource)
++void AxisVelocityCalculator::setTimeSource(const SharedTimeSource &timeSource)
+ {
--    if (m_timeSource && m_timeSource->parent() == this)
--        delete m_timeSource;
--
      m_timeSource = timeSource;
      if (numSamples() > 0) {
 === modified file 'plugins/Ubuntu/Gestures/AxisVelocityCalculator.h'
 --- plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	2013-06-26 16:20:32 +0000
 +++ plugins/Ubuntu/Gestures/AxisVelocityCalculator.h	2013-11-05 10:55:36 +0000
@@ -24,19 +24,7 @@
  #include "UbuntuGesturesGlobal.h"
  #include <stdint.h>
  #include <QtCore/QObject>
--
--namespace UbuntuGestures {
--/*
--    Interface for a time source.
-- */
--class UBUNTUGESTURES_EXPORT TimeSource : public QObject {
--    Q_OBJECT
--public:
--    virtual ~TimeSource() {}
--    /* Returns the current time in milliseconds since some reference time in the past. */
--    virtual qint64 msecsSinceReference() = 0;
--};
--}
++#include "TimeSource.h"
  /*
    Estimates the current velocity of a finger based on recent movement along an axis
@@ -73,10 +61,15 @@
  public:
      /*
--      Regular constructor
++      Regular, simple, constructor
       */
      AxisVelocityCalculator(QObject *parent = 0);
++    /*
++      Constructor that takes a TimeSource
++     */
++    AxisVelocityCalculator(const UbuntuGestures::SharedTimeSource &timeSource, QObject *parent = 0);
++
      virtual ~AxisVelocityCalculator();
      qreal trackedPosition() const;
@@ -97,7 +90,7 @@
      /*
          Replaces the TimeSource with the given one. Useful for testing purposes.
       */
--    void setTimeSource(UbuntuGestures::TimeSource *timeSource);
++    void setTimeSource(const UbuntuGestures::SharedTimeSource &timeSource);
      /*
          The minimum amount of samples needed for a velocity calculation.
@@ -145,7 +138,7 @@
      int m_samplesRead; /* index of the oldest sample available. -1 if buffer is empty */
      int m_samplesWrite; /* index where the next sample will be written */
--    UbuntuGestures::TimeSource *m_timeSource;
++    UbuntuGestures::SharedTimeSource m_timeSource;
      qreal m_trackedPosition;
  };
 === modified file 'plugins/Ubuntu/Gestures/CMakeLists.txt'
 --- plugins/Ubuntu/Gestures/CMakeLists.txt	2013-08-13 09:10:59 +0000
 +++ plugins/Ubuntu/Gestures/CMakeLists.txt	2013-11-05 10:55:36 +0000
@@ -6,6 +6,7 @@
      AxisVelocityCalculator.cpp
      Direction.cpp
      DirectionalDragArea.cpp
++    TimeSource.cpp
+ )
  add_definitions(-DUBUNTUGESTURES_LIBRARY)
 === modified file 'plugins/Ubuntu/Gestures/DirectionalDragArea.cpp'
 --- plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2013-07-01 11:12:03 +0000
 +++ plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2013-11-05 10:55:36 +0000
@@ -18,6 +18,75 @@
  #include <QtCore/qmath.h>
  #include <QtCore/QTimer>
++#include <QDebug>
++
++using namespace UbuntuGestures;
++
++#define DIRECTIONALDRAGAREA_DEBUG 0
++
++#if DIRECTIONALDRAGAREA_DEBUG
++#define DDA_DEBUG(msg) qDebug("[DDA] " msg)
++namespace {
++QString touchPointStateToString(Qt::TouchPointState state) {
++    switch (state) {
++    case Qt::TouchPointPressed:
++        return QString("pressed");
++    case Qt::TouchPointMoved:
++        return QString("moved");
++    case Qt::TouchPointStationary:
++        return QString("stationary");
++    default: // Qt::TouchPointReleased:
++        return QString("released");
++    }
++}
++QString touchEventToString(QTouchEvent *ev)
++{
++    QString message;
++
++    switch (ev->type()) {
++    case QEvent::TouchBegin:
++        message.append("TouchBegin ");
++        break;
++    case QEvent::TouchUpdate:
++        message.append("TouchUpdate ");
++        break;
++    case QEvent::TouchEnd:
++        message.append("TouchEnd ");
++        break;
++    default: //QEvent::TouchCancel
++        message.append("TouchCancel ");
++    }
++
++    for (int i=0; i < ev->touchPoints().size(); ++i) {
++
++        const QTouchEvent::TouchPoint& touchPoint = ev->touchPoints().at(i);
++        message.append(
++            QString("(id:%1, state:%2, scenePos:(%3,%4)) ")
++                .arg(touchPoint.id())
++                .arg(touchPointStateToString(touchPoint.state()))
++                .arg(touchPoint.scenePos().x())
++                .arg(touchPoint.scenePos().y())
++            );
++    }
++
++    return message;
++}
++
++const char *statusToString(DirectionalDragArea::Status status)
++{
++    if (status == DirectionalDragArea::WaitingForTouch) {
++        return "WaitingForTouch";
++    } else if (status == DirectionalDragArea::Undecided) {
++        return "Undecided";
++    } else {
++        return "Recognized";
++    }
++}
++
++} // namespace {
++#else // DIRECTIONALDRAGAREA_DEBUG
++#define DDA_DEBUG(msg) do{}while(0)
++#endif // DIRECTIONALDRAGAREA_DEBUG
  // Essentially a QTimer wrapper
  class RecognitionTimer : public UbuntuGestures::AbstractTimer
@@ -48,9 +117,12 @@
      , 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)
+ {
      setRecognitionTimer(new RecognitionTimer(this));
      m_recognitionTimer->setInterval(60);
@@ -73,8 +145,8 @@
  void DirectionalDragArea::setMaxDeviation(qreal value)
+ {
--    if (m_dampedPos.maxDelta() != value) {
--        m_dampedPos.setMaxDelta(value);
++    if (m_dampedScenePos.maxDelta() != value) {
++        m_dampedScenePos.setMaxDelta(value);
          Q_EMIT maxDeviationChanged(value);
+     }
+ }
@@ -118,6 +190,14 @@
+     }
+ }
++void DirectionalDragArea::setCompositionTime(int value)
++{
++    if (m_compositionTime != value) {
++        m_compositionTime = value;
++        Q_EMIT compositionTimeChanged(value);
++    }
++}
++
  void DirectionalDragArea::setRecognitionTimer(UbuntuGestures::AbstractTimer *timer)
+ {
      int interval = 0;
@@ -141,9 +221,11 @@
+     }
+ }
--void DirectionalDragArea::setTimeSource(UbuntuGestures::TimeSource *timeSource)
++void DirectionalDragArea::setTimeSource(const SharedTimeSource &timeSource)
+ {
++    m_timeSource = timeSource;
      m_velocityCalculator->setTimeSource(timeSource);
++    m_activeTouches.m_timeSource = timeSource;
+ }
  qreal DirectionalDragArea::distance() const
@@ -186,6 +268,12 @@
  void DirectionalDragArea::touchEvent(QTouchEvent *event)
+ {
++    #if DIRECTIONALDRAGAREA_DEBUG
++    // TODO Consider using qCDebug() when available (Qt 5.2)
++    qDebug() << "[DDA]" << m_timeSource->msecsSinceReference()
++        << qPrintable(touchEventToString(event));
++    #endif
++
      if (!isEnabled() || !isVisible()) {
          QQuickItem::touchEvent(event);
          return;
@@ -198,76 +286,124 @@
          case Undecided:
              touchEvent_undecided(event);
              break;
--        case Recognized:
++        default: // Recognized:
              touchEvent_recognized(event);
              break;
--        default: // Rejected
--            touchEvent_rejected(event);
--            break;
+     }
++
++    m_activeTouches.update(event);
+ }
  void DirectionalDragArea::touchEvent_absent(QTouchEvent *event)
+ {
--    if ((event->touchPointStates() && (Qt::TouchPointPressed || Qt::TouchPointMoved))
--            && event->touchPoints().count() == 1) {
--        const QTouchEvent::TouchPoint &touchPoint = event->touchPoints()[0];
--        m_startPos = touchPoint.pos();
--        m_startScenePos = touchPoint.scenePos();
--        m_touchId = touchPoint.id();
--        m_dampedPos.reset(m_startPos);
--        updateVelocityCalculator(m_startPos);
--        m_velocityCalculator->reset();
--        m_numSamplesOnLastSpeedCheck = 0;
--        m_silenceTime = 0;
--        setPreviousPos(m_startPos);
--        setPreviousScenePos(m_startScenePos);
--
--        if (m_distanceThreshold > 0)
--            setStatus(Undecided);
--        else
--            setStatus(Recognized);
--    }
++    if (!event->touchPointStates().testFlag(Qt::TouchPointPressed)) {
++        // Nothing to see here. No touch starting in this event.
++        return;
++    }
++
++    if (isWithinTouchCompositionWindow()) {
++        // too close to the last touch start. So we consider them as starting roughly at the same time.
++        // Can't be a single-touch gesture.
++        #if DIRECTIONALDRAGAREA_DEBUG
++        qDebug("[DDA] A new touch point came in but we're still within time composition window. Ignoring it.");
++        #endif
++        return;
++    }
++
++    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
++
++    const QTouchEvent::TouchPoint *newTouchPoint = nullptr;
++    for (int i = 0; i < touchPoints.count(); ++i) {
++        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
++        if (touchPoint.state() == Qt::TouchPointPressed) {
++            if (newTouchPoint) {
++                // more than one touch starting in this QTouchEvent. Can't be a single-touch gesture
++                return;
++            } else {
++                // that's our candidate
++                m_touchId = touchPoint.id();
++                newTouchPoint = &touchPoint;
++            }
++        }
++    }
++
++    Q_ASSERT(newTouchPoint);
++
++    // If we have made this far, we are good to go to the next status.
++
++    m_startPos = newTouchPoint->pos();
++    m_startScenePos = newTouchPoint->scenePos();
++    m_touchId = newTouchPoint->id();
++    m_dampedScenePos.reset(m_startScenePos);
++    updateVelocityCalculator(m_startScenePos);
++    m_velocityCalculator->reset();
++    m_numSamplesOnLastSpeedCheck = 0;
++    m_silenceTime = 0;
++    setPreviousPos(m_startPos);
++    setPreviousScenePos(m_startScenePos);
++
++    setStatus(Undecided);
+ }
  void DirectionalDragArea::touchEvent_undecided(QTouchEvent *event)
+ {
      const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);
--    const QPointF &touchPos = touchPoint->pos();
++
++    if (!touchPoint) {
++        qCritical() << "DirectionalDragArea[status=Undecided]: touch " << m_touchId
++            << "missing from QTouchEvent without first reaching state Qt::TouchPointReleased. "
++               "Considering it as released.";
++        setStatus(WaitingForTouch);
++        return;
++    }
++
++    const QPointF &touchScenePos = touchPoint->scenePos();
      if (touchPoint->state() == Qt::TouchPointReleased) {
          // touch has ended before recognition concluded
++        DDA_DEBUG("Touch has ended before recognition concluded");
          setStatus(WaitingForTouch);
          return;
+     }
--    if (event->touchPointStates().testFlag(Qt::TouchPointPressed)
--            || event->touchPoints().count() > 1) {
++    if (event->touchPointStates().testFlag(Qt::TouchPointPressed) && isWithinTouchCompositionWindow()) {
          // multi-finger drags are not accepted
--        setStatus(Rejected);
++        DDA_DEBUG("Multi-finger drags are not accepted");
++        setStatus(WaitingForTouch);
          return;
+     }
--    m_previousDampedPos.setX(m_dampedPos.x());
--    m_previousDampedPos.setY(m_dampedPos.y());
--    m_dampedPos.update(touchPos);
--    updateVelocityCalculator(touchPos);
++    m_previousDampedScenePos.setX(m_dampedScenePos.x());
++    m_previousDampedScenePos.setY(m_dampedScenePos.y());
++    m_dampedScenePos.update(touchScenePos);
++    updateVelocityCalculator(touchScenePos);
      if (!pointInsideAllowedArea()) {
--        setStatus(Rejected);
++        DDA_DEBUG("Rejecting gesture because touch point is outside allowed area.");
++        setStatus(WaitingForTouch);
          return;
+     }
      if (!movingInRightDirection()) {
--        setStatus(Rejected);
--        return;
--    }
--
--    setPreviousPos(touchPos);
--    setPreviousScenePos(touchPoint->scenePos());
--
--    if (movedFarEnough(touchPos)) {
++        DDA_DEBUG("Rejecting gesture becauuse touch point is moving in the wrong direction.");
++        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.
++        DDA_DEBUG("Sill within composition window. Let's wait more.");
++        return;
++    }
++
++    if (movedFarEnough(touchScenePos)) {
          setStatus(Recognized);
++    } else {
++        DDA_DEBUG("Didn't move far enough yet. Let's wait more.");
+     }
+ }
@@ -275,20 +411,18 @@
+ {
      const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);
--    setPreviousPos(touchPoint->pos());
--    setPreviousScenePos(touchPoint->scenePos());
--
--    if (touchPoint->state() == Qt::TouchPointReleased) {
--        setStatus(WaitingForTouch);
--    }
--}
--
--void DirectionalDragArea::touchEvent_rejected(QTouchEvent *event)
--{
--    const QTouchEvent::TouchPoint *touchPoint = fetchTargetTouchPoint(event);
--
--    if (!touchPoint || touchPoint->state() == Qt::TouchPointReleased) {
--        setStatus(WaitingForTouch);
++    if (!touchPoint) {
++        qCritical() << "DirectionalDragArea[status=Recognized]: touch " << m_touchId
++            << "missing from QTouchEvent without first reaching state Qt::TouchPointReleased. "
++               "Considering it as released.";
++        setStatus(WaitingForTouch);
++    } else {
++        setPreviousPos(touchPoint->pos());
++        setPreviousScenePos(touchPoint->scenePos());
++
++        if (touchPoint->state() == Qt::TouchPointReleased) {
++            setStatus(WaitingForTouch);
++        }
+     }
+ }
@@ -307,8 +441,8 @@
  bool DirectionalDragArea::pointInsideAllowedArea() const
+ {
--    qreal dX = m_dampedPos.x() - m_startPos.x();
--    qreal dY = m_dampedPos.y() - m_startPos.y();
++    qreal dX = m_dampedScenePos.x() - m_startScenePos.x();
++    qreal dY = m_dampedScenePos.y() - m_startScenePos.y();
      switch (m_direction) {
          case Direction::Upwards:
@@ -326,22 +460,26 @@
+ {
      switch (m_direction) {
          case Direction::Upwards:
--            return m_dampedPos.y() <= m_previousDampedPos.y();
++            return m_dampedScenePos.y() <= m_previousDampedScenePos.y();
          case Direction::Downwards:
--            return m_dampedPos.y() >= m_previousDampedPos.y();
++            return m_dampedScenePos.y() >= m_previousDampedScenePos.y();
          case Direction::Leftwards:
--            return m_dampedPos.x() <= m_previousDampedPos.x();
++            return m_dampedScenePos.x() <= m_previousDampedScenePos.x();
          default: // Direction::Rightwards:
--            return m_dampedPos.x() >= m_previousDampedPos.x();
++            return m_dampedScenePos.x() >= m_previousDampedScenePos.x();
+     }
+ }
  bool DirectionalDragArea::movedFarEnough(const QPointF &point) const
+ {
--    if (Direction::isHorizontal(m_direction))
--        return qFabs(point.x() - m_startPos.x()) > m_distanceThreshold;
--    else
--        return qFabs(point.y() - m_startPos.y()) > m_distanceThreshold;
++    if (m_distanceThreshold > 0) {
++        if (Direction::isHorizontal(m_direction))
++            return qFabs(point.x() - m_startScenePos.x()) > m_distanceThreshold;
++        else
++            return qFabs(point.y() - m_startScenePos.y()) > m_distanceThreshold;
++    } else {
++        return true;
++    }
+ }
  void DirectionalDragArea::checkSpeed()
@@ -351,7 +489,8 @@
          qreal minSpeedMsecs = m_minSpeed / 1000.0;
          if (speed < minSpeedMsecs) {
--            setStatus(Rejected);
++            DDA_DEBUG("Rejecting gesture because it's below minimum speed.");
++            setStatus(WaitingForTouch);
+         }
+     }
@@ -359,7 +498,8 @@
          m_silenceTime += m_recognitionTimer->interval();
          if (m_silenceTime > m_maxSilenceTime) {
--            setStatus(Rejected);
++            DDA_DEBUG("Rejecting gesture because it's silence time has been exceeded.");
++            setStatus(WaitingForTouch);
+         }
      } else {
          m_silenceTime = 0;
@@ -381,11 +521,13 @@
      m_status = newStatus;
      Q_EMIT statusChanged(m_status);
++    #if DIRECTIONALDRAGAREA_DEBUG
++    qDebug() << "[DDA]" << statusToString(oldStatus) << "->" << statusToString(newStatus);
++    #endif
++
      switch (newStatus) {
          case WaitingForTouch:
--            if (oldStatus != DirectionalDragArea::Rejected) {
--                Q_EMIT draggingChanged(false);
--            }
++            Q_EMIT draggingChanged(false);
              break;
          case Undecided:
              m_recognitionTimer->start();
@@ -395,9 +537,6 @@
              if (oldStatus == WaitingForTouch)
                  Q_EMIT draggingChanged(true);
              break;
--        case Rejected:
--            Q_EMIT draggingChanged(false);
--            break;
          default:
              // no-op
              break;
@@ -406,8 +545,6 @@
  void DirectionalDragArea::setPreviousPos(const QPointF &point)
+ {
--    Q_ASSERT(m_status != Rejected);
--
      bool xChanged = m_previousPos.x() != point.x();
      bool yChanged = m_previousPos.y() != point.y();
@@ -428,8 +565,6 @@
  void DirectionalDragArea::setPreviousScenePos(const QPointF &point)
+ {
--    Q_ASSERT(m_status != Rejected);
--
      bool xChanged = m_previousScenePos.x() != point.x();
      bool yChanged = m_previousScenePos.y() != point.y();
@@ -457,5 +592,106 @@
+     }
+ }
++bool DirectionalDragArea::isWithinTouchCompositionWindow()
++{
++    return !m_activeTouches.isEmpty() &&
++        m_timeSource->msecsSinceReference() <=
++            m_activeTouches.mostRecentStartTime() + (qint64)compositionTime();
++}
++
++//**************************  ActiveTouchesInfo **************************
++
++DirectionalDragArea::ActiveTouchesInfo::ActiveTouchesInfo(const SharedTimeSource &timeSource)
++    : m_timeSource(timeSource), m_lastUsedIndex(-1)
++{
++    // Estimate of the maximum number of active touches we might reach.
++    // Not a problem if it ends up being an underestimate as this is just
++    // an optimization.
++    m_vector.resize(3);
++}
++
++void DirectionalDragArea::ActiveTouchesInfo::update(QTouchEvent *event)
++{
++    if (!(event->touchPointStates() & (Qt::TouchPointPressed | Qt::TouchPointReleased))) {
++        // nothing to update
++        return;
++    }
++
++    const QList<QTouchEvent::TouchPoint> &touchPoints = event->touchPoints();
++    for (int i = 0; i < touchPoints.count(); ++i) {
++        const QTouchEvent::TouchPoint &touchPoint = touchPoints.at(i);
++        if (touchPoint.state() == Qt::TouchPointPressed) {
++            addTouchPoint(touchPoint);
++        } else if (touchPoint.state() == Qt::TouchPointReleased) {
++            removeTouchPoint(touchPoint);
++        }
++    }
++}
++
++void DirectionalDragArea::ActiveTouchesInfo::addTouchPoint(const QTouchEvent::TouchPoint &touchPoint)
++{
++    ActiveTouchInfo &activeTouchInfo = getEmptySlot();
++    activeTouchInfo.id = touchPoint.id();
++    activeTouchInfo.startTime = m_timeSource->msecsSinceReference();
++}
++
++void DirectionalDragArea::ActiveTouchesInfo::removeTouchPoint(const QTouchEvent::TouchPoint &touchPoint)
++{
++    for (int i = 0; i <= m_lastUsedIndex; ++i) {
++        if (touchPoint.id() == m_vector.at(i).id) {
++            freeSlot(i);
++            return;
++        }
++    }
++    Q_ASSERT(false); // shouldn't reach this point
++}
++
++DirectionalDragArea::ActiveTouchInfo &DirectionalDragArea::ActiveTouchesInfo::getEmptySlot()
++{
++    Q_ASSERT(m_lastUsedIndex < m_vector.size());
++
++    // Look for an in-between vacancy first
++    for (int i = 0; i < m_lastUsedIndex; ++i) {
++        ActiveTouchInfo &activeTouchInfo = m_vector[i];
++        if (!activeTouchInfo.isValid()) {
++            return activeTouchInfo;
++        }
++    }
++
++    ++m_lastUsedIndex;
++    if (m_lastUsedIndex >= m_vector.size()) {
++        m_vector.resize(m_lastUsedIndex + 1);
++    }
++
++    return m_vector[m_lastUsedIndex];
++}
++
++void DirectionalDragArea::ActiveTouchesInfo::freeSlot(int index)
++{
++    m_vector[index].reset();
++    if (index == m_lastUsedIndex) {
++        do {
++            --m_lastUsedIndex;
++        } while (m_lastUsedIndex >= 0 && !m_vector.at(m_lastUsedIndex).isValid());
++    }
++}
++
++qint64 DirectionalDragArea::ActiveTouchesInfo::mostRecentStartTime()
++{
++    Q_ASSERT(m_lastUsedIndex >= 0);
++
++    qint64 highestStartTime = m_vector.at(0).startTime;
++    int i = 1;
++    do {
++        const ActiveTouchInfo &activeTouchInfo = m_vector.at(i);
++        if (activeTouchInfo.isValid() && activeTouchInfo.startTime > highestStartTime) {
++            highestStartTime = activeTouchInfo.startTime;
++        }
++        ++i;
++    } while (i < m_lastUsedIndex);
++
++    return highestStartTime;
++}
++
  // Because we are defining a new QObject-based class (RecognitionTimer) here.
  #include "DirectionalDragArea.moc"
 === modified file 'plugins/Ubuntu/Gestures/DirectionalDragArea.h'
 --- plugins/Ubuntu/Gestures/DirectionalDragArea.h	2013-07-01 11:12:03 +0000
 +++ plugins/Ubuntu/Gestures/DirectionalDragArea.h	2013-11-05 10:55:36 +0000
@@ -117,9 +117,17 @@
      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)
++
      Q_ENUMS(Direction)
      Q_ENUMS(Status)
  public:
@@ -130,26 +138,23 @@
      // Describes the state of the directional drag gesture.
      enum Status {
--        // There's no touch point over this area.
++        // 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 Absent only once
++        // 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,
--
--        // A gesture was performed but it wasn't a single-touch drag in the correct
--        // direction.
--        // It will remain in this state until there are no more touch points over this
--        // area, at which point it will move to Absent state.
--        Rejected
      };
      Status status() const { return m_status; }
@@ -164,7 +169,7 @@
      bool dragging() const { return (m_status == Undecided) || (m_status == Recognized); }
--    qreal maxDeviation() const { return m_dampedPos.maxDelta(); }
++    qreal maxDeviation() const { return m_dampedScenePos.maxDelta(); }
      void setMaxDeviation(qreal value);
      qreal wideningAngle() const;
@@ -179,13 +184,16 @@
      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(UbuntuGestures::TimeSource *timeSource);
++    void setTimeSource(const UbuntuGestures::SharedTimeSource &timeSource);
  Q_SIGNALS:
      void directionChanged(Direction::Type direction);
@@ -198,6 +206,7 @@
      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);
@@ -213,7 +222,6 @@
      void touchEvent_absent(QTouchEvent *event);
      void touchEvent_undecided(QTouchEvent *event);
      void touchEvent_recognized(QTouchEvent *event);
--    void touchEvent_rejected(QTouchEvent *event);
      bool pointInsideAllowedArea() const;
      bool movingInRightDirection() const;
      bool movedFarEnough(const QPointF &point) const;
@@ -222,6 +230,7 @@
      void setPreviousPos(const QPointF &point);
      void setPreviousScenePos(const QPointF &point);
      void updateVelocityCalculator(const QPointF &point);
++    bool isWithinTouchCompositionWindow();
      Status m_status;
@@ -233,8 +242,8 @@
      // 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_dampedPos;
--    QPointF m_previousDampedPos;
++    DampedPointF m_dampedScenePos;
++    QPointF m_previousDampedScenePos;
      Direction::Type m_direction;
      qreal m_wideningAngle; // in degrees
@@ -243,9 +252,37 @@
      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);
++        ActiveTouchInfo &touchInfo(int id);
++        qint64 mostRecentStartTime();
++        UbuntuGestures::SharedTimeSource m_timeSource;
++        bool isEmpty() const { return m_lastUsedIndex == -1; }
++    private:
++        void addTouchPoint(const QTouchEvent::TouchPoint &touchPoint);
++        ActiveTouchInfo &getEmptySlot();
++        void freeSlot(int index);
++        void removeTouchPoint(const QTouchEvent::TouchPoint &touchPoint);
++        QVector<struct ActiveTouchInfo> m_vector;
++        int m_lastUsedIndex;
++    } m_activeTouches;
  };
  #endif // DIRECTIONAL_DRAG_AREA_H
 === added file 'plugins/Ubuntu/Gestures/TimeSource.cpp'
 --- plugins/Ubuntu/Gestures/TimeSource.cpp	1970-01-01 00:00:00 +0000
 +++ plugins/Ubuntu/Gestures/TimeSource.cpp	2013-11-05 10:55:36 +0000
@@ -0,0 +1,49 @@
++/*
++ * Copyright (C) 2013 - Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License, as
++ * published by the  Free Software Foundation; either version 2.1 or 3.0
++ * of the License.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the applicable version of the GNU Lesser General Public
++ * License for more details.
++ *
++ * You should have received a copy of both the GNU Lesser General Public
++ * License along with this program. If not, see <http://www.gnu.org/licenses/>
++ *
++ * Authored by: Daniel d'Andrada <daniel.dandrada@canonical.com>
++ */
++
++#include "TimeSource.h"
++
++#include <QElapsedTimer>
++
++namespace UbuntuGestures {
++class RealTimeSourcePrivate {
++public:
++    QElapsedTimer timer;
++};
++}
++
++using namespace UbuntuGestures;
++
++RealTimeSource::RealTimeSource()
++    : UbuntuGestures::TimeSource()
++    , d(new RealTimeSourcePrivate)
++{
++    d->timer.start();
++}
++
++RealTimeSource::~RealTimeSource()
++{
++    delete d;
++}
++
++qint64 RealTimeSource::msecsSinceReference()
++{
++    return d->timer.elapsed();
++}
 === added file 'plugins/Ubuntu/Gestures/TimeSource.h'
 --- plugins/Ubuntu/Gestures/TimeSource.h	1970-01-01 00:00:00 +0000
 +++ plugins/Ubuntu/Gestures/TimeSource.h	2013-11-05 10:55:36 +0000
@@ -0,0 +1,54 @@
++/*
++ * Copyright (C) 2013 - Canonical Ltd.
++ *
++ * This program is free software: you can redistribute it and/or modify it
++ * under the terms of the GNU Lesser General Public License, as
++ * published by the  Free Software Foundation; either version 2.1 or 3.0
++ * of the License.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranties of
++ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
++ * PURPOSE.  See the applicable version of the GNU Lesser General Public
++ * License for more details.
++ *
++ * You should have received a copy of both the GNU Lesser General Public
++ * License along with this program. If not, see <http://www.gnu.org/licenses/>
++ *
++ * Authored by: Daniel d'Andrada <daniel.dandrada@canonical.com>
++ */
++
++#ifndef UBUNTUGESTURES_TIMESOURCE_H
++#define UBUNTUGESTURES_TIMESOURCE_H
++
++#include "UbuntuGesturesGlobal.h"
++#include <QSharedPointer>
++
++namespace UbuntuGestures {
++/*
++    Interface for a time source.
++ */
++class UBUNTUGESTURES_EXPORT TimeSource {
++public:
++    virtual ~TimeSource() {}
++    /* Returns the current time in milliseconds since some reference time in the past. */
++    virtual qint64 msecsSinceReference() = 0;
++};
++typedef QSharedPointer<TimeSource> SharedTimeSource;
++
++/*
++    Implementation of a time source
++ */
++class RealTimeSourcePrivate;
++class RealTimeSource : public TimeSource {
++public:
++    RealTimeSource();
++    virtual ~RealTimeSource();
++    qint64 msecsSinceReference() override;
++private:
++    RealTimeSourcePrivate *d;
++};
++
++} // namespace UbuntuGestures
++
++#endif // UBUNTUGESTURES_TIMESOURCE_H
 === modified file 'tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml'
 --- tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml	2013-06-14 15:52:02 +0000
 +++ tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml	2013-11-05 10:55:36 +0000
@@ -31,10 +31,7 @@
          y: followDragArea()
          function followDragArea() {
--            if (dragArea.status === DirectionalDragArea.Rejected)
--                return -height
--            else
--                return dragArea.distance < height ? -height + dragArea.distance : 0
++            return dragArea.distance < height ? -height + dragArea.distance : 0
+         }
+     }
@@ -66,15 +63,10 @@
                      dragAreaRect.opacity = 0.3
                      launcher.y = Qt.binding(launcher.followDragArea)
                      break;
--                case DirectionalDragArea.Recognized:
++                defaut: // DirectionalDragArea.Recognized:
                      dragAreaRect.color = "green"
                      dragAreaRect.opacity = 0.5
                      break;
--                default: //case DirectionalDragArea.Rejected:
--                    dragAreaRect.color = "red"
--                    dragAreaRect.opacity = 0.5
--                    launcher.y = -launcher.height
--                    break;
+             }
+         }
 === modified file 'tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml'
 --- tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml	2013-06-14 15:52:02 +0000
 +++ tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml	2013-11-05 10:55:36 +0000
@@ -32,13 +32,10 @@
          y: 0
          function followDragArea() {
--            if (dragArea.status === DirectionalDragArea.Rejected)
--                return root.width
--            else
--                return dragArea.distance > -width ?
--                            root.width + dragArea.distance
--                        :
--                            root.width - width
++            return dragArea.distance > -width ?
++                        root.width + dragArea.distance
++                    :
++                        root.width - width
+         }
+     }
@@ -69,15 +66,10 @@
                      dragAreaRect.opacity = 0.3
                      launcher.x = Qt.binding(launcher.followDragArea)
                      break;
--                case DirectionalDragArea.Recognized:
++                default: //case DirectionalDragArea.Recognized:
                      dragAreaRect.color = "green"
                      dragAreaRect.opacity = 0.5
                      break;
--                default: //case DirectionalDragArea.Rejected:
--                    dragAreaRect.color = "red"
--                    dragAreaRect.opacity = 0.5
--                    launcher.x = -launcher.height
--                    break;
+             }
+         }
 === modified file 'tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml'
 --- tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml	2013-06-14 15:52:02 +0000
 +++ tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml	2013-11-05 10:55:36 +0000
@@ -19,6 +19,7 @@
  import Ubuntu.Components 0.1
  Item {
++    objectName: "rightwardsLauncher"
      function reset() { launcher.x = -launcher.width }
@@ -31,10 +32,7 @@
          y: 0
          function followDragArea() {
--            if (dragArea.status === DirectionalDragArea.Rejected)
--                return -width
--            else
--                return dragArea.distance < width ? -width + dragArea.distance : 0
++            return dragArea.distance < width ? -width + dragArea.distance : 0
+         }
+     }
@@ -66,15 +64,10 @@
                      dragAreaRect.opacity = 0.3
                      launcher.x = Qt.binding(launcher.followDragArea)
                      break;
--                case DirectionalDragArea.Recognized:
++                default: //case DirectionalDragArea.Recognized:
                      dragAreaRect.color = "green"
                      dragAreaRect.opacity = 0.5
                      break;
--                default: //case DirectionalDragArea.Rejected:
--                    dragAreaRect.color = "red"
--                    dragAreaRect.opacity = 0.5
--                    launcher.x = -launcher.height
--                    break;
+             }
+         }
 === modified file 'tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml'
 --- tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml	2013-06-14 15:52:02 +0000
 +++ tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml	2013-11-05 10:55:36 +0000
@@ -32,13 +32,10 @@
          y: root.height
          function followDragArea() {
--            if (dragArea.status === DirectionalDragArea.Rejected)
--                return root.height
--            else
--                return dragArea.distance > -height ?
--                            root.height + dragArea.distance
--                        :
--                            root.height - height
++            return dragArea.distance > -height ?
++                        root.height + dragArea.distance
++                    :
++                        root.height - height
+         }
+     }
@@ -69,15 +66,10 @@
                      dragAreaRect.opacity = 0.3
                      launcher.y = Qt.binding(launcher.followDragArea)
                      break;
--                case DirectionalDragArea.Recognized:
++                default: //case DirectionalDragArea.Recognized:
                      dragAreaRect.color = "green"
                      dragAreaRect.opacity = 0.5
                      break;
--                default: //case DirectionalDragArea.Rejected:
--                    dragAreaRect.color = "red"
--                    dragAreaRect.opacity = 0.5
--                    launcher.y = -launcher.height
--                    break;
+             }
+         }
 === modified file 'tests/plugins/Ubuntu/Gestures/edgeDragExample.qml'
 --- tests/plugins/Ubuntu/Gestures/edgeDragExample.qml	2013-06-05 22:03:08 +0000
 +++ tests/plugins/Ubuntu/Gestures/edgeDragExample.qml	2013-11-05 10:55:36 +0000
@@ -33,7 +33,13 @@
+         }
+     }
--    RightwardsLauncher { id: hpLauncher; anchors.fill: parent }
++    // NB: Do not anchor it as we will move it programmatically from the test
++    RightwardsLauncher {
++        id: hpLauncher;
++        width: parent.width
++        height: parent.height
++    }
++
      LeftwardsLauncher { id: hnLauncher; anchors.fill: parent }
      DownwardsLauncher { id: vpLauncher; anchors.fill: parent }
      UpwardsLauncher { id: vnLauncher; anchors.fill: parent }
 === modified file 'tests/plugins/Ubuntu/Gestures/tst_AxisVelocityCalculator.cpp'
 --- tests/plugins/Ubuntu/Gestures/tst_AxisVelocityCalculator.cpp	2013-06-19 08:30:17 +0000
 +++ tests/plugins/Ubuntu/Gestures/tst_AxisVelocityCalculator.cpp	2013-11-05 10:55:36 +0000
@@ -54,12 +54,12 @@
  private:
      AxisVelocityCalculator *velCalc;
--    FakeTimeSource *fakeTimeSource;
++    QSharedPointer<FakeTimeSource> fakeTimeSource;
  };
  void tst_AxisVelocityCalculator::init()
+ {
--    fakeTimeSource = new FakeTimeSource;
++    fakeTimeSource.reset(new FakeTimeSource);
      velCalc = new AxisVelocityCalculator;
      velCalc->setTimeSource(fakeTimeSource);
@@ -68,7 +68,7 @@
  void tst_AxisVelocityCalculator::cleanup()
+ {
      delete velCalc;
--    delete fakeTimeSource;
++    fakeTimeSource.reset();
+ }
  void tst_AxisVelocityCalculator::simpleSamples()
 === modified file 'tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp'
 --- tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp	2013-06-28 16:18:53 +0000
 +++ tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp	2013-11-05 10:55:36 +0000
@@ -19,23 +19,38 @@
  #include <qpa/qwindowsysteminterface.h>
  #include <QtQuick/QQuickView>
  #include <QtQml/QQmlEngine>
++#include <QPointer>
  #include <DirectionalDragArea.h>
--class FakeTimer : public UbuntuGestures::AbstractTimer
++using namespace UbuntuGestures;
++
++class FakeTimer : public AbstractTimer
+ {
      Q_OBJECT
  public:
--    FakeTimer(QObject *parent = 0)
--        : UbuntuGestures::AbstractTimer(parent)
++    FakeTimer(const SharedTimeSource &timeSource, QObject *parent = 0)
++        : UbuntuGestures::AbstractTimer(parent),
++          m_timeSource(timeSource)
      {}
--    virtual int interval() const { return m_duration; }
--    virtual void setInterval(int msecs) { m_duration = msecs; }
--
--    void emitTimeout() {Q_EMIT timeout();}
++    int interval() const override { return m_interval; }
++    void setInterval(int msecs) override { m_interval = msecs; }
++    void start() override {
++        AbstractTimer::start();
++        m_nextTimeoutTime = m_timeSource->msecsSinceReference() + (qint64)m_interval;
++    }
++
++    void emitTimeout() {
++        m_nextTimeoutTime += m_interval;
++        Q_EMIT timeout();
++    }
++
++    qint64 nextTimeoutTime() const { return m_nextTimeoutTime; }
  private:
--    int m_duration;
++    int m_interval;
++    SharedTimeSource m_timeSource;
++    qint64 m_nextTimeoutTime;
  };
  class FakeTimeSource : public UbuntuGestures::TimeSource
@@ -67,14 +82,17 @@
      void maxSilenceTime();
      void sceneXAndX();
      void sceneYAndY();
--    void emitDraggingChangedOnDirectRecognition();
++    void twoFingerTap();
++    void movingDDA();
++    void ignoreOldFinger();
  private:
      QQuickView *createView();
++    void passTime(qint64 timeSpan);
      QQuickView *view;
      QTouchDevice *device;
      FakeTimer *fakeTimer;
--    FakeTimeSource *fakeTimeSource;
++    QSharedPointer<FakeTimeSource> fakeTimeSource;
  };
  void tst_DirectionalDragArea::initTestCase()
@@ -101,8 +119,8 @@
      QVERIFY(view->rootObject() != 0);
      qApp->processEvents();
--    fakeTimer = new FakeTimer;
--    fakeTimeSource = new FakeTimeSource;
++    fakeTimeSource.reset(new FakeTimeSource);
++    fakeTimer = new FakeTimer(fakeTimeSource);
+ }
  void tst_DirectionalDragArea::cleanup()
@@ -113,8 +131,7 @@
      delete fakeTimer;
      fakeTimer = 0;
--    delete fakeTimeSource;
--    fakeTimeSource = 0;
++    fakeTimeSource.reset();
+ }
  QQuickView *tst_DirectionalDragArea::createView()
@@ -127,6 +144,23 @@
      return window;
+ }
++void tst_DirectionalDragArea::passTime(qint64 timeSpan)
++{
++    qint64 finalTime = fakeTimeSource->m_msecsSinceReference + timeSpan;
++
++    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;
++    }
++}
++
  namespace {
  QPointF calculateInitialTouchPos(DirectionalDragArea *edgeDragArea, QQuickView *view)
+ {
@@ -180,7 +214,7 @@
      QFETCH(QString, dragAreaObjectName);
      QFETCH(qreal, wideningAngleMultiplier);
      QFETCH(qreal, dragDistanceFactor);
--    QFETCH(int, expectedGestureRecognition);
++    QFETCH(bool, expectGestureRecognition);
      DirectionalDragArea *edgeDragArea =
          view->rootObject()->findChild<DirectionalDragArea*>(dragAreaObjectName);
@@ -196,7 +230,10 @@
      qreal desiredDragDistance = edgeDragArea->distanceThreshold()*dragDistanceFactor;
      QPointF dragDirectionVector = calculateDirectionVector(edgeDragArea,
                                                             wideningAngleMultiplier);
--    QPointF touchMovement = dragDirectionVector * (edgeDragArea->distanceThreshold() * 0.1f);
++    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
++    QPointF touchMovement = dragDirectionVector * movementStepDistance;
++    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
++    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
      QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
@@ -211,15 +248,16 @@
          QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
+     }
--    do {
++    for (int i = 0; i < totalMovementSteps; ++i) {
          touchPoint += touchMovement;
++        passTime(movementTimeStepMs);
          QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
--    } while ((touchPoint - initialTouchPos).manhattanLength() < desiredDragDistance);
++    }
--    if (expectedGestureRecognition)
++    if (expectGestureRecognition)
          QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
--    if (edgeDragArea->status() == DirectionalDragArea::Rejected) {
++    if (edgeDragArea->status() == DirectionalDragArea::WaitingForTouch) {
          QCOMPARE(edgeDragArea->dragging(), false);
          QCOMPARE(draggingSpy.count(), 2);
+     }
@@ -235,49 +273,49 @@
      QTest::addColumn<QString>("dragAreaObjectName");
      QTest::addColumn<qreal>("wideningAngleMultiplier");
      QTest::addColumn<qreal>("dragDistanceFactor");
--    QTest::addColumn<int>("expectedGestureRecognition");
++    QTest::addColumn<bool>("expectGestureRecognition");
      QTest::newRow("rightwards, tiny drag")
--        << "hpDragArea" << 0.0 << 0.2 << 0;
++        << "hpDragArea" << 0.0 << 0.2 << false;
      QTest::newRow("rightwards, straight drag")
--        << "hpDragArea" << 0.0 << 3.0 << 1;
++        << "hpDragArea" << 0.0 << 3.0 << true;
      QTest::newRow("rightwards, diagonal drag")
--        << "hpDragArea" << 0.9 << 3.0 << 1;
++        << "hpDragArea" << 0.9 << 3.0 << true;
      QTest::newRow("rightwards, overly diagonal drag")
--        << "hpDragArea" << 2.0 << 3.0 << 0;
++        << "hpDragArea" << 2.0 << 3.0 << false;
      QTest::newRow("leftwards, tiny drag")
--        << "hnDragArea" << 0.0 << 0.2 << 0;
++        << "hnDragArea" << 0.0 << 0.2 << false;
      QTest::newRow("leftwards, straight drag")
--        << "hnDragArea" << 0.0 << 3.0 << 1;
++        << "hnDragArea" << 0.0 << 3.0 << true;
      QTest::newRow("leftwards, diagonal drag")
--        << "hnDragArea" << 0.9 << 3.0 << 1;
++        << "hnDragArea" << 0.9 << 3.0 << true;
      QTest::newRow("downwards, tiny drag")
--        << "vpDragArea" << 0.0 << 0.2 << 0;
++        << "vpDragArea" << 0.0 << 0.2 << false;
      QTest::newRow("downwards, straight drag")
--        << "vpDragArea" << 0.0 << 3.0 << 1;
++        << "vpDragArea" << 0.0 << 3.0 << true;
      QTest::newRow("downwards, diagonal drag")
--        << "vpDragArea" << 0.9 << 3.0 << 1;
++        << "vpDragArea" << 0.9 << 3.0 << true;
      QTest::newRow("upwards, tiny drag")
--        << "vnDragArea" << 0.0 << 0.2 << 0;
++        << "vnDragArea" << 0.0 << 0.2 << false;
      QTest::newRow("upwards, straight drag")
--        << "vnDragArea" << 0.0 << 3.0 << 1;
++        << "vnDragArea" << 0.0 << 3.0 << true;
      QTest::newRow("upwards, diagonal drag")
--        << "vnDragArea" << 0.9 << 3.0 << 1;
++        << "vnDragArea" << 0.9 << 3.0 << true;
      QTest::newRow("upwards, overly diagonal drag")
--        << "vnDragArea" << 2.0 << 3.0 << 0;
++        << "vnDragArea" << 2.0 << 3.0 << false;
+ }
  /*
@@ -298,25 +336,33 @@
      qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0;
      QPointF dragDirectionVector(1.0, 0.0);
--    QPointF touchMovement = dragDirectionVector * (edgeDragArea->distanceThreshold() * 0.1f);
++    qreal touchStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
++    // make sure we are above minimum speed
++    int touchStepTimeMs = (touchStepDistance / (edgeDragArea->minSpeed() * 5.0f)) * 1000.0f;
++    QPointF touchMovement = dragDirectionVector * touchStepDistance;
      QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
      // Move a bit in the proper direction
      for (int i=0; i < 3; ++i) {
          touchPoint += touchMovement;
++        passTime(touchStepTimeMs);
          QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
+     }
      // Then a sudden and small movement to the opposite direction
--    touchPoint -= dragDirectionVector * (edgeDragArea->maxDeviation() * 0.7);
++    touchPoint -= touchMovement*0.2;
++    passTime(touchStepTimeMs*0.2);
      QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
--    // And then resume movment in the correct direction until it crosses the distance threshold.
++    // And then resume movment in the correct direction until it crosses the distance and time
++    // thresholds.
      do {
          touchPoint += touchMovement;
++        passTime(touchStepTimeMs);
          QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
--    } while ((touchPoint - initialTouchPos).manhattanLength() < desiredDragDistance);
++    } while ((touchPoint - initialTouchPos).manhattanLength() < desiredDragDistance
++            || fakeTimeSource->m_msecsSinceReference < (edgeDragArea->compositionTime() * 1.5f));
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
@@ -329,7 +375,8 @@
   */
  void tst_DirectionalDragArea::minSpeed()
+ {
--    QFETCH(int, minSpeedMsecsDeviation);
++    QFETCH(qreal, minSpeed);
++    QFETCH(qreal, speed);
      QFETCH(int, expectedStatusAfterSpeedCheck);
      DirectionalDragArea *edgeDragArea =
@@ -338,44 +385,40 @@
      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, view);
      QPointF touchPoint = initialTouchPos;
      QPointF dragDirectionVector(1.0, 0.0);
--    qreal distanceStep = edgeDragArea->distanceThreshold() * 0.1f;
++    qint64 timeStepMsecs = 10;
++    qreal distanceStep = (speed / 1000.0f) * timeStepMsecs;
      QPointF touchMovement = dragDirectionVector * distanceStep;
--    qreal minSpeedMsecs = edgeDragArea->minSpeed() / 1000.0;
--    qint64 timeStepMsecs = qFloor(distanceStep / minSpeedMsecs) + minSpeedMsecsDeviation;
--
--    // if it fails it means the params set in the QML file are not in harmony with the values
--    // used in this test
--    Q_ASSERT(timeStepMsecs > 0);
--
--    fakeTimeSource->m_msecsSinceReference = 0;
++
      QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
--    // Move a bit in the proper direction
--    for (int i=0; i < 4; ++i) {
++    // Move for a while to ensure our speed check is performed a couple of times
++    for (int i=0; i < 20; ++i) {
          touchPoint += touchMovement;
--        fakeTimeSource->m_msecsSinceReference += timeStepMsecs;
++        passTime(timeStepMsecs);
          QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
+     }
--    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
--
--    // Force the periodic speed check.
--    fakeTimer->emitTimeout();
--
      QCOMPARE((int)edgeDragArea->status(), expectedStatusAfterSpeedCheck);
+ }
  void tst_DirectionalDragArea::minSpeed_data()
+ {
--    QTest::addColumn<int>("minSpeedMsecsDeviation");
++    QTest::addColumn<qreal>("minSpeed");
++    QTest::addColumn<qreal>("speed");
      QTest::addColumn<int>("expectedStatusAfterSpeedCheck");
--    QTest::newRow("slower than minSpeed") << 20 << (int)DirectionalDragArea::Rejected;
--    QTest::newRow("faster than minSpeed") << -20 << (int)DirectionalDragArea::Undecided;
++    QTest::newRow("slower than minSpeed") << 100.0 << 50.0 << (int)DirectionalDragArea::WaitingForTouch;
++    QTest::newRow("faster than minSpeed") << 100.0 << 150.0 << (int)DirectionalDragArea::Undecided;
+ }
  /*
@@ -391,32 +434,37 @@
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
++    // don't let it interfere with our test
++    edgeDragArea->setMinSpeed(0.0);
++
++    int timeStepMs = 5; // some arbitrary small value.
++
      QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);
      QPointF touchPoint = initialTouchPos;
      QPointF dragDirectionVector(1.0, 0.0);
      QPointF touchMovement = dragDirectionVector * (edgeDragArea->distanceThreshold() * 0.2f);
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
      QVERIFY(!fakeTimer->isRunning());
      QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
      QVERIFY(fakeTimer->isRunning());
--    // Move a bit in the proper direction
--    for (int i=0; i < 3; ++i) {
++    // Move beyond distance threshold and composition time to ensure recognition
++    while (fakeTimeSource->m_msecsSinceReference <= edgeDragArea->compositionTime() ||
++           (touchPoint - initialTouchPos).manhattanLength() <= edgeDragArea->distanceThreshold()) {
++
++        QCOMPARE(edgeDragArea->status() == DirectionalDragArea::Undecided, fakeTimer->isRunning());
++
          touchPoint += touchMovement;
++        passTime(timeStepMs);
          QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
+     }
--    QVERIFY(fakeTimer->isRunning());
--
--    // Move beyond distance threshold
--    touchPoint += 3*touchMovement;
--    QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
--
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
--
      QVERIFY(!fakeTimer->isRunning());
+ }
@@ -432,29 +480,23 @@
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
++    // Make sure this property is not disabled
++    edgeDragArea->setMaxSilenceTime(100);
++
      QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);
      QPointF touchPoint = initialTouchPos;
--    fakeTimeSource->m_msecsSinceReference = 0;
      QTest::touchEvent(view, device).press(0, touchPoint.toPoint());
      QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
--
--    int neededTimeouts = qCeil((qreal)edgeDragArea->maxSilenceTime() / (qreal)fakeTimer->interval());
--    if ((edgeDragArea->maxSilenceTime() % fakeTimer->interval()) == 0) {
--        ++neededTimeouts;
--    }
--
--    // Force the periodic speed check.
--    for (int i = 0; i < neededTimeouts; ++i) {
--        fakeTimer->emitTimeout();
--
--        if (i < neededTimeouts - 1) {
--            QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
--        }
--    }
--
--    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Rejected);
++    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);
+ }
  /*
@@ -471,7 +513,6 @@
      QPointF touchScenePos(view->width() - (edgeDragArea->width()/2.0f), view->height()/2.0f);
--    fakeTimeSource->m_msecsSinceReference = 0;
      QTest::touchEvent(view, device).press(0, touchScenePos.toPoint());
      QSignalSpy touchXSpy(edgeDragArea, SIGNAL(touchXChanged(qreal)));
@@ -500,7 +541,6 @@
      QPointF touchScenePos(view->width()/2.0f, view->height() - (edgeDragArea->height()/2.0f));
--    fakeTimeSource->m_msecsSinceReference = 0;
      QTest::touchEvent(view, device).press(0, touchScenePos.toPoint());
      QSignalSpy touchYSpy(edgeDragArea, SIGNAL(touchYChanged(qreal)));
@@ -516,11 +556,12 @@
+ }
  /*
--  Emit draggingChanged() when status change from WaitingForTouch directly to Recognized.
--  This happens when the gesture recognition is effectively disabled (e.g. by setting a
--  distanceThreshold of zero)
++  Regression test for https://bugs.launchpad.net/bugs/1228336
++
++  Perform a quick two-finger double-tap and check that DirectionalDragArea properly
++  rejects those touch points. In the bug above it got confused and crashed.
   */
--void tst_DirectionalDragArea::emitDraggingChangedOnDirectRecognition()
++void tst_DirectionalDragArea::twoFingerTap()
+ {
      DirectionalDragArea *edgeDragArea =
          view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
@@ -528,22 +569,170 @@
      edgeDragArea->setRecognitionTimer(fakeTimer);
      edgeDragArea->setTimeSource(fakeTimeSource);
--    QPointF touchPos = calculateInitialTouchPos(edgeDragArea, view);
--
--    QSignalSpy draggingSpy(edgeDragArea, SIGNAL(draggingChanged(bool)));
--
--    // That will make it completetly skip the recognition phase ("Undecided" status).
--    edgeDragArea->setDistanceThreshold(0.0);
--
--    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
--    QCOMPARE(edgeDragArea->dragging(), false);
--
--    fakeTimeSource->m_msecsSinceReference = 0;
--    QTest::touchEvent(view, device).press(0, touchPos.toPoint());
--
--    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
--    QCOMPARE(draggingSpy.count(), 1);
--    QCOMPARE(edgeDragArea->dragging(), true);
++    // Make touches evenly spaced along the edgeDragArea
++    QPoint touchAPos(edgeDragArea->width()/2.0f, view->height()*0.33f);
++    QPoint touchBPos(edgeDragArea->width()/2.0f, view->height()*0.66f);
++
++    qint64 timeStepMsecs = 5; // some arbitrary, small value
++
++    // Perform the first two-finger tap
++    // NB: using move() instead of stationary() becasue in the latter you cannot provide
++    //     the touch position and therefore it's left with some garbage numbers.
++    QTest::touchEvent(view, device)
++        .press(0, touchAPos);
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
++
++    passTime(timeStepMsecs);
++    QTest::touchEvent(view, device)
++        .move(0, touchAPos)
++        .press(1, touchBPos);
++
++    // 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);
++
++    passTime(timeStepMsecs);
++    QTest::touchEvent(view, device)
++        .release(0, touchAPos)
++        .move(1, touchBPos);
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
++
++    passTime(timeStepMsecs);
++    QTest::touchEvent(view, device)
++        .release(1, touchBPos);
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
++
++    // Perform the second two-finger tap
++
++    passTime(timeStepMsecs);
++    QTest::touchEvent(view, device)
++        .press(0, touchAPos);
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
++
++    passTime(timeStepMsecs);
++    QTest::touchEvent(view, device)
++        .move(0, touchAPos)
++        .press(1, touchBPos);
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
++
++    passTime(timeStepMsecs);
++    QTest::touchEvent(view, device)
++        .release(0, touchAPos)
++        .move(1, touchBPos);
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
++
++    passTime(timeStepMsecs);
++    QTest::touchEvent(view, device)
++        .release(1, touchBPos);
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
++}
++
++/*
++   Tests that gesture recognition works normally even if the DirectionalDragArea moves
++   during recognition.
++   This effectively means that we have to do gesture recognition with scene coordinates
++   instead of local item coordinates.
++ */
++void tst_DirectionalDragArea::movingDDA()
++{
++    QQuickItem *rightwardsLauncher =  view->rootObject()->findChild<QQuickItem*>("rightwardsLauncher");
++    Q_ASSERT(rightwardsLauncher != 0);
++
++    DirectionalDragArea *edgeDragArea =
++        rightwardsLauncher->findChild<DirectionalDragArea*>("hpDragArea");
++    Q_ASSERT(edgeDragArea != 0);
++    edgeDragArea->setRecognitionTimer(fakeTimer);
++    edgeDragArea->setTimeSource(fakeTimeSource);
++
++    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, view);
++    QPointF touchPoint = initialTouchPos;
++
++    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
++    QPointF dragDirectionVector(1.0f, 0.0f);
++
++    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
++    QPointF touchMovement = dragDirectionVector * movementStepDistance;
++    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
++    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
++
++    QTest::touchEvent(view, 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);
++
++    for (int i = 0; i < totalMovementSteps; ++i) {
++        touchPoint += touchMovement;
++        passTime(movementTimeStepMs);
++        QTest::touchEvent(view, device).move(0, touchPoint.toPoint());
++    }
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
++
++    QTest::touchEvent(view, device).release(0, touchPoint.toPoint());
++}
++
++/*
++    The presence of and old, rejected, touch point lying on the DirectionalDragArea
++    shouldn't impede the recognition of a gesture from a new touch point.
++ */
++void tst_DirectionalDragArea::ignoreOldFinger()
++{
++    DirectionalDragArea *edgeDragArea =
++        view->rootObject()->findChild<DirectionalDragArea*>("hpDragArea");
++    Q_ASSERT(edgeDragArea != 0);
++    edgeDragArea->setRecognitionTimer(fakeTimer);
++    edgeDragArea->setTimeSource(fakeTimeSource);
++
++    // Make touches evenly spaced along the edgeDragArea
++    QPoint touch0Pos(edgeDragArea->width()/2.0f, view->height()*0.33f);
++    QPoint touch1Pos(edgeDragArea->width()/2.0f, view->height()*0.66f);
++
++    QTest::touchEvent(view, device).press(0, touch0Pos);
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::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;
++    QPointF dragDirectionVector(1.0f, 0.0f);
++
++    qreal movementStepDistance = edgeDragArea->distanceThreshold() * 0.1f;
++    QPointF touchMovement = dragDirectionVector * movementStepDistance;
++    int totalMovementSteps = qCeil(desiredDragDistance / movementStepDistance);
++    int movementTimeStepMs = (edgeDragArea->compositionTime() * 1.5f) / totalMovementSteps;
++
++    QTest::touchEvent(view, device)
++        .move(0, touch0Pos)
++        .press(1, touch1Pos);
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Undecided);
++
++    for (int i = 0; i < totalMovementSteps; ++i) {
++        touch1Pos += touchMovement.toPoint();
++        passTime(movementTimeStepMs);
++        QTest::touchEvent(view, device)
++            .move(0, touch0Pos)
++            .move(1, touch1Pos);
++    }
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
++
++    QTest::touchEvent(view, device)
++        .move(0, touch0Pos)
++        .release(1, touch1Pos);
++
++    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
+ }
  QTEST_MAIN(tst_DirectionalDragArea)
 === modified file 'tests/qmltests/Components/tst_DragHandle.cpp'
 --- tests/qmltests/Components/tst_DragHandle.cpp	2013-07-01 16:32:00 +0000
 +++ tests/qmltests/Components/tst_DragHandle.cpp	2013-11-05 10:55:36 +0000
@@ -41,7 +41,7 @@
+ {
  public:
      FakeTimeSource() { m_msecsSinceReference = 0; }
--    virtual qint64 msecsSinceReference() {return m_msecsSinceReference;}
++    qint64 msecsSinceReference() override {return m_msecsSinceReference;}
      qint64 m_msecsSinceReference;
  };
@@ -73,7 +73,7 @@
      QQuickView *m_view;
      QTouchDevice *m_device;
      FakeTimer *m_fakeTimer;
--    FakeTimeSource *m_fakeTimeSource;
++    QSharedPointer<FakeTimeSource> m_fakeTimeSource;
  };
@@ -102,7 +102,7 @@
      qApp->processEvents();
      m_fakeTimer = new FakeTimer;
--    m_fakeTimeSource = new FakeTimeSource;
++    m_fakeTimeSource.reset(new FakeTimeSource);
+ }
  void tst_DragHandle::cleanup()
@@ -113,8 +113,7 @@
      delete m_fakeTimer;
      m_fakeTimer = 0;
--    delete m_fakeTimeSource;
--    m_fakeTimeSource = 0;
++    m_fakeTimeSource.reset();
+ }
  QQuickView *tst_DragHandle::createView()
 === modified file 'tests/qmltests/Panel/tst_Panel.qml'
 --- tests/qmltests/Panel/tst_Panel.qml	2013-08-22 18:37:09 +0000
 +++ tests/qmltests/Panel/tst_Panel.qml	2013-11-05 10:55:36 +0000
@@ -52,7 +52,6 @@
              {tag: "fullscreen", fullscreenFlag: true }
          ]}
--
          function init() {
              searchClicked = false;
              panel.indicators.hide();
 === modified file 'tests/qmltests/tst_Shell.qml'
 --- tests/qmltests/tst_Shell.qml	2013-10-09 20:01:12 +0000
 +++ tests/qmltests/tst_Shell.qml	2013-11-05 10:55:36 +0000
@@ -55,19 +55,42 @@
          when: windowShown
          function initTestCase() {
++            var ok = false;
++            var attempts = 0;
++            var maxAttempts = 1000;
++
++            // Qt loads a qml scene asynchronously. So early on, some findChild() calls made in
++            // tests may fail because the desired child item wasn't loaded yet.
++            // Thus here we try to ensure the scene has been fully loaded before proceeding with the tests.
++            // As I couldn't find an API in QQuickView & friends to tell me that the scene is 100% loaded
++            // (all items instantiated, etc), I resort to checking the existence of some key items until
++            // repeatedly until they're all there.
++            do {
++                var dashContentList = findChild(shell, "dashContentList");
++                waitForRendering(dashContentList);
++                var homeLoader = findChild(dashContentList, "home.scope loader");
++                ok = homeLoader !== undefined
++                    && homeLoader.item !== undefined;
++
++                var greeter = findChild(shell, "greeter");
++                ok &= greeter !== undefined;
++
++                var launcherPanel = findChild(shell, "launcherPanel");
++                ok &= launcherPanel !== undefined;
++
++                attempts++;
++                if (!ok) {
++                    console.log("Attempt " + attempts + " failed. Waiting a bit before trying again.");
++                    // wait a bit before retrying
++                    wait(100);
++                } else {
++                    console.log("All seem fine after " + attempts + " attempts.");
++                }
++            } while (!ok && attempts <= maxAttempts);
++
++            verify(ok);
++
              swipeAwayGreeter();
--
--            // Ensure DashHome is loaded before continuing
--            var dashContentList = findChild(shell, "dashContentList");
--            waitForRendering(dashContentList);
--            var homeLoader = findChild(dashContentList, "home.scope loader");
--            verify(homeLoader);
--            tryCompareFunction(function() {return homeLoader.item !== undefined;}, true);
--
--            // FIXME: Desperate measure to ensure Jenkins has the scene graph fully loaded
--            // before it calls the test functions (otherwise findChild calls will fail).
--            // The code above just didn't solve it.
--            wait(2000);
+         }
          function cleanup() {
 === modified file 'tests/utils/modules/Unity/Test/UnityTestCase.qml'
 --- tests/utils/modules/Unity/Test/UnityTestCase.qml	2013-08-22 18:36:46 +0000
 +++ tests/utils/modules/Unity/Test/UnityTestCase.qml	2013-11-05 10:55:36 +0000
@@ -14,6 +14,7 @@
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
++import QtQuick 2.0
  import QtTest 1.0
  import Ubuntu.Components 0.1
  import Unity.Test 0.1 as UT
@@ -297,4 +298,37 @@
          event.release(0 /* touchId */, x, y)
          event.commit()
+     }
++
++    Component.onCompleted: {
++        var rootItem = parent;
++        while (rootItem.parent != undefined) {
++            rootItem = rootItem.parent;
++        }
++        removeTimeConstraintsFromDirectionalDragAreas(rootItem);
++    }
++
++    /*
++      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 from DirectionalDragAreas that are sensible to
++      elapsed time.
++
++      This effectively makes DirectionalDragAreas easier to fool.
++     */
++    function removeTimeConstraintsFromDirectionalDragAreas(item) {
++
++        // use duck-typing to identify a DirectionalDragArea
++        if (item.minSpeed != undefined
++                && item.maxSilenceTime != undefined
++                && item.compositionTime != undefined) {
++            item.minSpeed = 0;
++            item.maxSilenceTime = 60 * 60 * 1000;
++            item.compositionTime = 0;
++        } else {
++            for (var i in item.children) {
++                removeTimeConstraintsFromDirectionalDragAreas(item.children[i]);
++            }
++        }
++    }
+ }