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

[Albert Astals Cid]

Implementation of Pointer barriers and use in the launcher autohide behaviour

[Albert Astals Cid (aacid)]

There is the issue that it crashes when run inside of VirtualBox, it crashes because the XFixesBarrierNotifyEvent->xany.display is set to 0 (happens only inside the VirtualBox VM)

[Gerry Boland (gerboland)]

Setup: 2 monitors, and shell in RTL mode (so launcher is on right of monitor 1, which borders monitor 2)

Steps to repro:
1. On screen 1 I push mouse against barrier, so launcher reveals
2. I push a bit harder so mouse passes through barrier to screen 2

Bug: Launcher stays open.

I also notice you drop the barrier while the launcher is open. Then for the above bug, there's no barrier stopping the mouse passing from screen 2 to screen 1.

Yes this bug is a bit "multi-monitor" :)

review: Needs Fixing (functional)

[Gerry Boland (gerboland)]

Removing intellihide, you'll need to remove reference to it from com.canonical.Unity2d.gschema.xml. Also will we need a way to migrate existing intellihide settings to autohide/fixed?

[Gerry Boland (gerboland)]

Checking with Unity, I noticed 3 differences:
1. barrier extends along whole edge of screen, including panel
2. pushing the bit of the barrier that meets the panel does *not* reveal launcher
3. as you push launcher barrier, a small shadow appears which indicates you should push harder to get launcher to open.

[Gerry Boland (gerboland)]

Also in RTL multi-monitor setup described above (https://code.launchpad.net/~aacid/unity-2d/unity-2d_pointer_barrier/+merge/94983/comments/205455)

If I push the left edge of screen 2 (which borders the launcher on screen 1), it makes the launcher reveal.

review: Needs Fixing

[Gerry Boland (gerboland)]

Bug: for hide-mode: 0, no barrier in effect at all
hide-mode 1,2: while launcher visible, no barrier in effect at all

[Gerry Boland (gerboland)]

Some minor code style comments (possibly my code to start with!):

In PointerBarrierWrapper::createBarrier(), please add braces around statements like:

+ if (!m_enabled)
+ return;

Can you add a debug comment explaining that barrier must be horizontal/vertical here:
+ if ((m_p1.x() != m_p2.x()) && (m_p1.y() != m_p2.y()))
+ return;

In PointerBarrierWrapper::decay(), your indentation is wrong, 2 spaces instead of the usual 4.

You should add yourself as an author to pointerbarrier.h

review: Needs Fixing

[Gerry Boland (gerboland)]

Functionally this is perfect, nice!

Code-wise, I can find no problems with the math anywhere. There is a little more going on that I had expected, but I can see no way to avoid everything you've done. So again, nice job!

Just some names I think could be clearer:
- "breakp1" could simply be "p1" and so on.
- "trigger" more understandable with "triggerZone" maybe?
- DecayedValue::add maybe clearer with DecayedValue::addAndCheckExceedingTarget since it returns an important bool.

I also want to see more tests of this barrier. Could you write a couple of unit tests, which run under a fake X server (xvfb) - as all tests in libunity-2d-private/tests do right now. We'd need to verify that the barrier works inside xvfb first however.

You can use XTest to move the mouse around. The source code of xdotool is a nice place to see it being used.

review: Needs Fixing

[Gerry Boland (gerboland)]

Works great, and the simplification helps too. Test is good, I'm approving.
Thank you Albert!

review: Approve

[Gerry Boland (gerboland)]

Holding off approval until FFe obtained

[lp:~aacid/unity-2d/unity-2d_pointer_barrier]

973. By Albert Astals Cid on 2012-03-05

Merge lp:unity-2d

974. By Albert Astals Cid on 2012-03-05

Fix docu

[Gerry Boland (gerboland)]

FFe obtained, can now merge when tarmac instance happy again.

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2012-03-01 17:42:03 +0000
+++ CMakeLists.txt	2012-03-05 14:20:25 +0000
@@ -45,6 +45,10 @@
 pkg_check_modules(PANGO REQUIRED pango)
 pkg_check_modules(DCONFQT REQUIRED dconf-qt)
 
+# X11_XTest_FOUND is defined by find_package(X11 REQUIRED)
+if (NOT X11_XTest_FOUND)
+    message(SEND_ERROR "Xtest library not found")
+endif (NOT X11_XTest_FOUND)
 
 # GSettings schemas
 pkg_check_modules(GLIB REQUIRED glib-2.0)
 
=== modified file 'data/com.canonical.Unity2d.gschema.xml'
--- data/com.canonical.Unity2d.gschema.xml	2012-02-13 14:59:11 +0000
+++ data/com.canonical.Unity2d.gschema.xml	2012-03-05 14:20:25 +0000
@@ -31,6 +31,44 @@
         2: intellihide; same as auto hide but the launcher will disappear if a window is placed on top of it
        </description>
     </key>
+    <key name="edge-responsiveness" type="d">
+      <default>2</default>
+      <summary>Responsiveness of the Launcher</summary>
+      <description>How quickly the Launcher will reveal when you push the pointer against the 
+        monitor edge
+      </description>
+    </key>
+    <key name="edge-decayrate" type="i">
+      <default>1500</default>
+      <summary>Decay rate of mouse pressure against barrier</summary>
+      <description>The pressures against the monitor edge are continually added up, and when the sum
+        hits a certain threshold the launcher reveals. To prevent a series of distinct gentle pushes  
+        of the pointer against the barrier from causing the launcher to reveal, we substract this  
+        parameter - the decay rate - at a steady rate
+      </description>
+    </key>
+    <key name="edge-reveal-pressure" type="i">
+      <default>2000</default>
+      <summary>Launcher reveal edge pressure</summary>
+      <description>The minimum pressure to press the pointer against the monitor edge to 
+        cause the launcher to reveal
+      </description>
+    </key>
+    <key name="edge-stop-velocity" type="i">
+      <default>6500</default>
+      <summary>Barrier edge stop velocity</summary>
+      <description>The minimum velocity the pointer needs to travel to pass through the barrier without 
+        any resistance. Only relevant for multi-monitor setups
+      </description>
+    </key>
+    <key name="edge-overcome-pressure" type="i">
+      <default>2000</default>
+      <summary>Barrier edge overcome pressure
+      </summary>
+      <description>Minimum pressure the pointer needs to exert on the barrier for the barrier to drop.
+        Only relevant for multi-monitor setups
+      </description>
+    </key>
   </schema>
   <schema path="/com/canonical/unity-2d/panel/" id="com.canonical.Unity2d.Panel" gettext-domain="unity-2d">
     <key type="as" name="applets">
 
=== modified file 'debian/control'
--- debian/control	2012-02-17 13:14:40 +0000
+++ debian/control	2012-03-05 14:20:25 +0000
@@ -25,6 +25,7 @@
                libunity-core-5.0-dev (>= 5.2.0),
                libnux-2.0-dev (>= 2.4),
                libxi-dev,
+               libxtst-dev,
 Standards-Version: 3.9.2
 Vcs-Bzr: https://code.launchpad.net/~unity-2d-team/unity-2d/trunk
 
 
=== modified file 'libunity-2d-private/CMakeLists.txt'
--- libunity-2d-private/CMakeLists.txt	2011-12-08 19:00:51 +0000
+++ libunity-2d-private/CMakeLists.txt	2012-03-05 14:20:25 +0000
@@ -11,6 +11,7 @@
 pkg_check_modules(DEE REQUIRED dee-1.0)
 pkg_check_modules(XINPUT REQUIRED xi)
 pkg_check_modules(GEIS REQUIRED libutouch-geis)
+pkg_check_modules(XFIXES REQUIRED xfixes)
 
 set(libunity-2d-private_SOVERSION 0)
 set(libunity-2d-private_VERSION ${libunity-2d-private_SOVERSION}.0.0)
 
=== modified file 'libunity-2d-private/Unity2d/plugin.cpp'
--- libunity-2d-private/Unity2d/plugin.cpp	2012-02-28 12:30:17 +0000
+++ libunity-2d-private/Unity2d/plugin.cpp	2012-03-05 14:20:25 +0000
@@ -80,6 +80,8 @@
 #include "unity2dpanel.h"
 #include "strutmanager.h"
 
+#include "pointerbarrier.h"
+
 #include <QtDeclarative/qdeclarative.h>
 #include <QDeclarativeEngine>
 #include <QDeclarativeContext>
@@ -183,6 +185,8 @@
 
     qmlRegisterType<Unity2dPanel>(uri, 0, 1, "Unity2dPanel");
     qmlRegisterType<StrutManager>(uri, 0, 1, "StrutManager");
+    
+    qmlRegisterType<PointerBarrierWrapper>(uri, 0, 1, "PointerBarrier");
 }
 
 void Unity2dPlugin::initializeEngine(QDeclarativeEngine *engine, const char *uri)
 
=== modified file 'libunity-2d-private/src/CMakeLists.txt'
--- libunity-2d-private/src/CMakeLists.txt	2012-02-28 12:30:17 +0000
+++ libunity-2d-private/src/CMakeLists.txt	2012-03-05 14:20:25 +0000
@@ -78,6 +78,9 @@
     inputshaperectangle.cpp
     inputshapemask.cpp
     strutmanager.cpp
+    pointerbarrier.cpp
+    pointerbarriermanager.cpp
+    decayedvalue.cpp
     )
 
 # Build
@@ -106,6 +109,7 @@
     ${DEE_INCLUDE_DIRS}
     ${XINPUT_INCLUDE_DIRS}
     ${GEIS_INCLUDE_DIRS}
+    ${XFIXES_INCLUDE_DIRS}
     )
 
 add_library(${LIB_NAME} SHARED ${libunity-2d-private_SRCS} listmodelwrapper.h)
@@ -142,6 +146,7 @@
     ${DEE_LDFLAGS}
     ${XINPUT_LDFLAGS}
     ${GEIS_LDFLAGS}
+    ${XFIXES_LDFLAGS}
     )
 
 # Install
 
=== added file 'libunity-2d-private/src/decayedvalue.cpp'
--- libunity-2d-private/src/decayedvalue.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/decayedvalue.cpp	2012-03-05 14:20:25 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2012 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "decayedvalue.h"
+
+DecayedValue::DecayedValue()
+ : m_value(0)
+ , m_target(0)
+ , m_decayRate(0)
+{
+    m_valueDecayTimer.setInterval(10);
+    connect(&m_valueDecayTimer, SIGNAL(timeout()), this, SLOT(decay()));
+}
+
+bool DecayedValue::addAndCheckExceedingTarget(int i)
+{
+    m_value += i;
+    if (!m_valueDecayTimer.isActive()) {
+        m_valueDecayTimer.start();
+    }
+    if (m_value > m_target) {
+        m_value = 0;
+        m_valueDecayTimer.stop();
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void DecayedValue::setDecayRate(int decayRate)
+{
+    m_decayRate = decayRate;
+}
+
+void DecayedValue::setTarget(int target)
+{
+    m_target = target;
+}
+
+void DecayedValue::decay() {
+  const int partial_decay = m_decayRate / 100;
+
+  m_value -= partial_decay;
+
+  if (m_value <= 0)
+  {
+    m_value = 0;
+    m_valueDecayTimer.stop();
+  }
+}
+
+#include "decayedvalue.moc"
 \ No newline at end of file
 
=== added file 'libunity-2d-private/src/decayedvalue.h'
--- libunity-2d-private/src/decayedvalue.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/decayedvalue.h	2012-03-05 14:20:25 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2012 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef DECAYEDVALUE_H
+#define DECAYEDVALUE_H
+
+#include <QObject>
+
+#include <QTimer>
+
+class DecayedValue : public QObject
+{
+    Q_OBJECT
+public:
+    DecayedValue();
+
+    bool addAndCheckExceedingTarget(int i);
+
+    void setDecayRate(int decayRate);
+    void setTarget(int target);
+
+private Q_SLOTS:
+    void decay();
+
+private:
+    int m_value;
+    int m_target;
+    int m_decayRate;
+    QTimer m_valueDecayTimer;
+};
+
+#endif // DECAYEDVALUE_H
 
=== added file 'libunity-2d-private/src/pointerbarrier.cpp'
--- libunity-2d-private/src/pointerbarrier.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/pointerbarrier.cpp	2012-03-05 14:20:25 +0000
@@ -0,0 +1,361 @@
+/*
+ * Copyright (C) 2012 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/>.
+ */
+
+// Qt
+#include <QDebug>
+#include <QTimer>
+#include <QX11Info>
+
+// libunity-2d
+#include "pointerbarriermanager.h"
+
+// Self
+#include "pointerbarrier.h"
+
+PointerBarrierWrapper::PointerBarrierWrapper(QObject *parent)
+    : QObject(parent)
+    , m_barrier(0)
+    , m_triggerDirection(TriggerFromAnywhere)
+    , m_triggerZoneEnabled(false)
+    , m_threshold(-1)
+    , m_maxVelocityMultiplier(-1)
+    , m_decayRate(-1)
+    , m_triggerPressure(-1)
+    , m_breakPressure(-1)
+    , m_smoothingTimer(new QTimer(this))
+    , m_lastEventX(0)
+    , m_lastEventY(0)
+    , m_lastEventId(0)
+    , m_smoothingCount(0)
+    , m_smoothingAccumulator(0)
+{
+    m_smoothingTimer->setSingleShot(true);
+    m_smoothingTimer->setInterval(75);
+    connect(m_smoothingTimer, SIGNAL(timeout()), this, SLOT(smoother()));
+
+    PointerBarrierManager::instance()->addBarrier(this);
+}
+
+PointerBarrierWrapper::~PointerBarrierWrapper()
+{
+    PointerBarrierManager::instance()->removeBarrier(this);
+    destroyBarrier();
+}
+
+QPointF PointerBarrierWrapper::p1() const
+{
+    return m_p1;
+}
+
+void PointerBarrierWrapper::setP1(const QPointF& p)
+{
+    if (p != m_p1) {
+        if (m_barrier != 0) {
+            destroyBarrier();
+        }
+
+        m_p1 = p;
+        Q_EMIT p1Changed(p);
+
+        createBarrier();
+    }
+}
+
+QPointF PointerBarrierWrapper::p2() const
+{
+    return m_p2;
+}
+
+void PointerBarrierWrapper::setP2(const QPointF& p)
+{
+    if (p != m_p2) {
+        if (m_barrier != 0) {
+            destroyBarrier();
+        }
+
+        m_p2 = p;
+        Q_EMIT p2Changed(p);
+
+        createBarrier();
+    }
+}
+
+QPointF PointerBarrierWrapper::triggerZoneP1() const
+{
+    return m_triggerZoneP1;
+}
+
+void PointerBarrierWrapper::setTriggerZoneP1(const QPointF& p)
+{
+    if (p != m_triggerZoneP1) {
+        m_triggerZoneP1 = p;
+        Q_EMIT triggerZoneP1Changed(p);
+
+        handleTriggerZoneChanged();
+    }
+}
+
+QPointF PointerBarrierWrapper::triggerZoneP2() const
+{
+    return m_triggerZoneP2;
+}
+
+void PointerBarrierWrapper::setTriggerZoneP2(const QPointF& p)
+{
+    if (p != m_triggerZoneP2) {
+        m_triggerZoneP2 = p;
+        Q_EMIT triggerZoneP2Changed(p);
+
+        handleTriggerZoneChanged();
+    }
+}
+
+PointerBarrierWrapper::TriggerDirection PointerBarrierWrapper::triggerDirection() const
+{
+    return m_triggerDirection;
+}
+
+void PointerBarrierWrapper::setTriggerDirection(TriggerDirection direction)
+{
+    if (direction != m_triggerDirection) {
+        m_triggerDirection = direction;
+        Q_EMIT triggerDirectionChanged(direction);
+    }
+}
+
+bool PointerBarrierWrapper::triggerZoneEnabled() const
+{
+    return m_triggerZoneEnabled;
+}
+
+void PointerBarrierWrapper::setTriggerZoneEnabled(bool enabled)
+{
+    if (m_triggerZoneEnabled != enabled) {
+        m_triggerZoneEnabled = enabled;
+        Q_EMIT triggerZoneEnabledChanged(enabled);
+
+        handleTriggerZoneChanged();
+    }
+}
+
+void PointerBarrierWrapper::createBarrier()
+{
+    if (m_threshold < 0) {
+        return;
+    }
+
+    if (!isPointAlignmentCorrect()) {
+        return;
+    }
+
+    Display *display = QX11Info::display();
+
+    m_barrier = XFixesCreatePointerBarrierVelocity(display,
+                    DefaultRootWindow(display),
+                    m_p1.x(), m_p1.y(),
+                    m_p2.x(), m_p2.y(),
+                    0,
+                    m_threshold,
+                    0,
+                    NULL);
+    Q_ASSERT(m_barrier != 0);
+}
+
+void PointerBarrierWrapper::destroyBarrier()
+{
+    if (m_barrier != 0) {
+        XFixesDestroyPointerBarrier(QX11Info::display(), m_barrier);
+        m_barrier = 0;
+    }
+}
+
+void PointerBarrierWrapper::doProcess(XFixesBarrierNotifyEvent *notifyEvent)
+{
+    m_lastEventX = notifyEvent->x;
+    m_lastEventY = notifyEvent->y;
+    m_lastEventId = notifyEvent->event_id;
+    m_smoothingAccumulator += notifyEvent->velocity;
+    m_smoothingCount++;
+
+    /* Gathers events for m_smoothingTimer->interval() miliseconds, then takes average */
+    if (!m_smoothingTimer->isActive()) {
+        m_smoothingTimer->start();
+    }
+}
+
+int PointerBarrierWrapper::threshold() const
+{
+    return m_threshold;
+}
+
+void PointerBarrierWrapper::setThreshold(int threshold)
+{
+    if (m_threshold != threshold) {
+        m_threshold = threshold;
+        destroyBarrier();
+        createBarrier();
+        Q_EMIT thresholdChanged(threshold);
+    }
+}
+
+qreal PointerBarrierWrapper::maxVelocityMultiplier() const
+{
+    return m_maxVelocityMultiplier;
+}
+
+void PointerBarrierWrapper::setMaxVelocityMultiplier(qreal maxVelocityMultiplier)
+{
+    if (maxVelocityMultiplier != m_maxVelocityMultiplier) {
+        m_maxVelocityMultiplier = maxVelocityMultiplier;
+        Q_EMIT maxVelocityMultiplierChanged(maxVelocityMultiplier);
+
+        updateRealDecayTargetPressures();
+    }
+}
+
+int PointerBarrierWrapper::decayRate() const
+{
+    return m_decayRate;
+}
+
+void PointerBarrierWrapper::setDecayRate(int decayRate)
+{
+    if (decayRate != m_decayRate) {
+        m_decayRate = decayRate;
+        Q_EMIT decayRateChanged(decayRate);
+
+        updateRealDecayTargetPressures();
+    }
+}
+
+int PointerBarrierWrapper::triggerPressure() const
+{
+    return m_triggerPressure;
+}
+
+void PointerBarrierWrapper::setTriggerPressure(int pressure)
+{
+    if (m_triggerPressure != pressure) {
+        m_triggerPressure = pressure;
+        Q_EMIT triggerPressureChanged(pressure);
+
+        updateRealDecayTargetPressures();
+    }
+}
+
+int PointerBarrierWrapper::breakPressure() const
+{
+    return m_breakPressure;
+}
+
+void PointerBarrierWrapper::setBreakPressure(int breakPressure)
+{
+    if (m_breakPressure != breakPressure) {
+        m_breakPressure = breakPressure;
+        Q_EMIT breakPressureChanged(breakPressure);
+
+        updateRealDecayTargetPressures();
+    }
+}
+
+PointerBarrier PointerBarrierWrapper::barrier() const
+{
+    return m_barrier;
+}
+
+void PointerBarrierWrapper::smoother()
+{
+    if (m_maxVelocityMultiplier < 0 || m_decayRate < 0 || m_breakPressure < 0) {
+        qWarning() << "PointerBarrierWrapper::smoother: maxVelocityMultiplier, decayRate or breakPressure not set";
+        return;
+    }
+
+    if (m_smoothingCount <= 0) {
+        return;
+    }
+    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 (m_triggerValue.addAndCheckExceedingTarget(velocity)) {
+            Q_EMIT triggered();
+        }
+    } else {
+        if (m_breakValue.addAndCheckExceedingTarget(velocity)) {
+            Display *display = QX11Info::display();
+            XFixesBarrierReleasePointer (display, m_barrier, m_lastEventId);
+
+            Q_EMIT broken();
+        }
+    }
+
+    m_smoothingAccumulator = 0;
+    m_smoothingCount = 0;
+}
+
+void PointerBarrierWrapper::updateRealDecayTargetPressures()
+{
+    // make the effect half as strong as specified as other values shouldn't scale
+    // as quickly as the max velocity multiplier
+    const float responsiveness_mult = ((m_maxVelocityMultiplier - 1) * .025) + 1;
+    const int realDecayRate = m_decayRate * responsiveness_mult;
+    m_triggerValue.setDecayRate(realDecayRate);
+    m_breakValue.setDecayRate(realDecayRate);
+    m_triggerValue.setTarget(m_triggerPressure * responsiveness_mult);
+    m_breakValue.setTarget(m_breakPressure * responsiveness_mult);
+}
+
+void PointerBarrierWrapper::handleTriggerZoneChanged()
+{
+    // Make sure barrier point alignment is still valid
+    if (!isPointAlignmentCorrect()) {
+        destroyBarrier();
+    }
+    // If there is no barrier try to create one now
+    if (m_barrier == 0) {
+        createBarrier();
+    }
+}
+
+bool PointerBarrierWrapper::isPointAlignmentCorrect() const
+{
+    bool alignmentCorrect = false;
+
+    // Outer points can't be the same
+    if (m_p1 != m_p2) {
+        // The two points need to be aligned either vertically or horizontally
+        if (m_p1.x() == m_p2.x()) {
+            alignmentCorrect = !m_triggerZoneEnabled || (m_triggerZoneP1.x() == m_p1.x() && m_triggerZoneP2.x() == m_p1.x());
+        } else if (m_p1.y() == m_p2.y()) {
+            alignmentCorrect = !m_triggerZoneEnabled || (m_triggerZoneP1.y() == m_p1.y() && m_triggerZoneP2.y() == m_p1.y());
+        }
+    }
+
+    return alignmentCorrect;
+
+}
+
+#include <pointerbarrier.moc>
 
=== added file 'libunity-2d-private/src/pointerbarrier.h'
--- libunity-2d-private/src/pointerbarrier.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/pointerbarrier.h	2012-03-05 14:20:25 +0000
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2012 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef POINTERBARRIER_H
+#define POINTERBARRIER_H
+
+#include <QObject>
+#include <QPointF>
+
+// X11
+#include <X11/extensions/Xfixes.h>
+
+#include "decayedvalue.h"
+
+struct PointerBarrierWrapperPrivate;
+
+class PointerBarrierWrapper : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QPointF p1 READ p1 WRITE setP1 NOTIFY p1Changed)
+    Q_PROPERTY(QPointF p2 READ p2 WRITE setP2 NOTIFY p2Changed)
+    Q_PROPERTY(QPointF triggerZoneP1 READ triggerZoneP1 WRITE setTriggerZoneP1 NOTIFY triggerZoneP1Changed)
+    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(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)
+    Q_PROPERTY(int triggerPressure READ triggerPressure WRITE setTriggerPressure NOTIFY triggerPressureChanged)
+    Q_PROPERTY(int breakPressure READ breakPressure WRITE setBreakPressure NOTIFY breakPressureChanged)
+
+friend class PointerBarrierManager;
+
+public:
+    enum TriggerDirection {
+        TriggerFromAnywhere,
+        TriggerFromRight,
+        TriggerFromLeft,
+        TriggerFromTop,
+        TriggerFromBottom
+    };
+    Q_ENUMS(TriggerDirection)
+
+    PointerBarrierWrapper(QObject* parent = 0);
+    ~PointerBarrierWrapper();
+
+    QPointF p1() const;
+    void setP1(const QPointF &p);
+
+    QPointF p2() const;
+    void setP2(const QPointF &p);
+
+    QPointF triggerZoneP1() const;
+    void setTriggerZoneP1(const QPointF &p);
+
+    QPointF triggerZoneP2() const;
+    void setTriggerZoneP2(const QPointF &p);
+
+    TriggerDirection triggerDirection() const;
+    void setTriggerDirection(TriggerDirection direction);
+
+    bool triggerZoneEnabled() const;
+    void setTriggerZoneEnabled(bool enabled);
+
+    int threshold() const;
+    void setThreshold(int threshold);
+
+    qreal maxVelocityMultiplier() const;
+    void setMaxVelocityMultiplier(qreal maxVelocityMultiplier);
+
+    int decayRate() const;
+    void setDecayRate(int decayRate);
+
+    int triggerPressure() const;
+    void setTriggerPressure(int pressure);
+
+    int breakPressure() const;
+    void setBreakPressure(int pressure);
+
+    PointerBarrier barrier() const;
+
+Q_SIGNALS:
+    void p1Changed(const QPointF &p1);
+    void p2Changed(const QPointF &p2);
+    void triggerZoneP1Changed(const QPointF &p1);
+    void triggerZoneP2Changed(const QPointF &p2);
+    void triggerDirectionChanged(TriggerDirection direction);
+    void triggerZoneEnabledChanged(bool changed);
+    void thresholdChanged(int threshold);
+    void maxVelocityMultiplierChanged(qreal maxVelocityMultiplier);
+    void decayRateChanged(int decayRate);
+    void triggerPressureChanged(int breakPressure);
+    void breakPressureChanged(int breakPressure);
+
+    void triggered();
+    void broken();
+
+private Q_SLOTS:
+    void smoother();
+
+private:
+    Q_DISABLE_COPY(PointerBarrierWrapper);
+
+    void createBarrier();
+    void destroyBarrier();
+
+    void doProcess(XFixesBarrierNotifyEvent *event);
+
+    void updateRealDecayTargetPressures();
+
+    void handleTriggerZoneChanged();
+
+    bool isPointAlignmentCorrect() const;
+
+    PointerBarrier m_barrier;
+
+    QPointF m_p1;
+    QPointF m_p2;
+    QPointF m_triggerZoneP1;
+    QPointF m_triggerZoneP2;
+    TriggerDirection m_triggerDirection;
+    bool m_triggerZoneEnabled;
+    int m_threshold;
+    qreal m_maxVelocityMultiplier;
+    int m_decayRate;
+    int m_triggerPressure;
+    int m_breakPressure;
+
+    QTimer *m_smoothingTimer;
+
+    int m_lastEventX;
+    int m_lastEventY;
+    int m_lastEventId;
+    int m_smoothingCount;
+    int m_smoothingAccumulator;
+
+    DecayedValue m_triggerValue;
+    DecayedValue m_breakValue;
+};
+
+#endif // POINTERBARRIER_H
 
=== added file 'libunity-2d-private/src/pointerbarriermanager.cpp'
--- libunity-2d-private/src/pointerbarriermanager.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/pointerbarriermanager.cpp	2012-03-05 14:20:25 +0000
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2012 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/>.
+ */
+
+// Special ordering to bypass evil X11 include
+#include <QDebug>
+
+// Self
+#include "pointerbarriermanager.h"
+
+// libunity-2d
+#include "pointerbarrier.h"
+
+// Qt
+#include <QX11Info>
+
+// X
+#include <X11/extensions/Xfixes.h>
+
+PointerBarrierManager *PointerBarrierManager::instance()
+{
+    static PointerBarrierManager *bpm = NULL;
+    if (bpm == NULL) bpm = new PointerBarrierManager();
+    return bpm;
+}
+
+PointerBarrierManager::PointerBarrierManager()
+{
+    Display *display = QX11Info::display();
+
+    XFixesQueryExtension(display, &m_eventBase, &m_errorBase);
+
+    Unity2dApplication* application = Unity2dApplication::instance();
+    if (application == NULL) {
+        /* This can happen for example when using qmlviewer to run the launcher */
+        qWarning() << "The application is not an Unity2dApplication."
+                      "Barriers will not be monitored.";
+    } else {
+        application->installX11EventFilter(this);
+    }
+
+    /* Enables barrier detection events - only call once!! */
+    XFixesSelectBarrierInput(display, DefaultRootWindow(display), 0xdeadbeef);
+}
+
+void PointerBarrierManager::addBarrier(PointerBarrierWrapper *barrier)
+{
+    m_barriers += barrier;
+}
+
+void PointerBarrierManager::removeBarrier(PointerBarrierWrapper *barrier)
+{
+    m_barriers -= barrier;
+}
+
+bool PointerBarrierManager::x11EventFilter(XEvent* event)
+{
+    if (event->type - m_eventBase == XFixesBarrierNotify) {
+        XFixesBarrierNotifyEvent *notifyEvent = (XFixesBarrierNotifyEvent *)event;
+
+        if (notifyEvent->subtype == XFixesBarrierHitNotify) {
+            Q_FOREACH (PointerBarrierWrapper *barrier, m_barriers) {
+                if (barrier->barrier() == notifyEvent->barrier) {
+                    barrier->doProcess(notifyEvent);
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+
+}
 
=== added file 'libunity-2d-private/src/pointerbarriermanager.h'
--- libunity-2d-private/src/pointerbarriermanager.h	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/src/pointerbarriermanager.h	2012-03-05 14:20:25 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2012 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef POINTERBARRIERMANAGER_H
+#define POINTERBARRIERMANAGER_H
+
+#include "unity2dapplication.h"
+
+class PointerBarrierWrapper;
+
+class PointerBarrierManager : protected AbstractX11EventFilter
+{
+public:
+    static PointerBarrierManager *instance();
+
+    void addBarrier(PointerBarrierWrapper *barrier);
+    void removeBarrier(PointerBarrierWrapper *barrier);
+
+protected:
+    bool x11EventFilter(XEvent* event);
+
+private:
+    Q_DISABLE_COPY(PointerBarrierManager);
+
+    PointerBarrierManager();
+    QSet<PointerBarrierWrapper*> m_barriers;
+    int m_eventBase;
+    int m_errorBase;
+};
+
+#endif // POINTERBARRIERMANAGER_H
 
=== modified file 'libunity-2d-private/tests/CMakeLists.txt'
--- libunity-2d-private/tests/CMakeLists.txt	2012-01-24 08:38:24 +0000
+++ libunity-2d-private/tests/CMakeLists.txt	2012-03-05 14:20:25 +0000
@@ -8,6 +8,7 @@
     ${CMAKE_CURRENT_BINARY_DIR}
     ${GLIB_INCLUDE_DIRS}
     ${QT_QTTEST_INCLUDE_DIR}
+    ${X11_XTest_INCLUDE_PATH}
     )
 
 set(LIBUNITY_2D_TEST_DIR ${libunity-2d-private_BINARY_DIR}/tests)
@@ -37,7 +38,10 @@
     listaggregatormodeltest
     qsortfilterproxymodeltest
     focuspathtest
+    pointerbarriertest
     )
+
+target_link_libraries(pointerbarriertest ${X11_XTest_LIB})
     
 # unity2dtrtest - FIXME
 #add_test(NAME unity2dtrtest_check
 
=== added file 'libunity-2d-private/tests/pointerbarriertest.cpp'
--- libunity-2d-private/tests/pointerbarriertest.cpp	1970-01-01 00:00:00 +0000
+++ libunity-2d-private/tests/pointerbarriertest.cpp	2012-03-05 14:20:25 +0000
@@ -0,0 +1,312 @@
+/*
+ * This file is part of unity-2d
+ *
+ * Copyright 2010 Canonical Ltd.
+ *
+ * Authors:
+ * - Aurélien Gâteau <[e-mail]>
+ *
+ * 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/>.
+ */
+
+// Local
+#include <unitytestmacro.h>
+#include <pointerbarrier.h>
+
+// Qt
+#include <QApplication>
+#include <QSignalSpy>
+#include <QX11Info>
+#include <QtTestGui>
+
+#include <X11/extensions/XTest.h>
+
+class DisableTriggerZoneOnTriggerHelper : public QObject
+{
+    Q_OBJECT
+public:
+    DisableTriggerZoneOnTriggerHelper(PointerBarrierWrapper *barrier)
+    {
+        m_barrier = barrier;
+        connect(barrier, SIGNAL(triggered()), this, SLOT(disable()));
+    }
+
+public Q_SLOTS:
+    void disable()
+    {
+        m_barrier->setTriggerZoneEnabled(false);
+    }
+
+private:
+    PointerBarrierWrapper *m_barrier;
+};
+
+class PointerBarrierTest : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void testBreak()
+    {
+        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.setThreshold(6500);
+        barrier.setMaxVelocityMultiplier(2);
+        barrier.setDecayRate(1500);
+        barrier.setBreakPressure(2000);
+
+        XTestFakeRelativeMotionEvent(display, 300, 0, 0);
+        // We are stopped by the barrier and instead in 350, 50 we are in 99, 50
+        QCOMPARE(QCursor::pos(), QPoint(99, 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 broken the barrier and are somewhere else 
+        QVERIFY(QCursor::pos() != QPoint(99, 50));
+        QCOMPARE(brokenSpy.count(), 1);
+        QCOMPARE(triggeredSpy.count(), 0);
+    }
+
+    void testStopArea()
+    {
+        Display *display = QX11Info::display();
+        PointerBarrierWrapper barrier;
+
+        QSignalSpy brokenSpy(&barrier, SIGNAL(broken()));
+        QSignalSpy triggeredSpy(&barrier, SIGNAL(triggered()));
+
+        XTestFakeMotionEvent(display, -1, 50, 150, 0);
+        QCOMPARE(QCursor::pos(), QPoint(50, 150));
+
+        barrier.setP1(QPointF(100, 0));
+        barrier.setP2(QPointF(100, 100));
+        barrier.setThreshold(6500);
+        barrier.setMaxVelocityMultiplier(2);
+        barrier.setDecayRate(1500);
+        barrier.setBreakPressure(2000);
+
+        XTestFakeRelativeMotionEvent(display, 300, 0, 0);
+        // We are not stopped by the barrier because it's above us
+        // and are in 350, 150
+        QCOMPARE(QCursor::pos(), QPoint(350, 150));
+
+        QCOMPARE(brokenSpy.count(), 0);
+        QCOMPARE(triggeredSpy.count(), 0);
+    }
+
+    void testTrigger()
+    {
+        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.setThreshold(6500);
+        barrier.setMaxVelocityMultiplier(2);
+        barrier.setDecayRate(1500);
+        barrier.setTriggerPressure(2000);
+        barrier.setBreakPressure(2000);
+
+        XTestFakeRelativeMotionEvent(display, 300, 0, 0);
+        // We are stopped by the barrier and instead in 350, 50 we are in 99, 50
+        QCOMPARE(QCursor::pos(), QPoint(99, 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(99, 50));
+        QCOMPARE(brokenSpy.count(), 0);
+        QVERIFY(triggeredSpy.count() >= 1);
+    }
+
+    void testTriggerAndBreak()
+    {
+        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.setThreshold(6500);
+        barrier.setMaxVelocityMultiplier(2);
+        barrier.setDecayRate(1500);
+        barrier.setTriggerPressure(2000);
+        barrier.setBreakPressure(2000);
+
+        DisableTriggerZoneOnTriggerHelper helper(&barrier);
+
+        XTestFakeRelativeMotionEvent(display, 300, 0, 0);
+        // We are stopped by the barrier and instead in 350, 50 we are in 99, 50
+        QCOMPARE(QCursor::pos(), QPoint(99, 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 and broken the barrier and somewhere else
+        QVERIFY(QCursor::pos() != QPoint(99, 50));
+        QCOMPARE(brokenSpy.count(), 1);
+        QCOMPARE(triggeredSpy.count(), 1);
+    }
+
+    void testTriggerWithoutAndBreak()
+    {
+        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.setThreshold(6500);
+        barrier.setMaxVelocityMultiplier(2);
+        barrier.setDecayRate(1500);
+        barrier.setTriggerPressure(2000);
+        barrier.setBreakPressure(2000);
+
+        DisableTriggerZoneOnTriggerHelper helper(&barrier);
+
+        XTestFakeRelativeMotionEvent(display, 300, 0, 0);
+        // We are stopped by the barrier and instead in 350, 50 we are in 99, 50
+        QCOMPARE(QCursor::pos(), QPoint(99, 50));
+
+        QCOMPARE(brokenSpy.count(), 0);
+        QCOMPARE(triggeredSpy.count(), 0);
+
+        for (int i = 0; i < 10 && barrier.triggerZoneEnabled(); ++i) {
+            XTestFakeRelativeMotionEvent(display, 100, 0, 0);
+            QTest::qWait(100);
+        }
+        // We have triggered the barrier
+        QCOMPARE(QCursor::pos(), QPoint(99, 50));
+        QCOMPARE(brokenSpy.count(), 0);
+        QCOMPARE(triggeredSpy.count(), 1);
+
+        // We can push a bit more without breaking the barrier
+        for (int i = 0; i < 2; ++i) {
+            XTestFakeRelativeMotionEvent(display, 100, 0, 0);
+            QTest::qWait(100);
+        }
+        QCOMPARE(QCursor::pos(), QPoint(99, 50));
+        QCOMPARE(brokenSpy.count(), 0);
+        QCOMPARE(triggeredSpy.count(), 1);
+    }
+
+    void testTriggerAndBreakZones()
+    {
+        Display *display = QX11Info::display();
+        PointerBarrierWrapper barrier;
+
+        QSignalSpy brokenSpy(&barrier, SIGNAL(broken()));
+        QSignalSpy triggeredSpy(&barrier, SIGNAL(triggered()));
+
+        XTestFakeMotionEvent(display, -1, 50, 25, 0);
+        QCOMPARE(QCursor::pos(), QPoint(50, 25));
+
+        barrier.setP1(QPointF(100, 0));
+        barrier.setP2(QPointF(100, 200));
+        barrier.setTriggerZoneP1(QPointF(100, 50));
+        barrier.setTriggerZoneP2(QPointF(100, 150));
+        barrier.setTriggerZoneEnabled(true);
+        barrier.setThreshold(6500);
+        barrier.setMaxVelocityMultiplier(2);
+        barrier.setDecayRate(1500);
+        barrier.setTriggerPressure(2000);
+        barrier.setBreakPressure(2000);
+
+        DisableTriggerZoneOnTriggerHelper helper(&barrier);
+
+        XTestFakeRelativeMotionEvent(display, 300, 0, 0);
+        // We are stopped by the barrier and instead in 350, 25 we are in 99, 25
+        QCOMPARE(QCursor::pos(), QPoint(99, 25));
+
+        QCOMPARE(brokenSpy.count(), 0);
+        QCOMPARE(triggeredSpy.count(), 0);
+
+        for (int i = 0; i < 10; ++i) {
+            XTestFakeRelativeMotionEvent(display, 100, 0, 0);
+            QTest::qWait(100);
+        }
+
+        // We are above the trigger zone so we have only broke the barrier
+        QVERIFY(QCursor::pos() != QPoint(99, 25));
+        QCOMPARE(brokenSpy.count(), 1);
+        QCOMPARE(triggeredSpy.count(), 0);
+
+        // Go back
+        XTestFakeMotionEvent(display, -1, 50, 100, 0);
+
+        XTestFakeRelativeMotionEvent(display, 300, 0, 0);
+        // We are stopped by the barrier and instead in 350, 100 we are in 99, 100
+        QCOMPARE(QCursor::pos(), QPoint(99, 100));
+
+        for (int i = 0; i < 10; ++i) {
+            XTestFakeRelativeMotionEvent(display, 100, 0, 0);
+            QTest::qWait(100);
+        }
+
+        // We are in the trigger zone so we have triggered and broken the barrier
+        QVERIFY(QCursor::pos() != QPoint(99, 100));
+        QCOMPARE(brokenSpy.count(), 2);
+        QCOMPARE(triggeredSpy.count(), 1);
+    }
+};
+
+UAPP_TEST_MAIN(PointerBarrierTest)
+
+#include "pointerbarriertest.moc"
 
=== modified file 'shell/Shell.qml'
--- shell/Shell.qml	2012-02-28 12:00:14 +0000
+++ shell/Shell.qml	2012-03-05 14:20:25 +0000
@@ -93,6 +93,13 @@
                     if (dashLoader.status == Loader.Ready) dashLoader.item.deactivateAllLenses()
                 }
             }
+            onGlobalPositionChanged: {
+                var x = declarativeView.globalPosition.x + (Utils.isLeftToRight() ? 0 : shell.width)
+                launcherLoader.item.barrierP1 = Qt.point(x, 0)
+                launcherLoader.item.barrierP2 = Qt.point(x, declarativeView.screen.geometry.height)
+                launcherLoader.item.barrierTriggerZoneP1 = Qt.point(x, declarativeView.globalPosition.y)
+                launcherLoader.item.barrierTriggerZoneP2 = Qt.point(x, declarativeView.globalPosition.y + launcherLoader.height)
+            }
         }
 
         SpreadMonitor {
@@ -219,24 +226,10 @@
     Binding {
         target: launcherInputShape
         property: "rectangle"
-        value: {
-            // FIXME: this results in a 1px wide white rectangle on the launcher edge, we should switch
-            //        to cpp-based edge detection, and later XFixes barriers to get rid of that completely
-            var somewhatShown = Utils.isLeftToRight() ? -launcherLoader.x < launcherLoader.width : launcherLoader.x < shell.width
-            if (somewhatShown) {
-                return Qt.rect(launcherLoader.x,
-                                launcherLoader.y,
-                                launcherLoader.width,
-                                launcherLoader.height)
-            } else {
-                // The outerEdgeMouseArea is one pixel bigger on each side so use it
-                // when the launcher is hidden to have that extra pixel in the border
-                return Qt.rect(launcherLoader.x + launcherLoader.outerEdgeMouseArea.x,
-                                launcherLoader.y,
-                                launcherLoader.outerEdgeMouseArea.width,
-                                launcherLoader.height)
-            }
-        }
+        value: Qt.rect(launcherLoader.x,
+                       launcherLoader.y,
+                       launcherLoader.width,
+                       launcherLoader.height)
         when: !launcherLoaderXAnimation.running
     }
 
 
=== modified file 'shell/common/visibilityBehaviors/AutoHideBehavior.qml'
--- shell/common/visibilityBehaviors/AutoHideBehavior.qml	2012-03-02 13:48:01 +0000
+++ shell/common/visibilityBehaviors/AutoHideBehavior.qml	2012-03-05 14:20:25 +0000
@@ -18,13 +18,14 @@
 
 import QtQuick 1.0
 
-// Shows the target when it has the focus or when you move the
-// mouse for 500 msec to the edge of the target
+// Shows the target when it has the focus or when you trigger the pointer barrier
+// in the edge of the target
 // Hides the target when none of the above conditions are met
 // and you have not had the mouse over it during more than 1000 msec
-// To use this Behavior your target needs to provide two properties
+// To use this Behavior your target needs to provide one properties
 //  - containsMouse: Defines if the mouse is inside the target
-//  - outerEdgeContainsMouse: Defines if the mouse is in the edge of the target
+// and one signal
+//  - barrierTriggered: Defines when the pointer barrier has been triggered
 
 BaseBehavior {
     id: autoHide
@@ -51,12 +52,6 @@
         onTriggered: shownRegardlessOfFocus = false
     }
 
-    Timer {
-        id: edgeHitTimer
-        interval: 500
-        onTriggered: shownRegardlessOfFocus = true
-    }
-
     Connections {
         target: (autoHide.target !== undefined) ? autoHide.target : null
         onContainsMouseChanged: {
@@ -68,7 +63,6 @@
 
     Connections {
         target: autoHide.target !== undefined ? autoHide.target : null
-        onOuterEdgeContainsMouseChanged: edgeHitTimer.running = target.outerEdgeContainsMouse
-        ignoreUnknownSignals: true
+        onBarrierTriggered: shownRegardlessOfFocus = true
     }
 }
 
=== modified file 'shell/common/visibilityBehaviors/IntelliHideBehavior.qml'
--- shell/common/visibilityBehaviors/IntelliHideBehavior.qml	2012-03-02 13:48:01 +0000
+++ shell/common/visibilityBehaviors/IntelliHideBehavior.qml	2012-03-05 14:20:25 +0000
@@ -20,14 +20,14 @@
 import Unity2d 1.0
 import "../utils.js" as Utils
 
-// Shows the target when it has the focus or when you move the
-// mouse for 500 msec to the edge of the target or there are no 
-// windows that intersect with the target
+// Shows the target when it has the focus or when you trigger the pointer barrier
+// or there are no windows that intersect with the target
 // Hides the target when none of the above conditions are met
 // and you have not had the mouse over it during more than 1000 msec
-// To use this Behavior your target needs to provide two properties
+// To use this Behavior your target needs to provide one properties
 //  - containsMouse: Defines if the mouse is inside the target
-//  - outerEdgeContainsMouse: Defines if the mouse is in the edge of the target
+// and one signal
+//  - barrierTriggered: Defines when the pointer barrier has been triggered
 
 AutoHideBehavior {
     id: intellihide
 
=== modified file 'shell/launcher/Launcher.qml'
--- shell/launcher/Launcher.qml	2012-02-27 10:50:43 +0000
+++ shell/launcher/Launcher.qml	2012-03-05 14:20:25 +0000
@@ -25,11 +25,33 @@
     id: launcher
     Accessible.name: "launcher"
 
-    property bool outerEdgeContainsMouse
+    signal barrierTriggered
+
     property bool shown
     property bool showMenus: true
 
     property bool containsMouse: declarativeView.monitoredAreaContainsMouse
+    property variant barrierP1
+    property variant barrierP2
+    property variant barrierTriggerZoneP1
+    property variant barrierTriggerZoneP2
+
+    PointerBarrier {
+        id: barrier
+        triggerDirection: Utils.isLeftToRight() ? PointerBarrier.TriggerFromRight : PointerBarrier.TriggerFromLeft
+        triggerZoneEnabled: !shown
+        p1: barrierP1
+        p2: barrierP2
+        triggerZoneP1: barrierTriggerZoneP1
+        triggerZoneP2: barrierTriggerZoneP2
+        threshold: launcher2dConfiguration.edgeStopVelocity
+        maxVelocityMultiplier: launcher2dConfiguration.edgeResponsiveness
+        decayRate: launcher2dConfiguration.edgeDecayrate
+        triggerPressure: launcher2dConfiguration.edgeRevealPressure
+        breakPressure: launcher2dConfiguration.edgeOvercomePressure
+
+        onTriggered: launcher.barrierTriggered()
+    }
 
     function hideMenu() {
         if (main.visibleMenu !== undefined) {
 
=== modified file 'shell/launcher/LauncherLoader.qml'
--- shell/launcher/LauncherLoader.qml	2012-02-10 11:17:36 +0000
+++ shell/launcher/LauncherLoader.qml	2012-03-05 14:20:25 +0000
@@ -26,7 +26,6 @@
     source: "Launcher.qml"
     property variant visibilityController: visibilityController
     onLoaded: item.focus = true
-    property alias outerEdgeMouseArea: outerEdge
 
     VisibilityController {
         id: visibilityController
@@ -79,16 +78,7 @@
 
     Binding {
         target: launcherLoader.item
-        property: "outerEdgeContainsMouse"
-        value: outerEdge.containsMouse && outerEdge.enabled
-    }
-
-    MouseArea {
-        id: outerEdge
-        anchors.fill: parent
-        anchors.margins: -1
-        hoverEnabled: !visibilityController.shown
-        enabled: !visibilityController.shown
-    }
-
+        property: "shown"
+        value: visibilityController.shown
+    }
 }
 
=== modified file 'tests/launcher/autohide_show_tests.rb'
--- tests/launcher/autohide_show_tests.rb	2012-02-20 14:11:16 +0000
+++ tests/launcher/autohide_show_tests.rb	2012-03-05 14:20:25 +0000
@@ -55,6 +55,12 @@
     XDo::Mouse.move(0, 200, 0, true)
   end
 
+  def mouse_push_screen_edge
+    (1..100).each do |i|
+      $SUT.execute_shell_command 'xdotool mousemove_relative -- -10 0'
+    end
+  end
+
   def move_mouse_to_launcher_inner_border()
     XDo::Mouse.move(LAUNCHER_WIDTH-1,200)
   end
 
=== modified file 'tests/launcher/autohide_show_tests_common.rb'
--- tests/launcher/autohide_show_tests_common.rb	2012-02-20 16:44:00 +0000
+++ tests/launcher/autohide_show_tests_common.rb	2012-03-05 14:20:25 +0000
@@ -114,7 +114,7 @@
 #   * Open application in position overlapping Launcher
 #   * Verify Launcher hiding
 #   * Move mouse to left of screen to reveal Launcher
-#   * Verify Launcher shows but not immediately
+#   * Verify Launcher shows only if we push the barrier
 #   * Move mouse to the right, but still over the Launcher
 #   * Verify Launcher still showing
 #   * Move mouse further right to not overlap Launcher
@@ -128,8 +128,8 @@
   verify_launcher_hidden(TIMEOUT, 'Launcher visible with window in the way, should be hidden')
 
   move_mouse_to_screen_edge()
-  sleep 0.4
-  verify_launcher_hidden(0, 'Launcher should not be visible immediately after mouse moves to the edge, has to wait 0.5 seconds to show')
+  verify_launcher_hidden(0, 'Launcher should not be visible immediately without pushing the edge')
+  mouse_push_screen_edge()
   verify_launcher_visible(TIMEOUT, 'Launcher hiding when mouse at edge of screen')
 
   move_mouse_to_launcher_inner_border()
@@ -422,6 +422,7 @@
   if !tiles.empty?
     tile = tiles[0]
     move_mouse_to_screen_edge()
+    mouse_push_screen_edge()
     verify_launcher_visible(TIMEOUT, 'Launcher hiding when mouse at edge of screen, should be visible')
     tile.move_mouse()
     XDo::Mouse.click(nil, nil, :right)
@@ -457,6 +458,7 @@
 
   bfb = @app.LauncherList( :name => 'main' ).LauncherList( :isBfb => true );
   move_mouse_to_screen_edge()
+  mouse_push_screen_edge()
   verify_launcher_visible(TIMEOUT, 'Launcher hiding when mouse at edge of screen, should be visible')
   bfb.move_mouse()
   bfb.tap()
 
=== modified file 'tests/launcher/autohide_show_tests_rtl.rb'
--- tests/launcher/autohide_show_tests_rtl.rb	2012-02-20 14:11:16 +0000
+++ tests/launcher/autohide_show_tests_rtl.rb	2012-03-05 14:20:25 +0000
@@ -56,6 +56,12 @@
     XDo::Mouse.move(XDo::XWindow.display_geometry[0], 200, 0, true)
   end
 
+  def mouse_push_screen_edge
+    (1..100).each do |i|
+      $SUT.execute_shell_command 'xdotool mousemove_relative 10 0'
+    end
+  end
+
   def move_mouse_to_launcher_inner_border()
     XDo::Mouse.move(XDo::XWindow.display_geometry[0] - LAUNCHER_WIDTH, 200)
   end