Merge lp:~3v1n0/unity/input-monitor-menus-scrubbing-triangolation into lp:unity

[Marco Trevisan (Treviño)]

MenuManager: add support for mouse trackers with triangle algorithm support

It allows to register pointer trackers with menu entries selection by using the triangle
technique which prevents menus items from being opened on quick menu scrubbing

Then use use menu::Manager pointer tracker for entries activation in PanelView, LockScreenPanel and DecorationsMenuLayout

=== modified file 'decorations/DecoratedWindow.cpp'
--- decorations/DecoratedWindow.cpp	2016-08-06 16:24:45 +0000
+++ decorations/DecoratedWindow.cpp	2016-08-30 10:27:02 +0000
@@ -37,7 +37,6 @@
 {
 namespace
 {
-const std::string MENUS_PANEL_NAME = "WindowLIM";
 const int SHADOW_BLUR_MARGIN_FACTOR = 2;
 }
 
@@ -55,7 +54,6 @@
   , deco_elements_(cu::DecorationElement::NONE)
   , last_mwm_decor_(win_->mwmDecor())
   , last_actions_(win_->actions())
-  , panel_id_(MENUS_PANEL_NAME + std::to_string(win_->id()))
   , cv_(Settings::Instance().em())
 {
   active.changed.connect([this] (bool active) {
@@ -932,18 +930,13 @@
     sliding_layout->mouse_owner = grab_edge_->mouse_owner();
 }
 
-inline std::string const& Window::Impl::GetMenusPanelID() const
-{
-  return panel_id_;
-}
-
 void Window::Impl::UnsetAppMenu()
 {
   if (!menus_)
     return;
 
   auto const& indicators = manager_->impl_->menu_manager_->Indicators();
-  indicators->SyncGeometries(GetMenusPanelID(), indicator::EntryLocationMap());
+  indicators->SyncGeometries(menus_->MenubarId(), indicator::EntryLocationMap());
   sliding_layout_->SetInputItem(nullptr);
   grab_mouse_changed_->disconnect();
 }
@@ -956,7 +949,7 @@
   auto const& indicators = manager_->impl_->menu_manager_->Indicators();
   indicator::EntryLocationMap map;
   menus_->ChildrenGeometries(map);
-  indicators->SyncGeometries(GetMenusPanelID(), map);
+  indicators->SyncGeometries(menus_->MenubarId(), map);
 }
 
 bool Window::Impl::ActivateMenu(std::string const& entry_id)

=== modified file 'decorations/DecorationsMenuLayout.cpp'
--- decorations/DecorationsMenuLayout.cpp	2015-02-03 10:04:17 +0000
+++ decorations/DecorationsMenuLayout.cpp	2016-08-30 10:27:02 +0000
@@ -25,6 +25,10 @@
 {
 namespace decoration
 {
+namespace
+{
+const std::string MENUS_PANEL_NAME = "WindowLIM";
+}
 
 using namespace indicator;
 
@@ -33,8 +37,8 @@
   , show_now(false)
   , menu_manager_(menu)
   , win_(win)
-  , last_pointer_(-1, -1)
   , dropdown_(std::make_shared<MenuDropdown>(menu_manager_->Indicators(), win))
+  , menubar_id_(MENUS_PANEL_NAME + std::to_string(win_->id()))
 {
   visible = false;
 }
@@ -91,6 +95,11 @@
     Relayout();
 }
 
+std::string const& MenuLayout::MenubarId() const
+{
+  return menubar_id_;
+}
+
 bool MenuLayout::ActivateMenu(std::string const& entry_id)
 {
   MenuEntry::Ptr target;
@@ -117,16 +126,29 @@
   if (!activated)
     activated = dropdown_->ActivateChild(target);
 
-  if (activated)
-  {
-    // Since this generally happens on keyboard activation we need to avoid that
-    // the mouse position would interfere with this
-    last_pointer_.set(pointerX, pointerY);
-  }
-
   return activated;
 }
 
+bool MenuLayout::ActivateMenu(CompPoint const& pos)
+{
+  if (!Geometry().contains(pos))
+    return false;
+
+  for (auto const& item : items_)
+  {
+    if (!item->visible() || !item->sensitive())
+      continue;
+
+    if (item->Geometry().contains(pos))
+    {
+      std::static_pointer_cast<MenuEntry>(item)->ShowMenu(1);
+      return true;
+    }
+  }
+
+  return false;
+}
+
 void MenuLayout::OnEntryMouseOwnershipChanged(bool owner)
 {
   mouse_owner = owner;
@@ -154,39 +176,15 @@
 {
   active = actived;
 
-  if (active && !pointer_tracker_ && items_.size() > 1)
+  if (active && items_.size() > 1)
   {
-    pointer_tracker_.reset(new glib::Timeout(16));
-    pointer_tracker_->Run([this] {
-      Window win;
-      int i, x, y;
-      unsigned int ui;
-
-      XQueryPointer(screen->dpy(), screen->root(), &win, &win, &x, &y, &i, &i, &ui);
-
-      if (last_pointer_.x() != x || last_pointer_.y() != y)
-      {
-        last_pointer_.set(x, y);
-
-        for (auto const& item : items_)
-        {
-          if (!item->visible() || !item->sensitive())
-            continue;
-
-          if (item->Geometry().contains(last_pointer_))
-          {
-            std::static_pointer_cast<MenuEntry>(item)->ShowMenu(1);
-            break;
-          }
-        }
-      }
-
-      return true;
-    });
+    menu_manager_->RegisterTracker(menubar_id_, (sigc::track_obj([this] (int x, int y, double speed) {
+      ActivateMenu(CompPoint(x, y));
+    }, *this)));
   }
   else if (!active)
   {
-    pointer_tracker_.reset();
+    menu_manager_->UnregisterTracker(menubar_id_);
   }
 }
 

=== modified file 'decorations/DecorationsMenuLayout.h'
--- decorations/DecorationsMenuLayout.h	2014-02-13 03:01:30 +0000
+++ decorations/DecorationsMenuLayout.h	2016-08-30 10:27:02 +0000
@@ -42,7 +42,9 @@
 
   void Setup();
   bool ActivateMenu(std::string const& entry_id);
+  bool ActivateMenu(CompPoint const&);
   void ChildrenGeometries(indicator::EntryLocationMap&) const;
+  std::string const& MenubarId() const;
 
 protected:
   void DoRelayout() override;
@@ -55,10 +57,9 @@
 
   menu::Manager::Ptr menu_manager_;
   CompWindow* win_;
-  CompPoint last_pointer_;
-  glib::Source::UniquePtr pointer_tracker_;
   glib::Source::UniquePtr show_now_timeout_;
   std::shared_ptr<MenuDropdown> dropdown_;
+  std::string menubar_id_;
 };
 
 } // decoration namespace

=== modified file 'decorations/DecorationsPriv.h'
--- decorations/DecorationsPriv.h	2016-08-06 16:24:45 +0000
+++ decorations/DecorationsPriv.h	2016-08-30 10:27:02 +0000
@@ -162,7 +162,6 @@
   connection::Wrapper dpi_changed_;
   connection::Wrapper grab_mouse_changed_;
   std::string last_title_;
-  std::string panel_id_;
   std::vector<cu::SimpleTextureQuad> bg_textures_;
   cu::PixmapTexture::Ptr shaped_shadow_pixmap_;
   std::shared_ptr<ForceQuitDialog> force_quit_;

=== modified file 'launcher/EdgeBarrierController.cpp'
--- launcher/EdgeBarrierController.cpp	2015-12-23 09:29:24 +0000
+++ launcher/EdgeBarrierController.cpp	2016-08-30 10:27:02 +0000
@@ -25,6 +25,7 @@
 #include <NuxCore/Logger.h>
 #include "unity-shared/UnitySettings.h"
 #include "unity-shared/UScreen.h"
+#include "unity-shared/InputMonitor.h"
 #include "UnityCore/GLibSource.h"
 
 namespace unity
@@ -36,50 +37,12 @@
 {
   int const Y_BREAK_BUFFER = 20;
   int const X_BREAK_BUFFER = 20;
-  int const MAJOR = 2;
-  int const MINOR = 3;
 }
 
 DECLARE_LOGGER(logger, "unity.edge_barrier_controller");
 
-int GetXI2OpCode()
-{
-  Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
-
-  int opcode, event_base, error_base;
-  if (!XQueryExtension(dpy, "XFIXES",
-                       &opcode,
-                       &event_base,
-                       &error_base))
-  {
-    LOG_ERROR(logger) << "Missing XFixes";
-    return -1;
-  }
-
-  if (!XQueryExtension (dpy, "XInputExtension",
-                        &opcode,
-                        &event_base,
-                        &error_base))
-  {
-    LOG_ERROR(logger) << "Missing XInput";
-    return -1;
-  }
-
-  int maj = MAJOR;
-  int min = MINOR;
-
-  if (XIQueryVersion(dpy, &maj, &min) == BadRequest)
-  {
-    LOG_ERROR(logger) << "Need XInput version 2.3";
-    return -1;
-  }
-
-  return opcode;
-}
-
 EdgeBarrierController::Impl::Impl(EdgeBarrierController *parent)
-  : xi2_opcode_(-1)
-  , edge_overcome_pressure_(0)
+  : edge_overcome_pressure_(0)
   , parent_(parent)
 {
   UScreen *uscreen = UScreen::GetDefault();
@@ -119,8 +82,6 @@
     options->option_changed.connect(sigc::mem_fun(this, &EdgeBarrierController::Impl::OnOptionsChanged));
     SetupBarriers(UScreen::GetDefault()->GetMonitors());
   });
-
-  xi2_opcode_ = GetXI2OpCode();
 }
 
 EdgeBarrierController::Impl::~Impl()
@@ -202,36 +163,30 @@
   }
 }
 
-void SetupXI2Events()
-{
-  Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
-
-  unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
-  XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
-
-  XISetMask(mask.mask, XI_BarrierHit);
-  XISetMask(mask.mask, XI_BarrierLeave);
-  XISelectEvents (dpy, DefaultRootWindow(dpy), &mask, 1);
-}
-
 void EdgeBarrierController::Impl::SetupBarriers(std::vector<nux::Geometry> const& layout)
 {
   if (parent_->force_disable())
     return;
 
+  size_t monitors_size = layout.size();
+  auto launcher_position = Settings::Instance().launcher_position();
   bool edge_resist = parent_->sticky_edges();
-  auto launcher_position = Settings::Instance().launcher_position();
-
-  for (unsigned i = 0; i < layout.size(); i++)
+  bool needs_barrier = edge_resist && monitors_size > 1;
+  bool needs_vertical_barrier = needs_barrier;
+
+  if (parent_->options()->hide_mode() != launcher::LauncherHideMode::LAUNCHER_HIDE_NEVER)
+    needs_vertical_barrier = true;
+
+  for (unsigned i = 0; i < layout.size(); ++i)
   {
-    auto vertical_barrier = vertical_barriers_[i];
-    auto horizontal_barrier = horizontal_barriers_[i];
-    auto monitor = layout[i];
+    auto const& vertical_barrier = vertical_barriers_[i];
+    auto const& horizontal_barrier = horizontal_barriers_[i];
+    auto const& monitor = layout[i];
 
     vertical_barrier->DestroyBarrier();
     horizontal_barrier->DestroyBarrier();
 
-    if (edge_resist)
+    if (needs_barrier)
     {
       horizontal_barrier->x1 = monitor.x;
       horizontal_barrier->x2 = monitor.x + monitor.width;
@@ -246,7 +201,7 @@
       horizontal_barrier->ConstructBarrier();
     }
 
-    if (!edge_resist && parent_->options()->hide_mode() == launcher::LauncherHideMode::LAUNCHER_HIDE_NEVER)
+    if (!needs_vertical_barrier)
       continue;
 
     if (launcher_position == LauncherPosition::LEFT)
@@ -273,8 +228,10 @@
     vertical_barrier->ConstructBarrier();
   }
 
-  SetupXI2Events();
-  AddEventFilter();
+  if (needs_barrier || needs_vertical_barrier)
+    input::Monitor::Get().RegisterClient(input::Events::BARRIER, sigc::mem_fun(this, &Impl::HandleEvent));
+  else
+    input::Monitor::Get().UnregisterClient(sigc::mem_fun(this, &Impl::HandleEvent));
 
   float decay_responsiveness_mult = ((parent_->options()->edge_responsiveness() - 1) * .3f) + 1;
   decaymulator_.rate_of_decay = parent_->options()->edge_decay_rate() * decay_responsiveness_mult;
@@ -283,65 +240,25 @@
   edge_overcome_pressure_ = parent_->options()->edge_overcome_pressure() * overcome_responsiveness_mult;
 }
 
-void EdgeBarrierController::Impl::AddEventFilter()
-{
-  // Remove an old one, if it exists
-  nux::GetGraphicsDisplay()->RemoveEventFilter(this);
-
-  nux::GraphicsDisplay::EventFilterArg event_filter;
-  event_filter.filter = &HandleEventCB;
-  event_filter.data = this;
-
-  nux::GetGraphicsDisplay()->AddEventFilter(event_filter);
-}
-
-bool EdgeBarrierController::Impl::HandleEvent(XEvent xevent)
-{
-  Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
-  XGenericEventCookie *cookie = &xevent.xcookie;
-  bool ret = false;
-
-  switch (cookie->evtype)
-  {
-    case (XI_BarrierHit):
-    {
-      if (XGetEventData(dpy, cookie))
-      {
-        XIBarrierEvent* barrier_event = (XIBarrierEvent*)cookie->data;
-        PointerBarrierWrapper::Ptr wrapper = FindBarrierEventOwner(barrier_event);
-
-        if (wrapper)
-          ret = wrapper->HandleBarrierEvent(barrier_event);
-      }
-
-      XFreeEventData(dpy, cookie);
-      break;
-    }
-    default:
-      break;
-  }
-
-  return ret;
-}
-
-bool EdgeBarrierController::Impl::HandleEventCB(XEvent xevent, void* data)
-{
-  auto edge_barrier_controller = static_cast<EdgeBarrierController::Impl*>(data);
-  int const xi2_opcode = edge_barrier_controller->xi2_opcode_;
-
-  if (xevent.type != GenericEvent || xevent.xcookie.extension != xi2_opcode)
-    return false;
-
-  return edge_barrier_controller->HandleEvent(xevent);
+void EdgeBarrierController::Impl::HandleEvent(XEvent const& xevent)
+{
+  if (xevent.xcookie.evtype != XI_BarrierHit)
+    return;
+
+  auto* barrier_event = reinterpret_cast<XIBarrierEvent*>(xevent.xcookie.data);
+  PointerBarrierWrapper::Ptr const& wrapper = FindBarrierEventOwner(barrier_event);
+
+  if (wrapper)
+    wrapper->HandleBarrierEvent(barrier_event);
 }
 
 PointerBarrierWrapper::Ptr EdgeBarrierController::Impl::FindBarrierEventOwner(XIBarrierEvent* barrier_event)
 {
-  for (auto barrier : vertical_barriers_)
+  for (auto const& barrier : vertical_barriers_)
     if (barrier->OwnsBarrierEvent(barrier_event->barrier))
       return barrier;
 
-  for (auto barrier : horizontal_barriers_)
+  for (auto const& barrier : horizontal_barriers_)
     if (barrier->OwnsBarrierEvent(barrier_event->barrier))
       return barrier;
 

=== modified file 'launcher/EdgeBarrierControllerPrivate.h'
--- launcher/EdgeBarrierControllerPrivate.h	2015-12-23 09:29:24 +0000
+++ launcher/EdgeBarrierControllerPrivate.h	2016-08-30 10:27:02 +0000
@@ -53,12 +53,8 @@
   bool EventIsInsideYBreakZone(BarrierEvent::Ptr const& event);
   bool EventIsInsideXBreakZone(BarrierEvent::Ptr const& event);
 
-  void AddEventFilter();
-
   PointerBarrierWrapper::Ptr FindBarrierEventOwner(XIBarrierEvent* barrier_event);
-
-  static bool HandleEventCB(XEvent event, void* data);
-  bool HandleEvent(XEvent event);
+  void HandleEvent(XEvent const&);
 
   std::vector<PointerBarrierWrapper::Ptr> vertical_barriers_;
   std::vector<PointerBarrierWrapper::Ptr> horizontal_barriers_;
@@ -68,7 +64,6 @@
 
   Decaymulator decaymulator_;
   glib::Source::UniquePtr release_timeout_;
-  int xi2_opcode_;
   float edge_overcome_pressure_;
   EdgeBarrierController* parent_;
 };

=== modified file 'lockscreen/KylinLockScreenShield.cpp'
--- lockscreen/KylinLockScreenShield.cpp	2015-12-07 03:09:28 +0000
+++ lockscreen/KylinLockScreenShield.cpp	2016-08-30 10:27:02 +0000
@@ -37,7 +37,7 @@
                Accelerators::Ptr const& accelerators,
                nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
                int monitor_num, bool is_primary)
-  : BaseShield(session_manager, nullptr, accelerators, prompt_view, monitor_num, is_primary)
+  : BaseShield(session_manager, accelerators, prompt_view, monitor_num, is_primary)
 {
   is_primary ? ShowPrimaryView() : ShowSecondaryView();
   EnableInputWindow(true);

=== modified file 'lockscreen/LockScreenBaseShield.cpp'
--- lockscreen/LockScreenBaseShield.cpp	2015-12-03 14:13:10 +0000
+++ lockscreen/LockScreenBaseShield.cpp	2016-08-30 10:27:02 +0000
@@ -38,7 +38,6 @@
 }
 
 BaseShield::BaseShield(session::Manager::Ptr const& session,
-                       indicator::Indicators::Ptr const& indicators,
                        Accelerators::Ptr const& accelerators,
                        nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
                        int monitor_num, bool is_primary)
@@ -47,7 +46,6 @@
   , monitor(monitor_num)
   , scale(1.0)
   , session_manager_(session)
-  , indicators_(indicators)
   , accelerators_(accelerators)
   , prompt_view_(prompt_view)
   , bg_settings_(std::make_shared<BackgroundSettings>())

=== modified file 'lockscreen/LockScreenBaseShield.h'
--- lockscreen/LockScreenBaseShield.h	2016-03-31 09:51:33 +0000
+++ lockscreen/LockScreenBaseShield.h	2016-08-30 10:27:02 +0000
@@ -21,8 +21,8 @@
 #define UNITY_LOCKSCREEN_BASE_SHIELD_H
 
 #include <NuxCore/Property.h>
+#include "UnityCore/ConnectionManager.h"
 #include "UnityCore/SessionManager.h"
-#include "UnityCore/Indicators.h"
 #include "UnityCore/GLibSource.h"
 #include "unity-shared/MockableBaseWindow.h"
 
@@ -39,8 +39,8 @@
 class BaseShield : public MockableBaseWindow
 {
 public:
-  BaseShield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&,
-             Accelerators::Ptr const&, nux::ObjectPtr<AbstractUserPromptView> const&,
+  BaseShield(session::Manager::Ptr const&, Accelerators::Ptr const&,
+             nux::ObjectPtr<AbstractUserPromptView> const&,
              int monitor_num, bool is_primary);
 
   nux::Property<bool> primary;
@@ -69,7 +69,6 @@
   void UpdateScale();
 
   session::Manager::Ptr session_manager_;
-  indicator::Indicators::Ptr indicators_;
   Accelerators::Ptr accelerators_;
   nux::ObjectPtr<AbstractUserPromptView> prompt_view_;
   std::shared_ptr<BackgroundSettings> bg_settings_;

=== modified file 'lockscreen/LockScreenController.cpp'
--- lockscreen/LockScreenController.cpp	2016-07-04 12:45:06 +0000
+++ lockscreen/LockScreenController.cpp	2016-08-30 10:27:02 +0000
@@ -130,7 +130,7 @@
 
       upstart_wrapper_->Emit("desktop-unlock");
       accelerator_controller_.reset();
-      indicators_.reset();
+      menu_manager_.reset();
     }
     else if (!prompt_activation_)
     {
@@ -252,7 +252,7 @@
 
     if (i >= shields_size)
     {
-      shield = shield_factory_->CreateShield(session_manager_, indicators_, accelerator_controller_->GetAccelerators(), prompt_view, i, i == primary);
+      shield = shield_factory_->CreateShield(session_manager_, menu_manager_, accelerator_controller_->GetAccelerators(), prompt_view, i, i == primary);
       is_new = true;
     }
 
@@ -462,7 +462,7 @@
 
 void Controller::LockScreen()
 {
-  indicators_ = std::make_shared<indicator::LockScreenDBusIndicators>();
+  menu_manager_ = std::make_shared<menu::Manager>(std::make_shared<indicator::LockScreenDBusIndicators>(), key_grabber_);
   upstart_wrapper_->Emit("desktop-lock");
 
   accelerator_controller_ = std::make_shared<AcceleratorController>(key_grabber_);

=== modified file 'lockscreen/LockScreenController.h'
--- lockscreen/LockScreenController.h	2016-06-21 01:28:26 +0000
+++ lockscreen/LockScreenController.h	2016-08-30 10:27:02 +0000
@@ -30,7 +30,6 @@
 #include "SuspendInhibitorManager.h"
 #include "ScreenSaverDBusManager.h"
 #include "unity-shared/BackgroundEffectHelper.h"
-#include "unity-shared/KeyGrabber.h"
 #include "unity-shared/UpstartWrapper.h"
 
 namespace unity
@@ -85,8 +84,8 @@
 
   DBusManager::Ptr dbus_manager_;
   session::Manager::Ptr session_manager_;
+  menu::Manager::Ptr menu_manager_;
   key::Grabber::Ptr key_grabber_;
-  indicator::Indicators::Ptr indicators_;
   AcceleratorController::Ptr accelerator_controller_;
   UpstartWrapper::Ptr upstart_wrapper_;
   ShieldFactoryInterface::Ptr shield_factory_;

=== modified file 'lockscreen/LockScreenPanel.cpp'
--- lockscreen/LockScreenPanel.cpp	2015-11-05 14:55:54 +0000
+++ lockscreen/LockScreenPanel.cpp	2016-08-30 10:27:02 +0000
@@ -24,7 +24,7 @@
 
 #include "LockScreenSettings.h"
 #include "panel/PanelIndicatorsView.h"
-#include "unity-shared/CairoTexture.h"
+#include "unity-shared/InputMonitor.h"
 #include "unity-shared/StaticCairoText.h"
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/RawPixel.h"
@@ -38,24 +38,24 @@
 namespace
 {
 const RawPixel PADDING = 5_em;
+const nux::Color BG_COLOR(0.1, 0.1, 0.1, 0.4);
 }
 
 using namespace indicator;
 using namespace panel;
 
-Panel::Panel(int monitor_, Indicators::Ptr const& indicators, session::Manager::Ptr const& session_manager)
+Panel::Panel(int monitor_, menu::Manager::Ptr const& menu_manager, session::Manager::Ptr const& session_manager)
   : nux::View(NUX_TRACKER_LOCATION)
   , active(false)
   , monitor(monitor_)
-  , indicators_(indicators)
+  , menu_manager_(menu_manager)
   , needs_geo_sync_(true)
 {
   double scale = unity::Settings::Instance().em(monitor)->DPIScale();
   auto* layout = new nux::HLayout();
   layout->SetLeftAndRightPadding(PADDING.CP(scale), 0);
   SetLayout(layout);
-
-  BuildTexture();
+  UpdateSize();
 
   // Add setting
   auto *hostname = new StaticCairoText(session_manager->HostName());
@@ -72,34 +72,33 @@
   indicators_view_->on_indicator_updated.connect(sigc::mem_fun(this, &Panel::OnIndicatorViewUpdated));
   layout->AddView(indicators_view_, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
 
-  for (auto const& indicator : indicators_->GetIndicators())
+  auto indicators = menu_manager_->Indicators();
+  menu_manager_->RegisterTracker(GetPanelName(), (sigc::track_obj([this] (int x, int y, double speed) {
+    indicators_view_->ActivateEntryAt(x, y);
+  }, *this)));
+
+  for (auto const& indicator : indicators->GetIndicators())
     AddIndicator(indicator);
 
-  indicators_->on_object_added.connect(sigc::mem_fun(this, &Panel::AddIndicator));
-  indicators_->on_object_removed.connect(sigc::mem_fun(this, &Panel::RemoveIndicator));
-  indicators_->on_entry_show_menu.connect(sigc::mem_fun(this, &Panel::OnEntryShowMenu));
-  indicators_->on_entry_activated.connect(sigc::mem_fun(this, &Panel::OnEntryActivated));
-  indicators_->on_entry_activate_request.connect(sigc::mem_fun(this, &Panel::OnEntryActivateRequest));
+  indicators->on_object_added.connect(sigc::mem_fun(this, &Panel::AddIndicator));
+  indicators->on_object_removed.connect(sigc::mem_fun(this, &Panel::RemoveIndicator));
+  indicators->on_entry_show_menu.connect(sigc::mem_fun(this, &Panel::OnEntryShowMenu));
+  indicators->on_entry_activated.connect(sigc::mem_fun(this, &Panel::OnEntryActivated));
+  indicators->on_entry_activate_request.connect(sigc::mem_fun(this, &Panel::OnEntryActivateRequest));
 
   monitor.changed.connect([this, hostname] (int monitor) {
     double scale = unity::Settings::Instance().em(monitor)->DPIScale();
     hostname->SetScale(scale);
     static_cast<nux::HLayout*>(GetLayout())->SetLeftAndRightPadding(PADDING.CP(scale), 0);
     indicators_view_->SetMonitor(monitor);
-    BuildTexture();
+    UpdateSize();
     QueueRelayout();
   });
 }
 
-void Panel::BuildTexture()
+void Panel::UpdateSize()
 {
   int height = panel::Style::Instance().PanelHeight(monitor);
-  nux::CairoGraphics context(CAIRO_FORMAT_ARGB32, 1, height);
-  auto* cr = context.GetInternalContext();
-  cairo_set_source_rgb(cr, 0.1, 0.1, 0.1);
-  cairo_paint_with_alpha(cr, 0.4);
-  bg_texture_ = texture_ptr_from_cairo_graphics(context);
-
   view_layout_->SetMinimumHeight(height);
   view_layout_->SetMaximumHeight(height);
 }
@@ -165,12 +164,7 @@
   if (!GetInputEventSensitivity())
     return;
 
-  if (!active)
-  {
-    // This is ugly... But Nux fault!
-    WindowManager::Default().UnGrabMousePointer(CurrentTime, button, x, y);
-    active = true;
-  }
+  active = true;
 }
 
 void Panel::OnEntryActivateRequest(std::string const& entry_id)
@@ -184,36 +178,16 @@
   if (!GetInputEventSensitivity() || (!panel.empty() && panel != GetPanelName()))
     return;
 
-  bool active = !entry_id.empty();
+  bool valid_entry = !entry_id.empty();
 
-  if (active && !WindowManager::Default().IsScreenGrabbed())
+  if (valid_entry && !WindowManager::Default().IsScreenGrabbed())
   {
     // The menu didn't grab the keyboard, let's take it back.
     nux::GetWindowCompositor().GrabKeyboardAdd(static_cast<nux::BaseWindow*>(GetTopLevelViewWindow()));
   }
 
-  if (active && !track_menu_pointer_timeout_)
-  {
-    track_menu_pointer_timeout_.reset(new glib::Timeout(16));
-    track_menu_pointer_timeout_->Run([this] {
-      nux::Point const& mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-      if (tracked_pointer_pos_ != mouse)
-      {
-        if (GetAbsoluteGeometry().IsPointInside(mouse.x, mouse.y))
-          indicators_view_->ActivateEntryAt(mouse.x, mouse.y);
-
-        tracked_pointer_pos_ = mouse;
-      }
-
-      return true;
-    });
-  }
-  else if (!active)
-  {
-    track_menu_pointer_timeout_.reset();
-    tracked_pointer_pos_ = {-1, -1};
-    this->active = false;
-  }
+  if (!valid_entry)
+    active = valid_entry;
 }
 
 void Panel::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
@@ -227,12 +201,7 @@
   graphics_engine.PushClippingRectangle(geo);
   nux::GetPainter().PaintBackground(graphics_engine, geo);
 
-  nux::TexCoordXForm texxform;
-  texxform.SetWrap(nux::TEXWRAP_REPEAT, nux::TEXWRAP_CLAMP);
-  graphics_engine.QRP_1Tex(geo.x, geo.y, geo.width, geo.height,
-                           bg_texture_->GetDeviceTexture(), texxform,
-                           nux::color::White);
-
+  graphics_engine.QRP_Color(geo.x, geo.y, geo.width, geo.height, BG_COLOR);
   view_layout_->ProcessDraw(graphics_engine, force_draw);
 
   graphics_engine.PopClippingRectangle();
@@ -242,7 +211,7 @@
   {
     EntryLocationMap locations;
     indicators_view_->GetGeometryForSync(locations);
-    indicators_->SyncGeometries(GetPanelName(), locations);
+    menu_manager_->Indicators()->SyncGeometries(GetPanelName(), locations);
     needs_geo_sync_ = false;
   }
 }

=== modified file 'lockscreen/LockScreenPanel.h'
--- lockscreen/LockScreenPanel.h	2016-03-31 09:51:33 +0000
+++ lockscreen/LockScreenPanel.h	2016-08-30 10:27:02 +0000
@@ -22,9 +22,9 @@
 
 #include <Nux/Nux.h>
 #include <Nux/View.h>
-#include "UnityCore/Indicators.h"
 #include "UnityCore/GLibSource.h"
 #include "UnityCore/SessionManager.h"
+#include "unity-shared/MenuManager.h"
 
 namespace unity
 {
@@ -39,7 +39,7 @@
 class Panel : public nux::View
 {
 public:
-  Panel(int monitor, indicator::Indicators::Ptr const&, session::Manager::Ptr const&);
+  Panel(int monitor, menu::Manager::Ptr const&, session::Manager::Ptr const&);
 
   nux::Property<bool> active;
   nux::Property<int> monitor;
@@ -55,20 +55,16 @@
   void AddIndicator(indicator::Indicator::Ptr const&);
   void RemoveIndicator(indicator::Indicator::Ptr const&);
   void OnIndicatorViewUpdated();
-  void OnEntryActivated(std::string const& panel, std::string const& entry_id, nux::Rect const& geo);
+  void OnEntryActivated(std::string const& panel, std::string const& entry_id, nux::Rect const&);
   void OnEntryShowMenu(std::string const& entry_id, unsigned xid, int x, int y, unsigned button);
   void OnEntryActivateRequest(std::string const& entry_id);
 
-  void BuildTexture();
+  void UpdateSize();
   std::string GetPanelName() const;
 
-  indicator::Indicators::Ptr indicators_;
+  menu::Manager::Ptr menu_manager_;
   panel::PanelIndicatorsView* indicators_view_;
-  nux::ObjectPtr<nux::BaseTexture> bg_texture_;
-
   bool needs_geo_sync_;
-  nux::Point tracked_pointer_pos_;
-  glib::Source::UniquePtr track_menu_pointer_timeout_;
 };
 
 } // lockscreen namespace

=== modified file 'lockscreen/LockScreenShield.cpp'
--- lockscreen/LockScreenShield.cpp	2015-12-03 14:13:10 +0000
+++ lockscreen/LockScreenShield.cpp	2016-08-30 10:27:02 +0000
@@ -32,11 +32,12 @@
 {
 
 Shield::Shield(session::Manager::Ptr const& session_manager,
-               indicator::Indicators::Ptr const& indicators,
+               menu::Manager::Ptr const& menu_manager,
                Accelerators::Ptr const& accelerators,
                nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
                int monitor_num, bool is_primary)
-  : BaseShield(session_manager, indicators, accelerators, prompt_view, monitor_num, is_primary)
+  : BaseShield(session_manager, accelerators, prompt_view, monitor_num, is_primary)
+  , menu_manager_(menu_manager)
   , panel_view_(nullptr)
 {
   is_primary ? ShowPrimaryView() : ShowSecondaryView();
@@ -91,11 +92,11 @@
 
 Panel* Shield::CreatePanel()
 {
-  if (!indicators_ || !session_manager_)
+  if (!menu_manager_ || !session_manager_)
     return nullptr;
 
-  panel_view_ = new Panel(monitor, indicators_, session_manager_);
-  panel_active_conn_ = panel_view_->active.changed.connect([this] (bool active) {
+  panel_view_ = new Panel(monitor, menu_manager_, session_manager_);
+  panel_view_->active.changed.connect(sigc::track_obj([this] (bool active) {
     if (primary())
     {
       if (active)
@@ -109,7 +110,7 @@
         GrabScreen(false);
       }
     }
-  });
+  }, *this));
 
   return panel_view_;
 }

=== modified file 'lockscreen/LockScreenShield.h'
--- lockscreen/LockScreenShield.h	2015-12-03 14:13:10 +0000
+++ lockscreen/LockScreenShield.h	2016-08-30 10:27:02 +0000
@@ -20,8 +20,9 @@
 #ifndef UNITY_LOCKSCREEN_SHIELD_H
 #define UNITY_LOCKSCREEN_SHIELD_H
 
-#include <UnityCore/ConnectionManager.h>
 #include "LockScreenBaseShield.h"
+#include "unity-shared/MenuManager.h"
+
 
 namespace unity
 {
@@ -35,7 +36,7 @@
 {
 public:
   Shield(session::Manager::Ptr const&,
-         indicator::Indicators::Ptr const&,
+         menu::Manager::Ptr const&,
          Accelerators::Ptr const&,
          nux::ObjectPtr<AbstractUserPromptView> const&,
          int monitor, bool is_primary);
@@ -50,7 +51,7 @@
   void ShowPrimaryView() override;
   Panel* CreatePanel();
 
-  connection::Wrapper panel_active_conn_;
+  menu::Manager::Ptr menu_manager_;
   Panel* panel_view_;
 };
 

=== modified file 'lockscreen/LockScreenShieldFactory.cpp'
--- lockscreen/LockScreenShieldFactory.cpp	2015-12-04 08:17:46 +0000
+++ lockscreen/LockScreenShieldFactory.cpp	2016-08-30 10:27:02 +0000
@@ -28,7 +28,7 @@
 {
 
 nux::ObjectPtr<BaseShield> ShieldFactory::CreateShield(session::Manager::Ptr const& session_manager,
-                                                       indicator::Indicators::Ptr const& indicators,
+                                                       menu::Manager::Ptr const& menu_manager,
                                                        Accelerators::Ptr const& accelerators,
                                                        nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
                                                        int monitor, bool is_primary)
@@ -38,7 +38,7 @@
   if (Settings::Instance().desktop_type() == DesktopType::UBUNTUKYLIN)
     shield = new KylinShield(session_manager, accelerators, prompt_view, monitor, is_primary);
   else
-    shield = new Shield(session_manager, indicators, accelerators, prompt_view,  monitor, is_primary);
+    shield = new Shield(session_manager, menu_manager, accelerators, prompt_view,  monitor, is_primary);
 
   return shield;
 }

=== modified file 'lockscreen/LockScreenShieldFactory.h'
--- lockscreen/LockScreenShieldFactory.h	2016-03-31 09:51:33 +0000
+++ lockscreen/LockScreenShieldFactory.h	2016-08-30 10:27:02 +0000
@@ -22,7 +22,7 @@
 
 #include <NuxCore/NuxCore.h>
 #include "UnityCore/SessionManager.h"
-#include "UnityCore/Indicators.h"
+#include "unity-shared/MenuManager.h"
 #include "LockScreenAccelerators.h"
 
 namespace unity
@@ -41,7 +41,7 @@
   virtual ~ShieldFactoryInterface() = default;
 
   virtual nux::ObjectPtr<BaseShield> CreateShield(session::Manager::Ptr const&,
-                                                  indicator::Indicators::Ptr const&,
+                                                  menu::Manager::Ptr const&,
                                                   Accelerators::Ptr const&,
                                                   nux::ObjectPtr<AbstractUserPromptView> const&,
                                                   int monitor, bool is_primary) = 0;
@@ -50,7 +50,7 @@
 struct ShieldFactory : ShieldFactoryInterface
 {
   nux::ObjectPtr<BaseShield> CreateShield(session::Manager::Ptr const&,
-                                          indicator::Indicators::Ptr const&,
+                                          menu::Manager::Ptr const&,
                                           Accelerators::Ptr const&,
                                           nux::ObjectPtr<AbstractUserPromptView> const&,
                                           int monitor, bool is_primary) override;

=== modified file 'panel/PanelIndicatorEntryView.cpp'
--- panel/PanelIndicatorEntryView.cpp	2016-02-17 13:14:37 +0000
+++ panel/PanelIndicatorEntryView.cpp	2016-08-30 10:27:02 +0000
@@ -33,6 +33,8 @@
 #include "unity-shared/RawPixel.h"
 #include "unity-shared/WindowManager.h"
 #include "unity-shared/ThemeSettings.h"
+#include "unity-shared/UBusWrapper.h"
+#include "unity-shared/UBusMessages.h"
 #include "unity-shared/UnitySettings.h"
 
 namespace unity
@@ -117,6 +119,9 @@
     }
     else
     {
+      if (overlay_showing_)
+        UBusManager::SendMessage(UBUS_OVERLAY_CLOSE_REQUEST);
+
       WindowManager& wm = WindowManager::Default();
 
       if (wm.IsExpoActive())
@@ -140,6 +145,11 @@
         wm.TerminateScale();
       }
 
+      // This is ugly... But Nux fault!
+      auto const& abs_geo = GetAbsoluteGeometry();
+      guint64 timestamp = nux::GetGraphicsDisplay()->GetCurrentEvent().x11_timestamp;
+      WindowManager::Default().UnGrabMousePointer(timestamp, button, abs_geo.x, abs_geo.y);
+
       Activate(button);
     }
   }

=== modified file 'panel/PanelMenuView.cpp'
--- panel/PanelMenuView.cpp	2015-12-16 15:12:05 +0000
+++ panel/PanelMenuView.cpp	2016-08-30 10:27:02 +0000
@@ -102,7 +102,6 @@
   , ignore_menu_visibility_(false)
   , integrated_menus_(menu_manager_->integrated_menus())
   , always_show_menus_(menu_manager_->always_show_menus())
-  , ignore_leave_events_(false)
   , desktop_name_(get_current_desktop())
 {
   if (ApplicationWindowPtr const& win = ApplicationManager::Default().GetActiveWindow())
@@ -1814,14 +1813,9 @@
   }
 }
 
-void PanelMenuView::IgnoreLeaveEvents(bool ignore)
-{
-  ignore_leave_events_ = ignore;
-}
-
 void PanelMenuView::OnPanelViewMouseLeave(int x, int y, unsigned long mouse_button_state, unsigned long special_keys_state)
 {
-  if (always_show_menus_ || ignore_leave_events_)
+  if (always_show_menus_)
     return;
 
   if (is_inside_)

=== modified file 'panel/PanelMenuView.h'
--- panel/PanelMenuView.h	2015-11-05 14:54:13 +0000
+++ panel/PanelMenuView.h	2016-08-30 10:27:02 +0000
@@ -56,7 +56,6 @@
   bool HasKeyActivableMenus() const;
 
   void NotifyAllMenusClosed();
-  void IgnoreLeaveEvents(bool);
 
   virtual void AddIndicator(indicator::Indicator::Ptr const& indicator);
 
@@ -192,7 +191,6 @@
   bool ignore_menu_visibility_;
   bool integrated_menus_;
   bool always_show_menus_;
-  bool ignore_leave_events_;
 
   nux::Geometry monitor_geo_;
   const std::string desktop_name_;

=== modified file 'panel/PanelView.cpp'
--- panel/PanelView.cpp	2016-08-12 13:57:19 +0000
+++ panel/PanelView.cpp	2016-08-30 10:27:02 +0000
@@ -42,6 +42,7 @@
 namespace
 {
 const RawPixel TRIANGLE_THRESHOLD = 5_em;
+const double SCRUB_VELOCITY_THRESHOLD = 0.05;
 const int refine_gradient_midpoint = 959;
 }
 
@@ -113,10 +114,9 @@
 
   remote_->on_object_added.connect(sigc::mem_fun(this, &PanelView::OnObjectAdded));
   remote_->on_object_removed.connect(sigc::mem_fun(this, &PanelView::OnObjectRemoved));
-  remote_->on_entry_activated.connect(sigc::mem_fun(this, &PanelView::OnEntryActivated));
-  remote_->on_entry_show_menu.connect(sigc::mem_fun(this, &PanelView::OnEntryShowMenu));
   menus->key_activate_entry.connect(sigc::mem_fun(this, &PanelView::ActivateEntry));
   menus->open_first.connect(sigc::mem_fun(this, &PanelView::ActivateFirstSensitive));
+  menus->RegisterTracker(GetPanelName(), sigc::mem_fun(this, &PanelView::OnMenuPointerMoved));
 
   ubus_manager_.RegisterInterest(UBUS_OVERLAY_HIDDEN, sigc::mem_fun(this, &PanelView::OnOverlayHidden));
   ubus_manager_.RegisterInterest(UBUS_OVERLAY_SHOWN, sigc::mem_fun(this, &PanelView::OnOverlayShown));
@@ -627,7 +627,7 @@
   QueueDraw();
 }
 
-void PanelView::OnMenuPointerMoved(int x, int y)
+void PanelView::OnMenuPointerMoved(int x, int y, double speed)
 {
   nux::Geometry const& geo = GetAbsoluteGeometry();
 
@@ -648,116 +648,6 @@
   }
 }
 
-static bool PointInTriangle(nux::Point const& p, nux::Point const& t0, nux::Point const& t1, nux::Point const& t2)
-{
-  int s = t0.y * t2.x - t0.x * t2.y + (t2.y - t0.y) * p.x + (t0.x - t2.x) * p.y;
-  int t = t0.x * t1.y - t0.y * t1.x + (t0.y - t1.y) * p.x + (t1.x - t0.x) * p.y;
-
-  if ((s < 0) != (t < 0))
-    return false;
-
-  int A = -t1.y * t2.x + t0.y * (t2.x - t1.x) + t0.x * (t1.y - t2.y) + t1.x * t2.y;
-  if (A < 0)
-  {
-    s = -s;
-    t = -t;
-    A = -A;
-  }
-
-  return s > 0 && t > 0 && (s + t) < A;
-}
-
-static double GetMouseVelocity(nux::Point const& p0, nux::Point const& p1, util::Timer &timer)
-{
-  int dx, dy;
-  double speed;
-  auto millis = timer.ElapsedMicroSeconds();
-
-  if (millis == 0)
-    return 1;
-
-  dx = p0.x - p1.x;
-  dy = p0.y - p1.y;
-
-  speed = sqrt(dx * dx + dy * dy) / millis * 1000;
-
-  return speed;
-}
-
-bool PanelView::TrackMenuPointer()
-{
-  nux::Point const& mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-  double speed = GetMouseVelocity(mouse, tracked_pointer_pos_, mouse_tracker_timer_);
-
-  mouse_tracker_timer_.Reset();
-  tracked_pointer_pos_ = mouse;
-
-  double scale = Settings::Instance().em(monitor_)->DPIScale();
-  if (speed > 0 && PointInTriangle(mouse,
-                                   nux::Point(triangle_top_corner_.x, std::max(triangle_top_corner_.y - TRIANGLE_THRESHOLD.CP(scale), 0)),
-                                   nux::Point(menu_geo_.x, menu_geo_.y),
-                                   nux::Point(menu_geo_.x + menu_geo_.width, menu_geo_.y)))
-  {
-    return true;
-  }
-
-  if (mouse != triangle_top_corner_)
-  {
-    triangle_top_corner_ = mouse;
-    OnMenuPointerMoved(mouse.x, mouse.y);
-  }
-
-  return true;
-}
-
-void PanelView::OnEntryActivated(std::string const& panel, std::string const& entry_id, nux::Rect const& menu_geo)
-{
-  if (!panel.empty() && panel != GetPanelName())
-    return;
-
-  menu_geo_ = menu_geo;
-
-  bool active = !entry_id.empty();
-  if (active && !track_menu_pointer_timeout_)
-  {
-    //
-    // Track menus being scrubbed at 60Hz (about every 16 millisec)
-    // It might sound ugly, but it's far nicer (and more responsive) than the
-    // code it replaces which used to capture motion events in another process
-    // (unity-panel-service) and send them to us over dbus.
-    // NOTE: The reason why we have to use a timer instead of tracking motion
-    // events is because the motion events will never be delivered to this
-    // process. All the motion events will go to unity-panel-service while
-    // scrubbing because the active panel menu has (needs) the pointer grab.
-    //
-    mouse_tracker_timer_.Reset();
-    triangle_top_corner_ = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-    track_menu_pointer_timeout_.reset(new glib::Timeout(16));
-    track_menu_pointer_timeout_->Run(sigc::mem_fun(this, &PanelView::TrackMenuPointer));
-  }
-  else if (!active)
-  {
-    track_menu_pointer_timeout_.reset();
-    menu_view_->NotifyAllMenusClosed();
-    tracked_pointer_pos_ = {-1, -1};
-  }
-
-  if (overlay_is_open_)
-    ubus_manager_.SendMessage(UBUS_OVERLAY_CLOSE_REQUEST);
-}
-
-void PanelView::OnEntryShowMenu(std::string const& entry_id, unsigned xid,
-                                int x, int y, unsigned button)
-{
-  if (!track_menu_pointer_timeout_)
-  {
-    // This is ugly... But Nux fault!
-    menu_view_->IgnoreLeaveEvents(true);
-    WindowManager::Default().UnGrabMousePointer(CurrentTime, button, x, y);
-    menu_view_->IgnoreLeaveEvents(false);
-  }
-}
-
 bool PanelView::ActivateFirstSensitive()
 {
   if (!IsActive())
@@ -768,7 +658,6 @@
   {
     // Since this only happens on keyboard events, we need to prevent that the
     // pointer tracker would select another entry.
-    tracked_pointer_pos_ = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
     return true;
   }
 
@@ -785,7 +674,6 @@
   {
     // Since this only happens on keyboard events, we need to prevent that the
     // pointer tracker would select another entry.
-    tracked_pointer_pos_ = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
     return true;
   }
 

=== modified file 'panel/PanelView.h'
--- panel/PanelView.h	2016-03-30 18:18:07 +0000
+++ panel/PanelView.h	2016-08-30 10:27:02 +0000
@@ -35,7 +35,6 @@
 #include "unity-shared/Introspectable.h"
 #include "unity-shared/MenuManager.h"
 #include "unity-shared/MockableBaseWindow.h"
-#include "unity-shared/Timer.h"
 #include "PanelMenuView.h"
 #include "PanelTray.h"
 #include "PanelIndicatorsView.h"
@@ -88,9 +87,6 @@
   void OnObjectAdded(indicator::Indicator::Ptr const& proxy);
   void OnObjectRemoved(indicator::Indicator::Ptr const& proxy);
   void OnIndicatorViewUpdated();
-  void OnMenuPointerMoved(int x, int y);
-  void OnEntryActivated(std::string const& panel, std::string const& entry_id, nux::Rect const& geo);
-  void OnEntryShowMenu(std::string const& entry_id, unsigned xid, int x, int y, unsigned button);
 
 private:
   std::string GetPanelName() const;
@@ -100,6 +96,8 @@
   void OnSpreadInitiate();
   void OnSpreadTerminate();
   void OnLowGfxChanged();
+  void OnMenuPointerMoved(int x, int y, double speed);
+  void OnActiveEntryEvent(XEvent const&);
   void EnableOverlayMode(bool);
   void LoadTextures();
 
@@ -109,7 +107,6 @@
   bool IsTransparent();
   void UpdateBackground();
   void ForceUpdateBackground();
-  bool TrackMenuPointer();
   void SyncGeometries();
   void AddPanelView(PanelIndicatorsView* child, unsigned int stretchFactor);
 
@@ -133,10 +130,6 @@
   BaseTexturePtr bg_refine_single_column_tex_;
   std::unique_ptr<nux::AbstractPaintLayer> bg_refine_single_column_layer_;
 
-  std::string active_overlay_;
-  nux::Point  tracked_pointer_pos_, triangle_top_corner_;
-  util::Timer mouse_tracker_timer_;
-
   bool is_dirty_;
   bool opacity_maximized_toggle_;
   bool needs_geo_sync_;
@@ -144,15 +137,13 @@
   float opacity_;
   int monitor_;
   int stored_dash_width_;
-
-  nux::Geometry menu_geo_;
+  std::string active_overlay_;
 
   connection::Manager on_indicator_updated_connections_;
   connection::Manager maximized_opacity_toggle_connections_;
   BackgroundEffectHelper bg_effect_helper_;
   nux::ObjectPtr<nux::IOpenGLBaseTexture> bg_blur_texture_;
   UBusManager ubus_manager_;
-  glib::Source::UniquePtr track_menu_pointer_timeout_;
 };
 
 } // namespace panel

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2016-08-12 11:21:48 +0000
+++ plugins/unityshell/src/unityshell.h	2016-08-30 10:27:02 +0000
@@ -56,6 +56,7 @@
 #include "DashStyle.h"
 #include "EdgeBarrierController.h"
 #include "FavoriteStoreGSettings.h"
+#include "InputMonitor.h"
 #include "ShortcutController.h"
 #include "LauncherController.h"
 #include "LockScreenController.h"
@@ -317,6 +318,7 @@
   internal::FavoriteStoreGSettings favorite_store_;
   ThumbnailGenerator thumbnail_generator_;
   lockscreen::Settings lockscreen_settings_;
+  input::Monitor input_monitor_;
 
   /* The window thread should be the last thing removed, as c++ does it in reverse order */
   std::unique_ptr<nux::WindowThread> wt;

=== modified file 'tests/test_edge_barrier_controller.cpp'
--- tests/test_edge_barrier_controller.cpp	2015-01-15 15:02:24 +0000
+++ tests/test_edge_barrier_controller.cpp	2016-08-30 10:27:02 +0000
@@ -25,6 +25,7 @@
 
 #include "EdgeBarrierController.h"
 #include "EdgeBarrierControllerPrivate.h"
+#include "InputMonitor.h"
 
 using namespace unity;
 using namespace unity::ui;
@@ -108,6 +109,7 @@
 
   TestBarrierSubscriber horizontal_subscribers_[monitors::MAX];
   TestBarrierSubscriber vertical_subscribers_[monitors::MAX];
+  input::Monitor im;
   MockUScreen uscreen;
   EdgeBarrierController bc;
 };

=== modified file 'tests/test_lockscreen_controller.cpp'
--- tests/test_lockscreen_controller.cpp	2016-06-21 14:40:26 +0000
+++ tests/test_lockscreen_controller.cpp	2016-08-30 10:27:02 +0000
@@ -55,7 +55,7 @@
 struct MockShield : BaseShield
 {
   MockShield()
-    : BaseShield(nullptr, nullptr, nullptr, nux::ObjectPtr<AbstractUserPromptView>(), 0, false)
+    : BaseShield(nullptr, nullptr, nux::ObjectPtr<AbstractUserPromptView>(), 0, false)
   {}
 
   MOCK_CONST_METHOD0(IsIndicatorOpen, bool());
@@ -67,7 +67,7 @@
 struct ShieldFactoryMock : ShieldFactoryInterface
 {
   nux::ObjectPtr<BaseShield> CreateShield(session::Manager::Ptr const&,
-                                          indicator::Indicators::Ptr const&,
+                                          menu::Manager::Ptr const&,
                                           Accelerators::Ptr const&,
                                           nux::ObjectPtr<AbstractUserPromptView> const&,
                                           int, bool) override

=== modified file 'tests/test_panel_controller.cpp'
--- tests/test_panel_controller.cpp	2014-03-21 04:40:12 +0000
+++ tests/test_panel_controller.cpp	2016-08-30 10:27:02 +0000
@@ -19,6 +19,7 @@
 
 #include <gmock/gmock.h>
 
+#include "InputMonitor.h"
 #include "PanelController.h"
 #include "PanelStyle.h"
 #include "PanelView.h"
@@ -46,6 +47,7 @@
   menu::MockManager::Ptr menus;
   ui::EdgeBarrierController::Ptr edge_barriers;
   launcher::Options::Ptr options;
+  input::Monitor im;
 };
 
 TEST_F(TestPanelController, Construction)

=== modified file 'tests/test_panel_view.cpp'
--- tests/test_panel_view.cpp	2014-12-12 22:33:24 +0000
+++ tests/test_panel_view.cpp	2016-08-30 10:27:02 +0000
@@ -25,6 +25,7 @@
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/UBusMessages.h"
 #include "unity-shared/UBusWrapper.h"
+ #include "InputMonitor.h"
 
 #include "mock_menu_manager.h"
 #include "test_standalone_wm.h"
@@ -43,6 +44,7 @@
   nux::ObjectPtr<MockableBaseWindow> window_;
   nux::ObjectPtr<PanelView> panel_view_;
   testwrapper::StandaloneWM WM;
+  input::Monitor im;
 
   TestPanelView()
     : window_(new MockableBaseWindow())

=== modified file 'unity-shared/CMakeLists.txt'
--- unity-shared/CMakeLists.txt	2016-08-12 11:21:48 +0000
+++ unity-shared/CMakeLists.txt	2016-08-30 10:27:02 +0000
@@ -82,6 +82,7 @@
   set (UNITY_SHARED_SOURCES
     XKeyboardUtil.cpp
     XWindowManager.cpp
+    InputMonitor.cpp
     ${UNITY_SHARED_SOURCES}
     )
 else()

=== added file 'unity-shared/InputMonitor.cpp'
--- unity-shared/InputMonitor.cpp	1970-01-01 00:00:00 +0000
+++ unity-shared/InputMonitor.cpp	2016-08-30 10:27:02 +0000
@@ -0,0 +1,408 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2014 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: Marco Trevisan <[e-mail]>
+ */
+
+#include "InputMonitor.h"
+#include "SigcSlotHash.h"
+
+#include <Nux/Nux.h>
+#include <NuxCore/Logger.h>
+#include <X11/extensions/XInput2.h>
+#include <UnityCore/GLibSource.h>
+#include <unordered_set>
+#include <gdk/gdkx.h>
+#include <glib.h>
+
+namespace unity
+{
+namespace input
+{
+namespace
+{
+DECLARE_LOGGER(logger, "unity.input.monitor");
+
+Monitor* instance_ = nullptr;
+
+const unsigned XINPUT_MAJOR_VERSION = 2;
+const unsigned XINPUT_MINOR_VERSION = 3;
+
+bool operator&(Events l, Events r)
+{
+  typedef std::underlying_type<Events>::type ut;
+  return static_cast<ut>(static_cast<ut>(l) & static_cast<ut>(r));
+}
+
+Events& operator|=(Events& l, Events r)
+{
+  typedef std::underlying_type<Events>::type ut;
+  return l = static_cast<Events>(static_cast<ut>(l) | static_cast<ut>(r));
+}
+
+template <typename EVENT>
+void initialize_event_common(EVENT* ev, XIDeviceEvent* xiev)
+{
+  ev->serial = xiev->serial;
+  ev->send_event = xiev->send_event;
+  ev->display = xiev->display;
+  ev->window = xiev->event;
+  ev->root = xiev->root;
+  ev->subwindow = xiev->child;
+  ev->time = xiev->time;
+  ev->x = std::round(xiev->event_x);
+  ev->y = std::round(xiev->event_y);
+  ev->x_root = std::round(xiev->root_x);
+  ev->y_root = std::round(xiev->root_y);
+  ev->state = xiev->mods.effective;
+  ev->same_screen = True;
+}
+
+template <typename EVENT_TYPE, typename NATIVE_TYPE>
+void initialize_event(XEvent* ev, NATIVE_TYPE* xiev);
+
+template <>
+void initialize_event<XButtonEvent>(XEvent* ev, XIDeviceEvent* xiev)
+{
+  XButtonEvent* bev = &ev->xbutton;
+  ev->type = (xiev->evtype == XI_ButtonPress) ? ButtonPress : ButtonRelease;
+  initialize_event_common(bev, xiev);
+  bev->button = xiev->detail;
+}
+
+template <>
+void initialize_event<XKeyEvent>(XEvent* ev, XIDeviceEvent* xiev)
+{
+  XKeyEvent* kev = &ev->xkey;
+  ev->type = (xiev->evtype == XI_KeyPress) ? KeyPress : KeyRelease;
+  initialize_event_common(kev, xiev);
+  kev->keycode = xiev->detail;
+}
+
+template <>
+void initialize_event<XMotionEvent>(XEvent* ev, XIDeviceEvent* xiev)
+{
+  XMotionEvent* mev = &ev->xmotion;
+  ev->type = MotionNotify;
+  initialize_event_common(mev, xiev);
+  mev->is_hint = NotifyNormal;
+
+  for (int i = 0; i < xiev->buttons.mask_len * 8; ++i)
+  {
+    if (XIMaskIsSet(xiev->buttons.mask, i))
+    {
+      mev->is_hint = NotifyHint;
+      break;
+    }
+  }
+}
+
+template <>
+void initialize_event<XGenericEventCookie>(XEvent* ev, XIBarrierEvent* xiev)
+{
+  XGenericEventCookie* cev = &ev->xcookie;
+  cev->type = GenericEvent;
+  cev->serial = xiev->serial;
+  cev->send_event = xiev->send_event;
+  cev->display = xiev->display;
+  cev->evtype = xiev->evtype;
+  cev->data = xiev;
+}
+}
+
+struct Monitor::Impl
+{
+  Impl()
+    : xi_opcode_(0)
+    , event_filter_set_(false)
+    , invoking_callbacks_(false)
+  {
+    Display *dpy = gdk_x11_get_default_xdisplay();
+    int event_base, error_base;
+
+    if (XQueryExtension(dpy, "XInputExtension", &xi_opcode_, &event_base, &error_base))
+    {
+      int maj = XINPUT_MAJOR_VERSION;
+      int min = XINPUT_MINOR_VERSION;
+
+      if (XIQueryVersion(dpy, &maj, &min) == BadRequest)
+      {
+        LOG_ERROR(logger) << "Need XInput version "<< maj << "." << min << ", "
+                          << "impossible, to setup an InputMonitor";
+      }
+    }
+    else
+    {
+      LOG_ERROR(logger) << "Missing XInput, impossible to setup an InputMonitor";
+    }
+  }
+
+  ~Impl()
+  {
+    if (event_filter_set_)
+    {
+      pointer_callbacks_.clear();
+      key_callbacks_.clear();
+      barrier_callbacks_.clear();
+      UpdateEventMonitor();
+    }
+  }
+
+  bool RegisterClient(Events type, EventCallback const& cb)
+  {
+    bool added = false;
+
+    if (type & Events::POINTER)
+      added = pointer_callbacks_.insert(cb).second || added;
+
+    if (type & Events::KEYS)
+      added = key_callbacks_.insert(cb).second || added;
+
+    if (type & Events::BARRIER)
+      added = barrier_callbacks_.insert(cb).second || added;
+
+    if (added)
+      UpdateEventMonitor();
+
+    return added;
+  }
+
+  bool UnregisterClient(EventCallback const& cb)
+  {
+    if (invoking_callbacks_)
+    {
+      // Delay the event removal if we're currently invoking a callback
+      // not to break the callbacks loop
+      removal_queue_.insert(cb);
+      return false;
+    }
+
+    bool removed = false;
+    removed = pointer_callbacks_.erase(cb) > 0 || removed;
+    removed = key_callbacks_.erase(cb) > 0 || removed;
+    removed = barrier_callbacks_.erase(cb) > 0 || removed;
+
+    if (removed)
+      UpdateEventMonitor();
+
+    return removed;
+  }
+
+  Events RegisteredEvents(EventCallback const& cb) const
+  {
+    Events events = Events::NONE;
+
+    if (pointer_callbacks_.find(cb) != end(pointer_callbacks_))
+      events |= Events::POINTER;
+
+    if (key_callbacks_.find(cb) != end(key_callbacks_))
+      events |= Events::KEYS;
+
+    if (barrier_callbacks_.find(cb) != end(barrier_callbacks_))
+      events |= Events::BARRIER;
+
+    return events;
+  }
+
+  void UpdateEventMonitor()
+  {
+    auto* dpy = nux::GetGraphicsDisplay()->GetX11Display();
+    Window root = DefaultRootWindow(dpy);
+
+    unsigned char master_dev_bits[XIMaskLen(XI_LASTEVENT)] = { 0 };
+    XIEventMask master_dev = { XIAllMasterDevices, sizeof(master_dev_bits), master_dev_bits };
+
+    if (!barrier_callbacks_.empty())
+    {
+      XISetMask(master_dev.mask, XI_BarrierHit);
+      XISetMask(master_dev.mask, XI_BarrierLeave);
+    }
+
+    unsigned char all_devs_bits[XIMaskLen(XI_LASTEVENT)] = { 0 };
+    XIEventMask all_devs = { XIAllDevices, sizeof(all_devs_bits), all_devs_bits };
+
+    if (!pointer_callbacks_.empty())
+    {
+      XISetMask(all_devs.mask, XI_Motion);
+      XISetMask(all_devs.mask, XI_ButtonPress);
+      XISetMask(all_devs.mask, XI_ButtonRelease);
+    }
+
+    if (!key_callbacks_.empty())
+    {
+      XISetMask(all_devs.mask, XI_KeyPress);
+      XISetMask(all_devs.mask, XI_KeyRelease);
+    }
+
+    XIEventMask selected[] = {master_dev, all_devs};
+    XISelectEvents(dpy, root, selected, G_N_ELEMENTS(selected));
+    XSync(dpy, False);
+
+    if (!pointer_callbacks_.empty() || !key_callbacks_.empty() || !barrier_callbacks_.empty())
+    {
+      if (!event_filter_set_)
+      {
+        nux::GetGraphicsDisplay()->AddEventFilter({[] (XEvent event, void* data) {
+          return static_cast<Impl*>(data)->HandleEvent(event);
+        }, this});
+
+        event_filter_set_ = true;
+      }
+    }
+    else if (event_filter_set_)
+    {
+      nux::GetGraphicsDisplay()->RemoveEventFilter(this);
+      event_filter_set_ = false;
+    }
+  }
+
+  bool HandleEvent(XEvent& event)
+  {
+    bool handled = false;
+
+    if (event.type != GenericEvent || event.xcookie.extension != xi_opcode_)
+      return handled;
+
+    switch (event.xcookie.evtype)
+    {
+      case XI_ButtonPress:
+      case XI_ButtonRelease:
+        handled = InvokeCallbacks<XButtonEvent>(pointer_callbacks_, event);
+        break;
+      case XI_Motion:
+        handled = InvokeCallbacks<XMotionEvent>(pointer_callbacks_, event);
+        break;
+      case XI_KeyPress:
+      case XI_KeyRelease:
+        handled = InvokeCallbacks<XKeyEvent>(key_callbacks_, event);
+        break;
+      case XI_BarrierHit:
+      case XI_BarrierLeave:
+        handled = InvokeCallbacks<XGenericEventCookie, XIBarrierEvent>(barrier_callbacks_, event);
+        break;
+    }
+
+    return handled;
+  }
+
+  template <typename EVENT_TYPE, typename NATIVE_TYPE = XIDeviceEvent>
+  bool InvokeCallbacks(std::unordered_set<EventCallback>& callbacks, XEvent& xiev)
+  {
+    XGenericEventCookie *cookie = &xiev.xcookie;
+
+    if (!XGetEventData(xiev.xany.display, cookie))
+      return false;
+
+    XEvent event;
+    initialize_event<EVENT_TYPE>(&event, reinterpret_cast<NATIVE_TYPE*>(cookie->data));
+    invoking_callbacks_ = true;
+
+    for (auto it = callbacks.begin(); it != callbacks.end();)
+    {
+      if (it->empty())
+      {
+        it = callbacks.erase(it);
+        continue;
+      }
+
+      (*it)(event);
+      ++it;
+    }
+
+    XFreeEventData(xiev.xany.display, cookie);
+    invoking_callbacks_ = false;
+
+    // A callback might unregister itself on the event callback, causing the
+    // above callbacks loop to crash, so in this case we save the event in the
+    // removal queue and eventually we unregistered these callbacks.
+    bool update_event_monitor = false;
+    for (auto it = removal_queue_.begin(); it != removal_queue_.end(); it = removal_queue_.erase(it))
+    {
+      auto const& cb = *it;
+      pointer_callbacks_.erase(cb);
+      key_callbacks_.erase(cb);
+      barrier_callbacks_.erase(cb);
+      update_event_monitor = true;
+    }
+
+    if (callbacks.empty() || update_event_monitor)
+    {
+      idle_removal_.reset(new glib::Idle([this] {
+        UpdateEventMonitor();
+        return false;
+      }));
+
+      return false;
+    }
+
+    return true;
+  }
+
+  int xi_opcode_;
+  bool event_filter_set_;
+  bool invoking_callbacks_;
+  glib::Source::UniquePtr idle_removal_;
+  std::unordered_set<EventCallback> pointer_callbacks_;
+  std::unordered_set<EventCallback> key_callbacks_;
+  std::unordered_set<EventCallback> barrier_callbacks_;
+  std::unordered_set<EventCallback> removal_queue_;
+};
+
+Monitor::Monitor()
+{
+  if (instance_)
+  {
+    LOG_WARN(logger) << "More than one input::Monitor created.";
+    return;
+  }
+
+  instance_ = this;
+  impl_.reset(new Impl());
+}
+
+Monitor::~Monitor()
+{
+  if (this == instance_)
+    instance_ = nullptr;
+}
+
+Monitor& Monitor::Get()
+{
+  if (!instance_)
+  {
+    LOG_ERROR(logger) << "No input::Monitor created yet.";
+  }
+
+  return *instance_;
+}
+
+bool Monitor::RegisterClient(Events events, EventCallback const& cb)
+{
+  return impl_->RegisterClient(events, cb);
+}
+
+bool Monitor::UnregisterClient(EventCallback const& cb)
+{
+  return impl_->UnregisterClient(cb);
+}
+
+Events Monitor::RegisteredEvents(EventCallback const& cb) const
+{
+  return impl_->RegisteredEvents(cb);
+}
+
+} // input namespace
+} // unity namespace

=== added file 'unity-shared/InputMonitor.h'
--- unity-shared/InputMonitor.h	1970-01-01 00:00:00 +0000
+++ unity-shared/InputMonitor.h	2016-08-30 10:27:02 +0000
@@ -0,0 +1,67 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2014 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: Marco Trevisan <[e-mail]>
+ */
+
+#ifndef __UNITY_INPUT_MONITOR__
+#define __UNITY_INPUT_MONITOR__
+
+#include <X11/Xlib.h>
+#include <sigc++/slot.h>
+#include <memory>
+
+namespace unity
+{
+namespace input
+{
+enum class Events : unsigned
+{
+  NONE = 0,
+  POINTER = (1 << 0),
+  KEYS = (1 << 1),
+  BARRIER = (1 << 2),
+  INPUT = POINTER | KEYS,
+  ALL = POINTER | KEYS | BARRIER
+};
+
+class Monitor : public sigc::trackable
+{
+public:
+  typedef sigc::slot<void, XEvent const&> EventCallback;
+
+  static Monitor& Get();
+
+  Monitor();
+  virtual ~Monitor();
+
+  bool RegisterClient(Events, EventCallback const&);
+  bool UnregisterClient(EventCallback const&);
+
+  Events RegisteredEvents(EventCallback const&) const;
+
+private:
+  Monitor(Monitor const&) = delete;
+  Monitor& operator=(Monitor const&) = delete;
+
+  struct Impl;
+  std::unique_ptr<Impl> impl_;
+};
+
+} // input namespace
+} // unity namespace
+
+#endif // __UNITY_INPUT_MONITOR__

=== modified file 'unity-shared/MenuManager.cpp'
--- unity-shared/MenuManager.cpp	2015-10-02 14:02:05 +0000
+++ unity-shared/MenuManager.cpp	2016-08-30 10:27:02 +0000
@@ -21,11 +21,16 @@
 #include <gtk/gtk.h>
 #include <NuxCore/Logger.h>
 #include <UnityCore/GLibSignal.h>
+#include <UnityCore/GLibSource.h>
 #include <UnityCore/GLibWrapper.h>
 #include <UnityCore/DBusIndicators.h>
 #include <unordered_map>
 
 #include "MenuManager.h"
+#include "InputMonitor.h"
+#include "RawPixel.h"
+#include "UnitySettings.h"
+#include "UScreen.h"
 #include "WindowManager.h"
 
 namespace unity
@@ -40,6 +45,10 @@
 const std::string LIM_KEY = "integrated-menus";
 const std::string SHOW_MENUS_NOW_DELAY = "show-menus-now-delay";
 const std::string ALWAYS_SHOW_MENUS_KEY = "always-show-menus";
+
+const RawPixel TRIANGLE_THRESHOLD = 5_em;
+const double SCRUB_VELOCITY_THRESHOLD = 0.05;
+const unsigned MENU_OPEN_MOUSE_WAIT = 150;
 }
 
 using namespace indicator;
@@ -51,6 +60,7 @@
     , indicators_(indicators)
     , key_grabber_(grabber)
     , show_now_window_(0)
+    , last_pointer_time_(0)
     , settings_(g_settings_new(SETTINGS_NAME.c_str()))
   {
     for (auto const& indicator : indicators_->GetIndicators())
@@ -182,9 +192,15 @@
     parent_->key_activate_entry.emit(entry_id);
   }
 
-  void EntryActivated(std::string const&, std::string const&, nux::Rect const& geo)
+  void EntryActivated(std::string const& menubar, std::string const&, nux::Rect const& geo)
   {
     parent_->menu_open = !geo.IsNull();
+
+    if (active_menubar_ != menubar)
+    {
+      active_menubar_ = menubar;
+      UpdateActiveTracker();
+    }
   }
 
   void SetShowNowForWindow(Window xid, bool show)
@@ -231,15 +247,147 @@
     gtk_icon_theme_set_search_path(gtk_icon_theme_get_default(), gicon_paths.data(), gicon_paths.size());
   }
 
+  bool PointInTriangle(nux::Point const& p, nux::Point const& t0, nux::Point const& t1, nux::Point const& t2)
+  {
+    int s = t0.y * t2.x - t0.x * t2.y + (t2.y - t0.y) * p.x + (t0.x - t2.x) * p.y;
+    int t = t0.x * t1.y - t0.y * t1.x + (t0.y - t1.y) * p.x + (t1.x - t0.x) * p.y;
+
+    if ((s < 0) != (t < 0))
+      return false;
+
+    int A = -t1.y * t2.x + t0.y * (t2.x - t1.x) + t0.x * (t1.y - t2.y) + t1.x * t2.y;
+    if (A < 0)
+    {
+      s = -s;
+      t = -t;
+      A = -A;
+    }
+
+    return s > 0 && t > 0 && (s + t) < A;
+  }
+
+  double GetMouseVelocity(nux::Point const& p0, nux::Point const& p1, Time time_delta)
+  {
+    int dx, dy;
+    double speed;
+
+    if (time_delta == 0)
+      return 1;
+
+    dx = p0.x - p1.x;
+    dy = p0.y - p1.y;
+
+    speed = sqrt(dx * dx + dy * dy) / time_delta;
+
+    return speed;
+  }
+
+  void OnActiveEntryEvent(XEvent const& e)
+  {
+    if (e.type != MotionNotify)
+      return;
+
+    auto const& active_entry = indicators_->GetActiveEntry();
+
+    if (!active_entry)
+      return;
+
+    nux::Point mouse(e.xmotion.x_root, e.xmotion.y_root);
+    auto monitor = UScreen::GetDefault()->GetMonitorAtPosition(mouse.x, mouse.y);
+    double scale = Settings::Instance().em(monitor)->DPIScale();
+    double speed = GetMouseVelocity(mouse, tracked_pointer_pos_, e.xmotion.time - last_pointer_time_);
+    auto menu_geo = active_entry->geometry();
+
+    tracked_pointer_pos_ = mouse;
+    last_pointer_time_ = e.xmotion.time;
+
+    if (speed > SCRUB_VELOCITY_THRESHOLD &&
+        PointInTriangle(mouse, {mouse.x, std::max(mouse.y - TRIANGLE_THRESHOLD.CP(scale), 0)},
+                        menu_geo.GetPosition(), {menu_geo.x + menu_geo.width, menu_geo.y}))
+    {
+      pointer_movement_timeout_ = std::make_shared<glib::Timeout>(MENU_OPEN_MOUSE_WAIT, [this, mouse, speed] {
+        if (active_tracker_)
+          active_tracker_(mouse.x, mouse.y, speed);
+
+        return false;
+      });
+
+      return;
+    }
+
+    if (active_tracker_)
+    {
+      pointer_movement_timeout_.reset();
+      active_tracker_(mouse.x, mouse.y, speed);
+    }
+  }
+
+  bool RegisterTracker(std::string const& menubar, PositionTracker const& cb)
+  {
+    auto it = position_trackers_.find(menubar);
+
+    if (it != end(position_trackers_))
+      return false;
+
+    position_trackers_.insert({menubar, cb});
+
+    if (active_menubar_ == menubar)
+      UpdateActiveTracker();
+
+    return true;
+  }
+
+  bool UnregisterTracker(std::string const& menubar, PositionTracker const& cb)
+  {
+    auto it = position_trackers_.find(menubar);
+
+    if (it == end(position_trackers_))
+      return false;
+
+    if (!cb || (cb && it->second == cb))
+    {
+      position_trackers_.erase(it);
+      return true;
+    }
+
+    return false;
+  }
+
+  void UpdateActiveTracker()
+  {
+    auto it = position_trackers_.find(active_menubar_);
+    active_tracker_ = (it != end(position_trackers_)) ? it->second : PositionTracker();
+    pointer_movement_timeout_.reset();
+
+    if (active_tracker_)
+    {
+      if (input::Monitor::Get().RegisterClient(input::Events::POINTER, sigc::mem_fun(this, &Impl::OnActiveEntryEvent)))
+        last_pointer_time_ = 0;
+    }
+    else
+    {
+      input::Monitor::Get().UnregisterClient(sigc::mem_fun(this, &Impl::OnActiveEntryEvent));
+
+      if (it != end(position_trackers_))
+        position_trackers_.erase(it);
+    }
+  }
+
   Manager* parent_;
   Indicators::Ptr indicators_;
   AppmenuIndicator::Ptr appmenu_;
   key::Grabber::Ptr key_grabber_;
   Window show_now_window_;
+  std::string active_menubar_;
+  PositionTracker active_tracker_;
+  nux::Point tracked_pointer_pos_;
+  Time last_pointer_time_;
+  glib::Source::Ptr pointer_movement_timeout_;
   connection::Manager appmenu_connections_;
   connection::Wrapper active_win_conn_;
   glib::Object<GSettings> settings_;
   glib::SignalManager signals_;
+  std::unordered_map<std::string, PositionTracker> position_trackers_;
   std::unordered_map<indicator::Entry::Ptr, uint32_t> entry_actions_;
 };
 
@@ -278,5 +426,16 @@
   return impl_->key_grabber_;
 }
 
+bool Manager::RegisterTracker(std::string const& menubar, PositionTracker const& cb)
+{
+  return impl_->RegisterTracker(menubar, cb);
+}
+
+bool Manager::UnregisterTracker(std::string const& menubar, PositionTracker const& cb)
+{
+  return impl_->UnregisterTracker(menubar, cb);
+}
+
+
 } // menu namespace
 } // unity namespace

=== modified file 'unity-shared/MenuManager.h'
--- unity-shared/MenuManager.h	2015-06-05 14:28:27 +0000
+++ unity-shared/MenuManager.h	2016-08-30 10:27:02 +0000
@@ -67,6 +67,10 @@
 
   key::Grabber::Ptr const& KeyGrabber() const;
 
+  typedef sigc::slot<void, int /*x*/, int /*y*/, double /*speed*/> PositionTracker;
+  bool RegisterTracker(std::string const& menubar, PositionTracker const&);
+  bool UnregisterTracker(std::string const& menubar, PositionTracker const& = PositionTracker());
+
   sigc::signal<void> appmenu_added;
   sigc::signal<void> appmenu_removed;
   sigc::signal<bool>::accumulated<any_true> open_first;

=== added file 'unity-shared/SigcSlotHash.h'
--- unity-shared/SigcSlotHash.h	1970-01-01 00:00:00 +0000
+++ unity-shared/SigcSlotHash.h	2016-08-30 10:27:02 +0000
@@ -0,0 +1,64 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2016 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: Marco Trevisan <[e-mail]>
+ */
+
+#ifndef __UNITY_SIGC_SLOT_HASHER__
+#define __UNITY_SIGC_SLOT_HASHER__
+
+#include <sigc++/slot.h>
+
+namespace std
+{
+
+template<>
+struct hash<sigc::slot_base>
+{
+  size_t operator()(sigc::slot_base const& cb) const
+  {
+    if (cb.rep_)
+      return hash<size_t>()(reinterpret_cast<size_t>(cb.rep_->call_));
+
+    return hash<size_t>()(reinterpret_cast<size_t>(cb.rep_));
+  }
+};
+
+template<>
+struct equal_to<sigc::slot_base>
+{
+  bool operator()(sigc::slot_base const& lhs, sigc::slot_base const& rhs) const
+  {
+    if (!lhs.rep_ || !rhs.rep_)
+      return (lhs.rep_ == rhs.rep_);
+
+    return (lhs.rep_->call_ == rhs.rep_->call_);
+  }
+};
+
+template<class T>
+struct hash
+{
+  size_t operator()(T const& cb) const
+  {
+    static_assert(std::is_base_of<sigc::slot_base, T>::value, "Type is not derived from sigc::slot_base");
+    return hash<sigc::slot_base>()(cb);
+  }
+};
+
+} // std namespace
+
+#endif // __UNITY_SIGC_SLOT_HASHER__

=== modified file 'unity-shared/StandaloneWindowManager.cpp'
--- unity-shared/StandaloneWindowManager.cpp	2015-11-20 11:33:38 +0000
+++ unity-shared/StandaloneWindowManager.cpp	2016-08-30 10:27:02 +0000
@@ -624,6 +624,9 @@
   return std::string();
 }
 
+void StandaloneWindowManager::SetCardinalProperty(Window, Atom, std::vector<long> const&)
+{}
+
 std::vector<long> StandaloneWindowManager::GetCardinalProperty(Window, Atom) const
 {
   return std::vector<long>();

=== modified file 'unity-shared/StandaloneWindowManager.h'
--- unity-shared/StandaloneWindowManager.h	2016-03-18 18:58:26 +0000
+++ unity-shared/StandaloneWindowManager.h	2016-08-30 10:27:02 +0000
@@ -165,6 +165,7 @@
   virtual std::string GetWindowName(Window window_id) const;
   virtual bool IsOnscreenKeyboard(Window window_id) const;
   virtual std::string GetStringProperty(Window window_id, Atom) const;
+  virtual void SetCardinalProperty(Window window_id, Atom, std::vector<long> const&);
   virtual std::vector<long> GetCardinalProperty(Window window_id, Atom) const;
 
   // Mock functions

=== modified file 'unity-shared/WindowManager.h'
--- unity-shared/WindowManager.h	2016-03-18 18:58:26 +0000
+++ unity-shared/WindowManager.h	2016-08-30 10:27:02 +0000
@@ -170,6 +170,7 @@
   virtual bool IsOnscreenKeyboard(Window window_id) const = 0;
 
   virtual std::string GetStringProperty(Window, Atom) const = 0;
+  virtual void SetCardinalProperty(Window, Atom, std::vector<long> const&) = 0;
   virtual std::vector<long> GetCardinalProperty(Window, Atom) const = 0;
 
   virtual Cursor GetCachedCursor(unsigned int cursor_name) const = 0;

=== modified file 'unity-shared/XWindowManager.cpp'
--- unity-shared/XWindowManager.cpp	2015-01-21 15:28:59 +0000
+++ unity-shared/XWindowManager.cpp	2016-08-30 10:27:02 +0000
@@ -123,6 +123,12 @@
   return std::string(val, n_items);
 }
 
+void XWindowManager::SetCardinalProperty(Window window_id, Atom atom, std::vector<long> const& values)
+{
+  XChangeProperty(screen->dpy(), window_id, atom, XA_CARDINAL, 32, PropModeReplace,
+                  (unsigned char *) values.data(), values.size());
+}
+
 std::vector<long> XWindowManager::GetCardinalProperty(Window window_id, Atom atom) const
 {
   Atom type;

=== modified file 'unity-shared/XWindowManager.h'
--- unity-shared/XWindowManager.h	2015-01-21 15:28:59 +0000
+++ unity-shared/XWindowManager.h	2016-08-30 10:27:02 +0000
@@ -36,6 +36,7 @@
   std::string GetWindowName(Window window_id) const;
   bool IsOnscreenKeyboard(Window window_id) const;
   std::string GetStringProperty(Window window_id, Atom atom) const;
+  void SetCardinalProperty(Window, Atom, std::vector<long> const&);
   std::vector<long> GetCardinalProperty(Window, Atom) const;
 };