Merge lp:~aacid/unity-2d/non_sticky_barrier_on_non_activation_side into lp:unity-2d

[Albert Astals Cid]

Add the triggerOnly property to pointer barriers this way you can make a barrier release itself when the mouse travels the barrier in the non trigger direction

Add the triggerOnly property to pointer barriers this way you can make a barrier release itself when the mouse travels the barrier in the non trigger direction

[Paweł Stołowski (stolowski)]

Looks good and works as advertised!

review: Approve

[Unity Merger (unity-merger)]

No proposals found for merge of lp:~aacid/unity-2d/sticky_edges into lp:unity-2d.

=== modified file 'libunity-2d-private/src/pointerbarrier.cpp'
--- libunity-2d-private/src/pointerbarrier.cpp	2012-03-02 10:38:40 +0000
+++ libunity-2d-private/src/pointerbarrier.cpp	2012-04-03 09:17:21 +0000
@@ -30,6 +30,7 @@
     , m_barrier(0)
     , m_triggerDirection(TriggerFromAnywhere)
     , m_triggerZoneEnabled(false)
+    , m_triggerOnly(false)
     , m_threshold(-1)
     , m_maxVelocityMultiplier(-1)
     , m_decayRate(-1)
@@ -151,6 +152,19 @@
     }
 }
 
+bool PointerBarrierWrapper::triggerOnly() const
+{
+    return m_triggerOnly;
+}
+
+void PointerBarrierWrapper::setTriggerOnly(bool triggerOnly)
+{
+    if (triggerOnly != m_triggerOnly) {
+        m_triggerOnly = triggerOnly;
+        Q_EMIT triggerOnlyChanged(triggerOnly);
+    }
+}
+
 void PointerBarrierWrapper::createBarrier()
 {
     if (m_threshold < 0) {
@@ -194,6 +208,13 @@
     if (!m_smoothingTimer->isActive()) {
         m_smoothingTimer->start();
     }
+
+    if (m_triggerOnly && !isLastEventAgainstTrigger()) {
+        // We got to the barrier from the non triggering direction
+        // Release it so the mouse can continue its travel
+        Display *display = QX11Info::display();
+        XFixesBarrierReleasePointer (display, m_barrier, m_lastEventId);
+    }
 }
 
 int PointerBarrierWrapper::threshold() const
@@ -288,18 +309,7 @@
     }
     const int velocity = qMin<qreal>(600 * m_maxVelocityMultiplier, m_smoothingAccumulator / m_smoothingCount);
 
-    bool againstTrigger = false;
-    if (m_triggerZoneEnabled && m_triggerZoneP1.x() == m_triggerZoneP2.x() && m_triggerZoneP1.y() <= m_lastEventY && m_triggerZoneP2.y() >= m_lastEventY) {
-        againstTrigger = m_triggerDirection == TriggerFromAnywhere ||
-                        (m_triggerDirection == TriggerFromRight && m_lastEventX >= m_triggerZoneP1.x()) ||
-                        (m_triggerDirection == TriggerFromLeft && m_lastEventX < m_triggerZoneP1.x());
-    }
-    if (m_triggerZoneEnabled && m_triggerZoneP1.y() == m_triggerZoneP2.y() && m_triggerZoneP1.x() <= m_lastEventX && m_triggerZoneP2.x() >= m_lastEventX) {
-        againstTrigger = m_triggerDirection == TriggerFromAnywhere ||
-                        (m_triggerDirection == TriggerFromTop && m_lastEventY >= m_triggerZoneP1.y()) ||
-                        (m_triggerDirection == TriggerFromBottom && m_lastEventY < m_triggerZoneP1.y());
-    }
-    if (againstTrigger) {
+    if (isLastEventAgainstTrigger()) {
         if (m_triggerValue.addAndCheckExceedingTarget(velocity)) {
             Q_EMIT triggered();
         }
@@ -358,4 +368,20 @@
 
 }
 
+bool PointerBarrierWrapper::isLastEventAgainstTrigger() const
+{
+    bool againstTrigger = false;
+    if (m_triggerZoneEnabled && m_triggerZoneP1.x() == m_triggerZoneP2.x() && m_triggerZoneP1.y() <= m_lastEventY && m_triggerZoneP2.y() >= m_lastEventY) {
+        againstTrigger = m_triggerDirection == TriggerFromAnywhere ||
+                        (m_triggerDirection == TriggerFromRight && m_lastEventX >= m_triggerZoneP1.x()) ||
+                        (m_triggerDirection == TriggerFromLeft && m_lastEventX < m_triggerZoneP1.x());
+    }
+    if (m_triggerZoneEnabled && m_triggerZoneP1.y() == m_triggerZoneP2.y() && m_triggerZoneP1.x() <= m_lastEventX && m_triggerZoneP2.x() >= m_lastEventX) {
+        againstTrigger = m_triggerDirection == TriggerFromAnywhere ||
+                        (m_triggerDirection == TriggerFromTop && m_lastEventY >= m_triggerZoneP1.y()) ||
+                        (m_triggerDirection == TriggerFromBottom && m_lastEventY < m_triggerZoneP1.y());
+    }
+    return againstTrigger;
+}
+
 #include <pointerbarrier.moc>

=== modified file 'libunity-2d-private/src/pointerbarrier.h'
--- libunity-2d-private/src/pointerbarrier.h	2012-03-02 10:38:40 +0000
+++ libunity-2d-private/src/pointerbarrier.h	2012-04-03 09:17:21 +0000
@@ -36,6 +36,7 @@
     Q_PROPERTY(QPointF triggerZoneP2 READ triggerZoneP2 WRITE setTriggerZoneP2 NOTIFY triggerZoneP2Changed)
     Q_PROPERTY(TriggerDirection triggerDirection READ triggerDirection WRITE setTriggerDirection NOTIFY triggerDirectionChanged)
     Q_PROPERTY(bool triggerZoneEnabled READ triggerZoneEnabled WRITE setTriggerZoneEnabled NOTIFY triggerZoneEnabledChanged)
+    Q_PROPERTY(bool triggerOnly READ triggerOnly WRITE setTriggerOnly NOTIFY triggerOnlyChanged)
     Q_PROPERTY(int threshold READ threshold WRITE setThreshold NOTIFY thresholdChanged)
     Q_PROPERTY(int maxVelocityMultiplier READ maxVelocityMultiplier WRITE setMaxVelocityMultiplier NOTIFY maxVelocityMultiplierChanged)
     Q_PROPERTY(int decayRate READ decayRate WRITE setDecayRate NOTIFY decayRateChanged)
@@ -75,6 +76,9 @@
     bool triggerZoneEnabled() const;
     void setTriggerZoneEnabled(bool enabled);
 
+    bool triggerOnly() const;
+    void setTriggerOnly(bool triggerOnly);
+
     int threshold() const;
     void setThreshold(int threshold);
 
@@ -99,6 +103,7 @@
     void triggerZoneP2Changed(const QPointF &p2);
     void triggerDirectionChanged(TriggerDirection direction);
     void triggerZoneEnabledChanged(bool changed);
+    void triggerOnlyChanged(bool triggerOnly);
     void thresholdChanged(int threshold);
     void maxVelocityMultiplierChanged(qreal maxVelocityMultiplier);
     void decayRateChanged(int decayRate);
@@ -125,6 +130,8 @@
 
     bool isPointAlignmentCorrect() const;
 
+    bool isLastEventAgainstTrigger() const;
+
     PointerBarrier m_barrier;
 
     QPointF m_p1;
@@ -133,6 +140,7 @@
     QPointF m_triggerZoneP2;
     TriggerDirection m_triggerDirection;
     bool m_triggerZoneEnabled;
+    bool m_triggerOnly;
     int m_threshold;
     qreal m_maxVelocityMultiplier;
     int m_decayRate;

=== modified file 'libunity-2d-private/tests/pointerbarriertest.cpp'
--- libunity-2d-private/tests/pointerbarriertest.cpp	2012-03-12 10:11:56 +0000
+++ libunity-2d-private/tests/pointerbarriertest.cpp	2012-04-03 09:17:21 +0000
@@ -305,6 +305,61 @@
         QCOMPARE(brokenSpy.count(), 0);
         QCOMPARE(triggeredSpy.count(), 0);
     }
+
+    void testTriggerOnly()
+    {
+        Display *display = QX11Info::display();
+        PointerBarrierWrapper barrier;
+
+        QSignalSpy brokenSpy(&barrier, SIGNAL(broken()));
+        QSignalSpy triggeredSpy(&barrier, SIGNAL(triggered()));
+
+        XTestFakeMotionEvent(display, -1, 50, 50, 0);
+        QCOMPARE(QCursor::pos(), QPoint(50, 50));
+
+        barrier.setP1(QPointF(100, 0));
+        barrier.setP2(QPointF(100, 100));
+        barrier.setTriggerZoneP1(QPointF(100, 0));
+        barrier.setTriggerZoneP2(QPointF(100, 100));
+        barrier.setTriggerZoneEnabled(true);
+        barrier.setTriggerOnly(true);
+        barrier.setTriggerDirection(PointerBarrierWrapper::TriggerFromRight);
+        barrier.setThreshold(6500);
+        barrier.setMaxVelocityMultiplier(2);
+        barrier.setDecayRate(1500);
+        barrier.setTriggerPressure(2000);
+        barrier.setBreakPressure(2000);
+
+        for (int i = 0; i < 100; ++i) {
+            XTestFakeRelativeMotionEvent(display, 1, 0, 0);
+            QTest::qWait(1);
+        }
+
+        // We are not stopped by the barrier because
+        // we are not hitting it from the trigger direction
+        QVERIFY(QCursor::pos() != QPoint(99, 50));
+
+        QCOMPARE(brokenSpy.count(), 0);
+        QCOMPARE(triggeredSpy.count(), 0);
+
+        QTest::qWait(100); // Wait until X reenables the barrier
+
+        XTestFakeRelativeMotionEvent(display, -300, 0, 0);
+        // We are stopped by the barrier and instead in 50, 50 we are in 100, 50
+        QCOMPARE(QCursor::pos(), QPoint(100, 50));
+
+        QCOMPARE(brokenSpy.count(), 0);
+        QCOMPARE(triggeredSpy.count(), 0);
+
+        for (int i = 0; i < 10; ++i) {
+            XTestFakeRelativeMotionEvent(display, -100, 0, 0);
+            QTest::qWait(100);
+        }
+        // We have triggered the barrier and are still there
+        QCOMPARE(QCursor::pos(), QPoint(100, 50));
+        QCOMPARE(brokenSpy.count(), 0);
+        QVERIFY(triggeredSpy.count() >= 1);
+    }
 };
 
 UAPP_TEST_MAIN(PointerBarrierTest)

=== modified file 'shell/Shell.qml'
--- shell/Shell.qml	2012-04-03 09:17:21 +0000
+++ shell/Shell.qml	2012-04-03 09:17:21 +0000
@@ -282,6 +282,7 @@
         id: leftBarrier
         triggerDirection: Utils.isLeftToRight() ? PointerBarrier.TriggerFromRight : PointerBarrier.TriggerFromLeft
         triggerZoneEnabled: enableTrigger && !launcherLoader.visibilityController.shown
+        triggerOnly: enableTrigger && !enableSticky
         p1: Qt.point(x, declarativeView.screen.geometry.y)
         p2: Qt.point(x, declarativeView.screen.geometry.y + declarativeView.screen.geometry.height)
         triggerZoneP1: Qt.point(x, declarativeView.globalPosition.y)