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

[Daniel d'Andrada]

Make DirectionalDragArea work when rotated

The drag gesture direction is in local coordinates, not in scene coordinates

run "make tryDirectionalDragArea".
Then press the "rotated: 0" button to change it to "rotated: 90".
Try out dragging from the window edges.

Without this patch DirectionalDragAreas would fail recognizing gestures when rotated.

As for "make tryDragHandle", when rotated, the ubuntu logos would never stay open. Once released, they would always rollback.

This is needed for the "rotated nexus 7" work.
I.e.: having a rotated unity8 shell.

e.g.: a landscape unity8 (tablet mode) on a portrait display.

* Are there any related MPs required for this MP to build/function as expected?
  No
* Did you perform an exploratory manual test run of your code change and any related functionality?
 Yes, with "make tryDirectionalDragArea"
* 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:688
http://jenkins.qa.ubuntu.com/job/unity8-ci/2295/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/3137
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty-touch/2824
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-trusty/1165
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-trusty-amd64-ci/816
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-trusty-armhf-ci/820
        deb: http://jenkins.qa.ubuntu.com/job/unity8-trusty-armhf-ci/820/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-trusty-i386-ci/816
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-trusty/2756
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/3139
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/3139/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-armhf/2826
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-armhf/2826/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-runner-mako/5235
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/3848

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

review: Needs Fixing (continuous-integration)

[Michael Zanetti (mzanetti)]

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

Yip yip. Doesn't seem to break anything on Nexus 4. Gerry will do the test for the new functionality on the rotated Nexus 7.

 * Did CI run pass? If not, please explain why.

Nope :/ Unrelated test failure. It's fix is waiting to be picked up on the Train station still.

review: Approve

[Gerry Boland (gerboland)]

Works good on rotated shell. Approving

review: Approve

[Daniel d'Andrada (dandrader)]

There is still a bit more work to be done. Making use of this MP instead of opening another one as it hasn't been merged yet.

[Daniel d'Andrada (dandrader)]

All fixed now.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:693
http://jenkins.qa.ubuntu.com/job/unity8-ci/2306/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/3182
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty-touch/2863
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-trusty/1176
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-trusty-amd64-ci/827
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-trusty-armhf-ci/831
        deb: http://jenkins.qa.ubuntu.com/job/unity8-trusty-armhf-ci/831/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-trusty-i386-ci/827
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-trusty/2798
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/3184
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/3184/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-armhf/2865
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-armhf/2865/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-runner-mako/5273
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/3892

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

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

Approving, as works even better on rotated shell than before

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:693
http://jenkins.qa.ubuntu.com/job/unity8-ci/2332/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/3264
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty-touch/2933/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-trusty/1202
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-trusty-amd64-ci/853
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-trusty-armhf-ci/857
        deb: http://jenkins.qa.ubuntu.com/job/unity8-trusty-armhf-ci/857/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity8-trusty-i386-ci/853
    SUCCESS: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-trusty/2872
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/3266
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/3266/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-armhf/2935
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-armhf/2935/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-runner-mako/5339/console
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/4003

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

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

• Did you perform an exploratory manual test run of the code change and any related functionality?
Yes
• Did CI run pass? If not, please explain why.
It did

=== modified file 'plugins/Ubuntu/Gestures/DirectionalDragArea.cpp'
--- plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2013-10-23 13:09:39 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.cpp	2014-02-12 22:13:40 +0000
@@ -114,6 +114,7 @@
     , m_wideningAngle(0)
     , m_wideningFactor(0)
     , m_distanceThreshold(0)
+    , m_distanceThresholdSquared(0.)
     , m_minSpeed(0)
     , m_maxSilenceTime(200)
     , m_silenceTime(0)
@@ -162,7 +163,14 @@
         return;
 
     m_wideningAngle = angle;
-    m_wideningFactor = qTan(angle * M_PI / 180.0);
+
+    // 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);
 }
 
@@ -170,6 +178,7 @@
 {
     if (m_distanceThreshold != value) {
         m_distanceThreshold = value;
+        m_distanceThresholdSquared = m_distanceThreshold * m_distanceThreshold;
         Q_EMIT distanceThresholdChanged(value);
     }
 }
@@ -237,13 +246,15 @@
     }
 }
 
+void DirectionalDragArea::updateSceneDistance()
+{
+    QPointF totalMovement = m_previousScenePos - m_startScenePos;
+    m_sceneDistance = projectOntoDirectionVector(totalMovement);
+}
+
 qreal DirectionalDragArea::sceneDistance() const
 {
-    if (Direction::isHorizontal(m_direction)) {
-        return m_previousScenePos.x() - m_startScenePos.x();
-    } else {
-        return m_previousScenePos.y() - m_startScenePos.y();
-    }
+    return m_sceneDistance;
 }
 
 qreal DirectionalDragArea::touchX() const
@@ -335,12 +346,13 @@
     m_startScenePos = newTouchPoint->scenePos();
     m_touchId = newTouchPoint->id();
     m_dampedScenePos.reset(m_startScenePos);
-    updateVelocityCalculator(m_startScenePos);
+    m_velocityCalculator->setTrackedPosition(0.);
     m_velocityCalculator->reset();
     m_numSamplesOnLastSpeedCheck = 0;
     m_silenceTime = 0;
     setPreviousPos(m_startPos);
     setPreviousScenePos(m_startScenePos);
+    updateSceneDirectionVector();
 
     setStatus(Undecided);
 }
@@ -441,44 +453,53 @@
 
 bool DirectionalDragArea::pointInsideAllowedArea() const
 {
-    qreal dX = m_dampedScenePos.x() - m_startScenePos.x();
-    qreal dY = m_dampedScenePos.y() - m_startScenePos.y();
-
-    switch (m_direction) {
-        case Direction::Upwards:
-            return dY <= 0 && qFabs(dX) <= qFabs(dY) * m_wideningFactor;
-        case Direction::Downwards:
-            return dY >= 0 && qFabs(dX) <= dY * m_wideningFactor;
-        case Direction::Leftwards:
-            return dX <= 0  && qFabs(dY) <= qFabs(dX) * m_wideningFactor;
-        default: // Direction::Rightwards:
-            return dX >= 0 && qFabs(dY) <= dX * m_wideningFactor;
+    // 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
 {
-    switch (m_direction) {
-        case Direction::Upwards:
-            return m_dampedScenePos.y() <= m_previousDampedScenePos.y();
-        case Direction::Downwards:
-            return m_dampedScenePos.y() >= m_previousDampedScenePos.y();
-        case Direction::Leftwards:
-            return m_dampedScenePos.x() <= m_previousDampedScenePos.x();
-        default: // Direction::Rightwards:
-            return m_dampedScenePos.x() >= m_previousDampedScenePos.x();
-    }
+    QPointF movementVector(m_dampedScenePos.x() - m_previousDampedScenePos.x(),
+                           m_dampedScenePos.y() - m_previousDampedScenePos.y());
+
+    qreal scalarProjection = projectOntoDirectionVector(movementVector);
+
+    return scalarProjection >= 0.;
 }
 
 bool DirectionalDragArea::movedFarEnough(const QPointF &point) const
 {
-    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;
+    if (m_distanceThreshold <= 0.) {
+        // distance threshold check is disabled
+        return true;
     } else {
-        return true;
+        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;
     }
 }
 
@@ -568,28 +589,33 @@
     bool xChanged = m_previousScenePos.x() != point.x();
     bool yChanged = m_previousScenePos.y() != point.y();
 
+    if (!xChanged && !yChanged)
+        return;
+
+    qreal oldSceneDistance = sceneDistance();
     m_previousScenePos = point;
+    updateSceneDistance();
+
+    if (oldSceneDistance != sceneDistance()) {
+        Q_EMIT sceneDistanceChanged(sceneDistance());
+    }
 
     if (xChanged) {
         Q_EMIT touchSceneXChanged(point.x());
-        if (Direction::isHorizontal(m_direction))
-            Q_EMIT sceneDistanceChanged(sceneDistance());
     }
 
     if (yChanged) {
         Q_EMIT touchSceneYChanged(point.y());
-        if (Direction::isVertical(m_direction))
-            Q_EMIT sceneDistanceChanged(sceneDistance());
     }
 }
 
-void DirectionalDragArea::updateVelocityCalculator(const QPointF &point)
+void DirectionalDragArea::updateVelocityCalculator(const QPointF &scenePos)
 {
-    if (Direction::isHorizontal(m_direction)) {
-        m_velocityCalculator->setTrackedPosition(point.x());
-    } else {
-        m_velocityCalculator->setTrackedPosition(point.y());
-    }
+    QPointF totalSceneMovement = scenePos - m_startScenePos;
+
+    qreal scalarProjection = projectOntoDirectionVector(totalSceneMovement);
+
+    m_velocityCalculator->setTrackedPosition(scalarProjection);
 }
 
 bool DirectionalDragArea::isWithinTouchCompositionWindow()
@@ -693,5 +719,39 @@
     return highestStartTime;
 }
 
+void DirectionalDragArea::updateSceneDirectionVector()
+{
+    QPointF localOrigin(0., 0.);
+    QPointF localDirection;
+    switch (m_direction) {
+        case Direction::Upwards:
+            localDirection.rx() = 0.;
+            localDirection.ry() = -1.;
+            break;
+        case Direction::Downwards:
+            localDirection.rx() = 0.;
+            localDirection.ry() = 1;
+            break;
+        case Direction::Leftwards:
+            localDirection.rx() = -1.;
+            localDirection.ry() = 0.;
+            break;
+        default: // Direction::Rightwards:
+            localDirection.rx() = 1.;
+            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();
+}
+
 // 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-10-23 13:09:39 +0000
+++ plugins/Ubuntu/Gestures/DirectionalDragArea.h	2014-02-12 22:13:40 +0000
@@ -160,6 +160,7 @@
 
     qreal distance() const;
     qreal sceneDistance() const;
+    void updateSceneDistance();
 
     qreal touchX() const;
     qreal touchY() const;
@@ -231,6 +232,10 @@
     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;
 
     Status m_status;
 
@@ -238,6 +243,7 @@
     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
@@ -245,10 +251,14 @@
     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 tan(degreesToRadian(m_wideningAngle))
+    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

=== modified file 'qml/Components/DragHandle.qml'
--- qml/Components/DragHandle.qml	2014-01-21 15:30:06 +0000
+++ qml/Components/DragHandle.qml	2014-02-12 22:13:40 +0000
@@ -167,7 +167,8 @@
     EdgeDragEvaluator {
         objectName: "edgeDragEvaluator"
         id: dragEvaluator
-        trackedPosition: sceneDistance
+        // Effectively convert distance into the drag position projected onto the gesture direction axis
+        trackedPosition: Direction.isPositive(dragArea.direction) ? sceneDistance : -sceneDistance
         maxDragDistance: maxTotalDragDistance
         direction: dragArea.direction
     }

=== modified file 'tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml'
--- tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml	2013-10-22 15:56:37 +0000
+++ tests/plugins/Ubuntu/Gestures/DownwardsLauncher.qml	2014-02-12 22:13:40 +0000
@@ -63,7 +63,7 @@
                     dragAreaRect.opacity = 0.3
                     launcher.y = Qt.binding(launcher.followDragArea)
                     break;
-                defaut: // DirectionalDragArea.Recognized:
+                default: // DirectionalDragArea.Recognized:
                     dragAreaRect.color = "green"
                     dragAreaRect.opacity = 0.5
                     break;
@@ -76,4 +76,11 @@
             top: parent.top
         }
     }
+
+    Label {
+        text: "Downwards"
+        anchors.top: parent.top
+        anchors.horizontalCenter: parent.horizontalCenter
+        anchors.topMargin: units.gu(1)
+    }
 }

=== modified file 'tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml'
--- tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml	2013-10-22 15:56:37 +0000
+++ tests/plugins/Ubuntu/Gestures/LeftwardsLauncher.qml	2014-02-12 22:13:40 +0000
@@ -79,4 +79,11 @@
             bottom: parent.bottom
         }
     }
+
+    Label {
+        text: "Leftwards"
+        anchors.right: parent.right
+        anchors.verticalCenter: parent.verticalCenter
+        anchors.rightMargin: units.gu(1)
+    }
 }

=== modified file 'tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml'
--- tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml	2013-10-22 15:56:37 +0000
+++ tests/plugins/Ubuntu/Gestures/RightwardsLauncher.qml	2014-02-12 22:13:40 +0000
@@ -77,4 +77,11 @@
             bottom: parent.bottom
         }
     }
+
+    Label {
+        text: "Rightwards"
+        anchors.left: parent.left
+        anchors.verticalCenter: parent.verticalCenter
+        anchors.leftMargin: units.gu(1)
+    }
 }

=== modified file 'tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml'
--- tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml	2013-10-22 15:56:37 +0000
+++ tests/plugins/Ubuntu/Gestures/UpwardsLauncher.qml	2014-02-12 22:13:40 +0000
@@ -79,4 +79,11 @@
             bottom: parent.bottom
         }
     }
+
+    Label {
+        text: "Upwards"
+        anchors.bottom: parent.bottom
+        anchors.horizontalCenter: parent.horizontalCenter
+        anchors.bottomMargin: units.gu(1)
+    }
 }

=== modified file 'tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp'
--- tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp	2013-11-22 13:37:25 +0000
+++ tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.cpp	2014-02-12 22:13:40 +0000
@@ -83,6 +83,9 @@
     void twoFingerTap();
     void movingDDA();
     void ignoreOldFinger();
+    void rotated();
+    void sceneDistance();
+    void sceneDistance_data();
 
 private:
     void passTime(qint64 timeSpan);
@@ -131,18 +134,10 @@
 }
 
 namespace {
-QPointF calculateInitialTouchPos(DirectionalDragArea *edgeDragArea, QQuickView *view)
+QPointF calculateInitialTouchPos(DirectionalDragArea *edgeDragArea)
 {
-    switch (edgeDragArea->direction()) {
-        case Direction::Upwards:
-            return QPointF(view->width()/2.0f, view->height() - (edgeDragArea->height()/2.0f));
-        case Direction::Downwards:
-            return QPointF(view->width()/2.0f, edgeDragArea->height()/2.0f);
-        case Direction::Leftwards:
-            return QPointF(view->width() - (edgeDragArea->width()/2.0f), view->height()/2.0f);
-        default: // Direction::Rightwards:
-            return QPointF(edgeDragArea->width()/2.0f, view->height()/2.0f);
-    }
+    QPointF localCenter(edgeDragArea->width() / 2., edgeDragArea->height() / 2.);
+    return edgeDragArea->mapToScene(localCenter);
 }
 
 QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea,
@@ -193,7 +188,7 @@
 
     QSignalSpy draggingSpy(edgeDragArea, SIGNAL(draggingChanged(bool)));
 
-    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
+    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
     qreal desiredDragDistance = edgeDragArea->distanceThreshold()*dragDistanceFactor;
@@ -300,7 +295,7 @@
     edgeDragArea->setRecognitionTimer(fakeTimer);
     edgeDragArea->setTimeSource(fakeTimeSource);
 
-    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
+    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
     qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0;
@@ -360,7 +355,7 @@
 
     edgeDragArea->setMinSpeed(minSpeed);
 
-    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
+    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
     QPointF dragDirectionVector(1.0, 0.0);
@@ -408,7 +403,7 @@
 
     int timeStepMs = 5; // some arbitrary small value.
 
-    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
+    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
     QPointF dragDirectionVector(1.0, 0.0);
@@ -452,7 +447,7 @@
     // Make sure this property is not disabled
     edgeDragArea->setMaxSilenceTime(100);
 
-    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
+    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
     QTest::touchEvent(m_view, m_device).press(0, touchPoint.toPoint());
@@ -620,7 +615,7 @@
     edgeDragArea->setRecognitionTimer(fakeTimer);
     edgeDragArea->setTimeSource(fakeTimeSource);
 
-    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea, m_view);
+    QPointF initialTouchPos = calculateInitialTouchPos(edgeDragArea);
     QPointF touchPoint = initialTouchPos;
 
     qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
@@ -704,6 +699,102 @@
     QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::WaitingForTouch);
 }
 
+/*
+    A Rightwards DDA that is rotated 90 degrees clockwise should recognize gestures
+    that are done downwards in scene coordinates. I.e. the gesture recognition direction
+    should be in local coordinates, not scene coordinates.
+ */
+void tst_DirectionalDragArea::rotated()
+{
+    QQuickItem *baseItem =  m_view->rootObject()->findChild<QQuickItem*>("baseItem");
+    baseItem->setRotation(90.);
+
+    QQuickItem *rightwardsLauncher =  m_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);
+    QPointF touchPoint = initialTouchPos;
+
+    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.0f;
+    QPointF dragDirectionVector(0.0f, 1.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(m_view, m_device).press(0, touchPoint.toPoint());
+
+    for (int i = 0; i < totalMovementSteps; ++i) {
+        touchPoint += touchMovement;
+        passTime(movementTimeStepMs);
+        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
+    }
+
+    QCOMPARE((int)edgeDragArea->status(), (int)DirectionalDragArea::Recognized);
+
+    QTest::touchEvent(m_view, m_device).release(0, touchPoint.toPoint());
+}
+
+void tst_DirectionalDragArea::sceneDistance()
+{
+    QQuickItem *baseItem =  m_view->rootObject()->findChild<QQuickItem*>("baseItem");
+    QFETCH(qreal, rotation);
+    QFETCH(QPointF, dragDirectionVector);
+    baseItem->setRotation(rotation);
+
+    QQuickItem *rightwardsLauncher =  m_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);
+    QPointF touchPoint = initialTouchPos;
+
+    qreal desiredDragDistance = edgeDragArea->distanceThreshold()*2.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(m_view, m_device).press(0, touchPoint.toPoint());
+
+    for (int i = 0; i < totalMovementSteps; ++i) {
+        touchPoint += touchMovement;
+        passTime(movementTimeStepMs);
+        QTest::touchEvent(m_view, m_device).move(0, touchPoint.toPoint());
+    }
+
+    qreal actualDragDistance = ((qreal)totalMovementSteps) * movementStepDistance;
+
+    // DirectionalDragArea::sceneDistance() must match the actual drag distance as the
+    // drag was aligned with the gesture direction
+    // 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());
+}
+
+void tst_DirectionalDragArea::sceneDistance_data()
+{
+    QTest::addColumn<qreal>("rotation");
+    QTest::addColumn<QPointF>("dragDirectionVector");
+
+    QTest::newRow("not rotated")           << 0.  << QPointF(1., 0.);
+    QTest::newRow("rotated by 90 degrees") << 90. << QPointF(0., 1.);
+}
+
 QTEST_MAIN(tst_DirectionalDragArea)
 
 #include "tst_DirectionalDragArea.moc"

=== modified file 'tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.qml'
--- tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.qml	2013-11-22 11:28:28 +0000
+++ tests/plugins/Ubuntu/Gestures/tst_DirectionalDragArea.qml	2014-02-12 22:13:40 +0000
@@ -18,8 +18,8 @@
 import Ubuntu.Components 0.1
 
 Rectangle {
-    width: units.gu(40)
-    height: units.gu(71)
+    width: units.gu(60)
+    height: units.gu(60)
     color: "white"
 
     MouseArea {
@@ -33,14 +33,36 @@
         }
     }
 
-    // NB: Do not anchor it as we will move it programmatically from the test
-    RightwardsLauncher {
-        id: hpLauncher;
+    Item {
+        id: baseItem
+        objectName: "baseItem"
         width: parent.width
         height: parent.height
-    }
-
-    LeftwardsLauncher { id: hnLauncher; anchors.fill: parent }
-    DownwardsLauncher { id: vpLauncher; anchors.fill: parent }
-    UpwardsLauncher { id: vnLauncher; 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 }
+    }
+
+    Button {
+        anchors.bottom: parent.bottom
+        anchors.left: parent.left
+        anchors.margins: units.gu(1)
+
+        text: "rotation: " + baseItem.rotation
+        onClicked: {
+            if (baseItem.rotation === 0.0) {
+                baseItem.rotation = 90.0
+            } else {
+                baseItem.rotation = 0.0
+            }
+        }
+    }
 }

=== modified file 'tests/qmltests/Components/tst_DragHandle.cpp'
--- tests/qmltests/Components/tst_DragHandle.cpp	2014-01-21 15:29:34 +0000
+++ tests/qmltests/Components/tst_DragHandle.cpp	2014-02-12 22:13:40 +0000
@@ -58,7 +58,9 @@
     void cleanup(); // called right after each and every test function is executed
 
     void dragThreshold_horizontal();
+    void dragThreshold_horizontal_data();
     void dragThreshold_vertical();
+    void dragThreshold_vertical_data();
     void stretch_horizontal();
     void stretch_vertical();
     void hintingAnimation();
@@ -145,17 +147,29 @@
 namespace {
 QPointF calculateDirectionVector(DirectionalDragArea *edgeDragArea)
 {
-
+    QPointF localOrigin(0., 0.);
+    QPointF localDirection;
     switch (edgeDragArea->direction()) {
         case Direction::Upwards:
-            return QPointF(0, -1);
+            localDirection.rx() = 0.;
+            localDirection.ry() = -1.;
+            break;
         case Direction::Downwards:
-            return QPointF(0, 1);
+            localDirection.rx() = 0.;
+            localDirection.ry() = 1;
+            break;
         case Direction::Leftwards:
-            return QPointF(-1, 0);
+            localDirection.rx() = -1.;
+            localDirection.ry() = 0.;
+            break;
         default: // Direction::Rightwards:
-            return QPointF(1, 0);
+            localDirection.rx() = 1.;
+            localDirection.ry() = 0.;
+            break;
     }
+    QPointF sceneOrigin = edgeDragArea->mapToScene(localOrigin);
+    QPointF sceneDirection = edgeDragArea->mapToScene(localDirection);
+    return sceneDirection - sceneOrigin;
 }
 }
 
@@ -222,6 +236,11 @@
  */
 void tst_DragHandle::dragThreshold_horizontal()
 {
+    QFETCH(qreal, rotation);
+
+    QQuickItem *baseItem =  m_view->rootObject()->findChild<QQuickItem*>("baseItem");
+    baseItem->setRotation(rotation);
+
     DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("rightwardsDragHandle");
 
     qreal dragThreshold = fetchDragThreshold(dragHandle);
@@ -260,8 +279,21 @@
     QCOMPARE(parentItem->property("shown").toBool(), false);
 }
 
+void tst_DragHandle::dragThreshold_horizontal_data()
+{
+    QTest::addColumn<qreal>("rotation");
+
+    QTest::newRow("not rotated") << 0.;
+    QTest::newRow("rotated 90")  << 90.;
+}
+
 void tst_DragHandle::dragThreshold_vertical()
 {
+    QFETCH(qreal, rotation);
+
+    QQuickItem *baseItem =  m_view->rootObject()->findChild<QQuickItem*>("baseItem");
+    baseItem->setRotation(rotation);
+
     DirectionalDragArea *dragHandle = fetchAndSetupDragHandle("downwardsDragHandle");
 
     qreal dragThreshold = fetchDragThreshold(dragHandle);
@@ -300,6 +332,14 @@
     QCOMPARE(parentItem->property("shown").toBool(), false);
 }
 
+void tst_DragHandle::dragThreshold_vertical_data()
+{
+    QTest::addColumn<qreal>("rotation");
+
+    QTest::newRow("not rotated") << 0.;
+    QTest::newRow("rotated 90")  << 90.;
+}
+
 /*
   Checks that when the stretch property is true, dragging the DragHandle increases
   the width or height (depending on its direction) of its parent Showable

=== modified file 'tests/qmltests/Components/tst_DragHandle.qml'
--- tests/qmltests/Components/tst_DragHandle.qml	2013-12-17 16:04:47 +0000
+++ tests/qmltests/Components/tst_DragHandle.qml	2014-02-12 22:13:40 +0000
@@ -29,62 +29,68 @@
  */
 Item {
     id: root
-    width: 700
-    height: 500
+    width: units.gu(70)
+    height: units.gu(70)
 
     property var dragHandle
 
     property bool stretch: false
     property real hintDisplacement: 0
 
-    VerticalShowable {
-        onDragHandleRecognizedGesture: { root.dragHandle = dragHandle }
-        stretch: root.stretch
-        hintDisplacement: root.hintDisplacement
-    }
-
-    HorizontalShowable {
-        onDragHandleRecognizedGesture: { root.dragHandle = dragHandle }
-        stretch: root.stretch
-        hintDisplacement: root.hintDisplacement
-    }
-
-    // Visually mark drag threshold
-    Rectangle {
-        color: "black"
-        width: 2
-        height: parent.height
-
-        visible: dragHandle !== undefined && Direction.isHorizontal(dragHandle.direction)
-
-        x: {
-            if (dragHandle) {
-                if (dragHandle.direction === Direction.Rightwards) {
-                    dragHandle.edgeDragEvaluator.dragThreshold;
+    Item {
+        id: baseItem
+        objectName: "baseItem"
+        anchors.fill: parent
+
+        VerticalShowable {
+            onDragHandleRecognizedGesture: { root.dragHandle = dragHandle }
+            stretch: root.stretch
+            hintDisplacement: root.hintDisplacement
+        }
+
+        HorizontalShowable {
+            onDragHandleRecognizedGesture: { root.dragHandle = dragHandle }
+            stretch: root.stretch
+            hintDisplacement: root.hintDisplacement
+        }
+
+        // Visually mark drag threshold
+        Rectangle {
+            color: "black"
+            width: 2
+            height: parent.height
+
+            visible: dragHandle !== undefined && Direction.isHorizontal(dragHandle.direction)
+
+            x: {
+                if (dragHandle) {
+                    if (dragHandle.direction === Direction.Rightwards) {
+                        dragHandle.edgeDragEvaluator.dragThreshold;
+                    } else {
+                        parent.width - dragHandle.edgeDragEvaluator.dragThreshold;
+                    }
                 } else {
-                    parent.width - dragHandle.edgeDragEvaluator.dragThreshold;
+                    0
                 }
-            } else {
-                0
             }
         }
-    }
-    Rectangle {
-        color: "black";
-        height: 2
-        width: parent.width
-
-        visible: dragHandle !== undefined && Direction.isVertical(dragHandle.direction)
-
-        y: {
-            if (dragHandle) {
-                if (dragHandle.direction === Direction.Downwards) {
-                    dragHandle.edgeDragEvaluator.dragThreshold;
+        Rectangle {
+            color: "black";
+            height: 2
+            width: parent.width
+
+            visible: dragHandle !== undefined && Direction.isVertical(dragHandle.direction)
+
+            y: {
+                if (dragHandle) {
+                    if (dragHandle.direction === Direction.Downwards) {
+                        dragHandle.edgeDragEvaluator.dragThreshold;
+                    } else {
+                        parent.height - dragHandle.edgeDragEvaluator.dragThreshold;
+                    }
                 } else {
-                    parent.height - dragHandle.edgeDragEvaluator.dragThreshold;
+                    0
                 }
-            } else {
-                0
             }
         }
     }
@@ -119,27 +125,37 @@
         }
     }
 
-    TestButton {
-        id: stretchButton
+    Row {
         anchors.bottom: parent.bottom
         anchors.left: parent.left
         anchors.margins: units.gu(1)
-
-        text: root.stretch ? "stretch" : "move"
-        onClicked: { root.stretch = !root.stretch; }
-    }
-
-    TestButton {
-        anchors.bottom: parent.bottom
-        anchors.left: stretchButton.right
-        anchors.margins: units.gu(1)
-
-        text: root.hintDisplacement > 0 ? "hint" : "no hint"
-        onClicked: {
-            if (root.hintDisplacement > 0) {
-                root.hintDisplacement = 0;
-            } else {
-                root.hintDisplacement = units.gu(6);
+        spacing: units.gu(1)
+
+        Button {
+            id: stretchButton
+            text: root.stretch ? "stretch" : "move"
+            onClicked: { root.stretch = !root.stretch; }
+        }
+
+        Button {
+            text: root.hintDisplacement > 0 ? "hint" : "no hint"
+            onClicked: {
+                if (root.hintDisplacement > 0) {
+                    root.hintDisplacement = 0;
+                } else {
+                    root.hintDisplacement = units.gu(6);
+                }
+            }
+        }
+
+        Button {
+            text: "rotation: " + baseItem.rotation
+            onClicked: {
+                if (baseItem.rotation === 0.0) {
+                    baseItem.rotation = 90.0
+                } else {
+                    baseItem.rotation = 0.0
+                }
             }
         }
     }

=== removed file 'tests/qmltests/Components/tst_DragHandle/TestButton.qml'
--- tests/qmltests/Components/tst_DragHandle/TestButton.qml	2013-07-01 16:32:00 +0000
+++ tests/qmltests/Components/tst_DragHandle/TestButton.qml	1970-01-01 00:00:00 +0000
@@ -1,41 +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
-
-Rectangle {
-    id: rect
-    width: childrenRect.width
-    height: childrenRect.height
-
-    property alias text: textComponent.text
-
-    signal clicked
-
-    color: "yellow"
-    Text {
-        id: textComponent
-        font.pixelSize: units.gu(2)
-        text: root.stretch ? "stretch" : "move"
-        MouseArea {
-            anchors.fill: parent
-            onClicked: {
-                rect.clicked()
-            }
-        }
-    }
-}