Merge lp:~jassmith/unity/unity.sticky-edges into lp:unity

[Jason Smith]

Implement sticky edge behavior as requested by design. Add EdgeBarrierController class to handle complexity of edge barriers.

== Problem ==
Launcher behavior with edge stickiness is inconsisten with design. Further details available with bug #961285

== Solution ==
Implement behavior consisten with design. A new class was created to control all barrier edges and launchers are subscribed to that class as needed.

== Testing ==
Autopilot tests are in place to test new behavior.

[Thomi Richards (thomir-deactivatedaccount)]

Hi,

ResizeBarrierList should pass it's std::vector by const ref:

void ResizeBarrierList(std::vector<nux::Geometry> const& layout);

same with SetupBarriers:

void SetupBarriers(std::vector<nux::Geometry> const& layout);

Should probably fix this, just to bzr / lp don't complain:

194 \ No newline at end of file

...and definitely fix this one:

257 \ No newline at end of file

Is a lack of newline character at the end of header files can cause real problems.

Pro tip - this:

edge_barriers_(new ui::EdgeBarrierController())

Is better written as this:

edge_barriers_(std::make_shared<ui::EdgeBarrierController>())

std::make_shared returns a std::shared_ptr<T> constructed with the arguments you pass it, but it does it in only one memory allocation. Using "edge_barriers_(new ui::EdgeBarrierController())" requires at least two. Also, I believe that make_shared is exception safe, whereas the other method may throw if you cannot allocate an object (TBH though, if you get into that situation you're pretty screwed anyway). I don't mind if you choose to ignore this - it's something that I've started doing.

471 +enum BarrierDirection
472 +{
473 + BOTH = 0,
474 + LEFT = 1,
475 + RIGHT = 4,
476 +};

0, 1, 4? If you want this to be a bitmask, shouldn't RIGHT = 2?

500 +from autopilot.emulators.X11 import Mouse
512 + mouse = Mouse()

You don't need these two lines - all Autopilot test classes have access to 'self.mouse' already.

509 +class LauncherCaptureTests(ScenariodLauncherTests):

I don't think you want to derive from ScenariodLauncherTests - deriving from this class ensures that your tests get called several times with different sets of launcher options. It seems to me that your tests specify the options under which they'll work already? If that is in fact the case, just derive from AutopilotTestCase instead.

530 + if self.screen_geo.get_num_monitors() <= 1:
531 + return

Instead of returning, please do this:

self.skipTest("Cannot run this test with a single monitor configured.")

... obviously this applies to all the tests.

539 + self.assertThat(x_fin, NotEquals(x - width / 2))

Try not to do negative assertions - it's too easy to have the test pass when it shouldn't. Should the mouse value be less than, or greater than x_fin? Use GreaterThan / LessThen matchers instead (you may need to import them).

This code:

565 + self.set_unity_option('launcher_hide_mode', 1)
567 +
568 + launcher = self.get_launcher()
569 + for counter in range(10):
570 + sleep(1)
571 + if launcher.hidemode == 1:
572 + break
573 + self.assertThat(launcher.hidemode, Equals(1),
574 + "Launcher did not enter hidden mode.")

Should go in a method, so you can call it as often as you want from the setUp method and from within your tests.

Looking good though (apart from the issues above).

Cheers,

609 + self.assertThat(x_fin, NotEquals(x + width * 1.5))

Same thing as before with the negative assertions. Better to use Equals, or GreatherThan or LessTHan to test what you really mean.

review: Needs Fixing

[Thomi Richards (thomir-deactivatedaccount)]

Looks good to me.

review: Approve

=== added file 'plugins/unityshell/src/EdgeBarrierController.cpp'
--- plugins/unityshell/src/EdgeBarrierController.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/EdgeBarrierController.cpp	2012-04-04 23:48:21 +0000
@@ -0,0 +1,189 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * 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 version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Jason Smith <[e-mail]>
+ */
+
+#include "EdgeBarrierController.h"
+#include "Decaymulator.h"
+#include "UScreen.h"
+
+namespace unity {
+namespace ui {
+
+struct EdgeBarrierController::Impl
+{
+  Impl(EdgeBarrierController *parent);
+  ~Impl();
+
+  void ResizeBarrierList(std::vector<nux::Geometry> const& layout);
+  void SetupBarriers(std::vector<nux::Geometry> const& layout);
+
+  void OnPointerBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event);
+
+  std::vector<PointerBarrierWrapper::Ptr> barriers_;
+  Decaymulator::Ptr decaymulator_;
+  float edge_overcome_pressure_;
+  EdgeBarrierController* parent_;
+  std::vector<EdgeBarrierSubscriber*> subscribers_;
+};
+
+EdgeBarrierController::Impl::Impl(EdgeBarrierController *parent)
+  : decaymulator_(Decaymulator::Ptr(new Decaymulator()))
+  , edge_overcome_pressure_(0)
+  , parent_(parent)
+{
+  UScreen *uscreen = UScreen::GetDefault();
+
+  auto monitors = uscreen->GetMonitors();
+  ResizeBarrierList(monitors);
+
+  uscreen->changed.connect([&](int primary, std::vector<nux::Geometry>& layout) {
+    ResizeBarrierList(layout);
+    SetupBarriers(layout);
+  });
+
+  parent_->sticky_edges.changed.connect([&](bool value) {
+    SetupBarriers(UScreen::GetDefault()->GetMonitors());
+  });
+
+  parent_->options.changed.connect([&](launcher::Options::Ptr options) {
+    options->option_changed.connect([&]() {
+      SetupBarriers(UScreen::GetDefault()->GetMonitors());
+    });
+    SetupBarriers(UScreen::GetDefault()->GetMonitors());
+  });
+}
+
+EdgeBarrierController::Impl::~Impl()
+{
+
+}
+
+void EdgeBarrierController::Impl::ResizeBarrierList(std::vector<nux::Geometry> const& layout)
+{
+  size_t num_monitors = layout.size();
+  if (barriers_.size() > num_monitors)
+  {
+    barriers_.resize(num_monitors);
+  }
+
+  while (barriers_.size() < num_monitors)
+  {
+    auto barrier = PointerBarrierWrapper::Ptr(new PointerBarrierWrapper());
+    barrier->barrier_event.connect(sigc::mem_fun(this, &EdgeBarrierController::Impl::OnPointerBarrierEvent));
+    barriers_.push_back(barrier);
+  }
+}
+
+void EdgeBarrierController::Impl::SetupBarriers(std::vector<nux::Geometry> const& layout)
+{
+  bool edge_resist = parent_->options()->edge_resist();
+
+  size_t size = layout.size();
+  for (size_t i = 0; i < size; i++)
+  {
+    auto barrier = barriers_[i];
+    auto monitor = layout[i];
+
+    barrier->DestroyBarrier();
+
+    if (!edge_resist && (subscribers_[i] == nullptr || parent_->options()->hide_mode() == launcher::LauncherHideMode::LAUNCHER_HIDE_NEVER))
+      continue;
+
+    barrier->x1 = monitor.x;
+    barrier->x2 = monitor.x;
+    barrier->y1 = monitor.y;
+    barrier->y2 = monitor.y + monitor.height;
+    barrier->index = i;
+
+    barrier->threshold = parent_->options()->edge_stop_velocity();
+    barrier->max_velocity_multiplier = parent_->options()->edge_responsiveness();
+
+    if (edge_resist)
+      barrier->direction = BarrierDirection::BOTH;
+    else
+      barrier->direction = BarrierDirection::LEFT;
+
+    barrier->ConstructBarrier();
+  }
+
+  float decay_responsiveness_mult = ((parent_->options()->edge_responsiveness() - 1) * .3f) + 1;
+  decaymulator_->rate_of_decay = parent_->options()->edge_decay_rate() * decay_responsiveness_mult;
+  
+  float overcome_responsiveness_mult = ((parent_->options()->edge_responsiveness() - 1) * 1.0f) + 1;
+  edge_overcome_pressure_ = parent_->options()->edge_overcome_pressure() * overcome_responsiveness_mult;
+}
+
+void EdgeBarrierController::Impl::OnPointerBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
+{
+  int monitor = owner->index;
+  bool process = true;
+
+  if ((size_t)monitor <= subscribers_.size())
+  {
+    auto subscriber = subscribers_[monitor];
+    if (subscriber && subscriber->HandleBarrierEvent(owner, event))
+      process = false;
+  }
+
+  if (process && owner->x1 > 0)
+  {
+    decaymulator_->value = decaymulator_->value + event->velocity;
+    if (decaymulator_->value > edge_overcome_pressure_ || !parent_->options()->edge_resist())
+    {
+      owner->ReleaseBarrier(event->event_id);
+      decaymulator_->value = 0;
+    }
+  }
+  else
+  {
+    decaymulator_->value = 0;
+  }
+}
+
+EdgeBarrierController::EdgeBarrierController()
+  : sticky_edges(false)
+  , pimpl(new Impl(this))
+{
+}
+
+EdgeBarrierController::~EdgeBarrierController()
+{
+
+}
+
+void EdgeBarrierController::Subscribe(EdgeBarrierSubscriber* subscriber, int monitor)
+{
+  if (pimpl->subscribers_.size() <= (size_t)monitor)
+    pimpl->subscribers_.resize(monitor + 1);
+  pimpl->subscribers_[monitor] = subscriber;
+
+  pimpl->SetupBarriers(UScreen::GetDefault()->GetMonitors());
+}
+
+void EdgeBarrierController::Unsubscribe(EdgeBarrierSubscriber* subscriber, int monitor)
+{
+  if (pimpl->subscribers_.size() < (size_t)monitor || pimpl->subscribers_[monitor] != subscriber)
+    return;
+  pimpl->subscribers_[monitor] = nullptr;
+
+  pimpl->SetupBarriers(UScreen::GetDefault()->GetMonitors());
+}
+
+
+}
+}

=== added file 'plugins/unityshell/src/EdgeBarrierController.h'
--- plugins/unityshell/src/EdgeBarrierController.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/EdgeBarrierController.h	2012-04-04 23:48:21 +0000
@@ -0,0 +1,57 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * 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 version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Jason Smith <[e-mail]>
+ */
+
+#ifndef UNITY_EDGEBARRIERCONTROLLER_H
+#define UNITY_EDGEBARRIERCONTROLLER_H
+
+#include "PointerBarrier.h"
+#include "LauncherOptions.h"
+
+namespace unity {
+namespace ui {
+
+class EdgeBarrierSubscriber
+{
+public:
+  virtual bool HandleBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr event) { return false; };
+};
+
+class EdgeBarrierController : public sigc::trackable
+{
+public:
+  typedef std::shared_ptr<EdgeBarrierController> Ptr;
+
+  EdgeBarrierController();
+  ~EdgeBarrierController();
+
+  nux::Property<bool> sticky_edges;
+  nux::Property<launcher::Options::Ptr> options;
+
+  void Subscribe(EdgeBarrierSubscriber* subscriber, int monitor);
+  void Unsubscribe(EdgeBarrierSubscriber* subscriber, int monitor);
+
+private:
+  struct Impl;
+  Impl* pimpl;
+};
+
+}
+}
+
+#endif

=== modified file 'plugins/unityshell/src/Launcher.cpp'
--- plugins/unityshell/src/Launcher.cpp	2012-04-04 21:30:56 +0000
+++ plugins/unityshell/src/Launcher.cpp	2012-04-04 23:48:21 +0000
@@ -74,7 +74,6 @@
 namespace unity
 {
 using ui::RenderArg;
-using ui::PointerBarrierWrapper;
 using ui::Decaymulator;
 
 namespace launcher
@@ -294,11 +293,6 @@
   launcher_sheen_ = cache.FindTexture("dash_sheen", 0, 0, cb);
   launcher_pressure_effect_ = cache.FindTexture("launcher_pressure_effect", 0, 0, cb);
 
-  _pointer_barrier = PointerBarrierWrapper::Ptr(new PointerBarrierWrapper());
-  _pointer_barrier->barrier_event.connect(sigc::mem_fun(this, &Launcher::OnPointerBarrierEvent));
-
-  decaymulator_ = Decaymulator::Ptr(new Decaymulator());
-
   options.changed.connect (sigc::mem_fun (this, &Launcher::OnOptionsChanged));
 }
 
@@ -1598,30 +1592,12 @@
 void Launcher::ConfigureBarrier()
 {
   nux::Geometry geo = GetAbsoluteGeometry();
-  _pointer_barrier->DestroyBarrier();
-
-  if (options()->edge_resist || geo.x == 0)
-  {
-    unity::panel::Style &panel_style = panel::Style::Instance();
-
-    _pointer_barrier->x1 = geo.x;
-    _pointer_barrier->x2 = geo.x;
-    _pointer_barrier->y1 = geo.y - panel_style.panel_height;
-    _pointer_barrier->y2 = geo.y + geo.height;
-
-    float decay_responsiveness_mult = ((options()->edge_responsiveness() - 1) * .3f) + 1;
-    float reveal_responsiveness_mult = ((options()->edge_responsiveness() - 1) * .025f) + 1;
-    float overcome_responsiveness_mult = ((options()->edge_responsiveness() - 1) * 1.0f) + 1;
-    decaymulator_->rate_of_decay = options()->edge_decay_rate() * decay_responsiveness_mult;
-    _edge_overcome_pressure = options()->edge_overcome_pressure() * overcome_responsiveness_mult;
-
-    _pointer_barrier->threshold = options()->edge_stop_velocity();
-    _pointer_barrier->max_velocity_multiplier = options()->edge_responsiveness();
-    _pointer_barrier->ConstructBarrier();
-
-    _hide_machine->reveal_pressure = options()->edge_reveal_pressure() * reveal_responsiveness_mult;
-    _hide_machine->edge_decay_rate = options()->edge_decay_rate() * decay_responsiveness_mult;
-  }
+
+  float decay_responsiveness_mult = ((options()->edge_responsiveness() - 1) * .3f) + 1;
+  float reveal_responsiveness_mult = ((options()->edge_responsiveness() - 1) * .025f) + 1;
+  
+  _hide_machine->reveal_pressure = options()->edge_reveal_pressure() * reveal_responsiveness_mult;
+  _hide_machine->edge_decay_rate = options()->edge_decay_rate() * decay_responsiveness_mult;
 }
 
 void Launcher::SetHideMode(LauncherHideMode hidemode)
@@ -2416,7 +2392,7 @@
   EnsureAnimation();
 }
 
-void Launcher::OnPointerBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
+bool Launcher::HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
 {
   nux::Geometry abs_geo = GetAbsoluteGeometry();
 
@@ -2450,19 +2426,11 @@
     }
   }
 
-  if (apply_to_reveal)
-  {
-    _hide_machine->AddRevealPressure(event->velocity);
-    decaymulator_->value = 0;
-  }
-  else if (abs_geo.x > 0)
-  {
-    decaymulator_->value = decaymulator_->value + event->velocity;
-    if (decaymulator_->value > _edge_overcome_pressure)
-    {
-      _pointer_barrier->ReleaseBarrier(event->event_id);
-    }
-  }
+  if (!apply_to_reveal)
+    return false;
+
+  _hide_machine->AddRevealPressure(event->velocity);
+  return true;
 }
 
 bool Launcher::IsInKeyNavMode() const

=== modified file 'plugins/unityshell/src/Launcher.h'
--- plugins/unityshell/src/Launcher.h	2012-03-30 04:00:05 +0000
+++ plugins/unityshell/src/Launcher.h	2012-04-04 23:48:21 +0000
@@ -33,6 +33,7 @@
 #include "BackgroundEffectHelper.h"
 #include "DNDCollectionWindow.h"
 #include "DndData.h"
+#include "EdgeBarrierController.h"
 #include "GeisAdapter.h"
 #include "Introspectable.h"
 #include "LauncherOptions.h"
@@ -50,7 +51,7 @@
 class AbstractLauncherIcon;
 class LauncherModel;
 
-class Launcher : public unity::debug::Introspectable, public nux::View
+class Launcher : public unity::debug::Introspectable, public nux::View, public ui::EdgeBarrierSubscriber
 {
   NUX_DECLARE_OBJECT_TYPE(Launcher, nux::View);
 public:
@@ -187,7 +188,7 @@
   void OnDragUpdate(GeisAdapter::GeisDragData* data);
   void OnDragFinish(GeisAdapter::GeisDragData* data);
 
-  void OnPointerBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event);
+  bool HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event);
 
   void OnPluginStateChanged();
 
@@ -342,9 +343,6 @@
 
   nux::ObjectPtr<nux::IOpenGLBaseTexture> _offscreen_drag_texture;
 
-  ui::PointerBarrierWrapper::Ptr _pointer_barrier;
-  ui::Decaymulator::Ptr decaymulator_;
-
   int _space_between_icons;
   int _icon_size;
   int _icon_image_size;

=== modified file 'plugins/unityshell/src/LauncherController.cpp'
--- plugins/unityshell/src/LauncherController.cpp	2012-04-03 01:58:52 +0000
+++ plugins/unityshell/src/LauncherController.cpp	2012-04-04 23:48:21 +0000
@@ -32,6 +32,7 @@
 #include "DesktopLauncherIcon.h"
 #include "DeviceLauncherIcon.h"
 #include "DeviceLauncherSection.h"
+#include "EdgeBarrierController.h"
 #include "FavoriteStore.h"
 #include "HudLauncherIcon.h"
 #include "Launcher.h"
@@ -173,6 +174,8 @@
 
   int                    launcher_key_press_time_;
 
+  ui::EdgeBarrierController::Ptr edge_barriers_;
+
   LauncherList launchers;
 
   sigc::connection on_expoicon_activate_connection_;
@@ -188,7 +191,10 @@
   , sort_priority_(0)
   , show_desktop_icon_(false)
   , display_(display)
+  , edge_barriers_(new ui::EdgeBarrierController())
 {
+  edge_barriers_->options = parent_->options();
+
   UScreen* uscreen = UScreen::GetDefault();
   auto monitors = uscreen->GetMonitors();
   int primary = uscreen->GetPrimaryMonitor();
@@ -331,10 +337,16 @@
     {
       parent_->RemoveChild(launcher.GetPointer());
       launcher->GetParent()->UnReference();
+      edge_barriers_->Unsubscribe(launcher.GetPointer(), launcher->monitor);
     }
   }
 
   launchers.resize(num_launchers);
+
+  for (size_t i = 0; i < launchers.size(); ++i)
+  {
+    edge_barriers_->Subscribe(launchers[i].GetPointer(), launchers[i]->monitor);
+  }
 }
 
 void Controller::Impl::OnScreenChanged(int primary_monitor, std::vector<nux::Geometry>& monitors)

=== modified file 'plugins/unityshell/src/PointerBarrier.cpp'
--- plugins/unityshell/src/PointerBarrier.cpp	2012-03-27 20:47:58 +0000
+++ plugins/unityshell/src/PointerBarrier.cpp	2012-04-04 23:48:21 +0000
@@ -37,6 +37,7 @@
 
 PointerBarrierWrapper::PointerBarrierWrapper()
 {
+  direction = BOTH;
   last_event_ = 0;
   last_y_ = 0;
   last_x_ = 0;
@@ -72,7 +73,7 @@
                                                DefaultRootWindow(dpy),
                                                x1, y1,
                                                x2, y2,
-                                               0,
+                                               (int) direction,
                                                threshold,
                                                0,
                                                NULL);

=== modified file 'plugins/unityshell/src/PointerBarrier.h'
--- plugins/unityshell/src/PointerBarrier.h	2012-02-07 07:42:12 +0000
+++ plugins/unityshell/src/PointerBarrier.h	2012-04-04 23:48:21 +0000
@@ -41,6 +41,15 @@
   int event_id;
 };
 
+
+// values picked to match Xfixes values
+enum BarrierDirection
+{
+  BOTH = 0,
+  LEFT = 1,
+  RIGHT = 4,
+};
+
 class PointerBarrierWrapper
 {
 public:
@@ -59,6 +68,10 @@
 
   nux::Property<float> max_velocity_multiplier;
 
+  nux::Property<int> index;
+
+  nux::Property<BarrierDirection> direction;
+
   PointerBarrierWrapper();
   ~PointerBarrierWrapper();
 

=== modified file 'tests/autopilot/autopilot/tests/test_launcher.py'
--- tests/autopilot/autopilot/tests/test_launcher.py	2012-04-04 21:33:39 +0000
+++ tests/autopilot/autopilot/tests/test_launcher.py	2012-04-04 23:48:21 +0000
@@ -635,3 +635,109 @@
         launcher_instance.mouse_reveal_launcher()
         self.assertThat(launcher_instance.is_showing(), Equals(False))
         self.mouse.release(1)
+
+class LauncherCaptureTests(AutopilotTestCase):
+    """Test the launchers ability to capture/not capture the mouse."""
+
+    screen_geo = ScreenGeometry()
+
+    def setHideMode(self, mode):
+        launcher = self.launcher.get_launcher_for_monitor(0)
+        for counter in range(10):
+            sleep(1)
+            if launcher.hidemode == mode:
+                break
+        self.assertThat(launcher.hidemode, Equals(mode),
+                        "Launcher did not enter revealed mode.")
+
+    def leftMostMonitor(self):
+        x1, y1, width, height = self.screen_geo.get_monitor_geometry(0)
+        x2, y2, width, height = self.screen_geo.get_monitor_geometry(1)
+
+        if x1 < x2:
+            return 0
+        return 1
+
+    def rightMostMonitor(self):
+        return 1 - self.leftMostMonitor()
+
+    def setUp(self):
+        super(LauncherCaptureTests, self).setUp()
+        self.set_unity_option('launcher_capture_mouse', True)
+        self.set_unity_option('launcher_hide_mode', 0)
+        self.set_unity_option('num_launchers', 0)
+        self.setHideMode(0)
+
+    def test_launcher_captures_while_sticky_and_revealed(self):
+        """Tests that the launcher captures the mouse when moving between monitors
+        while revealed.
+        """
+        if self.screen_geo.get_num_monitors() <= 1:
+            self.skipTest("Cannot run this test with a single monitor configured.")
+
+        x, y, width, height = self.screen_geo.get_monitor_geometry(self.rightMostMonitor())
+        self.mouse.move(x + width / 2, y + height / 2, False)
+        self.mouse.move(x - width / 2, y + height / 2, True, 5, .002)
+
+        x_fin, y_fin = self.mouse.position()
+        # The launcher should have held the mouse a little bit
+        self.assertThat(x_fin, GreaterThan(x - width / 2))
+
+    def test_launcher_not_capture_while_not_sticky_and_revealed(self):
+        """Tests that the launcher doesn't captures the mouse when moving between monitors
+        while revealed and stick is off.
+        """
+        if self.screen_geo.get_num_monitors() <= 1:
+            self.skipTest("Cannot run this test with a single monitor configured.")
+
+        self.set_unity_option('launcher_capture_mouse', False)
+
+        x, y, width, height = self.screen_geo.get_monitor_geometry(self.rightMostMonitor())
+        self.mouse.move(x + width / 2, y + height / 2, False)
+        self.mouse.move(x - width / 2, y + height / 2, True, 5, .002)
+
+        x_fin, y_fin = self.mouse.position()
+        # The launcher should have held the mouse a little bit
+        self.assertThat(x_fin, Equals(x - width / 2))
+
+    def test_launcher_not_capture_while_not_sticky_and_hidden_moving_right(self):
+        """Tests that the launcher doesn't capture the mouse when moving between monitors
+        while hidden and sticky is off.
+        """
+        if self.screen_geo.get_num_monitors() <= 1:
+            self.skipTest("Cannot run this test with a single monitor configured.")
+
+        self.set_unity_option('launcher_hide_mode', 1)
+        self.set_unity_option('launcher_capture_mouse', False)
+
+        self.setHideMode(1)
+
+        x, y, width, height = self.screen_geo.get_monitor_geometry(self.leftMostMonitor())
+        self.mouse.move(x + width / 2, y + height / 2, False)
+        sleep(1.5)
+        self.mouse.move(x + width * 1.5, y + height / 2, True, 5, .002)
+
+        x_fin, y_fin = self.mouse.position()
+        # The launcher should have held the mouse a little bit
+        self.assertThat(x_fin, Equals(x + width * 1.5))
+
+    def test_launcher_capture_while_sticky_and_hidden_moving_right(self):
+        """Tests that the launcher captures the mouse when moving between monitors
+        while hidden.
+        """
+        if self.screen_geo.get_num_monitors() <= 1:
+            self.skipTest("Cannot run this test with a single monitor configured.")
+
+        self.set_unity_option('launcher_hide_mode', 1)
+
+        self.setHideMode(1)
+
+        x, y, width, height = self.screen_geo.get_monitor_geometry(self.leftMostMonitor())
+        self.mouse.move(x + width / 2, y + height / 2, False)
+        sleep(1.5)
+        self.mouse.move(x + width * 1.5, y + height / 2, True, 5, .002)
+
+        x_fin, y_fin = self.mouse.position()
+        # The launcher should have held the mouse a little bit
+        self.assertThat(x_fin, LessThan(x + width * 1.5))
+                
\ No newline at end of file