Merge lp:~azzar1/unity/fix-lp-931384 into lp:unity

[Andrea Azzarone]

Add edge barriers to unity::panel::PanelView.

== Problem ==
Bug #931384: Window management, Launcher, multi-monitor - Windows can't be maximized on the lower display in vertically-stacked configuration

== Fix ==
Add edge barriers to panels.

== Test ==
Unit tests added.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3459
http://jenkins.qa.ubuntu.com/job/unity-ci/294/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/183
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/181
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/182

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-ci/294/rebuild

review: Approve (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

Code looks good, but I mentioned a clean up in IRC.

When testing, I couldn't actually get the horizontal edge to hit. It was just always passing through :(. The vertical ones were working.

review: Needs Fixing

[Andrea Azzarone (azzar1)]

You need to move a window, trying to activate the grid plugin.

[Brandon Schaefer (brandontschaefer)]

O, I was under the impression it would work the same way as the vertical edge :). As I already have the window part working, soo yay

[Andrea Azzarone (azzar1)]

> O, I was under the impression it would work the same way as the vertical edge
> :). As I already have the window part working, soo yay

Done.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3460
http://jenkins.qa.ubuntu.com/job/unity-ci/299/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/188
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/186
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/187

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-ci/299/rebuild

review: Approve (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

New functions look good :)

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/unity-autolanding/208/
Executed test runs:
    FAILURE: http://s-jenkins:8080/job/generic-cleanup-mbs/1347/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-autolanding/164/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-autolanding/164/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-autolanding/164/console

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/unity-autolanding/212/
Executed test runs:
    FAILURE: http://s-jenkins:8080/job/generic-cleanup-mbs/1356/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-autolanding/168/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-autolanding/168/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-autolanding/168/console

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'launcher/EdgeBarrierController.cpp'
--- launcher/EdgeBarrierController.cpp	2013-05-29 22:32:21 +0000
+++ launcher/EdgeBarrierController.cpp	2013-08-09 16:16:17 +0000
@@ -16,6 +16,7 @@
  *
  * Authored by: Jason Smith <[e-mail]>
  *              Marco Trevisan <[e-mail]>
+ *              Andrea Azzarone <[e-mail]>
  */
 
 #include "EdgeBarrierController.h"
@@ -33,6 +34,7 @@
 namespace
 {
   int const Y_BREAK_BUFFER = 20;
+  int const X_BREAK_BUFFER = 20;
   int const MAJOR = 2;
   int const MINOR = 3;
 }
@@ -117,19 +119,52 @@
   nux::GetGraphicsDisplay()->RemoveEventFilter(this);
 }
 
+void EdgeBarrierController::Impl::AddSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor, std::vector<EdgeBarrierSubscriber*>& subscribers)
+{
+  if (monitor >= subscribers.size())
+    subscribers.resize(monitor + 1);
+
+  auto const& monitors = UScreen::GetDefault()->GetMonitors();
+  subscribers[monitor] = subscriber;
+  ResizeBarrierList(monitors);
+  SetupBarriers(monitors);
+}
+
+void EdgeBarrierController::Impl::RemoveSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor, std::vector<EdgeBarrierSubscriber*>& subscribers)
+{
+  if (monitor >= subscribers.size() || subscribers[monitor] != subscriber)
+    return;
+
+  auto const& monitors = UScreen::GetDefault()->GetMonitors();
+  subscribers[monitor] = nullptr;
+  ResizeBarrierList(monitors);
+  SetupBarriers(monitors);
+}
+
 void EdgeBarrierController::Impl::ResizeBarrierList(std::vector<nux::Geometry> const& layout)
 {
   auto num_monitors = layout.size();
-  if (barriers_.size() > num_monitors)
+
+  if (vertical_barriers_.size() > num_monitors)
+    vertical_barriers_.resize(num_monitors);
+
+  if (horizontal_barriers_.size() > num_monitors)
+    horizontal_barriers_.resize(num_monitors);
+
+  while (vertical_barriers_.size() < num_monitors)
   {
-    barriers_.resize(num_monitors);
+    auto barrier = std::make_shared<PointerBarrierWrapper>();
+    barrier->orientation = VERTICAL;
+    barrier->barrier_event.connect(sigc::mem_fun(this, &EdgeBarrierController::Impl::OnPointerBarrierEvent));
+    vertical_barriers_.push_back(barrier);
   }
 
-  while (barriers_.size() < num_monitors)
+  while (horizontal_barriers_.size() < num_monitors)
   {
     auto barrier = std::make_shared<PointerBarrierWrapper>();
+    barrier->orientation = HORIZONTAL;
     barrier->barrier_event.connect(sigc::mem_fun(this, &EdgeBarrierController::Impl::OnPointerBarrierEvent));
-    barriers_.push_back(barrier);
+    horizontal_barriers_.push_back(barrier);
   }
 }
 
@@ -151,24 +186,41 @@
 
   for (unsigned i = 0; i < layout.size(); i++)
   {
-    auto barrier = barriers_[i];
+    auto vertical_barrier = vertical_barriers_[i];
+    auto horizontal_barrier = horizontal_barriers_[i];
     auto monitor = layout[i];
 
-    barrier->DestroyBarrier();
+    vertical_barrier->DestroyBarrier();
+    horizontal_barrier->DestroyBarrier();
+
+    if (edge_resist)
+    {
+      horizontal_barrier->x1 = monitor.x;
+      horizontal_barrier->x2 = monitor.x + monitor.width;
+      horizontal_barrier->y1 = monitor.y;
+      horizontal_barrier->y2 = monitor.y;
+      horizontal_barrier->index = i;
+      horizontal_barrier->direction = UP;
+
+      horizontal_barrier->threshold = parent_->options()->edge_stop_velocity();
+      horizontal_barrier->max_velocity_multiplier = parent_->options()->edge_responsiveness();
+
+      horizontal_barrier->ConstructBarrier();
+    }
 
     if (!edge_resist && 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();
-
-    barrier->ConstructBarrier();
+    vertical_barrier->x1 = monitor.x;
+    vertical_barrier->x2 = monitor.x;
+    vertical_barrier->y1 = monitor.y;
+    vertical_barrier->y2 = monitor.y + monitor.height;
+    vertical_barrier->index = i;
+
+    vertical_barrier->threshold = parent_->options()->edge_stop_velocity();
+    vertical_barrier->max_velocity_multiplier = parent_->options()->edge_responsiveness();
+
+    vertical_barrier->ConstructBarrier();
   }
 
   SetupXI2Events();
@@ -235,7 +287,11 @@
 
 PointerBarrierWrapper::Ptr EdgeBarrierController::Impl::FindBarrierEventOwner(XIBarrierEvent* barrier_event)
 {
-  for (auto barrier : barriers_)
+  for (auto barrier : vertical_barriers_)
+    if (barrier->OwnsBarrierEvent(barrier_event->barrier))
+      return barrier;
+
+  for (auto barrier : horizontal_barriers_)
     if (barrier->OwnsBarrierEvent(barrier_event->barrier))
       return barrier;
 
@@ -249,7 +305,8 @@
 
 void EdgeBarrierController::Impl::BarrierPush(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event)
 {
-  if (EventIsInsideYBreakZone(event))
+  if ((owner->orientation == VERTICAL and EventIsInsideYBreakZone(event)) or
+      (owner->orientation == HORIZONTAL and EventIsInsideXBreakZone(event)))
   {
     decaymulator_.value = decaymulator_.value + event->velocity;
   }
@@ -280,6 +337,22 @@
   return false;
 }
 
+bool EdgeBarrierController::Impl::EventIsInsideXBreakZone(BarrierEvent::Ptr const& event)
+{
+  static int x_break_zone = event->y;
+
+  if (decaymulator_.value <= 0)
+    x_break_zone = event->x;
+
+  if (event->x <= x_break_zone + X_BREAK_BUFFER &&
+      event->x >= x_break_zone - X_BREAK_BUFFER)
+  {
+    return true;
+  }
+
+  return false;
+}
+
 void EdgeBarrierController::Impl::OnPointerBarrierEvent(PointerBarrierWrapper* owner, BarrierEvent::Ptr const& event)
 {
   if (owner->released)
@@ -289,11 +362,14 @@
   }
 
   unsigned int monitor = owner->index;
+  auto orientation = owner->orientation();
   auto result = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
 
-  if (monitor < subscribers_.size())
+  auto subscribers = orientation == VERTICAL ? vertical_subscribers_ : horizontal_subscribers_ ;
+
+  if (monitor < subscribers.size())
   {
-    auto subscriber = subscribers_[monitor];
+    auto subscriber = subscribers[monitor];
 
     if (subscriber)
       result = subscriber->HandleBarrierEvent(owner, event);
@@ -352,34 +428,40 @@
 EdgeBarrierController::~EdgeBarrierController()
 {}
 
-void EdgeBarrierController::Subscribe(EdgeBarrierSubscriber* subscriber, unsigned int monitor)
-{
-  if (monitor >= pimpl->subscribers_.size())
-    pimpl->subscribers_.resize(monitor + 1);
-
-  auto const& monitors = UScreen::GetDefault()->GetMonitors();
-  pimpl->subscribers_[monitor] = subscriber;
-  pimpl->ResizeBarrierList(monitors);
-  pimpl->SetupBarriers(monitors);
-}
-
-void EdgeBarrierController::Unsubscribe(EdgeBarrierSubscriber* subscriber, unsigned int monitor)
-{
-  if (monitor >= pimpl->subscribers_.size() || pimpl->subscribers_[monitor] != subscriber)
-    return;
-
-  auto const& monitors = UScreen::GetDefault()->GetMonitors();
-  pimpl->subscribers_[monitor] = nullptr;
-  pimpl->ResizeBarrierList(monitors);
-  pimpl->SetupBarriers(monitors);
-}
-
-EdgeBarrierSubscriber* EdgeBarrierController::GetSubscriber(unsigned int monitor)
-{
-  if (monitor >= pimpl->subscribers_.size())
-    return nullptr;
-
-  return pimpl->subscribers_[monitor];
+void EdgeBarrierController::AddVerticalSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor)
+{
+  pimpl->AddSubscriber(subscriber, monitor, pimpl->vertical_subscribers_);
+}
+
+void EdgeBarrierController::RemoveVerticalSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor)
+{
+  pimpl->RemoveSubscriber(subscriber, monitor, pimpl->vertical_subscribers_);
+}
+
+void EdgeBarrierController::AddHorizontalSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor)
+{
+  pimpl->AddSubscriber(subscriber, monitor, pimpl->horizontal_subscribers_);
+}
+
+void EdgeBarrierController::RemoveHorizontalSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor)
+{
+  pimpl->RemoveSubscriber(subscriber, monitor, pimpl->horizontal_subscribers_);
+}
+
+EdgeBarrierSubscriber* EdgeBarrierController::GetVerticalSubscriber(unsigned int monitor)
+{
+  if (monitor >= pimpl->vertical_subscribers_.size())
+    return nullptr;
+
+  return pimpl->vertical_subscribers_[monitor];
+}
+
+EdgeBarrierSubscriber* EdgeBarrierController::GetHorizontalSubscriber(unsigned int monitor)
+{
+  if (monitor >= pimpl->horizontal_subscribers_.size())
+    return nullptr;
+
+  return pimpl->horizontal_subscribers_[monitor];
 }
 
 }

=== modified file 'launcher/EdgeBarrierController.h'
--- launcher/EdgeBarrierController.h	2013-02-07 21:47:21 +0000
+++ launcher/EdgeBarrierController.h	2013-08-09 16:16:17 +0000
@@ -42,15 +42,22 @@
 class EdgeBarrierController : public sigc::trackable
 {
 public:
+  typedef std::shared_ptr<EdgeBarrierController> Ptr;
+
   EdgeBarrierController();
   ~EdgeBarrierController();
 
   nux::RWProperty<bool> sticky_edges;
   nux::Property<launcher::Options::Ptr> options;
 
-  void Subscribe(EdgeBarrierSubscriber* subscriber, unsigned int monitor);
-  void Unsubscribe(EdgeBarrierSubscriber* subscriber, unsigned int monitor);
-  EdgeBarrierSubscriber* GetSubscriber(unsigned int monitor);
+  void AddHorizontalSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor);
+  void RemoveHorizontalSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor);
+
+  void AddVerticalSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor);
+  void RemoveVerticalSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor);
+
+  EdgeBarrierSubscriber* GetHorizontalSubscriber(unsigned int monitor);
+  EdgeBarrierSubscriber* GetVerticalSubscriber(unsigned int monitor);
 
 private:
   struct Impl;

=== modified file 'launcher/EdgeBarrierControllerPrivate.h'
--- launcher/EdgeBarrierControllerPrivate.h	2013-02-25 18:39:29 +0000
+++ launcher/EdgeBarrierControllerPrivate.h	2013-08-09 16:16:17 +0000
@@ -35,6 +35,9 @@
   Impl(EdgeBarrierController *parent);
   ~Impl();
 
+  void AddSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor, std::vector<EdgeBarrierSubscriber*>& subscribers);
+  void RemoveSubscriber(EdgeBarrierSubscriber* subscriber, unsigned int monitor, std::vector<EdgeBarrierSubscriber*>& subscribers);
+
   void ResizeBarrierList(std::vector<nux::Geometry> const& layout);
   void SetupBarriers(std::vector<nux::Geometry> const& layout);
 
@@ -44,6 +47,7 @@
   void BarrierReset();
 
   bool EventIsInsideYBreakZone(BarrierEvent::Ptr const& event);
+  bool EventIsInsideXBreakZone(BarrierEvent::Ptr const& event);
 
   void AddEventFilter();
 
@@ -52,8 +56,12 @@
   static bool HandleEventCB(XEvent event, void* data);
   bool HandleEvent(XEvent event);
 
-  std::vector<PointerBarrierWrapper::Ptr> barriers_;
-  std::vector<EdgeBarrierSubscriber*> subscribers_;
+  std::vector<PointerBarrierWrapper::Ptr> vertical_barriers_;
+  std::vector<PointerBarrierWrapper::Ptr> horizontal_barriers_;
+
+  std::vector<EdgeBarrierSubscriber*> vertical_subscribers_;
+  std::vector<EdgeBarrierSubscriber*> horizontal_subscribers_;
+
   Decaymulator decaymulator_;
   glib::Source::UniquePtr release_timeout_;
   int xi2_opcode_;

=== modified file 'launcher/LauncherController.cpp'
--- launcher/LauncherController.cpp	2013-08-06 09:54:24 +0000
+++ launcher/LauncherController.cpp	2013-08-09 16:16:17 +0000
@@ -104,13 +104,14 @@
 
 }
 
-Controller::Impl::Impl(Controller* parent, XdndManager::Ptr const& xdnd_manager)
+Controller::Impl::Impl(Controller* parent, XdndManager::Ptr const& xdnd_manager, ui::EdgeBarrierController::Ptr const& edge_barriers)
   : parent_(parent)
   , model_(std::make_shared<LauncherModel>())
   , xdnd_manager_(xdnd_manager)
   , device_section_(std::make_shared<VolumeMonitorWrapper>(), std::make_shared<DevicesSettingsImp>())
   , expo_icon_(new ExpoLauncherIcon())
   , desktop_icon_(new DesktopLauncherIcon())
+  , edge_barriers_(edge_barriers)
   , sort_priority_(AbstractLauncherIcon::DefaultPriority(AbstractLauncherIcon::IconType::APPLICATION))
   , launcher_open(false)
   , launcher_keynav(false)
@@ -122,7 +123,7 @@
   , dbus_server_(DBUS_NAME)
 {
 #ifdef USE_X11
-  edge_barriers_.options = parent_->options();
+  edge_barriers_->options = parent_->options();
 #endif
 
   ubus.RegisterInterest(UBUS_BACKGROUND_COLOR_CHANGED, [this](GVariant * data) {
@@ -225,7 +226,7 @@
     if (launchers[i]->monitor() != monitor)
     {
 #ifdef USE_X11
-      edge_barriers_.Unsubscribe(launchers[i].GetPointer(), launchers[i]->monitor);
+      edge_barriers_->RemoveVerticalSubscriber(launchers[i].GetPointer(), launchers[i]->monitor);
 #endif
       launchers[i]->monitor = monitor;
     }
@@ -235,7 +236,7 @@
     }
 
 #ifdef USE_X11
-    edge_barriers_.Subscribe(launchers[i].GetPointer(), launchers[i]->monitor);
+    edge_barriers_->AddVerticalSubscriber(launchers[i].GetPointer(), launchers[i]->monitor);
 #endif
   }
 
@@ -247,7 +248,7 @@
       parent_->RemoveChild(launcher.GetPointer());
       launcher->GetParent()->UnReference();
 #ifdef USE_X11
-      edge_barriers_.Unsubscribe(launcher.GetPointer(), launcher->monitor);
+      edge_barriers_->RemoveVerticalSubscriber(launcher.GetPointer(), launcher->monitor);
 #endif
     }
   }
@@ -1058,10 +1059,10 @@
                    g_variant_new("(sus)", "home.scope", dash::NOT_HANDLED, ""));
 }
 
-Controller::Controller(XdndManager::Ptr const& xdnd_manager)
+Controller::Controller(XdndManager::Ptr const& xdnd_manager, ui::EdgeBarrierController::Ptr const& edge_barriers)
  : options(std::make_shared<Options>())
  , multiple_launchers(true)
- , pimpl(new Impl(this, xdnd_manager))
+ , pimpl(new Impl(this, xdnd_manager, edge_barriers))
 {
   multiple_launchers.changed.connect([&](bool value) -> void {
     UScreen* uscreen = UScreen::GetDefault();

=== modified file 'launcher/LauncherController.h'
--- launcher/LauncherController.h	2013-03-29 13:59:11 +0000
+++ launcher/LauncherController.h	2013-08-09 16:16:17 +0000
@@ -25,6 +25,7 @@
 #include <vector>
 #include <sigc++/sigc++.h>
 
+#include "EdgeBarrierController.h"
 #include "LauncherOptions.h"
 #include "SoftwareCenterLauncherIcon.h"
 #include "XdndManager.h"
@@ -48,7 +49,7 @@
   nux::Property<Options::Ptr> options;
   nux::Property<bool> multiple_launchers;
 
-  Controller(XdndManager::Ptr const& xdnd_manager);
+  Controller(XdndManager::Ptr const& xdnd_manager, ui::EdgeBarrierController::Ptr const& edge_barriers);
   ~Controller();
 
   Launcher& launcher() const;

=== modified file 'launcher/LauncherControllerPrivate.h'
--- launcher/LauncherControllerPrivate.h	2013-07-01 21:20:51 +0000
+++ launcher/LauncherControllerPrivate.h	2013-08-09 16:16:17 +0000
@@ -50,7 +50,7 @@
 class Controller::Impl : public sigc::trackable
 {
 public:
-  Impl(Controller* parent, XdndManager::Ptr const& xdnd_manager);
+  Impl(Controller* parent, XdndManager::Ptr const& xdnd_manager, ui::EdgeBarrierController::Ptr const& edge_barriers);
   ~Impl();
 
   void UpdateNumWorkspaces(int workspaces);
@@ -131,7 +131,7 @@
   AbstractLauncherIcon::Ptr desktop_icon_;
 
 #ifdef USE_X11
-  ui::EdgeBarrierController edge_barriers_;
+  ui::EdgeBarrierController::Ptr edge_barriers_;
 #endif
 
   LauncherList launchers;

=== modified file 'launcher/PointerBarrier.cpp'
--- launcher/PointerBarrier.cpp	2013-07-09 23:18:29 +0000
+++ launcher/PointerBarrier.cpp	2013-08-09 16:16:17 +0000
@@ -36,6 +36,7 @@
   , smoothing(75)
   , max_velocity_multiplier(1.0f)
   , direction(BOTH)
+  , orientation(VERTICAL)
   , xi2_opcode_(0)
   , last_event_(0)
   , current_device_(0)
@@ -137,7 +138,7 @@
 {
   int velocity = GetEventVelocity(barrier_event);
   smoothing_accum_ += velocity;
-  smoothing_count_++;
+  ++smoothing_count_;
 
   current_device_ = barrier_event->deviceid;
 

=== modified file 'launcher/PointerBarrier.h'
--- launcher/PointerBarrier.h	2013-02-23 00:29:28 +0000
+++ launcher/PointerBarrier.h	2013-08-09 16:16:17 +0000
@@ -51,7 +51,15 @@
 {
   BOTH = 0,
   LEFT = 1,
+  UP = 2,
   RIGHT = 4,
+  DOWN =  8
+};
+
+enum BarrierOrientation
+{
+  VERTICAL = 0,
+  HORIZONTAL
 };
 
 class PointerBarrierWrapper : public sigc::trackable
@@ -80,6 +88,7 @@
   nux::Property<int> index;
 
   nux::Property<BarrierDirection> direction;
+  nux::Property<BarrierOrientation> orientation;
 
   virtual void ConstructBarrier();
   virtual void DestroyBarrier();

=== modified file 'launcher/StandaloneLauncher.cpp'
--- launcher/StandaloneLauncher.cpp	2013-06-26 17:35:47 +0000
+++ launcher/StandaloneLauncher.cpp	2013-08-09 16:16:17 +0000
@@ -25,6 +25,7 @@
 #include <gtk/gtk.h>
 
 #include "unity-shared/BackgroundEffectHelper.h"
+#include "EdgeBarrierController.h"
 #include "FavoriteStoreGSettings.h"
 #include "LauncherController.h"
 #include "Launcher.h"
@@ -67,7 +68,7 @@
   void Init()
   {
     SetupBackground();
-    controller.reset(new launcher::Controller(std::make_shared<XdndManager>()));
+    controller.reset(new launcher::Controller(std::make_shared<XdndManager>(), std::make_shared<ui::EdgeBarrierController>()));
 
     UScreen* uscreen = UScreen::GetDefault();
     std::vector<nux::Geometry> fake_monitor({nux::Geometry(0, 0, win_size.width, win_size.height)});

=== modified file 'panel/PanelController.cpp'
--- panel/PanelController.cpp	2013-08-01 05:01:01 +0000
+++ panel/PanelController.cpp	2013-08-09 16:16:17 +0000
@@ -40,7 +40,7 @@
 class Controller::Impl
 {
 public:
-  Impl();
+  Impl(ui::EdgeBarrierController::Ptr const& edge_barriers);
   ~Impl();
 
   void FirstMenuShow();
@@ -65,6 +65,7 @@
 
   unity::PanelView* ViewForWindow(BaseWindowPtr const& window) const;
 
+  ui::EdgeBarrierController::Ptr edge_barriers_;
   PanelVector panels_;
   std::vector<Window> tray_xids_;
   float opacity_;
@@ -78,8 +79,9 @@
 };
 
 
-Controller::Impl::Impl()
-  : opacity_(1.0f)
+Controller::Impl::Impl(ui::EdgeBarrierController::Ptr const& edge_barriers)
+  : edge_barriers_(edge_barriers)
+  , opacity_(1.0f)
   , opacity_maximized_toggle_(false)
   , menus_fadein_(0)
   , menus_fadeout_(0)
@@ -205,8 +207,15 @@
       panels_[i] = CreatePanel(iobj);
     }
 
+    if (panels_[i]->GetMonitor() != static_cast<int>(i))
+    {
+      edge_barriers_->RemoveHorizontalSubscriber(panels_[i].GetPointer(), panels_[i]->GetMonitor());
+    }
+
     panels_[i]->SetMonitor(i);
     tray_xids_[i] = panels_[i]->GetTrayXid();
+
+    edge_barriers_->AddHorizontalSubscriber(panels_[i].GetPointer(), panels_[i]->GetMonitor());
   }
     
   for (unsigned int i = last_panel; i < panels_size; ++i)
@@ -216,6 +225,7 @@
     {
       iobj->RemoveChild(panel.GetPointer());
       panel->GetParent()->UnReference();
+      edge_barriers_->RemoveHorizontalSubscriber(panel.GetPointer(), panel->GetMonitor());
     }
   }
 
@@ -270,9 +280,9 @@
   return opacity_;
 }
 
-Controller::Controller()
+Controller::Controller(ui::EdgeBarrierController::Ptr const& edge_barriers)
   : launcher_width(64)
-  , pimpl(new Impl())
+  , pimpl(new Impl(edge_barriers))
 {
   UScreen* screen = UScreen::GetDefault();
   screen->changed.connect(sigc::mem_fun(this, &Controller::OnScreenChanged));

=== modified file 'panel/PanelController.h'
--- panel/PanelController.h	2013-08-01 05:01:01 +0000
+++ panel/PanelController.h	2013-08-09 16:16:17 +0000
@@ -23,6 +23,7 @@
 #include <memory>
 #include <Nux/Nux.h>
 
+#include "launcher/EdgeBarrierController.h"
 #include "unity-shared/Introspectable.h"
 namespace unity
 {
@@ -38,7 +39,7 @@
   typedef std::shared_ptr<Controller> Ptr;
   typedef std::vector<nux::ObjectPtr<PanelView>> PanelVector;
 
-  Controller();
+  Controller(ui::EdgeBarrierController::Ptr const& barrier_controller);
   ~Controller();
 
   void FirstMenuShow();

=== modified file 'panel/PanelView.cpp'
--- panel/PanelView.cpp	2013-08-01 15:23:54 +0000
+++ panel/PanelView.cpp	2013-08-09 16:16:17 +0000
@@ -788,4 +788,12 @@
   return stored_dash_width_;
 }
 
+ui::EdgeBarrierSubscriber::Result PanelView::HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event)
+{
+  if (WindowManager::Default().IsAnyWindowMoving())
+    return ui::EdgeBarrierSubscriber::Result::IGNORED;
+
+  return ui::EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
+}
+
 } // namespace unity

=== modified file 'panel/PanelView.h'
--- panel/PanelView.h	2013-08-01 15:23:54 +0000
+++ panel/PanelView.h	2013-08-09 16:16:17 +0000
@@ -32,6 +32,7 @@
 
 #include <UnityCore/DBusIndicators.h>
 
+#include "launcher/EdgeBarrierController.h"
 #include "unity-shared/BackgroundEffectHelper.h"
 #include "unity-shared/Introspectable.h"
 #include "unity-shared/MockableBaseWindow.h"
@@ -43,7 +44,9 @@
 namespace unity
 {
 
-class PanelView : public unity::debug::Introspectable, public nux::View
+class PanelView : public unity::debug::Introspectable, 
+                  public ui::EdgeBarrierSubscriber,
+                  public nux::View
 {
   NUX_DECLARE_OBJECT_TYPE(PanelView, nux::View);
 public:
@@ -73,6 +76,8 @@
 
   bool IsMouseInsideIndicator(nux::Point const& mouse_position) const;
 
+  ui::EdgeBarrierSubscriber::Result HandleBarrierEvent(ui::PointerBarrierWrapper* owner, ui::BarrierEvent::Ptr event) override;
+
 protected:
   void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
   void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw);

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2013-08-07 13:27:56 +0000
+++ plugins/unityshell/src/unityshell.cpp	2013-08-09 16:16:17 +0000
@@ -46,6 +46,7 @@
 #include "unityshell.h"
 #include "BackgroundEffectHelper.h"
 #include "UnityGestureBroker.h"
+#include "launcher/EdgeBarrierController.h"
 #include "launcher/XdndCollectionWindowImp.h"
 #include "launcher/XdndManagerImp.h"
 #include "launcher/XdndStartStopNotifierImp.h"
@@ -3247,8 +3248,9 @@
   auto xdnd_collection_window = std::make_shared<XdndCollectionWindowImp>();
   auto xdnd_start_stop_notifier = std::make_shared<XdndStartStopNotifierImp>();
   auto xdnd_manager = std::make_shared<XdndManagerImp>(xdnd_start_stop_notifier, xdnd_collection_window);
+  auto edge_barriers = std::make_shared<ui::EdgeBarrierController>();
 
-  launcher_controller_ = std::make_shared<launcher::Controller>(xdnd_manager);
+  launcher_controller_ = std::make_shared<launcher::Controller>(xdnd_manager, edge_barriers);
   AddChild(launcher_controller_.get());
 
   switcher_controller_ = std::make_shared<switcher::Controller>();
@@ -3258,7 +3260,7 @@
 
   /* Setup panel */
   timer.Reset();
-  panel_controller_ = std::make_shared<panel::Controller>();
+  panel_controller_ = std::make_shared<panel::Controller>(edge_barriers);
   AddChild(panel_controller_.get());
   panel_controller_->SetMenuShowTimings(optionGetMenusFadein(),
                                         optionGetMenusFadeout(),

=== modified file 'tests/MockWindowManager.h'
--- tests/MockWindowManager.h	2013-05-17 22:53:57 +0000
+++ tests/MockWindowManager.h	2013-08-09 16:16:17 +0000
@@ -68,6 +68,7 @@
     MOCK_METHOD0(TerminateExpo, void());
     MOCK_CONST_METHOD0(IsExpoActive, bool());
     MOCK_CONST_METHOD0(IsWallActive, bool());
+    MOCK_CONST_METHOD0(IsAnyWindowMoving, bool());    
 
     MOCK_METHOD4(FocusWindowGroup, void(std::vector<Window> const&,
                                         FocusVisibility, int,

=== modified file 'tests/test_edge_barrier_controller.cpp'
--- tests/test_edge_barrier_controller.cpp	2013-07-29 17:17:43 +0000
+++ tests/test_edge_barrier_controller.cpp	2013-08-09 16:16:17 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 Canonical Ltd.
+ * Copyright 2012-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 version 3, as published
@@ -15,6 +15,7 @@
  * <http://www.gnu.org/licenses/>
  *
  * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ *              Andrea Azzarone <[e-mail]>
  *
  */
 
@@ -32,14 +33,15 @@
 namespace
 {
 
-class MockPointerBarrier : public PointerBarrierWrapper
+class MockPointerBarrierWrapper : public PointerBarrierWrapper
 {
 public:
-  MockPointerBarrier(int monitor = 0, bool released_ = false)
+  MockPointerBarrierWrapper(int monitor = 0, bool released_ = false, BarrierOrientation orientation_ = VERTICAL)
   {
     index = monitor;
     x1 = 1;
     released = released_;
+    orientation = orientation_;
   }
 
   MOCK_METHOD0(ConstructBarrier, void());
@@ -80,7 +82,8 @@
     for (unsigned i = 0; i < monitors::MAX; ++i)
     {
       // By default we assume that no subscriber handles the events!!!
-      bc.Subscribe(&subscribers_[i], i);
+      bc.AddVerticalSubscriber(&vertical_subscribers_[i], i);
+      bc.AddHorizontalSubscriber(&horizontal_subscribers_[i], i);
     }
   }
 
@@ -101,7 +104,8 @@
   }
 
 
-  TestBarrierSubscriber subscribers_[monitors::MAX];
+  TestBarrierSubscriber horizontal_subscribers_[monitors::MAX];
+  TestBarrierSubscriber vertical_subscribers_[monitors::MAX];
   MockUScreen uscreen;
   EdgeBarrierController bc;
 };
@@ -116,207 +120,414 @@
   EXPECT_TRUE(bc.sticky_edges);
 
   for (unsigned i = 0; i < monitors::MAX; ++i)
-    ASSERT_EQ(bc.GetSubscriber(i), &subscribers_[i]);
-}
-
-TEST_F(TestEdgeBarrierController, Unsubscribe)
-{
-  for (unsigned i = 0; i < monitors::MAX; ++i)
-  {
-    bc.Unsubscribe(&subscribers_[i], i);
-    ASSERT_EQ(bc.GetSubscriber(i), nullptr);
-  }
-}
-
-TEST_F(TestEdgeBarrierController, UnsubscribeInvalid)
-{
-  bc.Unsubscribe(&subscribers_[2], 1);
-  ASSERT_EQ(bc.GetSubscriber(2), &subscribers_[2]);
-}
-
-TEST_F(TestEdgeBarrierController, SubscriberReplace)
-{
-  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
-  bc.Subscribe(&handling_subscriber, 0);
-  EXPECT_EQ(bc.GetSubscriber(0), &handling_subscriber);
-}
-
-TEST_F(TestEdgeBarrierController, ProcessHandledEvent)
-{
-  int monitor = 0;
-
-  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
-  bc.Subscribe(&handling_subscriber, monitor);
-
-  MockPointerBarrier owner(monitor);
-  auto breaking_barrier_event = MakeBarrierEvent(0, true);
-
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
-  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
-}
-
-TEST_F(TestEdgeBarrierController, ProcessHandledEventOnReleasedBarrier)
-{
-  int monitor = monitors::MAX-1;
-
-  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
-  bc.Subscribe(&handling_subscriber, monitor);
-
-  MockPointerBarrier owner(monitor, true);
-  auto breaking_barrier_event = MakeBarrierEvent(5, true);
-
-  EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
-}
-
-TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrier)
-{
-  int monitor = 1;
-
-  MockPointerBarrier owner(monitor);
-  int breaking_id = 12345;
-  auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
-
-  EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
-}
-
-TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitor)
-{
-  int monitor = monitors::MAX;
-
-  MockPointerBarrier owner(monitor);
-  auto breaking_barrier_event = MakeBarrierEvent(0, true);
-
-  EXPECT_CALL(owner, ReleaseBarrier(_));
-  ProcessBarrierEvent(&owner, breaking_barrier_event);
-}
-
-TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrier)
-{
-  int monitor = 2;
-
-  MockPointerBarrier owner(monitor);
-  int not_breaking_id = 54321;
-  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
-
-  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
-  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
-}
-
-TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrier)
-{
-  int monitor = 2;
-
-  MockPointerBarrier owner(monitor, true);
-  int not_breaking_id = 345678;
-  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
-
-  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
-  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
-}
-
-TEST_F(TestEdgeBarrierController, ProcessAlreadyHandledEvent)
-{
-  int monitor = g_random_int_range(0, monitors::MAX);
-
-  MockPointerBarrier owner(monitor);
-  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
-
-  auto event = MakeBarrierEvent(g_random_int(), false);
-
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, event);
-  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
-}
-
-TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithStickyEdges)
-{
-  int monitor = g_random_int_range(0, monitors::MAX);
-
-  bc.sticky_edges = true;
-  MockPointerBarrier owner(monitor);
-  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
-
-  auto event = MakeBarrierEvent(g_random_int(), false);
-
-  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
-  ProcessBarrierEvent(&owner, event);
-  EXPECT_FALSE(owner.released());
-  EXPECT_FALSE(owner.release_once());
-  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
-}
-
-TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithOutStickyEdges)
-{
-  int monitor = g_random_int_range(0, monitors::MAX);
-
-  bc.sticky_edges = false;
-  MockPointerBarrier owner(monitor);
-  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
-
-  auto event = MakeBarrierEvent(g_random_int(), false);
-
-  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
-  ProcessBarrierEvent(&owner, event);
-  EXPECT_TRUE(owner.released());
-  EXPECT_TRUE(owner.release_once());
-  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
-}
-
-TEST_F(TestEdgeBarrierController, ProcessNeedsReleaseEvent)
-{
-  int monitor = g_random_int_range(0, monitors::MAX);
-
-  MockPointerBarrier owner(monitor);
-  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
-
-  auto event = MakeBarrierEvent(g_random_int(), false);
-
-  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
-  ProcessBarrierEvent(&owner, event);
-  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
-}
-
-TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrier)
-{
-  MockPointerBarrier owner;
-
-  EXPECT_CALL(owner, ReleaseBarrier(1));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
-  ASSERT_TRUE(owner.released());
-
-  Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
-  EXPECT_FALSE(owner.released());
-}
-
-TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEvents)
-{
-  MockPointerBarrier owner;
-  int monitor = 0;
-  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
-
-  EXPECT_CALL(owner, ReleaseBarrier(5));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
-  ASSERT_TRUE(owner.released());
-
-  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
-  EXPECT_CALL(owner, ReleaseBarrier(6));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
-}
-
-TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEvents)
-{
-  MockPointerBarrier owner;
-  int monitor = 0;
-  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
-
-  EXPECT_CALL(owner, ReleaseBarrier(5));
-  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
-  ASSERT_TRUE(owner.released());
-
-  subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
+  {
+    ASSERT_EQ(bc.GetVerticalSubscriber(i), &vertical_subscribers_[i]);
+    ASSERT_EQ(bc.GetHorizontalSubscriber(i), &horizontal_subscribers_[i]);
+  }
+}
+
+TEST_F(TestEdgeBarrierController, RemoveVerticalSubscriber)
+{
+  for (unsigned i = 0; i < monitors::MAX; ++i)
+  {
+    bc.RemoveVerticalSubscriber(&vertical_subscribers_[i], i);
+    ASSERT_EQ(bc.GetVerticalSubscriber(i), nullptr);
+  }
+}
+
+TEST_F(TestEdgeBarrierController, RemoveHorizontalSubscriber)
+{
+  for (unsigned i = 0; i < monitors::MAX; ++i)
+  {
+    bc.RemoveHorizontalSubscriber(&horizontal_subscribers_[i], i);
+    ASSERT_EQ(bc.GetHorizontalSubscriber(i), nullptr);
+  }
+}
+
+TEST_F(TestEdgeBarrierController, RemoveVerticalSubscriberInvalid)
+{
+  bc.RemoveVerticalSubscriber(&vertical_subscribers_[2], 1);
+  ASSERT_EQ(bc.GetVerticalSubscriber(2), &vertical_subscribers_[2]);
+}
+
+TEST_F(TestEdgeBarrierController, RemoveHorizontalSubscriberInvalid)
+{
+  bc.RemoveHorizontalSubscriber(&horizontal_subscribers_[2], 1);
+  ASSERT_EQ(bc.GetHorizontalSubscriber(2), &horizontal_subscribers_[2]);
+}
+
+TEST_F(TestEdgeBarrierController, VerticalSubscriberReplace)
+{
+  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
+  bc.AddVerticalSubscriber(&handling_subscriber, 0);
+  EXPECT_EQ(bc.GetVerticalSubscriber(0), &handling_subscriber);
+}
+
+TEST_F(TestEdgeBarrierController, HorizontalSubscriberReplace)
+{
+  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
+  bc.AddHorizontalSubscriber(&handling_subscriber, 0);
+  EXPECT_EQ(bc.GetHorizontalSubscriber(0), &handling_subscriber);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessHandledEventForVerticalSubscriber)
+{
+  int monitor = 0;
+
+  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
+  bc.AddVerticalSubscriber(&handling_subscriber, monitor);
+
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto breaking_barrier_event = MakeBarrierEvent(0, true);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessHandledEventForHorizontalSubscriber)
+{
+  int monitor = 0;
+
+  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
+  bc.AddHorizontalSubscriber(&handling_subscriber, monitor);
+
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto breaking_barrier_event = MakeBarrierEvent(0, true);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessHandledEventOnReleasedBarrierForVerticalSubscriber)
+{
+  int monitor = monitors::MAX-1;
+
+  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
+  bc.AddVerticalSubscriber(&handling_subscriber, monitor);
+
+  MockPointerBarrierWrapper owner(monitor, true, VERTICAL);
+  auto breaking_barrier_event = MakeBarrierEvent(5, true);
+
+  EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessHandledEventOnReleasedBarrierForHorizontalSubscriber)
+{
+  int monitor = monitors::MAX-1;
+
+  TestBarrierSubscriber handling_subscriber(EdgeBarrierSubscriber::Result::HANDLED);
+  bc.AddHorizontalSubscriber(&handling_subscriber, monitor);
+
+  MockPointerBarrierWrapper owner(monitor, true, HORIZONTAL);
+  auto breaking_barrier_event = MakeBarrierEvent(5, true);
+
+  EXPECT_CALL(owner, ReleaseBarrier(5)).Times(1);
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierForVerticalSubscriber)
+{
+  int monitor = 1;
+
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  int breaking_id = 12345;
+  auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
+
+  EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierForHorizontalSubscriber)
+{
+  int monitor = 1;
+
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  int breaking_id = 12345;
+  auto breaking_barrier_event = MakeBarrierEvent(breaking_id, true);
+
+  EXPECT_CALL(owner, ReleaseBarrier(breaking_id));
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitorForVerticalSubscriber)
+{
+  int monitor = monitors::MAX;
+
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  auto breaking_barrier_event = MakeBarrierEvent(0, true);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_));
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventBreakingBarrierOnMaxMonitorForHorizontalSubscriber)
+{
+  int monitor = monitors::MAX;
+
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  auto breaking_barrier_event = MakeBarrierEvent(0, true);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_));
+  ProcessBarrierEvent(&owner, breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrierForVerticalSubscriber)
+{
+  int monitor = 2;
+
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  int not_breaking_id = 54321;
+  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
+  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventNotBreakingBarrierForHorizontalSubscriber)
+{
+  int monitor = 2;
+
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  int not_breaking_id = 54321;
+  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id)).Times(0);
+  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrierForVerticalSubscriber)
+{
+  int monitor = 2;
+
+  MockPointerBarrierWrapper owner(monitor, true, VERTICAL);
+  int not_breaking_id = 345678;
+  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
+  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessUnHandledEventOnReleasedBarrierForHorizontalSubscriber)
+{
+  int monitor = 2;
+
+  MockPointerBarrierWrapper owner(monitor, true, HORIZONTAL);
+  int not_breaking_id = 345678;
+  auto not_breaking_barrier_event = MakeBarrierEvent(not_breaking_id, false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(not_breaking_id));
+  ProcessBarrierEvent(&owner, not_breaking_barrier_event);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessAlreadyHandledEventForVerticalSubscriber)
+{
+  int monitor = g_random_int_range(0, monitors::MAX);
+
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
+
+  auto event = MakeBarrierEvent(g_random_int(), false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(&owner, event);
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessAlreadyHandledEventForHorizontalSubscriber)
+{
+  int monitor = g_random_int_range(0, monitors::MAX);
+
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::ALREADY_HANDLED;
+
+  auto event = MakeBarrierEvent(g_random_int(), false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(&owner, event);
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithStickyEdgesForVerticalSubscriber)
+{
+  int monitor = g_random_int_range(0, monitors::MAX);
+
+  bc.sticky_edges = true;
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+
+  auto event = MakeBarrierEvent(g_random_int(), false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(&owner, event);
+  EXPECT_FALSE(owner.released());
+  EXPECT_FALSE(owner.release_once());
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithStickyEdgesForHorizontalSubscriber)
+{
+  int monitor = g_random_int_range(0, monitors::MAX);
+
+  bc.sticky_edges = true;
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+
+  auto event = MakeBarrierEvent(g_random_int(), false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(&owner, event);
+  EXPECT_FALSE(owner.released());
+  EXPECT_FALSE(owner.release_once());
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), event->velocity);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithOutStickyEdgesForVerticalSubscriber)
+{
+  int monitor = g_random_int_range(0, monitors::MAX);
+
+  bc.sticky_edges = false;
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+
+  auto event = MakeBarrierEvent(g_random_int(), false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
+  ProcessBarrierEvent(&owner, event);
+  EXPECT_TRUE(owner.released());
+  EXPECT_TRUE(owner.release_once());
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessIgnoredEventWithOutStickyEdgesForHoriziontalSubscriber)
+{
+  int monitor = g_random_int_range(0, monitors::MAX);
+
+  bc.sticky_edges = false;
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+
+  auto event = MakeBarrierEvent(g_random_int(), false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
+  ProcessBarrierEvent(&owner, event);
+  EXPECT_TRUE(owner.released());
+  EXPECT_TRUE(owner.release_once());
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessNeedsReleaseEventForVerticalSubscriber)
+{
+  int monitor = g_random_int_range(0, monitors::MAX);
+
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
+
+  auto event = MakeBarrierEvent(g_random_int(), false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
+  ProcessBarrierEvent(&owner, event);
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
+}
+
+TEST_F(TestEdgeBarrierController, ProcessNeedsReleaseEventForHorizontalSubscriber)
+{
+  int monitor = g_random_int_range(0, monitors::MAX);
+
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::NEEDS_RELEASE;
+
+  auto event = MakeBarrierEvent(g_random_int(), false);
+
+  EXPECT_CALL(owner, ReleaseBarrier(event->event_id));
+  ProcessBarrierEvent(&owner, event);
+  EXPECT_EQ(GetPrivateImpl()->decaymulator_.value(), 0);
+}
+
+TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForVerticalSubscriber)
+{
+  int monitor = g_random_int_range(0, monitors::MAX);
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+
+  EXPECT_CALL(owner, ReleaseBarrier(1));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
+  ASSERT_TRUE(owner.released());
+
+  Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
+  EXPECT_FALSE(owner.released());
+}
+
+TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHoriziontalSubscriber)
+{
+  int monitor = g_random_int_range(0, monitors::MAX);
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+
+  EXPECT_CALL(owner, ReleaseBarrier(1));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(1, true));
+  ASSERT_TRUE(owner.released());
+
+  Utils::WaitForTimeoutMSec(bc.options()->edge_passed_disabled_ms);
+  EXPECT_FALSE(owner.released());
+}
+
+TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEventsForVerticalSubscriber)
+{
+  int monitor = 0;
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+
+  EXPECT_CALL(owner, ReleaseBarrier(5));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
+  ASSERT_TRUE(owner.released());
+
+  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+  EXPECT_CALL(owner, ReleaseBarrier(6));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
+}
+
+TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForNotHandledEventsForHorizontalSubscriber)
+{
+  int monitor = 0;
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+
+  EXPECT_CALL(owner, ReleaseBarrier(5));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
+  ASSERT_TRUE(owner.released());
+
+  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+  EXPECT_CALL(owner, ReleaseBarrier(6));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, false));
+}
+
+TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEventsForVerticalSubscriber)
+{
+  int monitor = 0;
+  MockPointerBarrierWrapper owner(monitor, false, VERTICAL);
+  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+
+  EXPECT_CALL(owner, ReleaseBarrier(5));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
+  ASSERT_TRUE(owner.released());
+
+  vertical_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
+  EXPECT_CALL(owner, ReleaseBarrier(6)).Times(1);
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
+}
+
+TEST_F(TestEdgeBarrierController, BreakingEdgeTemporaryReleasesBarrierForHandledEventsForHoriziontalSubscriber)
+{
+  int monitor = 0;
+  MockPointerBarrierWrapper owner(monitor, false, HORIZONTAL);
+  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::IGNORED;
+
+  EXPECT_CALL(owner, ReleaseBarrier(5));
+  ProcessBarrierEvent(&owner, MakeBarrierEvent(5, true));
+  ASSERT_TRUE(owner.released());
+
+  horizontal_subscribers_[monitor].handle_result_ = EdgeBarrierSubscriber::Result::HANDLED;
   EXPECT_CALL(owner, ReleaseBarrier(6)).Times(1);
   ProcessBarrierEvent(&owner, MakeBarrierEvent(6, true));
 }
@@ -338,13 +549,19 @@
 
 TEST_F(TestEdgeBarrierController, TestTheDirectionIsAlawysSetToBothSides)
 {
-  for (auto barrier : GetPrivateImpl()->barriers_)
+  for (auto barrier : GetPrivateImpl()->vertical_barriers_)
     ASSERT_EQ(barrier->direction, BarrierDirection::BOTH);
 }
 
-TEST_F(TestEdgeBarrierController, BarrierDoesNotBreakIfYEventToFarApart)
-{
-  MockPointerBarrier owner;
+TEST_F(TestEdgeBarrierController, TestTheDirectionIsAlawysSetToUp)
+{
+  for (auto barrier : GetPrivateImpl()->horizontal_barriers_)
+    ASSERT_EQ(barrier->direction, BarrierDirection::UP);
+}
+
+TEST_F(TestEdgeBarrierController, VerticalBarrierDoesNotBreakIfYEventToFarApart)
+{
+  MockPointerBarrierWrapper owner(0, false, VERTICAL);
 
   int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
   auto firstEvent = std::make_shared<BarrierEvent>(0, 50, velocity, 10);
@@ -355,9 +572,22 @@
   ProcessBarrierEvent(&owner, secondEvent);
 }
 
-TEST_F(TestEdgeBarrierController, BarrierBreaksInYBreakZone)
-{
-  MockPointerBarrier owner;
+TEST_F(TestEdgeBarrierController, HorizontalBarrierDoesNotBreakIfXEventToFarApart)
+{
+  MockPointerBarrierWrapper owner(0, false, HORIZONTAL);
+
+  int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
+  auto firstEvent = std::make_shared<BarrierEvent>(50, 0, velocity, 10);
+  auto secondEvent = std::make_shared<BarrierEvent>(150, 0, velocity, 11);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(0);
+  ProcessBarrierEvent(&owner, firstEvent);
+  ProcessBarrierEvent(&owner, secondEvent);
+}
+
+TEST_F(TestEdgeBarrierController, VerticalBarrierBreaksInYBreakZone)
+{
+  MockPointerBarrierWrapper owner(0, false, VERTICAL);
 
   int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
   auto firstEvent = std::make_shared<BarrierEvent>(0, 50, velocity, 10);
@@ -367,13 +597,34 @@
   ProcessBarrierEvent(&owner, firstEvent);
 }
 
-TEST_F(TestEdgeBarrierController, BarrierReleaseIfNoSubscriberForMonitor)
-{
-  MockPointerBarrier owner(monitors::MAX);
+TEST_F(TestEdgeBarrierController, HorizontalBarrierBreaksInXBreakZone)
+{
+  MockPointerBarrierWrapper owner(0, false, HORIZONTAL);
+
+  int velocity = bc.options()->edge_overcome_pressure() * bc.options()->edge_responsiveness();
+  auto firstEvent = std::make_shared<BarrierEvent>(50, 0, velocity, 10);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
+  ProcessBarrierEvent(&owner, firstEvent);
+  ProcessBarrierEvent(&owner, firstEvent);
+}
+
+TEST_F(TestEdgeBarrierController, VerticalBarrierReleaseIfNoSubscriberForMonitor)
+{
+  MockPointerBarrierWrapper owner(monitors::MAX, false, VERTICAL);
   auto firstEvent = std::make_shared<BarrierEvent>(0, 50, 1, 10);
 
   EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
   ProcessBarrierEvent(&owner, firstEvent);
 }
 
+TEST_F(TestEdgeBarrierController, HorizontalBarrierReleaseIfNoSubscriberForMonitor)
+{
+  MockPointerBarrierWrapper owner(monitors::MAX, false, HORIZONTAL);
+  auto firstEvent = std::make_shared<BarrierEvent>(50, 0, 1, 10);
+
+  EXPECT_CALL(owner, ReleaseBarrier(_)).Times(1);
+  ProcessBarrierEvent(&owner, firstEvent);
+}
+
 }

=== modified file 'tests/test_launcher_controller.cpp'
--- tests/test_launcher_controller.cpp	2013-08-06 09:55:08 +0000
+++ tests/test_launcher_controller.cpp	2013-08-09 16:16:17 +0000
@@ -201,7 +201,8 @@
   TestLauncherController()
     : logger_output_(std::make_shared<helper::CaptureLogOutput>())
     , xdnd_manager_(std::make_shared<XdndManager>())
-    , lc(xdnd_manager_)
+    , edge_barriers_(std::make_shared<ui::EdgeBarrierController>())
+    , lc(xdnd_manager_, edge_barriers_)
   {}
 
   virtual void SetUp()
@@ -221,8 +222,8 @@
 protected:
   struct MockLauncherController : Controller
   {
-    MockLauncherController(XdndManager::Ptr const& xdnd_manager)
-      : Controller(xdnd_manager)
+    MockLauncherController(XdndManager::Ptr const& xdnd_manager, ui::EdgeBarrierController::Ptr const& edge_barriers)
+      : Controller(xdnd_manager, edge_barriers)
     {}
 
     Controller::Impl* Impl() const { return pimpl.get(); }
@@ -269,6 +270,7 @@
   panel::Style panel_style;
   MockFavoriteStore favorite_store;
   XdndManager::Ptr xdnd_manager_;
+  ui::EdgeBarrierController::Ptr edge_barriers_;
   MockLauncherController lc;
 };
 }
@@ -413,7 +415,7 @@
   uscreen.SetupFakeMultiMonitor();
 
   for (unsigned i = 0; i < monitors::MAX; ++i)
-    ASSERT_EQ(lc.Impl()->edge_barriers_.GetSubscriber(i), lc.launchers()[i].GetPointer());
+    ASSERT_EQ(edge_barriers_->GetVerticalSubscriber(i), lc.launchers()[i].GetPointer());
 }
 
 TEST_F(TestLauncherController, SingleMonitorEdgeBarrierSubscriptionsUpdates)
@@ -429,11 +431,11 @@
     {
       if (j == i)
       {
-        ASSERT_EQ(lc.Impl()->edge_barriers_.GetSubscriber(j), &lc.launcher());
+        ASSERT_EQ(edge_barriers_->GetVerticalSubscriber(j), &lc.launcher());
       }
       else
       {
-        ASSERT_EQ(lc.Impl()->edge_barriers_.GetSubscriber(j), nullptr);
+        ASSERT_EQ(edge_barriers_->GetVerticalSubscriber(j), nullptr);
       }
     }
   }

=== modified file 'tests/test_panel_controller.cpp'
--- tests/test_panel_controller.cpp	2013-08-01 05:12:52 +0000
+++ tests/test_panel_controller.cpp	2013-08-09 16:16:17 +0000
@@ -24,14 +24,24 @@
 #include "PanelView.h"
 #include "UnitySettings.h"
 #include "test_uscreen_mock.h"
+#include "launcher/LauncherOptions.h"
 
 namespace {
 
 struct TestPanelController : public testing::Test
 {
+  TestPanelController()
+  : edge_barriers(std::make_shared<unity::ui::EdgeBarrierController>())
+  , options(std::make_shared<unity::launcher::Options>())
+  {
+    edge_barriers->options = options;
+  }
+
   unity::MockUScreen uscreen;
   unity::Settings settings;
   unity::panel::Style panel_style;
+  unity::ui::EdgeBarrierController::Ptr edge_barriers;
+  unity::launcher::Options::Ptr options;
 };
 
 TEST_F(TestPanelController, Construction)
@@ -39,7 +49,8 @@
   nux::ObjectPtr<unity::PanelView> panel_ptr;
 
   {
-    unity::panel::Controller pc;
+    unity::panel::Controller pc(edge_barriers);
+
     ASSERT_EQ(pc.panels().size(), 1);
     EXPECT_EQ(pc.panels()[0]->GetMonitor(), 0);
     panel_ptr = pc.panels()[0];
@@ -54,7 +65,8 @@
   unity::panel::Controller::PanelVector panel_ptrs;
 
   {
-    unity::panel::Controller pc;
+    unity::panel::Controller pc(edge_barriers);
+
     ASSERT_EQ(pc.panels().size(), unity::monitors::MAX);
 
     for (unsigned int i = 0; i < unity::monitors::MAX; ++i)
@@ -75,7 +87,8 @@
   uscreen.SetupFakeMultiMonitor();
 
   {
-    unity::panel::Controller pc;
+    unity::panel::Controller pc(edge_barriers);
+
     ASSERT_EQ(pc.panels().size(), unity::monitors::MAX);
 
     uscreen.Reset();
@@ -89,7 +102,8 @@
   uscreen.SetupFakeMultiMonitor();
 
   {
-    unity::panel::Controller pc;
+    unity::panel::Controller pc(edge_barriers);
+
     ASSERT_EQ(pc.panels().size(), unity::monitors::MAX);
 
     std::vector<nux::Geometry> &monitors = uscreen.GetMonitors();
@@ -105,7 +119,8 @@
 TEST_F(TestPanelController, SingleMonitorSwitchToMultimonitor)
 {
   {
-    unity::panel::Controller pc;
+    unity::panel::Controller pc(edge_barriers);
+
     ASSERT_EQ(pc.panels().size(), 1);
 
     uscreen.SetupFakeMultiMonitor();
@@ -118,7 +133,8 @@
   uscreen.SetupFakeMultiMonitor();
 
   {
-    unity::panel::Controller pc;  
+    unity::panel::Controller pc(edge_barriers);
+
     for (unsigned int i = 0; i < unity::monitors::MAX; ++i)
     {
       auto const& monitor_geo = uscreen.GetMonitorGeometry(i);
@@ -133,7 +149,7 @@
 
 TEST_F(TestPanelController, MonitorResizesPanels)
 {
-  unity::panel::Controller pc;
+  unity::panel::Controller pc(edge_barriers);
 
   nux::Geometry monitor_geo = uscreen.GetMonitorGeometry(0);
   monitor_geo.SetSize(monitor_geo.width/2, monitor_geo.height/2);
@@ -153,4 +169,16 @@
   ASSERT_EQ(panel_geo.height, panel_style.panel_height);
 }
 
-}
\ No newline at end of file
+TEST_F(TestPanelController, MultiMonitorEdgeBarrierSubscriptions)
+{
+  uscreen.SetupFakeMultiMonitor();
+
+  {
+    unity::panel::Controller pc(edge_barriers);
+
+    for (unsigned i = 0; i < unity::monitors::MAX; ++i)
+      ASSERT_EQ(edge_barriers->GetHorizontalSubscriber(i), pc.panels()[i].GetPointer());
+  }
+}
+
+}

=== modified file 'tests/test_panel_view.cpp'
--- tests/test_panel_view.cpp	2013-08-01 05:01:01 +0000
+++ tests/test_panel_view.cpp	2013-08-09 16:16:17 +0000
@@ -23,9 +23,11 @@
 #include "PanelView.h"
 #include "unity-shared/MockableBaseWindow.h"
 #include "unity-shared/PanelStyle.h"
+#include "unity-shared/StandaloneWindowManager.h"
 #include "unity-shared/UBusMessages.h"
 #include "unity-shared/UBusWrapper.h"
 #include "unity-shared/UnitySettings.h"
+
 #include "test_utils.h"
 
 namespace
@@ -39,10 +41,12 @@
   unity::UBusManager ubus_manager_;
   nux::ObjectPtr<unity::MockableBaseWindow> window_;
   nux::ObjectPtr<unity::PanelView> panel_view_;
+  unity::StandaloneWindowManager* WM;
 
   TestPanelView()
     : window_(new unity::MockableBaseWindow())
     , panel_view_(new unity::PanelView(window_.GetPointer(), std::make_shared<unity::indicator::DBusIndicators>()))
+    , WM (dynamic_cast<unity::StandaloneWindowManager*>(&unity::WindowManager::Default()))
   {}
 
 };
@@ -66,4 +70,18 @@
   Utils::WaitUntil(std::bind(check_function, width));
 }
 
+TEST_F(TestPanelView, HandleBarrierEvent)
+{
+  auto barrier = std::make_shared<unity::ui::PointerBarrierWrapper>();
+  auto event = std::make_shared<ui::BarrierEvent>(0, 0, 0, 100);
+ 
+  WM->SetIsAnyWindowMoving(false);
+  EXPECT_EQ(panel_view_->HandleBarrierEvent(barrier.get(), event),
+            ui::EdgeBarrierSubscriber::Result::NEEDS_RELEASE);
+
+  WM->SetIsAnyWindowMoving(true);
+  EXPECT_EQ(panel_view_->HandleBarrierEvent(barrier.get(), event),
+            ui::EdgeBarrierSubscriber::Result::IGNORED);
+}
+
 }

=== modified file 'unity-shared/PluginAdapter.cpp'
--- unity-shared/PluginAdapter.cpp	2013-07-10 16:55:17 +0000
+++ unity-shared/PluginAdapter.cpp	2013-08-09 16:16:17 +0000
@@ -417,6 +417,11 @@
   return m_Screen->grabExist("wall");
 }
 
+bool PluginAdapter::IsAnyWindowMoving() const
+{
+    return m_Screen->grabExist("move");
+}
+
 void PluginAdapter::InitiateExpo()
 {
   m_ExpoActionList.InitiateAll();

=== modified file 'unity-shared/PluginAdapter.h'
--- unity-shared/PluginAdapter.h	2013-07-01 19:20:28 +0000
+++ unity-shared/PluginAdapter.h	2013-08-09 16:16:17 +0000
@@ -109,6 +109,8 @@
 
   bool IsWallActive() const;
 
+  bool IsAnyWindowMoving() const override;
+
   void ShowGrabHandles(CompWindow* window, bool use_timer);
   void HideGrabHandles(CompWindow* window);
   void ToggleGrabHandles(CompWindow* window);

=== modified file 'unity-shared/StandaloneWindowManager.cpp'
--- unity-shared/StandaloneWindowManager.cpp	2013-05-17 22:53:57 +0000
+++ unity-shared/StandaloneWindowManager.cpp	2013-08-09 16:16:17 +0000
@@ -79,6 +79,7 @@
   , in_show_desktop_(false)
   , scale_active_(false)
   , scale_active_for_group_(false)
+  , is_any_window_moving_(false)
   , current_desktop_(0)
   , viewport_size_(2, 2)
 {}
@@ -393,6 +394,16 @@
   return false;
 }
 
+void StandaloneWindowManager::SetIsAnyWindowMoving(bool is_any_window_moving)
+{
+  is_any_window_moving_ = is_any_window_moving;
+}
+
+bool StandaloneWindowManager::IsAnyWindowMoving() const
+{
+  return is_any_window_moving_;
+}
+
 void StandaloneWindowManager::FocusWindowGroup(std::vector<Window> const& windows,
                                                FocusVisibility,
                                                int monitor,

=== modified file 'unity-shared/StandaloneWindowManager.h'
--- unity-shared/StandaloneWindowManager.h	2013-05-17 22:53:57 +0000
+++ unity-shared/StandaloneWindowManager.h	2013-08-09 16:16:17 +0000
@@ -110,6 +110,9 @@
 
   virtual bool IsWallActive() const;
 
+  void SetIsAnyWindowMoving(bool is_any_window_moving);
+  virtual bool IsAnyWindowMoving() const override;
+
   virtual void FocusWindowGroup(std::vector<Window> const& windows,
                                 FocusVisibility, int monitor = -1, bool only_top_win = true);
   virtual bool ScaleWindowGroup(std::vector<Window> const& windows,
@@ -166,6 +169,7 @@
   bool in_show_desktop_;
   bool scale_active_;
   bool scale_active_for_group_;
+  bool is_any_window_moving_;
   unsigned current_desktop_;
   nux::Size viewport_size_;
   nux::Point current_vp_;

=== modified file 'unity-shared/WindowManager.h'
--- unity-shared/WindowManager.h	2013-05-17 22:53:57 +0000
+++ unity-shared/WindowManager.h	2013-08-09 16:16:17 +0000
@@ -114,6 +114,8 @@
 
   virtual bool IsWallActive() const = 0;
 
+  virtual bool IsAnyWindowMoving() const = 0;
+
   virtual void FocusWindowGroup(std::vector<Window> const& windows,
                                 FocusVisibility, int monitor = -1,
                                 bool only_top_win = true) = 0;

=== modified file 'unity-standalone/StandaloneUnity.cpp'
--- unity-standalone/StandaloneUnity.cpp	2012-11-22 16:35:20 +0000
+++ unity-standalone/StandaloneUnity.cpp	2013-08-09 16:16:17 +0000
@@ -87,8 +87,9 @@
 void UnityStandalone::Init ()
 {
   auto xdnd_manager = std::make_shared<XdndManager>();
-  launcher_controller = std::make_shared<launcher::Controller>(xdnd_manager);
-  panel_controller = std::make_shared<panel::Controller>();
+  auto edge_barriers = std::make_shared<ui::EdgeBarrierController>();
+  launcher_controller = std::make_shared<launcher::Controller>(xdnd_manager, edge_barriers);
+  panel_controller = std::make_shared<panel::Controller>(edge_barriers);
   dash_controller = std::make_shared<dash::Controller>();
 
   dash_controller->launcher_width = launcher_controller->launcher().GetAbsoluteWidth() - 1;
@@ -121,7 +122,8 @@
 void UnityStandaloneTV::Init()
 {
   auto xdnd_manager = std::make_shared<XdndManager>();
-  launcher_controller = std::make_shared<launcher::Controller>(xdnd_manager);
+  auto edge_barriers = std::make_shared<ui::EdgeBarrierController>();
+  launcher_controller = std::make_shared<launcher::Controller>(xdnd_manager, edge_barriers);
   dash_controller = std::make_shared<dash::Controller>();
   dash_controller->launcher_width = launcher_controller->launcher().GetAbsoluteWidth() - 1;