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

[Andrea Azzarone (azzar1)]

+1

review: Approve

=== modified file 'decorations/DecoratedWindow.cpp'
--- decorations/DecoratedWindow.cpp	2016-08-06 16:24:45 +0000
+++ decorations/DecoratedWindow.cpp	2016-09-01 22:11:45 +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	2016-09-01 22:11:44 +0000
+++ decorations/DecorationsMenuLayout.cpp	2016-09-01 22:11:45 +0000
@@ -20,12 +20,15 @@
 #include "DecorationsMenuLayout.h"
 #include "DecorationsMenuEntry.h"
 #include "DecorationsMenuDropdown.h"
-#include "InputMonitor.h"
 
 namespace unity
 {
 namespace decoration
 {
+namespace
+{
+const std::string MENUS_PANEL_NAME = "WindowLIM";
+}
 
 using namespace indicator;
 
@@ -35,6 +38,7 @@
   , menu_manager_(menu)
   , win_(win)
   , 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;
@@ -169,21 +178,16 @@
 
   if (active && items_.size() > 1)
   {
-    auto const& event_cb = sigc::mem_fun(this, &MenuLayout::OnEntryInputEvent);
-    input::Monitor::Get().RegisterClient(input::Events::POINTER, event_cb);
+    menu_manager_->RegisterTracker(menubar_id_, (sigc::track_obj([this] (int x, int y, double speed) {
+      ActivateMenu(CompPoint(x, y));
+    }, *this)));
   }
   else if (!active)
   {
-    input::Monitor::Get().UnregisterClient(sigc::mem_fun(this, &MenuLayout::OnEntryInputEvent));
+    menu_manager_->UnregisterTracker(menubar_id_);
   }
 }
 
-void MenuLayout::OnEntryInputEvent(XEvent const& e)
-{
-  if (e.type == MotionNotify)
-    ActivateMenu(CompPoint(e.xmotion.x_root, e.xmotion.y_root));
-}
-
 void MenuLayout::ChildrenGeometries(EntryLocationMap& map) const
 {
   for (auto const& item : items_)
 
=== modified file 'decorations/DecorationsMenuLayout.h'
--- decorations/DecorationsMenuLayout.h	2016-09-01 22:11:44 +0000
+++ decorations/DecorationsMenuLayout.h	2016-09-01 22:11:45 +0000
@@ -44,6 +44,7 @@
   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;
@@ -53,12 +54,12 @@
   void OnEntryMouseOwnershipChanged(bool);
   void OnEntryActiveChanged(bool);
   void OnEntryShowNowChanged(bool);
-  void OnEntryInputEvent(XEvent const&);
 
   menu::Manager::Ptr menu_manager_;
   CompWindow* win_;
   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-09-01 22:11:45 +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 'lockscreen/KylinLockScreenShield.cpp'
--- lockscreen/KylinLockScreenShield.cpp	2015-12-07 03:09:28 +0000
+++ lockscreen/KylinLockScreenShield.cpp	2016-09-01 22:11:45 +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-09-01 22:11:45 +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-09-01 22:11:45 +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-09-01 22:11:45 +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-09-01 22:11:45 +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	2016-09-01 22:11:44 +0000
+++ lockscreen/LockScreenPanel.cpp	2016-09-01 22:11:45 +0000
@@ -44,11 +44,11 @@
 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();
@@ -72,14 +72,19 @@
   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();
@@ -159,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)
@@ -178,33 +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()));
   }
 
-  auto& im = input::Monitor::Get();
-  auto const& event_cb = sigc::mem_fun(this, &Panel::OnEntryEvent);
-
-  if (active)
-  {
-    if (im.RegisterClient(input::Events::POINTER, event_cb))
-      indicators_view_->ActivateEntry(entry_id);
-  }
-  else
-  {
-    im.UnregisterClient(event_cb);
-    this->active = active;
-  }
-}
-
-void Panel::OnEntryEvent(XEvent const& e)
-{
-  if (e.type == MotionNotify && GetAbsoluteGeometry().IsPointInside(e.xmotion.x, e.xmotion.y))
-    indicators_view_->ActivateEntryAt(e.xmotion.x, e.xmotion.y);
+  if (!valid_entry)
+    active = valid_entry;
 }
 
 void Panel::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
@@ -228,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-09-01 22:11:44 +0000
+++ lockscreen/LockScreenPanel.h	2016-09-01 22:11:45 +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,15 +55,14 @@
   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 OnEntryEvent(XEvent const&);
 
   void UpdateSize();
   std::string GetPanelName() const;
 
-  indicator::Indicators::Ptr indicators_;
+  menu::Manager::Ptr menu_manager_;
   panel::PanelIndicatorsView* indicators_view_;
   bool needs_geo_sync_;
 };
 
=== modified file 'lockscreen/LockScreenShield.cpp'
--- lockscreen/LockScreenShield.cpp	2015-12-03 14:13:10 +0000
+++ lockscreen/LockScreenShield.cpp	2016-09-01 22:11:45 +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-09-01 22:11:45 +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-09-01 22:11:45 +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-09-01 22:11:45 +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-09-01 22:11:45 +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-09-01 22:11:45 +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-09-01 22:11:45 +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-09-01 22:11:44 +0000
+++ panel/PanelView.cpp	2016-09-01 22:11:45 +0000
@@ -23,7 +23,6 @@
 
 #include <UnityCore/GLibWrapper.h>
 
-#include "unity-shared/InputMonitor.h"
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/RawPixel.h"
 #include "unity-shared/TextureCache.h"
@@ -54,7 +53,6 @@
   : View(NUX_FILE_LINE_PARAM)
   , parent_(parent)
   , remote_(menus->Indicators())
-  , last_pointer_time_(0)
   , is_dirty_(true)
   , opacity_maximized_toggle_(false)
   , needs_geo_sync_(false)
@@ -116,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));
@@ -630,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();
 
@@ -651,106 +648,6 @@
   }
 }
 
-namespace
-{
-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;
-}
-} // anonymous namespace
-
-void PanelView::OnActiveEntryEvent(XEvent const& e)
-{
-  if (e.type != MotionNotify)
-    return;
-
-  double scale = Settings::Instance().em(monitor_)->DPIScale();
-  nux::Point mouse(e.xmotion.x_root, e.xmotion.y_root);
-  double speed = GetMouseVelocity(mouse, tracked_pointer_pos_, e.xmotion.time - last_pointer_time_);
-
-  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}))
-  {
-    return;
-  }
-
-  OnMenuPointerMoved(mouse.x, mouse.y);
-}
-
-void PanelView::OnEntryActivated(std::string const& panel, std::string const& entry_id, nux::Rect const& menu_geo)
-{
-  if (!panel.empty() && panel != GetPanelName())
-    return;
-
-  bool active = !entry_id.empty();
-  auto const& activation_cb = sigc::mem_fun(this, &PanelView::OnActiveEntryEvent);
-  menu_geo_ = menu_geo;
-
-  if (active)
-  {
-    auto& im = input::Monitor::Get();
-    if (im.RegisterClient(input::Events::POINTER, activation_cb))
-    {
-      last_pointer_time_ = 0;
-      ActivateEntry(entry_id);
-    }
-
-    if (overlay_is_open_)
-      ubus_manager_.SendMessage(UBUS_OVERLAY_CLOSE_REQUEST);
-  }
-  else
-  {
-    input::Monitor::Get().UnregisterClient(activation_cb);
-    menu_view_->NotifyAllMenusClosed();
-  }
-}
-
-void PanelView::OnEntryShowMenu(std::string const& entry_id, unsigned xid,
-                                int x, int y, unsigned button)
-{
-  if (menu_geo_.IsNull())
-  {
-    // 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())
 
=== modified file 'panel/PanelView.h'
--- panel/PanelView.h	2016-09-01 22:11:44 +0000
+++ panel/PanelView.h	2016-09-01 22:11:45 +0000
@@ -87,8 +87,6 @@
   void OnObjectAdded(indicator::Indicator::Ptr const& proxy);
   void OnObjectRemoved(indicator::Indicator::Ptr const& proxy);
   void OnIndicatorViewUpdated();
-  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;
@@ -98,7 +96,7 @@
   void OnSpreadInitiate();
   void OnSpreadTerminate();
   void OnLowGfxChanged();
-  void OnMenuPointerMoved(int x, int y);
+  void OnMenuPointerMoved(int x, int y, double speed);
   void OnActiveEntryEvent(XEvent const&);
   void EnableOverlayMode(bool);
   void LoadTextures();
@@ -132,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_;
-  Time last_pointer_time_;
-
   bool is_dirty_;
   bool opacity_maximized_toggle_;
   bool needs_geo_sync_;
@@ -143,8 +137,7 @@
   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_;
 
=== 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-09-01 22:11:45 +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 'unity-shared/InputMonitor.cpp'
--- unity-shared/InputMonitor.cpp	2016-09-01 22:11:44 +0000
+++ unity-shared/InputMonitor.cpp	2016-09-01 22:11:45 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "InputMonitor.h"
+#include "SigcSlotHash.h"
 
 #include <Nux/Nux.h>
 #include <NuxCore/Logger.h>
@@ -46,6 +47,12 @@
   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)
 {
@@ -118,6 +125,12 @@
 
 struct Monitor::Impl
 {
+#if __GNUC__ < 6
+  using EventCallbackSet = std::unordered_set<EventCallback>;
+#else
+  using EventCallbackSet = std::unordered_set<EventCallback, std::hash<sigc::slot_base>>;
+#endif
+
   Impl()
     : xi_opcode_(0)
     , event_filter_set_(false)
@@ -194,6 +207,22 @@
     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();
@@ -276,7 +305,7 @@
   }
 
   template <typename EVENT_TYPE, typename NATIVE_TYPE = XIDeviceEvent>
-  bool InvokeCallbacks(std::unordered_set<EventCallback>& callbacks, XEvent& xiev)
+  bool InvokeCallbacks(EventCallbackSet& callbacks, XEvent& xiev)
   {
     XGenericEventCookie *cookie = &xiev.xcookie;
 
@@ -332,10 +361,10 @@
   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_;
+  EventCallbackSet pointer_callbacks_;
+  EventCallbackSet key_callbacks_;
+  EventCallbackSet barrier_callbacks_;
+  EventCallbackSet removal_queue_;
 };
 
 Monitor::Monitor()
@@ -376,5 +405,10 @@
   return impl_->UnregisterClient(cb);
 }
 
+Events Monitor::RegisteredEvents(EventCallback const& cb) const
+{
+  return impl_->RegisteredEvents(cb);
+}
+
 } // input namespace
 } // unity namespace
 
=== modified file 'unity-shared/InputMonitor.h'
--- unity-shared/InputMonitor.h	2016-09-01 22:11:44 +0000
+++ unity-shared/InputMonitor.h	2016-09-01 22:11:45 +0000
@@ -30,6 +30,7 @@
 {
 enum class Events : unsigned
 {
+  NONE = 0,
   POINTER = (1 << 0),
   KEYS = (1 << 1),
   BARRIER = (1 << 2),
@@ -50,6 +51,8 @@
   bool RegisterClient(Events, EventCallback const&);
   bool UnregisterClient(EventCallback const&);
 
+  Events RegisteredEvents(EventCallback const&) const;
+
 private:
   Monitor(Monitor const&) = delete;
   Monitor& operator=(Monitor const&) = delete;
@@ -61,31 +64,4 @@
 } // input namespace
 } // unity namespace
 
-namespace std
-{
-template<>
-struct hash<unity::input::Monitor::EventCallback>
-{
-  size_t operator()(unity::input::Monitor::EventCallback const& cb) const
-  {
-    if (cb.rep_)
-      return std::hash<size_t>()(reinterpret_cast<size_t>(cb.rep_->call_));
-
-    return std::hash<size_t>()(reinterpret_cast<size_t>(cb.rep_));
-  }
-};
-
-template<>
-struct equal_to<unity::input::Monitor::EventCallback>
-{
-  bool operator()(unity::input::Monitor::EventCallback const& lhs, unity::input::Monitor::EventCallback const& rhs) const
-  {
-    if (!lhs.rep_ || !rhs.rep_)
-      return (lhs.rep_ == rhs.rep_);
-
-    return (lhs.rep_->call_ == rhs.rep_->call_);
-  }
-};
-} // std 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-09-01 22:11:45 +0000
@@ -21,11 +21,17 @@
 #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 "SigcSlotHash.h"
+#include "UnitySettings.h"
+#include "UScreen.h"
 #include "WindowManager.h"
 
 namespace unity
@@ -40,6 +46,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 +61,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 +193,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 +248,148 @@
     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);
+      UpdateActiveTracker();
+      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 +428,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-09-01 22:11:45 +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-09-01 22:11:45 +0000
@@ -0,0 +1,70 @@
+// -*- 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 sigc
+{
+inline bool operator==(slot_base const& lhs, slot_base const& rhs)
+{
+  if (!lhs.rep_ || !rhs.rep_)
+    return (lhs.rep_ == rhs.rep_);
+
+  return (lhs.rep_->call_ == rhs.rep_->call_);
+}
+
+inline bool operator!=(slot_base const& lhs, slot_base const& rhs)
+{
+  return !(lhs == rhs);
+}
+} // sigc namespace
+
+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_));
+  }
+};
+
+#if __GNUC__ < 6
+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);
+  }
+};
+#endif
+
+} // std namespace
+
+#endif // __UNITY_SIGC_SLOT_HASHER__