Merge lp:~3v1n0/unity/lim-everywhere into lp:unity

[Marco Trevisan (Treviño)]

Decorations, Panel: add menus for unfocused windows as well

Now the indicator-appmenu exports the menus for all the windows,
then it's up to us to filter them based on their parent window and
show on relevant place.
Also, set LIM as default now.

This depends on lp:~3v1n0/indicator-appmenu/all-menus-mode/+merge/248064

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3957
http://jenkins.qa.ubuntu.com/job/unity-ci/1144/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/31/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/31/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/31/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3961
http://jenkins.qa.ubuntu.com/job/unity-ci/1145/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/32/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/32/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/32/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3965
http://jenkins.qa.ubuntu.com/job/unity-ci/1146/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/33
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/33
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/33

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

review: Approve (continuous-integration)

[Andrea Azzarone (azzar1)]

+1 for me as discussed over irc.

review: Approve

[Stephen M. Webb (bregma)]

AP tests need fixing, see inline comments.

review: Needs Fixing

[Marco Trevisan (Treviño) (3v1n0)]

fixed

[Stephen M. Webb (bregma)]

review: Approve

=== modified file 'UnityCore/AppmenuIndicator.cpp'
--- UnityCore/AppmenuIndicator.cpp	2014-12-18 19:30:05 +0000
+++ UnityCore/AppmenuIndicator.cpp	2015-02-19 19:24:14 +0000
@@ -17,41 +17,81 @@
  * Authored by: Marco Trevisan (Treviño) <[e-mail]>
  */
 
-#include "GLibSource.h"
+#include <unordered_set>
+
 #include "AppmenuIndicator.h"
+#include "ConnectionManager.h"
 
 namespace unity
 {
 namespace indicator
 {
+namespace
+{
+const Indicator::Entries empty_entries_;
+}
 
 struct AppmenuIndicator::Impl
 {
   Impl(AppmenuIndicator* parent)
   {
-    // When the active window has changed we might need to emit an updated signal
-    parent->active_window.changed.connect([this, parent] (unsigned long) {
-      update_wait_.reset(new glib::Timeout(250, [parent] {
-        parent->updated.emit();
-        return false;
-      }));
-    });
-
-    parent->updated.connect([this] { update_wait_.reset(); });
+    connections_.Add(parent->on_entry_added.connect([this] (Entry::Ptr const& entry) {
+      window_entries_[entry->parent_window()].push_back(entry);
+    }));
+
+    connections_.Add(parent->on_entry_removed.connect([this] (Entry::Ptr const& entry) {
+      auto it = window_entries_.find(entry->parent_window());
+
+      if (it != window_entries_.end())
+      {
+        auto& entries = it->second;
+        entries.erase(std::remove(entries.begin(), entries.end(), entry), entries.end());
+
+        if (entries.empty())
+          window_entries_.erase(it);
+      }
+    }));
   }
 
-  glib::Source::UniquePtr update_wait_;
+  connection::Manager connections_;
+  std::unordered_map<uint32_t, Indicator::Entries> window_entries_;
 };
 
 AppmenuIndicator::AppmenuIndicator(std::string const& name)
   : Indicator(name)
-  , active_window(0)
   , impl_(new AppmenuIndicator::Impl(this))
 {}
 
 AppmenuIndicator::~AppmenuIndicator()
 {}
 
+void AppmenuIndicator::Sync(Indicator::Entries const& entries)
+{
+  std::unordered_set<uint32_t> changed_windows;
+  connection::Wrapper added_conn(on_entry_added.connect([this, &changed_windows] (Entry::Ptr const& entry) {
+    changed_windows.insert(entry->parent_window());
+  }));
+
+  connection::Wrapper rm_conn(on_entry_removed.connect([this, &changed_windows] (Entry::Ptr const& entry) {
+    changed_windows.insert(entry->parent_window());
+  }));
+
+  Indicator::Sync(entries);
+
+  for (uint32_t win : changed_windows)
+    updated_win.emit(win);
+}
+
+Indicator::Entries const& AppmenuIndicator::GetEntriesForWindow(uint32_t parent_window) const
+{
+  auto it = impl_->window_entries_.find(parent_window);
+
+  if (it != impl_->window_entries_.end())
+    return it->second;
+
+  return empty_entries_;
+}
+
 void AppmenuIndicator::ShowAppmenu(unsigned int xid, int x, int y) const
 {
   on_show_appmenu.emit(xid, x, y);
 
=== modified file 'UnityCore/AppmenuIndicator.h'
--- UnityCore/AppmenuIndicator.h	2014-12-18 18:46:29 +0000
+++ UnityCore/AppmenuIndicator.h	2015-02-19 19:24:14 +0000
@@ -36,12 +36,13 @@
   AppmenuIndicator(std::string const& name);
   ~AppmenuIndicator();
 
-  nux::Property<unsigned> active_window;
-
-  virtual bool IsAppmenu() const { return true; }
+  bool IsAppmenu() const override { return true; }
+  void Sync(Entries const&) override;
+  Entries const& GetEntriesForWindow(uint32_t parent_window) const;
 
   void ShowAppmenu(unsigned xid, int x, int y) const;
 
+  sigc::signal<void, uint32_t> updated_win;
   sigc::signal<void, unsigned, int, int> on_show_appmenu;
 
 private:
 
=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2014-02-05 11:38:22 +0000
+++ UnityCore/CMakeLists.txt	2015-02-19 19:24:14 +0000
@@ -117,6 +117,7 @@
 #
 include_directories(${CORE_DEPS_INCLUDE_DIRS})
 include_directories(${CMAKE_BINARY_DIR})
+include_directories(..)
 
 set (LIBS ${CORE_DEPS_LDFLAGS} ${PRIVATE_CORE_DEPS_LDFLAGS})
 
 
=== modified file 'UnityCore/DBusIndicators.cpp'
--- UnityCore/DBusIndicators.cpp	2014-09-19 18:48:04 +0000
+++ UnityCore/DBusIndicators.cpp	2015-02-19 19:24:14 +0000
@@ -27,19 +27,29 @@
 #include "GLibSource.h"
 #include "Variant.h"
 #include "DBusIndicators.h"
+#include "services/panel-service-private.h"
 
 namespace unity
 {
 namespace indicator
 {
+
+namespace
+{
 DECLARE_LOGGER(logger, "unity.indicator.dbus");
 
-namespace
+inline bool verify_variant_type(GVariant* value, const gchar* type)
 {
-const std::string SERVICE_NAME_DESKTOP("com.canonical.Unity.Panel.Service.Desktop");
-const std::string SERVICE_NAME_LOCKSCREEN("com.canonical.Unity.Panel.Service.LockScreen");
-const std::string SERVICE_PATH("/com/canonical/Unity/Panel/Service");
-const std::string SERVICE_IFACE("com.canonical.Unity.Panel.Service");
+  if (!g_variant_is_of_type (value, G_VARIANT_TYPE(type)))
+  {
+    LOG_ERROR(logger) << "Got invalid variant type: '"
+                      << g_variant_get_type_string(value) << "' ('"
+                      << type << "' was expected)";
+    return false;
+  }
+
+  return true;
+}
 } // anonymous namespace
 
 
@@ -78,15 +88,15 @@
   glib::Source::UniquePtr show_entry_idle_;
   glib::Source::UniquePtr show_appmenu_idle_;
   std::vector<std::string> icon_paths_;
-  std::map<std::string, EntryLocationMap> cached_locations_;
+  std::unordered_map<std::string, EntryLocationMap> cached_locations_;
 };
 
 
 // Public Methods
 DBusIndicators::Impl::Impl(std::string const& dbus_name, DBusIndicators* owner)
   : owner_(owner)
-  , gproxy_(dbus_name, SERVICE_PATH, SERVICE_IFACE,
-            G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES)
+  , gproxy_(dbus_name, UPS_PATH, UPS_IFACE, G_BUS_TYPE_SESSION,
+            G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES)
 {
   gproxy_.Connect("ReSync", sigc::mem_fun(this, &DBusIndicators::Impl::OnReSync));
   gproxy_.Connect("IconPathsChanged", sigc::mem_fun(this, &DBusIndicators::Impl::OnIconsPathChanged));
@@ -208,6 +218,9 @@
 
 void DBusIndicators::Impl::OnEntryActivated(GVariant* parameters)
 {
+  if (!verify_variant_type(parameters, "(ss(iiuu))"))
+    return;
+
   glib::String panel;
   glib::String entry_id;
   nux::Rect geo;
@@ -219,6 +232,9 @@
 
 void DBusIndicators::Impl::OnEntryActivatedRequest(GVariant* parameters)
 {
+  if (!verify_variant_type(parameters, "(s)"))
+    return;
+
   glib::String entry_name;
   g_variant_get(parameters, "(s)", &entry_name);
 
@@ -228,6 +244,9 @@
 
 void DBusIndicators::Impl::OnEntryShowNowChanged(GVariant* parameters)
 {
+  if (!verify_variant_type(parameters, "(sb)"))
+    return;
+
   glib::String entry_name;
   gboolean show_now;
   g_variant_get(parameters, "(sb)", &entry_name, &show_now);
@@ -325,9 +344,10 @@
     return;
 
   GVariantIter* iter            = nullptr;
-  gchar*        name_hint       = nullptr;
   gchar*        indicator_id    = nullptr;
   gchar*        entry_id        = nullptr;
+  gchar*        name_hint       = nullptr;
+  guint32       parent_window   = 0;
   gchar*        label           = nullptr;
   gboolean      label_sensitive = false;
   gboolean      label_visible   = false;
@@ -337,15 +357,17 @@
   gboolean      image_visible   = false;
   gint32        priority        = -1;
 
-  std::map<Indicator::Ptr, Indicator::Entries> indicators;
-  int wanted_idx = 0;
-  bool any_different_idx = false;
-
-  g_variant_get(args, "(a(ssssbbusbbi))", &iter);
-  while (g_variant_iter_loop(iter, "(ssssbbusbbi)",
+  if (!verify_variant_type(args, "(" ENTRY_ARRAY_SIGNATURE ")"))
+    return;
+
+  std::unordered_map<Indicator::Ptr, Indicator::Entries> indicators;
+
+  g_variant_get(args, "(" ENTRY_ARRAY_SIGNATURE ")", &iter);
+  while (g_variant_iter_loop(iter, ENTRY_SIGNATURE,
                              &indicator_id,
                              &entry_id,
                              &name_hint,
+                             &parent_window,
                              &label,
                              &label_sensitive,
                              &label_visible,
@@ -369,27 +391,20 @@
     // Empty entries are empty indicators.
     if (!entry.empty())
     {
-      Entry::Ptr e;
-      if (!any_different_idx)
-      {
-        // Indicators can only add or remove entries, so if
-        // there is a index change we can't reuse the existing ones
-        // after that index
-        if (indicator->EntryIndex(entry_id) == wanted_idx)
-        {
-          e = indicator->GetEntry(entry_id);
-        }
-        else
-        {
-          any_different_idx = true;
-        }
-      }
+      Entry::Ptr e = indicator->GetEntry(entry_id);
+      int old_priority = e ? e->priority() : -1;
+
+      // Indicators can only add or remove entries, so if
+      // there is a priority change we can't reuse the existing ones
+      if (old_priority != priority)
+        e.reset();
 
       if (!e)
       {
-        e = std::make_shared<Entry>(entry, name_hint, label, label_sensitive,
-                                    label_visible, image_type, image_data,
-                                    image_sensitive, image_visible, priority);
+        e = std::make_shared<Entry>(entry, name_hint, parent_window,
+                                    label, label_sensitive, label_visible,
+                                    image_type, image_data, image_sensitive, image_visible,
+                                    priority);
       }
       else
       {
@@ -399,15 +414,12 @@
       }
 
       entries.push_back(e);
-      ++wanted_idx;
     }
   }
   g_variant_iter_free(iter);
 
-  for (auto i = indicators.begin(), end = indicators.end(); i != end; ++i)
-  {
-    i->first->Sync(indicators[i->first]);
-  }
+  for (auto const& i : indicators)
+    i.first->Sync(i.second);
 }
 
 void DBusIndicators::Impl::SyncGeometries(std::string const& name,
@@ -463,7 +475,7 @@
 }
 
 DBusIndicators::DBusIndicators()
-  : pimpl(new Impl(SERVICE_NAME_DESKTOP, this))
+  : pimpl(new Impl(UPS_NAME_DESKTOP, this))
 {}
 
 DBusIndicators::DBusIndicators(std::string const& dbus_name)
@@ -471,7 +483,7 @@
 {}
 
 LockScreenDBusIndicators::LockScreenDBusIndicators()
-  : DBusIndicators(SERVICE_NAME_LOCKSCREEN)
+  : DBusIndicators(UPS_NAME_LOCKSCREEN)
 {}
 
 DBusIndicators::~DBusIndicators()
 
=== modified file 'UnityCore/GLibDBusServer.cpp'
--- UnityCore/GLibDBusServer.cpp	2014-04-09 13:19:33 +0000
+++ UnityCore/GLibDBusServer.cpp	2015-02-19 19:24:14 +0000
@@ -17,6 +17,7 @@
 * Authored by: Marco Trevisan (Treviño) <[e-mail]>
 */
 
+#include <unordered_map>
 #include <NuxCore/Logger.h>
 
 #include "GLibDBusServer.h"
@@ -406,8 +407,8 @@
 
   GDBusInterfaceVTable interface_vtable_;
   std::shared_ptr<GDBusInterfaceInfo> interface_info_;
-  std::map<guint, std::string> registrations_;
-  std::map<std::string, glib::Object<GDBusConnection>> connection_by_path_;
+  std::unordered_map<guint, std::string> registrations_;
+  std::unordered_map<std::string, glib::Object<GDBusConnection>> connection_by_path_;
 };
 
 DBusObject::DBusObject(std::string const& introspection_xml, std::string const& interface_name)
 
=== modified file 'UnityCore/GLibSource.h'
--- UnityCore/GLibSource.h	2013-10-10 09:47:24 +0000
+++ UnityCore/GLibSource.h	2015-02-19 19:24:14 +0000
@@ -24,7 +24,7 @@
 #include <sigc++/sigc++.h>
 #include <glib.h>
 #include <memory>
-#include <map>
+#include <unordered_map>
 
 namespace unity
 {
@@ -223,7 +223,7 @@
   Source::Ptr GetSource(unsigned int id) const;
 
 protected: // For testing purposes
-  typedef std::map<std::string, Source::Ptr> SourcesMap;
+  typedef std::unordered_map<std::string, Source::Ptr> SourcesMap;
   SourcesMap sources_;
 
 private:
 
=== modified file 'UnityCore/Indicator.cpp'
--- UnityCore/Indicator.cpp	2014-01-27 17:31:30 +0000
+++ UnityCore/Indicator.cpp	2015-02-19 19:24:14 +0000
@@ -36,7 +36,7 @@
 Indicator::~Indicator()
 {
   for (auto const& entry : entries_)
-    on_entry_removed.emit(entry->id());
+    on_entry_removed.emit(entry);
 }
 
 std::string const& Indicator::name() const
@@ -51,23 +51,23 @@
 
 void Indicator::Sync(Indicator::Entries const& new_entries)
 {
-  bool added = false;
-  Entries to_rm;
+  bool changed = false;
 
-  if (!entries_.empty())
+  for (auto it = entries_.begin(); it != entries_.end();)
   {
-    for (auto const& entry : entries_)
+    auto entry = *it;
+
+    if (std::find(new_entries.begin(), new_entries.end(), entry) == new_entries.end())
     {
-      if (std::find(new_entries.begin(), new_entries.end(), entry) == new_entries.end())
-        to_rm.push_back(entry);
+      auto entry_id = entry->id();
+      entries_connections_.erase(entry);
+      it = entries_.erase(it);
+      on_entry_removed.emit(entry);
+      changed = true;
+      continue;
     }
-  }
 
-  for (auto const& entry : to_rm)
-  {
-    entries_connections_.erase(entry);
-    on_entry_removed.emit(entry->id());
-    entries_.remove(entry);
+    ++it;
   }
 
   for (auto const& new_entry : new_entries)
@@ -93,10 +93,10 @@
     entries_.push_back(new_entry);
     on_entry_added.emit(new_entry);
 
-    added = true;
+    changed = true;
   }
 
-  if (!to_rm.empty() || added)
+  if (changed)
     updated.emit();
 }
 
@@ -109,21 +109,6 @@
   return Entry::Ptr();
 }
 
-int Indicator::EntryIndex(std::string const& entry_id) const
-{
-  int i = 0;
-  for (auto const& entry : entries_)
-  {
-    if (entry->id() == entry_id)
-    {
-      return i;
-    }
-    ++i;
-  }
-
-  return -1;
-}
-
 std::ostream& operator<<(std::ostream& out, Indicator const& i)
 {
   out << "<Indicator " << i.name() << std::endl;
 
=== modified file 'UnityCore/Indicator.h'
--- UnityCore/Indicator.h	2014-02-05 17:16:41 +0000
+++ UnityCore/Indicator.h	2015-02-19 19:24:14 +0000
@@ -38,7 +38,7 @@
 {
 public:
   typedef std::shared_ptr<Indicator> Ptr;
-  typedef std::list<Entry::Ptr> Entries;
+  typedef std::vector<Entry::Ptr> Entries;
 
   Indicator(std::string const& name);
   virtual ~Indicator();
@@ -47,15 +47,14 @@
 
   virtual bool IsAppmenu() const { return false; }
 
-  void Sync(Entries const& new_entries);
+  virtual void Sync(Entries const&);
   Entry::Ptr GetEntry(std::string const& entry_id) const;
-  int EntryIndex(std::string const& entry_id) const;
   Entries const& GetEntries() const;
 
   // Signals
   sigc::signal<void> updated;
   sigc::signal<void, Entry::Ptr const&> on_entry_added;
-  sigc::signal<void, std::string const&> on_entry_removed;
+  sigc::signal<void, Entry::Ptr const&> on_entry_removed;
   sigc::signal<void, std::string const&, unsigned, int, int, unsigned> on_show_menu;
   sigc::signal<void, std::string const&> on_secondary_activate;
   sigc::signal<void, std::string const&, int> on_scroll;
 
=== modified file 'UnityCore/IndicatorEntry.cpp'
--- UnityCore/IndicatorEntry.cpp	2014-02-07 23:54:15 +0000
+++ UnityCore/IndicatorEntry.cpp	2015-02-19 19:24:14 +0000
@@ -30,6 +30,7 @@
 
 Entry::Entry(std::string const& id,
              std::string const& name_hint,
+             uint32_t parent_window,
              std::string const& label,
              bool label_sensitive,
              bool label_visible,
@@ -40,6 +41,7 @@
              int priority)
   : id_(id)
   , name_hint_(name_hint)
+  , parent_window_(parent_window)
   , label_(label)
   , label_visible_(label_visible)
   , label_sensitive_(label_sensitive)
@@ -52,9 +54,10 @@
   , active_(false)
 {}
 
-Entry::Entry(std::string const& id, std::string const& name_hint)
+Entry::Entry(std::string const& id, std::string const& name_hint, uint32_t parent_window)
   : id_(id)
   , name_hint_(name_hint)
+  , parent_window_(parent_window)
   , label_visible_(false)
   , label_sensitive_(false)
   , image_type_(0)
@@ -65,14 +68,19 @@
   , active_(false)
 {}
 
+std::string const& Entry::id() const
+{
+  return id_;
+}
+
 std::string const& Entry::name_hint() const
 {
   return name_hint_;
 }
 
-std::string const& Entry::id() const
+uint32_t Entry::parent_window() const
 {
-  return id_;
+  return parent_window_;
 }
 
 std::string const& Entry::label() const
@@ -199,6 +207,7 @@
 
   id_ = rhs.id_;
   name_hint_ = rhs.name_hint_;
+  parent_window_ = rhs.parent_window_;
   label_ = rhs.label_;
   label_sensitive_ = rhs.label_sensitive_;
   label_visible_ = rhs.label_visible_;
@@ -258,7 +267,7 @@
 
 void Entry::ShowMenu(int x, int y, unsigned button)
 {
-  ShowMenu(0, x, y, button);
+  ShowMenu(parent_window_, x, y, button);
 }
 
 void Entry::ShowMenu(unsigned int xid, int x, int y, unsigned button)
@@ -278,7 +287,8 @@
 
 std::ostream& operator<<(std::ostream& out, Entry const& e)
 {
-  out << "<indicator::Entry " << e.id() << " hint: '" << e.name_hint() << "' "
+  out << "<indicator::Entry " << e.id() << " hint: '" << e.name_hint() << "'"
+      << " parent window: " << e.parent_window()
       << std::boolalpha
       << " \"" << e.label() << "\" ("
       << e.label_sensitive() << ", " << e.label_visible() << ") image ("
 
=== modified file 'UnityCore/IndicatorEntry.h'
--- UnityCore/IndicatorEntry.h	2014-02-05 17:16:41 +0000
+++ UnityCore/IndicatorEntry.h	2015-02-19 19:24:14 +0000
@@ -44,9 +44,10 @@
 public:
   typedef std::shared_ptr<Entry> Ptr;
 
-  Entry(std::string const& id, std::string const& name_hint = "");
+  Entry(std::string const& id, std::string const& name_hint = "", uint32_t parent_window = 0);
   Entry(std::string const& id,
         std::string const& name_hint,
+        uint32_t parent_window,
         std::string const& label,
         bool label_sensitive,
         bool label_visible,
@@ -61,6 +62,7 @@
 
   std::string const& id() const;
   std::string const& name_hint() const;
+  uint32_t parent_window() const;
 
   void set_image(int type, std::string const& data, bool sensitive, bool visible);
   bool image_visible() const;
@@ -114,6 +116,7 @@
 private:
   std::string id_;
   std::string name_hint_;
+  uint32_t parent_window_;
 
   std::string label_;
   bool label_visible_;
 
=== modified file 'UnityCore/Indicators.cpp'
--- UnityCore/Indicators.cpp	2014-02-11 03:11:47 +0000
+++ UnityCore/Indicators.cpp	2015-02-19 19:24:14 +0000
@@ -20,6 +20,7 @@
 
 #include "Indicators.h"
 #include "AppmenuIndicator.h"
+#include "services/panel-service-private.h"
 
 namespace unity
 {
@@ -143,7 +144,7 @@
   if (indicator)
     return indicator;
 
-  if (name == "libappmenu.so")
+  if (name == APPMENU_INDICATOR_NAME)
   {
     auto appmenu = std::make_shared<AppmenuIndicator>(name);
     appmenu->on_show_appmenu.connect(sigc::mem_fun(owner_, &Indicators::OnShowAppMenu));
 
=== modified file 'UnityCore/pch/unitycore_pch.hh'
--- UnityCore/pch/unitycore_pch.hh	2014-01-28 15:39:57 +0000
+++ UnityCore/pch/unitycore_pch.hh	2015-02-19 19:24:14 +0000
@@ -29,6 +29,7 @@
 #include <map>
 #include <memory>
 #include <unordered_map>
+#include <functional>
 
 #include <boost/utility.hpp>
 #include <dee.h>
 
=== modified file 'com.canonical.Unity.gschema.xml'
--- com.canonical.Unity.gschema.xml	2014-12-19 12:43:56 +0000
+++ com.canonical.Unity.gschema.xml	2015-02-19 19:24:14 +0000
@@ -47,7 +47,7 @@
       <description>This is used to enable/disable double-click result activation in the dash. Double-click to activate, single click preview</description>
     </key>
     <key type="b" name="integrated-menus">
-      <default>false</default>
+      <default>true</default>
       <summary>Enable/Disable the integrated menus in Unity.</summary>
       <description>When this is enabled, the application menus will be shown
         on the window decoration, otherwise they will be always shown on the
@@ -176,5 +176,11 @@
         a window by double-clicking on its menus if the second click happens before the
         specified value of ms is elapsed</description>
     </key>
+    <key type="b" name="unfocused-windows-popup">
+      <default>true</default>
+      <summary>Whether to pop-up a menu when clicking over unfocused windows entries</summary>
+      <description>By disabling this setting you can make unity to only focus a window
+        when clicking over unfocused menu entries</description>
+    </key>
   </schema>
 </schemalist>
 
=== modified file 'dash/DashView.h'
--- dash/DashView.h	2014-07-07 13:16:18 +0000
+++ dash/DashView.h	2015-02-19 19:24:14 +0000
@@ -56,7 +56,7 @@
 class DashView : public nux::View, public unity::debug::Introspectable
 {
   NUX_DECLARE_OBJECT_TYPE(DashView, nux::View);
-  typedef std::map<std::string, nux::ObjectPtr<ScopeView>> ScopeViews;
+  typedef std::unordered_map<std::string, nux::ObjectPtr<ScopeView>> ScopeViews;
 
 public:
   DashView(Scopes::Ptr const& scopes, ApplicationStarter::Ptr const& application_starter);
 
=== modified file 'dash/ScopeView.h'
--- dash/ScopeView.h	2014-07-11 20:53:25 +0000
+++ dash/ScopeView.h	2015-02-19 19:24:14 +0000
@@ -35,6 +35,7 @@
 #include "unity-shared/Introspectable.h"
 #include "PlacesGroup.h"
 #include "ResultViewGrid.h"
+#include "unity-shared/NuxObjectPtrHash.h"
 #include "unity-shared/UBusWrapper.h"
 
 namespace unity
@@ -48,7 +49,7 @@
 {
   NUX_DECLARE_OBJECT_TYPE(ScopeView, nux::View);
   typedef std::vector<PlacesGroup::Ptr> CategoryGroups;
-  typedef std::map<PlacesGroup::Ptr, unsigned int> ResultCounts;
+  typedef std::unordered_map<PlacesGroup::Ptr, unsigned int> ResultCounts;
 
 public:
   ScopeView(Scope::Ptr const& scope, nux::Area* show_filters);
 
=== modified file 'debian/control'
--- debian/control	2014-11-04 18:57:33 +0000
+++ debian/control	2015-02-19 19:24:14 +0000
@@ -80,7 +80,7 @@
 Provides: indicator-renderer
 Recommends: unity-control-center,
             ${unity-default-masterscopes}
-            indicator-appmenu,
+            indicator-appmenu (>= 15.02.0),
             indicator-application,
             indicator-sound,
             indicator-bluetooth,
 
=== modified file 'decorations/DecoratedWindow.cpp'
--- decorations/DecoratedWindow.cpp	2014-12-19 13:03:44 +0000
+++ decorations/DecoratedWindow.cpp	2015-02-19 19:24:14 +0000
@@ -50,17 +50,13 @@
   , 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) {
     bg_textures_.clear();
     if (top_layout_)
-    {
       top_layout_->focused = active;
-
-      if (!active)
-        UnsetAppMenu();
-    }
     RedrawDecorations();
   });
 
@@ -701,7 +697,7 @@
 
 void Window::Impl::SetupAppMenu()
 {
-  if (!active() || !top_layout_)
+  if (!top_layout_)
     return;
 
   auto const& menu_manager = manager_->impl_->menu_manager_;
@@ -716,8 +712,11 @@
 
   auto menus = std::make_shared<MenuLayout>(menu_manager, win_);
   menus->Setup();
+
+  if (menus->Items().empty())
+    return;
+
   menus_ = menus;
-
   auto const& grab_edge = grab_edge_.lock();
   sliding_layout->SetInputItem(menus);
   sliding_layout->fadein = menu_manager->fadein();
@@ -759,13 +758,18 @@
     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(MENUS_PANEL_NAME, indicator::EntryLocationMap());
+  indicators->SyncGeometries(GetMenusPanelID(), indicator::EntryLocationMap());
   sliding_layout_->SetInputItem(nullptr);
   grab_mouse_changed_->disconnect();
 }
@@ -778,7 +782,7 @@
   auto const& indicators = manager_->impl_->menu_manager_->Indicators();
   indicator::EntryLocationMap map;
   menus_->ChildrenGeometries(map);
-  indicators->SyncGeometries(MENUS_PANEL_NAME, map);
+  indicators->SyncGeometries(GetMenusPanelID(), map);
 }
 
 bool Window::Impl::ActivateMenu(std::string const& entry_id)
 
=== modified file 'decorations/DecorationsManager.cpp'
--- decorations/DecorationsManager.cpp	2014-12-19 13:03:44 +0000
+++ decorations/DecorationsManager.cpp	2015-02-19 19:24:14 +0000
@@ -141,27 +141,24 @@
     return;
   }
 
-  appmenu->active_window = screen->activeWindow();
-
-  auto setup_active_window = [this] {
-    if (Window::Ptr const& active_win = active_deco_win_.lock())
-      active_win->impl_->SetupAppMenu();
-  };
+  for (auto const& win : windows_)
+    win.second->impl_->SetupAppMenu();
 
   menu_connections_.Remove(appmenu_connection_);
-  appmenu_connection_ = menu_connections_.Add(appmenu->updated.connect(setup_active_window));
-  setup_active_window();
+  appmenu_connection_ = menu_connections_.Add(appmenu->updated_win.connect([this] (uint32_t xid) {
+    if (Window::Ptr const& win = GetWindowByXid(xid))
+      win->impl_->SetupAppMenu();
+  }));
 }
 
 void Manager::Impl::UnsetAppMenu()
 {
   menu_connections_.Remove(appmenu_connection_);
-  auto const& active_win = active_deco_win_.lock();
 
-  if (active_win)
+  for (auto const& win : windows_)
   {
-    active_win->impl_->UnsetAppMenu();
-    active_win->impl_->Damage();
+    win.second->impl_->UnsetAppMenu();
+    win.second->impl_->Damage();
   }
 }
 
@@ -265,9 +262,6 @@
 
         if (new_active)
           new_active->impl_->active = true;
-
-        if (indicator::AppmenuIndicator::Ptr const& appmenu = menu_manager_->AppMenu())
-          appmenu->active_window = active_xid;
       }
       else if (event->xproperty.atom == Atoms::mwmHints ||
                event->xproperty.atom == Atoms::wmAllowedActions)
@@ -308,6 +302,9 @@
 
 bool Manager::Impl::HandleFrameEvent(XEvent* event)
 {
+  if (WindowManager::Default().IsScaleActive())
+    return false;
+
   auto const& win = GetWindowByFrame(event->xany.window);
 
   // ButtonRelease events might happen also outside the frame window, in this
 
=== modified file 'decorations/DecorationsMenuDropdown.cpp'
--- decorations/DecorationsMenuDropdown.cpp	2014-02-24 23:53:50 +0000
+++ decorations/DecorationsMenuDropdown.cpp	2015-02-19 19:24:14 +0000
@@ -33,7 +33,7 @@
 using namespace indicator;
 
 MenuDropdown::MenuDropdown(Indicators::Ptr const& indicators, CompWindow* win)
-  : MenuEntry(std::make_shared<Entry>("LIM-dropdown"), win)
+  : MenuEntry(std::make_shared<Entry>("LIM"+std::to_string(win->id())+"-dropdown"), win)
   , indicators_(indicators)
 {
   natural_.width = ICON_SIZE;
@@ -53,7 +53,7 @@
   for (auto const& child : children_)
     entries.push_back(child->GetEntry());
 
-  indicators_->ShowEntriesDropdown(entries, active_, 0, geo.x(), geo.y2());
+  indicators_->ShowEntriesDropdown(entries, active_, grab_.Window()->id(), geo.x(), geo.y2());
 }
 
 bool MenuDropdown::ActivateChild(MenuEntry::Ptr const& child)
@@ -118,7 +118,8 @@
 
 void MenuDropdown::RenderTexture()
 {
-  WidgetState state = active() ? WidgetState::PRELIGHT : WidgetState::NORMAL;
+  WidgetState normal_state = focused() ? WidgetState::NORMAL : WidgetState::BACKDROP;
+  WidgetState state = active() ? WidgetState::PRELIGHT : normal_state;
   cu::CairoContext icon_ctx(GetNaturalWidth(), GetNaturalHeight(), scale());
 
   if (state == WidgetState::PRELIGHT)
 
=== modified file 'decorations/DecorationsMenuEntry.cpp'
--- decorations/DecorationsMenuEntry.cpp	2014-03-31 18:36:33 +0000
+++ decorations/DecorationsMenuEntry.cpp	2015-02-19 19:24:14 +0000
@@ -37,11 +37,13 @@
   , in_dropdown(false)
   , entry_(entry)
   , grab_(win, true)
+  , show_menu_enabled_(true)
 {
   entry_->updated.connect(sigc::mem_fun(this, &MenuEntry::EntryUpdated));
   horizontal_padding.changed.connect(sigc::hide(sigc::mem_fun(this, &MenuEntry::RenderTexture)));
   vertical_padding.changed.connect(sigc::hide(sigc::mem_fun(this, &MenuEntry::RenderTexture)));
   scale.changed.connect(sigc::hide(sigc::mem_fun(this, &MenuEntry::RenderTexture)));
+  focused.changed.connect(sigc::hide(sigc::mem_fun(this, &MenuEntry::RenderTexture)));
   in_dropdown.changed.connect([this] (bool in) { visible = entry_->visible() && !in; });
   EntryUpdated();
 }
@@ -63,7 +65,7 @@
 
 void MenuEntry::RenderTexture()
 {
-  WidgetState state = WidgetState::NORMAL;
+  WidgetState state = focused() ? WidgetState::NORMAL : WidgetState::BACKDROP;
 
   if (show_now())
     state = WidgetState::PRESSED;
@@ -120,10 +122,17 @@
 {
   button_up_timer_.reset();
   grab_.ButtonDownEvent(p, button, timestamp);
+  show_menu_enabled_ = (focused() || Settings::Instance().lim_unfocused_popup());
 }
 
 void MenuEntry::ButtonUpEvent(CompPoint const& p, unsigned button, Time timestamp)
 {
+  if (!show_menu_enabled_)
+  {
+    grab_.ButtonUpEvent(p, button, timestamp);
+    return;
+  }
+
   if (button == 1 && !grab_.IsGrabbed())
   {
     unsigned double_click_wait = Settings::Instance().lim_double_click_wait();
@@ -143,7 +152,8 @@
 
   if (button == 2 || button == 3)
   {
-    ShowMenu(button);
+    if (Style::Get()->WindowManagerAction(WMEvent(button)) == WMAction::NONE)
+      ShowMenu(button);
   }
 
   grab_.ButtonUpEvent(p, button, timestamp);
 
=== modified file 'decorations/DecorationsMenuEntry.h'
--- decorations/DecorationsMenuEntry.h	2014-02-27 07:10:31 +0000
+++ decorations/DecorationsMenuEntry.h	2015-02-19 19:24:14 +0000
@@ -63,10 +63,11 @@
 
 protected:
   indicator::Entry::Ptr entry_;
+  GrabEdge grab_;
 
 private:
+  bool show_menu_enabled_;
   glib::Source::UniquePtr button_up_timer_;
-  GrabEdge grab_;
 };
 
 } // decoration namespace
 
=== modified file 'decorations/DecorationsMenuLayout.cpp'
--- decorations/DecorationsMenuLayout.cpp	2014-02-26 00:14:46 +0000
+++ decorations/DecorationsMenuLayout.cpp	2015-02-19 19:24:14 +0000
@@ -35,7 +35,9 @@
   , win_(win)
   , last_pointer_(-1, -1)
   , dropdown_(std::make_shared<MenuDropdown>(menu_manager_->Indicators(), win))
-{}
+{
+  visible = false;
+}
 
 void MenuLayout::Setup()
 {
@@ -56,7 +58,7 @@
   dropdown_->active.changed.connect(active_cb);
   dropdown_->show_now.changed.connect(show_now_cb);
 
-  for (auto const& entry : menu_manager_->AppMenu()->GetEntries())
+  for (auto const& entry : menu_manager_->AppMenu()->GetEntriesForWindow(win_->id()))
   {
     auto menu = std::make_shared<MenuEntry>(entry, win_);
     menu->mouse_owner.changed.connect(ownership_cb);
@@ -65,7 +67,24 @@
     menu->focused = focused();
     menu->scale = scale();
     menu->SetParent(shared_from_this());
-    items_.push_back(menu);
+
+    if (items_.empty() || entry->priority() < 0)
+    {
+      items_.push_back(menu);
+    }
+    else
+    {
+      auto pos = items_.rbegin();
+
+      for (; pos != items_.rend(); ++pos)
+      {
+        auto menu = std::static_pointer_cast<MenuEntry>(*pos);
+        if (entry->priority() >= menu->GetEntry()->priority())
+          break;
+      }
+
+      items_.insert(pos.base(), menu);
+    }
   }
 
   if (!items_.empty())
@@ -195,12 +214,14 @@
   int accumolated_width = dropdown_width + left_padding + right_padding - inner_padding;
   int max_width = max_.width;
   std::list<MenuEntry::Ptr> to_hide;
+  bool is_visible = visible();
 
   for (auto const& item : items_)
   {
     if (!item->visible() || item == dropdown_)
       continue;
 
+    is_visible = true;
     accumolated_width += item->GetNaturalWidth() + inner_padding;
 
     if (accumolated_width > max_width)
@@ -235,6 +256,7 @@
       dropdown_->Push(hidden);
   }
 
+  visible = is_visible;
   Layout::DoRelayout();
 }
 
 
=== modified file 'decorations/DecorationsPriv.h'
--- decorations/DecorationsPriv.h	2014-10-22 14:38:06 +0000
+++ decorations/DecorationsPriv.h	2015-02-19 19:24:14 +0000
@@ -111,6 +111,7 @@
   bool ShouldBeDecorated() const;
   GLTexture* ShadowTexture() const;
   unsigned ShadowRadius() const;
+  std::string const& GetMenusPanelID() const;
 
   void ComputeShadowQuads();
   void UpdateDecorationTextures();
@@ -143,6 +144,7 @@
   connection::Wrapper dpi_changed_;
   connection::Wrapper grab_mouse_changed_;
   std::string last_title_;
+  std::string panel_id_;
   std::vector<cu::SimpleTextureQuad> bg_textures_;
   std::shared_ptr<ForceQuitDialog> force_quit_;
   InputMixer::Ptr input_mixer_;
@@ -194,7 +196,7 @@
 
   uweak_ptr<decoration::Window> active_deco_win_;
   uweak_ptr<InputMixer> last_mouse_owner_;
-  std::map<CompWindow*, decoration::Window::Ptr> windows_;
+  std::unordered_map<CompWindow*, decoration::Window::Ptr> windows_;
   std::unordered_map<::Window, std::weak_ptr<decoration::Window>> framed_windows_;
 
   menu::Manager::Ptr menu_manager_;
 
=== modified file 'decorations/DecorationsSlidingLayout.cpp'
--- decorations/DecorationsSlidingLayout.cpp	2014-12-19 12:02:34 +0000
+++ decorations/DecorationsSlidingLayout.cpp	2015-02-19 19:24:14 +0000
@@ -137,7 +137,7 @@
   auto& main_item_ = items_[ItemRole::MAIN];
   auto& input_item_ = items_[ItemRole::INPUT];
 
-  if (!input_item_)
+  if (!input_item_ || !input_item_->visible())
   {
     if (main_item_)
       main_item_->Draw(ctx, transformation, attrib, clip, mask);
 
=== modified file 'decorations/DecorationsWidgets.cpp'
--- decorations/DecorationsWidgets.cpp	2014-09-24 01:40:50 +0000
+++ decorations/DecorationsWidgets.cpp	2015-02-19 19:24:14 +0000
@@ -192,15 +192,10 @@
 
 BasicContainer::Ptr Item::GetTopParent() const
 {
-  BasicContainer::Ptr parent = GetParent();
-
-  while (parent)
-  {
-    if (!parent->parent_)
-      return parent;
-
-    parent = parent->GetParent();
-  }
+  BasicContainer::Ptr parent = parent_;
+
+  while (parent && parent->parent_)
+    parent = parent->parent_;
 
   return parent;
 }
 
=== modified file 'launcher/LauncherEntryRemoteModel.h'
--- launcher/LauncherEntryRemoteModel.h	2012-05-07 19:52:54 +0000
+++ launcher/LauncherEntryRemoteModel.h	2015-02-19 19:24:14 +0000
@@ -22,7 +22,7 @@
 
 #include <gio/gio.h>
 #include <sigc++/sigc++.h>
-#include <map>
+#include <unordered_map>
 
 #include "LauncherEntryRemote.h"
 
@@ -68,7 +68,7 @@
   glib::Object<GDBusConnection> _conn;
   unsigned int _launcher_entry_dbus_signal_id;
   unsigned int _dbus_name_owner_changed_signal_id;
-  std::map<std::string, LauncherEntryRemote::Ptr> _entries_by_uri;
+  std::unordered_map<std::string, LauncherEntryRemote::Ptr> _entries_by_uri;
 };
 
 } // namespace
 
=== modified file 'lockscreen/LockScreenPanel.cpp'
--- lockscreen/LockScreenPanel.cpp	2014-09-19 18:22:14 +0000
+++ lockscreen/LockScreenPanel.cpp	2015-02-19 19:24:14 +0000
@@ -118,7 +118,7 @@
       if (entry->active())
       {
         active = true;
-        indicators_view_->ActivateEntry(entry->id());
+        indicators_view_->ActivateEntry(entry);
         OnEntryActivated(GetPanelName(), entry->id(), entry->geometry());
         break;
       }
 
=== modified file 'panel/PanelIndicatorEntryDropdownView.cpp'
--- panel/PanelIndicatorEntryDropdownView.cpp	2014-02-25 00:28:58 +0000
+++ panel/PanelIndicatorEntryDropdownView.cpp	2015-02-19 19:24:14 +0000
@@ -98,6 +98,11 @@
   return child;
 }
 
+void PanelIndicatorEntryDropdownView::Clear()
+{
+  children_.clear();
+}
+
 std::deque<PanelIndicatorEntryView::Ptr> const& PanelIndicatorEntryDropdownView::Children() const
 {
   return children_;
@@ -144,7 +149,7 @@
     entries.push_back(entry->GetEntry());
 
   auto const& geo = GetAbsoluteGeometry();
-  indicators_->ShowEntriesDropdown(entries, active_entry_, 0, geo.x, geo.y + geo.height);
+  indicators_->ShowEntriesDropdown(entries, active_entry_, entries[0]->parent_window(), geo.x, geo.y + geo.height);
 }
 
 bool PanelIndicatorEntryDropdownView::ActivateChild(PanelIndicatorEntryView::Ptr const& child)
 
=== modified file 'panel/PanelIndicatorEntryDropdownView.h'
--- panel/PanelIndicatorEntryDropdownView.h	2014-02-07 23:29:46 +0000
+++ panel/PanelIndicatorEntryDropdownView.h	2015-02-19 19:24:14 +0000
@@ -39,6 +39,7 @@
   void Insert(PanelIndicatorEntryView::Ptr const&);
   void Remove(PanelIndicatorEntryView::Ptr const&);
   PanelIndicatorEntryView::Ptr Pop();
+  void Clear();
 
   PanelIndicatorEntryView::Ptr Top() const;
   std::deque<PanelIndicatorEntryView::Ptr> const& Children() const;
 
=== modified file 'panel/PanelIndicatorEntryView.cpp'
--- panel/PanelIndicatorEntryView.cpp	2014-08-07 13:15:17 +0000
+++ panel/PanelIndicatorEntryView.cpp	2015-02-19 19:24:14 +0000
@@ -59,6 +59,7 @@
   , cv_(unity::Settings::Instance().em(monitor_))
 {
   proxy_->active_changed.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnActiveChanged));
+  proxy_->show_now_changed.connect(sigc::mem_fun(&show_now_changed, &sigc::signal<void, bool>::emit));
   proxy_->updated.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::Refresh));
 
   InputArea::mouse_down.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnMouseDown));
@@ -84,11 +85,6 @@
   Refresh();
 }
 
-PanelIndicatorEntryView::~PanelIndicatorEntryView()
-{
-  // Nothing to do...
-}
-
 void PanelIndicatorEntryView::OnActiveChanged(bool is_active)
 {
   active_changed.emit(this, is_active);
@@ -114,10 +110,16 @@
     });
 
     wm.TerminateExpo();
+    return;
   }
 
   if (wm.IsScaleActive())
+  {
+    if (type_ == MENU)
+      return;
+
     wm.TerminateScale();
+  }
 
   auto const& abs_geo = GetAbsoluteGeometry();
   proxy_->ShowMenu(abs_geo.x, abs_geo.y + abs_geo.height, button);
 
=== modified file 'panel/PanelIndicatorEntryView.h'
--- panel/PanelIndicatorEntryView.h	2014-03-31 21:08:10 +0000
+++ panel/PanelIndicatorEntryView.h	2015-02-19 19:24:14 +0000
@@ -53,10 +53,8 @@
   PanelIndicatorEntryView(indicator::Entry::Ptr const& proxy, int padding = 5,
                           IndicatorEntryType type = INDICATOR);
 
-  virtual ~PanelIndicatorEntryView();
-
   IndicatorEntryType GetType() const;
-  indicator::Entry::Ptr GetEntry() const { return proxy_; }
+  indicator::Entry::Ptr const& GetEntry() const { return proxy_; }
   std::string GetEntryID() const;
   int GetEntryPriority() const;
 
@@ -93,6 +91,7 @@
 
   sigc::signal<void, PanelIndicatorEntryView*, bool> active_changed;
   sigc::signal<void, PanelIndicatorEntryView*> refreshed;
+  sigc::signal<void, bool> show_now_changed;
 
 protected:
   std::string GetName() const;
 
=== modified file 'panel/PanelIndicatorsView.cpp'
--- panel/PanelIndicatorsView.cpp	2014-03-06 09:26:03 +0000
+++ panel/PanelIndicatorsView.cpp	2015-02-19 19:24:14 +0000
@@ -71,7 +71,7 @@
   indicators_.push_back(indicator);
 
   for (auto const& entry : indicator->GetEntries())
-    AddEntry(entry);
+    OnEntryAdded(entry);
 
   auto& conn_manager = indicators_connections_[indicator];
   conn_manager.Add(indicator->on_entry_added.connect(sigc::mem_fun(this, &PanelIndicatorsView::OnEntryAdded)));
@@ -83,7 +83,7 @@
   indicators_connections_.erase(indicator);
 
   for (auto const& entry : indicator->GetEntries())
-    RemoveEntry(entry->id());
+    RemoveEntry(entry);
 
   for (auto i = indicators_.begin(); i != indicators_.end(); ++i)
   {
@@ -158,13 +158,13 @@
   }
 }
 
-PanelIndicatorEntryView* PanelIndicatorsView::ActivateEntry(std::string const& entry_id, int button)
+PanelIndicatorEntryView* PanelIndicatorsView::ActivateEntry(indicator::Entry::Ptr const& entry, int button)
 {
-  auto entry = entries_.find(entry_id);
+  auto it = entries_.find(entry);
 
-  if (entry != entries_.end())
+  if (it != entries_.end())
   {
-    PanelIndicatorEntryView* view = entry->second;
+    PanelIndicatorEntryView* view = it->second;
 
     if (view->IsSensitive() && view->IsVisible())
     {
@@ -181,6 +181,17 @@
   return nullptr;
 }
 
+PanelIndicatorEntryView* PanelIndicatorsView::ActivateEntry(std::string const& entry_id, int button)
+{
+  for (auto const& it : entries_)
+  {
+    if (it.first->id() == entry_id)
+      return ActivateEntry(it.first, button);
+  }
+
+  return nullptr;
+}
+
 bool PanelIndicatorsView::ActivateIfSensitive()
 {
   for (auto* area : layout_->GetChildren())
@@ -222,7 +233,7 @@
     if (!view->IsVisible())
       continue;
 
-    if (!target && view->IsFocused() &&
+    if (!target &&
         view->IsSensitive() &&
         view->GetAbsoluteGeometry().IsPointInside(x, y))
     {
@@ -267,9 +278,8 @@
   if (!view)
     return;
 
-  auto const& entry_id = view->GetEntryID();
   bool added_to_dropdown = false;
-  bool known_entry = (entries_.find(entry_id) != entries_.end());
+  bool known_entry = (entries_.find(view->GetEntry()) != entries_.end());
   view->SetOpacity(opacity());
 
   if (!known_entry && dropdown_ && !dropdown_->Empty())
@@ -317,7 +327,7 @@
   {
     view->SetMonitor(monitor_);
     view->refreshed.connect(sigc::mem_fun(this, &PanelIndicatorsView::OnEntryRefreshed));
-    entries_.insert({entry_id, view});
+    entries_.insert({view->GetEntry(), view});
     on_indicator_updated.emit();
     entry_added.emit(view);
   }
@@ -346,6 +356,23 @@
   on_indicator_updated.emit();
 }
 
+void PanelIndicatorsView::ClearEntries()
+{
+  for (auto it = entries_.begin(); it != entries_.end();)
+  {
+    auto* entry = it->second;
+    ++it;
+
+    if (entry != dropdown_.GetPointer())
+      RemoveEntryView(entry);
+  }
+
+  on_indicator_updated.emit();
+
+  QueueRelayout();
+  QueueDraw();
+}
+
 void PanelIndicatorsView::RemoveEntryView(PanelIndicatorEntryView* view)
 {
   if (!view)
@@ -357,7 +384,7 @@
     dropdown_->Remove(PanelIndicatorEntryView::Ptr(view));
 
   RemoveChild(view);
-  entries_.erase(view->GetEntryID());
+  entries_.erase(view->GetEntry());
   layout_->RemoveChildObject(view);
   on_indicator_updated.emit();
 
@@ -365,9 +392,12 @@
   QueueDraw();
 }
 
-void PanelIndicatorsView::RemoveEntry(std::string const& entry_id)
+void PanelIndicatorsView::RemoveEntry(indicator::Entry::Ptr const& entry)
 {
-  RemoveEntryView(entries_[entry_id]);
+  auto it = entries_.find(entry);
+
+  if (it != entries_.end())
+    RemoveEntryView(it->second);
 }
 
 void PanelIndicatorsView::OverlayShown()
 
=== modified file 'panel/PanelIndicatorsView.h'
--- panel/PanelIndicatorsView.h	2014-03-06 09:26:03 +0000
+++ panel/PanelIndicatorsView.h	2015-02-19 19:24:14 +0000
@@ -55,9 +55,10 @@
                                     int padding = 5,
                                     IndicatorEntryPosition pos = AUTO,
                                     IndicatorEntryType type = IndicatorEntryType::INDICATOR);
-  void RemoveEntry(std::string const& entry_id);
+  void RemoveEntry(indicator::Entry::Ptr const&);
 
   PanelIndicatorEntryView* ActivateEntryAt(int x, int y, int button = 1);
+  PanelIndicatorEntryView* ActivateEntry(indicator::Entry::Ptr const&, int button = 1);
   PanelIndicatorEntryView* ActivateEntry(std::string const& entry_id, int button = 1);
   bool ActivateIfSensitive();
 
@@ -84,18 +85,19 @@
   typedef std::vector<indicator::Indicator::Ptr> Indicators;
   Indicators const& GetIndicators() const;
 
+  void ClearEntries();
+
   virtual void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
   virtual void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw);
 
-  virtual void OnEntryAdded(indicator::Entry::Ptr const& entry);
+  virtual void OnEntryAdded(indicator::Entry::Ptr const&);
   virtual void OnEntryRefreshed(PanelIndicatorEntryView* view);
 
   void AddEntryView(PanelIndicatorEntryView* view, IndicatorEntryPosition pos = AUTO);
   void RemoveEntryView(PanelIndicatorEntryView* view);
 
   nux::HLayout* layout_;
-  typedef std::map<std::string, PanelIndicatorEntryView*> Entries;
-  Entries entries_;
+  std::unordered_map<indicator::Entry::Ptr, PanelIndicatorEntryView*> entries_;
 
   int monitor_;
   bool overlay_showing_;
 
=== modified file 'panel/PanelMenuView.cpp'
--- panel/PanelMenuView.cpp	2014-12-19 13:03:44 +0000
+++ panel/PanelMenuView.cpp	2015-02-19 19:24:14 +0000
@@ -27,6 +27,7 @@
 #include "unity-shared/CairoTexture.h"
 #include "unity-shared/DecorationStyle.h"
 #include "unity-shared/PanelStyle.h"
+#include "unity-shared/RawPixel.h"
 #include "unity-shared/UnitySettings.h"
 #include "unity-shared/UBusMessages.h"
 #include "unity-shared/UScreen.h"
@@ -43,15 +44,14 @@
 
 namespace
 {
-  const int MAIN_LEFT_PADDING = 4;
-  const int TITLE_PADDING = 2;
-  const int MENUBAR_PADDING = 4;
+  const RawPixel MAIN_LEFT_PADDING = 4_em;
+  const RawPixel TITLE_PADDING = 2_em;
+  const RawPixel MENUBAR_PADDING = 4_em;
   const int MENU_ENTRIES_PADDING = 6;
 
   const std::string NEW_APP_HIDE_TIMEOUT = "new-app-hide-timeout";
   const std::string NEW_APP_SHOW_TIMEOUT = "new-app-show-timeout";
   const std::string WINDOW_MOVED_TIMEOUT = "window-moved-timeout";
-  const std::string WINDOW_ACTIVATED_TIMEOUT = "window-activated-timeout";
   const std::string UPDATE_SHOW_NOW_TIMEOUT = "update-show-now-timeout";
   const std::string INTEGRATED_MENUS_DOUBLE_CLICK_TIMEOUT = "integrated-menus-double-click-timeout";
 
@@ -83,7 +83,10 @@
 }
 
 PanelMenuView::PanelMenuView(menu::Manager::Ptr const& menus)
-  : menu_manager_(menus)
+  : active_window(0)
+  , maximized_window(0)
+  , focused(true)
+  , menu_manager_(menus)
   , matcher_(bamf_matcher_get_default())
   , is_inside_(false)
   , is_grabbed_(false)
@@ -100,16 +103,15 @@
   , ignore_menu_visibility_(false)
   , integrated_menus_(menu_manager_->integrated_menus())
   , always_show_menus_(menu_manager_->always_show_menus())
-  , active_xid_(0)
   , desktop_name_(get_current_desktop())
 {
   BamfWindow* active_win = bamf_matcher_get_active_window(matcher_);
   if (BAMF_IS_WINDOW(active_win))
-    active_xid_ = bamf_window_get_xid(active_win);
+    active_window = bamf_window_get_xid(active_win);
 
-  SetupPanelMenuViewSignals();
   SetupWindowButtons();
   SetupTitlebarGrabArea();
+  SetupPanelMenuViewSignals();
   SetupWindowManagerSignals();
   SetupUBusManagerInterests();
 
@@ -128,8 +130,10 @@
 void PanelMenuView::OnStyleChanged()
 {
   int height = panel::Style::Instance().PanelHeight(monitor_);
+  double scale = Settings::Instance().em(monitor_)->DPIScale();
   window_buttons_->SetMinimumHeight(height);
   window_buttons_->SetMaximumHeight(height);
+  window_buttons_->SetLeftAndRightPadding(MAIN_LEFT_PADDING.CP(scale), MENUBAR_PADDING.CP(scale));
   window_buttons_->UpdateDPIChanged();
 
   layout_->SetLeftAndRightPadding(window_buttons_->GetContentWidth(), 0);
@@ -157,6 +161,20 @@
 
   menu_manager_->integrated_menus.changed.connect(sigc::mem_fun(this, &PanelMenuView::OnLIMChanged));
   menu_manager_->always_show_menus.changed.connect(sigc::mem_fun(this, &PanelMenuView::OnAlwaysShowMenusChanged));
+
+  auto update_target_cb = sigc::hide(sigc::mem_fun(this, &PanelMenuView::UpdateTargetWindowItems));
+  maximized_window.changed.connect(update_target_cb);
+  active_window.changed.connect(update_target_cb);
+
+  focused.changed.connect([this] (bool focused) {
+    Refresh(true);
+    window_buttons_->focused = focused;
+
+    for (auto const& entry : entries_)
+      entry.second->SetFocusedState(focused);
+
+    FullRedraw();
+  });
 }
 
 void PanelMenuView::SetupWindowButtons()
@@ -164,7 +182,7 @@
   window_buttons_ = new WindowButtons();
   window_buttons_->SetParentObject(this);
   window_buttons_->monitor = monitor_;
-  window_buttons_->controlled_window = active_xid_;
+  window_buttons_->controlled_window = active_window();
   window_buttons_->opacity = 0.0f;
   window_buttons_->SetLeftAndRightPadding(MAIN_LEFT_PADDING, MENUBAR_PADDING);
   window_buttons_->SetMaximumHeight(panel::Style::Instance().PanelHeight(monitor_));
@@ -252,6 +270,27 @@
   PanelIndicatorsView::AddIndicator(indicator);
 }
 
+void PanelMenuView::UpdateTargetWindowItems()
+{
+  Window old_target = window_buttons_->controlled_window;
+  Window target_window = integrated_menus_ ? maximized_window() : active_window();
+
+  if (old_target != target_window)
+  {
+    window_buttons_->controlled_window = target_window;
+    ClearEntries();
+
+    if (indicator::AppmenuIndicator::Ptr appmenu = menu_manager_->AppMenu())
+    {
+      for (auto const& entry : appmenu->GetEntriesForWindow(target_window))
+        OnEntryAdded(entry);
+    }
+  }
+
+  if (integrated_menus_)
+    focused = (target_window == active_window());
+}
+
 void PanelMenuView::FullRedraw()
 {
   QueueDraw();
@@ -266,9 +305,11 @@
   if (!integrated_menus_)
   {
     CheckMouseInside();
-    window_buttons_->focused = true;
+    focused = true;
   }
 
+  UpdateTargetWindowItems();
+
   Refresh(true);
   FullRedraw();
 }
@@ -302,7 +343,7 @@
       return titlebar_grab_area_.GetPointer();
   }
 
-  if (is_maximized_ || spread_showing_ || (integrated_menus_ && GetMaximizedWindow() != 0))
+  if (is_maximized_ || spread_showing_ || (integrated_menus_ && maximized_window() != 0))
   {
     found_area = window_buttons_->FindAreaUnderMouse(mouse_position, event_type);
     NUX_RETURN_VALUE_IF_NOTNULL(found_area, found_area);
@@ -313,7 +354,7 @@
     found_area = titlebar_grab_area_->FindAreaUnderMouse(mouse_position, event_type);
     NUX_RETURN_VALUE_IF_NOTNULL(found_area, found_area);
 
-    if (integrated_menus_ && GetMaximizedWindow() != 0)
+    if (integrated_menus_ && maximized_window() != 0)
     {
       /* When the integrated menus are enabled, that area must act both like an
        * indicator-entry view and like a panel-grab-area, so not to re-implement
@@ -382,10 +423,7 @@
 
 bool PanelMenuView::ShouldDrawMenus() const
 {
-  if (integrated_menus_ && !is_maximized_)
-    return false;
-
-  if (we_control_active_ && !switcher_showing_ && !launcher_keynav_ && !ignore_menu_visibility_ && !entries_.empty())
+  if ((we_control_active_ || integrated_menus_) && !switcher_showing_ && !launcher_keynav_ && !ignore_menu_visibility_ && HasVisibleMenus())
   {
     WindowManager& wm = WindowManager::Default();
 
@@ -410,7 +448,7 @@
   if (integrated_menus_)
   {
     if (!WindowManager::Default().IsExpoActive())
-      return (GetMaximizedWindow() != 0);
+      return (maximized_window() != 0);
 
     return false;
   }
@@ -796,7 +834,7 @@
 
 std::string PanelMenuView::GetMaximizedViewName(bool use_appname) const
 {
-  Window maximized = GetMaximizedWindow();
+  Window maximized = maximized_window();
   BamfWindow* window = nullptr;
   std::string label;
 
@@ -830,18 +868,18 @@
   auto const& style = decoration::Style::Get();
   auto text_size = style->TitleNaturalSize(label);
   auto state = WidgetState::NORMAL;
-  float dpi_scale = Settings::Instance().em(monitor_)->DPIScale();
+  double dpi_scale = Settings::Instance().em(monitor_)->DPIScale();
 
   if (integrated_menus_ && !is_desktop_focused_ && !WindowManager::Default().IsExpoActive())
   {
     title_geo_.x = geo.x + window_buttons_->GetBaseWidth() + (style->TitleIndent() * dpi_scale);
 
-    if (!window_buttons_->focused())
+    if (!focused())
       state = WidgetState::BACKDROP;
   }
   else
   {
-    title_geo_.x = geo.x + (MAIN_LEFT_PADDING + TITLE_PADDING) * dpi_scale;
+    title_geo_.x = geo.x + MAIN_LEFT_PADDING.CP(dpi_scale) + TITLE_PADDING.CP(dpi_scale);
   }
 
   title_geo_.y = geo.y + (geo.height - (text_size.height * dpi_scale)) / 2;
@@ -904,20 +942,9 @@
   if (geo.width > monitor_geo_.width)
     return false;
 
-  if (integrated_menus_)
-  {
-    Window maximized = GetMaximizedWindow();
-    window_buttons_->controlled_window = maximized;
-    window_buttons_->focused = (active_xid_ == maximized);
-  }
-  else
-  {
-    window_buttons_->controlled_window = active_xid_;
-  }
-
   std::string const& new_title = GetCurrentTitle();
 
-  if (new_title == panel_title_ && !force && last_geo_ == geo && title_texture_)
+  if (!force && new_title == panel_title_ && last_geo_ == geo && title_texture_)
   {
     // No need to redraw the title, let's save some CPU time!
     return false;
@@ -956,18 +983,20 @@
 
 void PanelMenuView::OnEntryAdded(indicator::Entry::Ptr const& entry)
 {
-  PanelIndicatorEntryView* view;
+  auto parent_window = entry->parent_window();
+  Window target = integrated_menus_ ? maximized_window() : active_window();
 
-  view = new PanelIndicatorEntryView(entry, MENU_ENTRIES_PADDING, IndicatorEntryType::MENU);
-  entry->show_now_changed.connect(sigc::mem_fun(this, &PanelMenuView::UpdateShowNow));
-  AddEntryView(view);
+  if (!parent_window || parent_window == target)
+    AddEntryView(new PanelIndicatorEntryView(entry, MENU_ENTRIES_PADDING, IndicatorEntryType::MENU));
 }
 
 void PanelMenuView::OnEntryViewAdded(PanelIndicatorEntryView* view)
 {
+  view->SetFocusedState(focused());
   view->mouse_enter.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseEnter));
   view->mouse_leave.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseLeave));
   view->active_changed.connect(sigc::mem_fun(this, &PanelMenuView::OnActiveChanged));
+  view->show_now_changed.connect(sigc::mem_fun(this, &PanelMenuView::UpdateShowNow));
 }
 
 void PanelMenuView::NotifyAllMenusClosed()
@@ -1116,58 +1145,41 @@
   show_now_activated_ = false;
   is_maximized_ = false;
   is_desktop_focused_ = false;
-  active_xid_ = 0;
-  bool force_refresh = false;
+  Window active_xid = 0;
 
   sources_.Remove(WINDOW_MOVED_TIMEOUT);
 
   if (BAMF_IS_WINDOW(new_view))
   {
     BamfWindow* window = reinterpret_cast<BamfWindow*>(new_view);
-    active_xid_ = bamf_window_get_xid(window);
+    active_xid = bamf_window_get_xid(window);
     is_maximized_ = (bamf_window_maximized(window) == BAMF_WINDOW_MAXIMIZED);
 
     if (bamf_window_get_window_type(window) == BAMF_WINDOW_DESKTOP)
     {
-      is_desktop_focused_ = !GetMaximizedWindow();
+      is_desktop_focused_ = !maximized_window();
       we_control_active_ = true;
     }
     else
     {
-      we_control_active_ = IsWindowUnderOurControl(active_xid_);
+      we_control_active_ = IsWindowUnderOurControl(active_xid);
     }
 
     if (is_maximized_)
     {
-      maximized_wins_.erase(std::remove(maximized_wins_.begin(), maximized_wins_.end(), active_xid_), maximized_wins_.end());
-      maximized_wins_.push_front(active_xid_);
+      maximized_wins_.erase(std::remove(maximized_wins_.begin(), maximized_wins_.end(), active_xid), maximized_wins_.end());
+      maximized_wins_.push_front(active_xid);
+      UpdateMaximizedWindow();
     }
 
     // register callback for new view
     view_name_changed_signal_.Connect(new_view, "name-changed",
                                       sigc::mem_fun(this, &PanelMenuView::OnNameChanged));
-
-    if (integrated_menus_)
-      force_refresh = is_maximized_;
-  }
-
-  if (!force_refresh && BAMF_IS_WINDOW(old_view) && integrated_menus_)
-    force_refresh = (bamf_window_maximized(reinterpret_cast<BamfWindow*>(old_view)) == BAMF_WINDOW_MAXIMIZED);
-
-  if (ShouldDrawMenus())
-  {
-    // Wait 100ms before showing the menus again if we've just switched view
-    // this is done because the menus are updated by the indicator with some
-    // delay, and we don't want to see the previous menus and then the new ones
-    ignore_menu_visibility_ = true;
-    sources_.AddTimeout(100, [this] {
-      ignore_menu_visibility_ = false;
-      QueueDraw();
-      return false;
-    }, WINDOW_ACTIVATED_TIMEOUT);
-  }
-
-  if (Refresh(force_refresh))
+  }
+
+  active_window = active_xid;
+
+  if (Refresh())
     FullRedraw();
 }
 
@@ -1198,8 +1210,9 @@
 void PanelMenuView::OnWindowMinimized(Window xid)
 {
   maximized_wins_.erase(std::remove(maximized_wins_.begin(), maximized_wins_.end(), xid), maximized_wins_.end());
+  UpdateMaximizedWindow();
 
-  if (xid == active_xid_)
+  if (xid == active_window())
   {
     if (Refresh())
       QueueDraw();
@@ -1213,10 +1226,13 @@
 
 void PanelMenuView::OnWindowUnminimized(Window xid)
 {
-  if (xid == active_xid_)
+  if (xid == active_window())
   {
     if (WindowManager::Default().IsWindowMaximized(xid))
+    {
       maximized_wins_.push_front(xid);
+      UpdateMaximizedWindow();
+    }
 
     if (Refresh())
       QueueDraw();
@@ -1224,7 +1240,10 @@
   else
   {
     if (WindowManager::Default().IsWindowMaximized(xid))
+    {
       maximized_wins_.push_back(xid);
+      UpdateMaximizedWindow();
+    }
 
     if (integrated_menus_ && IsWindowUnderOurControl(xid))
     {
@@ -1239,8 +1258,9 @@
   // FIXME: compiz doesn't give us a valid xid (is always 0 on unmap)
   // we need to do this again on BamfView closed signal.
   maximized_wins_.erase(std::remove(maximized_wins_.begin(), maximized_wins_.end(), xid), maximized_wins_.end());
+  UpdateMaximizedWindow();
 
-  if (xid == active_xid_)
+  if (xid == active_window())
   {
     if (Refresh())
       QueueDraw();
@@ -1256,9 +1276,10 @@
 {
   if (WindowManager::Default().IsWindowMaximized(xid))
   {
-    if (xid == active_xid_)
+    if (xid == active_window())
     {
       maximized_wins_.push_front(xid);
+      UpdateMaximizedWindow();
 
       if (Refresh())
         QueueDraw();
@@ -1266,15 +1287,17 @@
     else
     {
       maximized_wins_.push_back(xid);
+      UpdateMaximizedWindow();
     }
   }
 }
 
 void PanelMenuView::OnWindowMaximized(Window xid)
 {
-  if (xid == active_xid_)
+  if (xid == active_window())
   {
     maximized_wins_.push_front(xid);
+    UpdateMaximizedWindow();
 
     // We need to update the is_inside_ state in the case of maximization by grab
     CheckMouseInside();
@@ -1286,6 +1309,7 @@
   else
   {
     maximized_wins_.push_back(xid);
+    UpdateMaximizedWindow();
 
     if (integrated_menus_ && IsWindowUnderOurControl(xid))
     {
@@ -1298,8 +1322,9 @@
 void PanelMenuView::OnWindowRestored(Window xid)
 {
   maximized_wins_.erase(std::remove(maximized_wins_.begin(), maximized_wins_.end(), xid), maximized_wins_.end());
+  UpdateMaximizedWindow();
 
-  if (active_xid_ == xid)
+  if (active_window() == xid)
   {
     is_maximized_ = false;
     is_grabbed_ = false;
@@ -1316,13 +1341,13 @@
 
 bool PanelMenuView::UpdateActiveWindowPosition()
 {
-  bool we_control_window = IsWindowUnderOurControl(active_xid_);
+  bool we_control_window = IsWindowUnderOurControl(active_window);
 
   if (we_control_window != we_control_active_)
   {
     we_control_active_ = we_control_window;
 
-    if (!entries_.empty())
+    if (HasVisibleMenus())
       on_indicator_updated.emit();
 
     if (Refresh())
@@ -1334,21 +1359,17 @@
 
 void PanelMenuView::OnWindowMoved(Window xid)
 {
-  if (active_xid_ == xid)
+  if (!integrated_menus_ && active_window() == xid && UScreen::GetDefault()->GetMonitors().size() > 1)
   {
     /* When moving the active window, if the current panel is controlling
      * the active window, then we postpone the timeout function every movement
      * that we have, setting a longer timeout.
-     * Otherwise, if the moved window is not controlled by the current panel
+     * Otherwise, if the movedPanelMenuView::OnWindowMovedPanelMenuView::OnWindowMoved window is not controlled by the current panel
      * every few millisecond we check the new window position */
 
     unsigned int timeout_length = 250;
 
-    if (we_control_active_)
-    {
-      sources_.Remove(WINDOW_MOVED_TIMEOUT);
-    }
-    else
+    if (!we_control_active_)
     {
       if (sources_.GetSource(WINDOW_MOVED_TIMEOUT))
         return;
@@ -1359,6 +1380,9 @@
     auto cb_func = sigc::mem_fun(this, &PanelMenuView::UpdateActiveWindowPosition);
     sources_.AddTimeout(timeout_length, cb_func, WINDOW_MOVED_TIMEOUT);
   }
+
+  if (std::find(maximized_wins_.begin(), maximized_wins_.end(), xid) != maximized_wins_.end())
+    UpdateMaximizedWindow();
 }
 
 bool PanelMenuView::IsWindowUnderOurControl(Window xid) const
@@ -1391,7 +1415,7 @@
   return false;
 }
 
-Window PanelMenuView::GetMaximizedWindow() const
+void PanelMenuView::UpdateMaximizedWindow()
 {
   Window window_xid = 0;
 
@@ -1406,7 +1430,7 @@
     }
   }
 
-  return window_xid;
+  maximized_window = window_xid;
 }
 
 Window PanelMenuView::GetTopWindow() const
@@ -1466,11 +1490,14 @@
   if (!layout_->GetAbsoluteGeometry().IsInside(click))
     return;
 
-  unsigned double_click_wait = Settings::Instance().lim_double_click_wait();
-
-  if (double_click_wait > 0)
+  auto& settings = Settings::Instance();
+
+  if (!focused && !settings.lim_unfocused_popup())
+    return;
+
+  if (settings.lim_double_click_wait() > 0)
   {
-    sources_.AddTimeout(double_click_wait, [this, click] {
+    sources_.AddTimeout(settings.lim_double_click_wait(), [this, click] {
       ActivateEntryAt(click.x, click.y);
       return false;
     }, INTEGRATED_MENUS_DOUBLE_CLICK_TIMEOUT);
@@ -1489,15 +1516,18 @@
 
 void PanelMenuView::OnMaximizedActivate(int x, int y)
 {
-  Window maximized = GetMaximizedWindow();
+  Window maximized = maximized_window();
 
   if (maximized != 0)
   {
-    if (maximized != active_xid_)
+    if (maximized != active_window())
     {
-      WindowManager::Default().Activate(maximized);
+      auto& wm = WindowManager::Default();
+      wm.Raise(maximized);
+      wm.Activate(maximized);
     }
-    else if (integrated_menus_)
+
+    if (integrated_menus_)
     {
       // Adjusting the click coordinates to be absolute.
       auto const& grab_geo = titlebar_grab_area_->GetAbsoluteGeometry();
@@ -1509,7 +1539,7 @@
 
 void PanelMenuView::MaximizedWindowWMAction(int x, int y, unsigned button)
 {
-  Window maximized = GetMaximizedWindow();
+  Window maximized = maximized_window();
 
   if (!maximized)
     return;
@@ -1590,7 +1620,7 @@
    * This is a workaround to avoid that the grid plugin would be fired
    * showing the window shape preview effect. See bug #838923 */
 
-  Window maximized = GetMaximizedWindow();
+  Window maximized = maximized_window();
 
   if (maximized != 0)
   {
@@ -1611,7 +1641,7 @@
   x += titlebar_grab_area_->GetAbsoluteX();
   y += titlebar_grab_area_->GetAbsoluteY();
 
-  Window maximized = GetMaximizedWindow();
+  Window maximized = maximized_window();
 
   /* When the drag goes out from the Panel, start the real movement.
    *
@@ -1686,6 +1716,8 @@
   PanelIndicatorsView::AddProperties(introspection);
 
   introspection
+  .add("focused", focused())
+  .add("integrated_menus", integrated_menus_)
   .add("mouse_inside", is_inside_)
   .add("always_show_menus", always_show_menus_)
   .add("grabbed", is_grabbed_)
@@ -1694,7 +1726,8 @@
   .add("panel_title", panel_title_)
   .add("desktop_active", (panel_title_ == desktop_name_))
   .add("monitor", monitor_)
-  .add("active_window", active_xid_)
+  .add("active_window", active_window())
+  .add("maximized_window", maximized_window())
   .add("draw_menus", ShouldDrawMenus())
   .add("draw_window_buttons", ShouldDrawButtons())
   .add("controls_active_window", we_control_active_)
@@ -1833,32 +1866,19 @@
     auto xid = bamf_window_get_xid(window);
 
     if (bamf_view_is_active(view))
-      active_xid_ = xid;
+      active_window = xid;
 
     if (bamf_window_maximized(window) == BAMF_WINDOW_MAXIMIZED)
     {
-      if (xid == active_xid_)
+      if (xid == active_window())
         maximized_wins_.push_front(xid);
       else
         maximized_wins_.push_back(xid);
     }
   }
 
-  Window maximized = GetMaximizedWindow();
-  Window buttons_win = 0;
-
-  if (integrated_menus_)
-  {
-    buttons_win = maximized;
-    window_buttons_->focused = (maximized == active_xid_);
-  }
-  else
-  {
-    buttons_win = (maximized == active_xid_) ? maximized : 0;
-  }
-
   window_buttons_->monitor = monitor_;
-  window_buttons_->controlled_window = buttons_win;
+  UpdateMaximizedWindow();
 
   OnStyleChanged();
   g_list_free(windows);
@@ -1866,7 +1886,15 @@
 
 bool PanelMenuView::HasMenus() const
 {
-  if (entries_.empty())
+  if (!HasVisibleMenus())
+    return false;
+
+  return integrated_menus_ || we_control_active_;
+}
+
+bool PanelMenuView::HasKeyActivableMenus() const
+{
+  if (!HasVisibleMenus())
     return false;
 
   return integrated_menus_ ? is_maximized_ : we_control_active_;
 
=== modified file 'panel/PanelMenuView.h'
--- panel/PanelMenuView.h	2014-12-19 12:09:16 +0000
+++ panel/PanelMenuView.h	2015-02-19 19:24:14 +0000
@@ -44,13 +44,17 @@
   PanelMenuView(menu::Manager::Ptr const&);
   ~PanelMenuView();
 
+  nux::Property<Window> active_window;
+  nux::Property<Window> maximized_window;
+  nux::Property<bool> focused;
+
   void SetMousePosition(int x, int y);
   void SetMonitor(int monitor) override;
 
   Window GetTopWindow() const;
-  Window GetMaximizedWindow() const;
   bool GetControlsActive() const;
   bool HasMenus() const;
+  bool HasKeyActivableMenus() const;
 
   void NotifyAllMenusClosed();
 
@@ -120,9 +124,9 @@
   bool Refresh(bool force = false);
 
   void UpdateTitleTexture(nux::Geometry const&, std::string const& label);
-
   void UpdateLastGeometry(nux::Geometry const& geo);
   void UpdateTitleGradientTexture();
+  void UpdateMaximizedWindow();
 
   void OnPanelViewMouseEnter(int x, int y, unsigned long mouse_button_state, unsigned long special_keys_state);
   void OnPanelViewMouseLeave(int x, int y, unsigned long mouse_button_state, unsigned long special_keys_state);
@@ -134,6 +138,7 @@
   void OnLauncherKeyNavEnded(GVariant* data);
   void OnLauncherSelectionChanged(GVariant* data);
 
+  void UpdateTargetWindowItems();
   void UpdateShowNow(bool ignore);
   bool CheckMouseInside();
 
@@ -158,7 +163,7 @@
 
   void ActivateIntegratedMenus(nux::Point const&);
 
-  menu::Manager::Ptr const& menu_manager_;
+  menu::Manager::Ptr menu_manager_;
   glib::Object<BamfMatcher> matcher_;
 
   nux::TextureLayer* title_layer_;
@@ -190,7 +195,6 @@
   bool integrated_menus_;
   bool always_show_menus_;
 
-  Window active_xid_;
   nux::Geometry monitor_geo_;
   const std::string desktop_name_;
 
 
=== modified file 'panel/PanelView.cpp'
--- panel/PanelView.cpp	2014-12-12 22:33:24 +0000
+++ panel/PanelView.cpp	2015-02-19 19:24:14 +0000
@@ -516,7 +516,7 @@
 
     if (opacity_maximized_toggle_)
     {
-      Window maximized_win = menu_view_->GetMaximizedWindow();
+      Window maximized_win = menu_view_->maximized_window();
 
       if (wm.IsExpoActive() || (maximized_win != 0 && !wm.IsWindowObscured(maximized_win)))
         opacity = 1.0f;
@@ -673,7 +673,7 @@
   if (!IsActive())
     return false;
 
-  if ((menu_view_->HasMenus() && menu_view_->ActivateIfSensitive()) ||
+  if ((menu_view_->HasKeyActivableMenus() && menu_view_->ActivateIfSensitive()) ||
       indicators_->ActivateIfSensitive())
   {
     // Since this only happens on keyboard events, we need to prevent that the
@@ -690,7 +690,7 @@
   if (!IsActive())
     return false;
 
-  if ((menu_view_->HasMenus() && menu_view_->ActivateEntry(entry_id, 0)) ||
+  if ((menu_view_->HasKeyActivableMenus() && menu_view_->ActivateEntry(entry_id, 0)) ||
       indicators_->ActivateEntry(entry_id, 0))
   {
     // Since this only happens on keyboard events, we need to prevent that the
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2015-01-22 22:37:32 +0000
+++ plugins/unityshell/src/unityshell.cpp	2015-02-19 19:24:14 +0000
@@ -157,6 +157,7 @@
   , cScreen(CompositeScreen::get(screen))
   , gScreen(GLScreen::get(screen))
   , sScreen(ScaleScreen::get(screen))
+  , WM(PluginAdapter::Initialize(screen))
   , menus_(std::make_shared<menu::Manager>(std::make_shared<indicator::DBusIndicators>(), std::make_shared<key::GnomeGrabber>()))
   , deco_manager_(std::make_shared<decoration::Manager>(menus_))
   , debugger_(this)
@@ -281,9 +282,6 @@
      ScaleScreenInterface::setHandler(sScreen);
      screen->updateSupportedWmHints();
 
-     PluginAdapter::Initialize(screen);
-     AddChild(&WindowManager::Default());
-
      nux::NuxInitialize(0);
 #ifndef USE_GLES
      wt.reset(nux::CreateFromForeignWindow(cScreen->output(),
@@ -442,13 +440,13 @@
       sigc::mem_fun(this, &UnityScreen::OnMinimizeDurationChanged)
     );
 
-    WindowManager& wm = WindowManager::Default();
-    wm.initiate_spread.connect(sigc::mem_fun(this, &UnityScreen::OnInitiateSpread));
-    wm.terminate_spread.connect(sigc::mem_fun(this, &UnityScreen::OnTerminateSpread));
-    wm.initiate_expo.connect(sigc::mem_fun(this, &UnityScreen::DamagePanelShadow));
-    wm.terminate_expo.connect(sigc::mem_fun(this, &UnityScreen::DamagePanelShadow));
+    WM.initiate_spread.connect(sigc::mem_fun(this, &UnityScreen::OnInitiateSpread));
+    WM.terminate_spread.connect(sigc::mem_fun(this, &UnityScreen::OnTerminateSpread));
+    WM.initiate_expo.connect(sigc::mem_fun(this, &UnityScreen::DamagePanelShadow));
+    WM.terminate_expo.connect(sigc::mem_fun(this, &UnityScreen::DamagePanelShadow));
 
-    AddChild(&screen_introspection_);
+    Introspectable::AddChild(&WM);
+    Introspectable::AddChild(&screen_introspection_);
 
     /* Create blur backup texture */
     auto gpu_device = nux::GetGraphicsDisplay()->GetGpuDevice();
@@ -687,7 +685,7 @@
   if (sources_.GetSource(local::RELAYOUT_TIMEOUT))
     return;
 
-  if (WindowManager::Default().IsExpoActive())
+  if (WM.IsExpoActive())
     return;
 
   CompOutput* output = _last_output;
@@ -948,7 +946,7 @@
   nux::TexCoordXForm texxform;
   texxform.SetWrap(nux::TEXWRAP_REPEAT, nux::TEXWRAP_CLAMP);
 
-  int monitor = WindowManager::Default().MonitorGeometryIn(NuxGeometryFromCompRect(output_dev));
+  int monitor = WM.MonitorGeometryIn(NuxGeometryFromCompRect(output_dev));
   auto const& texture = panel_style_.GetBackground(monitor)->GetDeviceTexture();
   graphics_engine->QRP_GLSL_1Tex(0, 0, output_dev.width(), texture->GetHeight(), texture, texxform, nux::color::White);
 }
@@ -961,7 +959,7 @@
          hud_controller_->IsVisible() ||
          session_controller_->Visible() ||
           ((switcher_controller_->Visible() ||
-            WindowManager::Default().IsExpoActive())
+            WM.IsExpoActive())
            && !fullscreen_windows_.empty () && (!(screen->grabbed () && !screen->otherGrabExist (NULL))));
 }
 
@@ -2219,7 +2217,7 @@
                                          CompAction::State state,
                                          CompOption::Vector& options)
 {
-  WindowManager::Default().ShowDesktop();
+  WM.ShowDesktop();
   return true;
 }
 
@@ -2323,7 +2321,7 @@
                                         CompAction::State state,
                                         CompOption::Vector& options)
 {
-  if (WindowManager::Default().IsWallActive())
+  if (WM.IsWallActive())
     return false;
   else if (switcher_controller_->Visible())
     switcher_controller_->Next();
@@ -2531,11 +2529,9 @@
     if (QuicklistManager::Default()->Current())
       QuicklistManager::Default()->Current()->Hide();
 
-    auto& wm = WindowManager::Default();
-
-    if (wm.IsScreenGrabbed())
+    if (WM.IsScreenGrabbed())
     {
-      hud_ungrab_slot_ = wm.screen_ungrabbed.connect([this] { ShowHud(); });
+      hud_ungrab_slot_ = WM.screen_ungrabbed.connect([this] { ShowHud(); });
 
       // Let's wait ungrab event for maximum a couple of seconds...
       sources_.AddTimeoutSeconds(2, [this] {
@@ -2664,7 +2660,7 @@
   KeySym keysym = XkbKeycodeToKeysym(screen->dpy(), keybind.keycode(), 0, 0);
   unsigned modifiers = CompizModifiersToNux(keybind.modifiers());
 
-  WindowManager::Default().close_window_key = std::make_pair(modifiers, keysym);
+  WM.close_window_key = std::make_pair(modifiers, keysym);
 }
 
 void UnityScreen::UpdateActivateIndicatorsKey()
@@ -2673,7 +2669,7 @@
   KeySym keysym = XkbKeycodeToKeysym(screen->dpy(), keybind.keycode(), 0, 0);
   unsigned modifiers = CompizModifiersToNux(keybind.modifiers());
 
-  WindowManager::Default().activate_indicators_key = std::make_pair(modifiers, keysym);
+  WM.activate_indicators_key = std::make_pair(modifiers, keysym);
 }
 
 bool UnityScreen::initPluginActions()
@@ -2926,7 +2922,7 @@
     }
   }
 
-  if (WindowManager::Default().IsScaleActive() &&
+  if (uScreen->WM.IsScaleActive() &&
       uScreen->sScreen->getSelectedWindow() == window->id())
   {
     nux::Geometry const& scaled_geo = GetScaledGeometry();
@@ -3027,9 +3023,8 @@
             !(window_state & CompWindowStateFullscreenMask) &&
             !(window_type & CompWindowTypeFullscreenMask))
         {
-          WindowManager& wm = WindowManager::Default();
           auto const& output = uScreen->screen->currentOutputDev();
-          int monitor = wm.MonitorGeometryIn(NuxGeometryFromCompRect(output));
+          int monitor = uScreen->WM.MonitorGeometryIn(NuxGeometryFromCompRect(output));
 
           if (window->y() - window->border().top < output.y() + uScreen->panel_style_.PanelHeight(monitor))
           {
@@ -3662,8 +3657,7 @@
     {
       if (strcmp(name, "hsize") == 0 || strcmp(name, "vsize") == 0)
       {
-        WindowManager& wm = WindowManager::Default();
-        wm.viewport_layout_changed.emit(screen->vpSize().width(), screen->vpSize().height());
+        WM.viewport_layout_changed.emit(screen->vpSize().width(), screen->vpSize().height());
       }
       else if (strcmp(name, "close_window_key") == 0)
       {
@@ -3779,13 +3773,11 @@
   if (QuicklistManager::Default()->Current())
     QuicklistManager::Default()->Current()->Hide();
 
-  auto& wm = WindowManager::Default();
-
-  if (wm.IsScaleActive())
-    wm.TerminateScale();
-
-  if (wm.IsExpoActive())
-    wm.TerminateExpo();
+  if (WM.IsScaleActive())
+    WM.TerminateScale();
+
+  if (WM.IsExpoActive())
+    WM.TerminateExpo();
 
   RaiseOSK();
 }
@@ -3889,24 +3881,24 @@
   edge_barriers_ = std::make_shared<ui::EdgeBarrierController>();
 
   launcher_controller_ = std::make_shared<launcher::Controller>(xdnd_manager, edge_barriers_);
-  AddChild(launcher_controller_.get());
+  Introspectable::AddChild(launcher_controller_.get());
 
   switcher_controller_ = std::make_shared<switcher::Controller>();
   switcher_controller_->detail.changed.connect(sigc::mem_fun(this, &UnityScreen::OnSwitcherDetailChanged));
-  AddChild(switcher_controller_.get());
+  Introspectable::AddChild(switcher_controller_.get());
 
   LOG_INFO(logger) << "initLauncher-Launcher " << timer.ElapsedSeconds() << "s";
 
   /* Setup panel */
   timer.Reset();
   panel_controller_ = std::make_shared<panel::Controller>(menus_, edge_barriers_);
-  AddChild(panel_controller_.get());
+  Introspectable::AddChild(panel_controller_.get());
   LOG_INFO(logger) << "initLauncher-Panel " << timer.ElapsedSeconds() << "s";
 
   /* Setup Places */
   dash_controller_ = std::make_shared<dash::Controller>();
   dash_controller_->on_realize.connect(sigc::mem_fun(this, &UnityScreen::OnDashRealized));
-  AddChild(dash_controller_.get());
+  Introspectable::AddChild(dash_controller_.get());
 
   /* Setup Hud */
   hud_controller_ = std::make_shared<hud::Controller>();
@@ -3915,14 +3907,14 @@
   hud_controller_->multiple_launchers = (optionGetNumLaunchers() == 0);
   hud_controller_->icon_size = launcher_controller_->options()->icon_size();
   hud_controller_->tile_size = launcher_controller_->options()->tile_size();
-  AddChild(hud_controller_.get());
+  Introspectable::AddChild(hud_controller_.get());
   LOG_INFO(logger) << "initLauncher-hud " << timer.ElapsedSeconds() << "s";
 
   // Setup Shortcut Hint
   auto base_window_raiser = std::make_shared<shortcut::BaseWindowRaiserImp>();
   auto shortcuts_modeller = std::make_shared<shortcut::CompizModeller>();
   shortcut_controller_ = std::make_shared<shortcut::Controller>(base_window_raiser, shortcuts_modeller);
-  AddChild(shortcut_controller_.get());
+  Introspectable::AddChild(shortcut_controller_.get());
   ShowFirstRunHints();
 
   // Setup Session Controller
@@ -3933,7 +3925,7 @@
   manager->unlocked.connect(sigc::mem_fun(this, &UnityScreen::OnScreenUnlocked));
   session_dbus_manager_ = std::make_shared<session::DBusManager>(manager);
   session_controller_ = std::make_shared<session::Controller>(manager);
-  AddChild(session_controller_.get());
+  Introspectable::AddChild(session_controller_.get());
 
   // Setup Lockscreen Controller
   screensaver_dbus_manager_ = std::make_shared<lockscreen::DBusManager>(manager);
@@ -4119,7 +4111,7 @@
     window->minimizedSetEnabled (this, false);
   }
 
-  /* Keep this after the optionGetShowMinimizedWindows branch */
+  /* Keep this after the optionGetShowMIntrospectable.hinimizedWindows branch */
 
   if (window->state() & CompWindowStateFullscreenMask)
     uScreen->fullscreen_windows_.push_back(window);
@@ -4136,8 +4128,8 @@
 {
   Window xid = window->id();
   auto const& swins = uScreen->sScreen->getWindows();
+  WindowManager& wm = uScreen->WM;
   bool scaled = std::find(swins.begin(), swins.end(), ScaleWindow::get(window)) != swins.end();
-  WindowManager& wm = WindowManager::Default();
 
   introspection
     .add(scaled ? GetScaledGeometry() : wm.GetWindowGeometry(xid))
@@ -4373,9 +4365,7 @@
 
 nux::Geometry UnityWindow::GetScaledGeometry()
 {
-  WindowManager& wm = WindowManager::Default();
-
-  if (!wm.IsScaleActive())
+  if (!uScreen->WM.IsScaleActive())
     return nux::Geometry();
 
   ScaleWindow* scale_win = ScaleWindow::get(window);
 
=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2014-12-12 20:44:52 +0000
+++ plugins/unityshell/src/unityshell.h	2015-02-19 19:24:14 +0000
@@ -332,6 +332,7 @@
 
   /* The window thread should be the last thing removed, as c++ does it in reverse order */
   std::unique_ptr<nux::WindowThread> wt;
+  WindowManager& WM;
 
   menu::Manager::Ptr menus_;
   std::shared_ptr<decoration::Manager> deco_manager_;
@@ -368,7 +369,7 @@
   typedef std::vector<CompActionPtr> ShortcutActions;
   ShortcutActions _shortcut_actions;
   std::map<CancelActionTarget, CompActionPtr> _escape_actions;
-  std::map<int, unsigned int> windows_for_monitor_;
+  std::unordered_map<int, unsigned int> windows_for_monitor_;
 
   /* keyboard-nav mode */
   CompWindow* newFocusedWindow;
 
=== modified file 'services/panel-main.c'
--- services/panel-main.c	2014-11-04 14:25:04 +0000
+++ services/panel-main.c	2015-02-19 19:24:14 +0000
@@ -27,20 +27,21 @@
 #include "config.h"
 #include "panel-a11y.h"
 #include "panel-service.h"
+#include "panel-service-private.h"
 
 static GDBusNodeInfo *introspection_data = NULL;
 
 static const gchar introspection_xml[] =
   "<node>"
-  "  <interface name='com.canonical.Unity.Panel.Service'>"
+  "  <interface name='"UPS_IFACE"'>"
   ""
   "    <method name='Sync'>"
-  "      <arg type='a(ssssbbusbbi)' name='state' direction='out'/>"
+  "      <arg type='"ENTRY_ARRAY_SIGNATURE"' name='state' direction='out'/>"
   "    </method>"
   ""
   "    <method name='SyncOne'>"
   "      <arg type='s' name='indicator_id' direction='in'/>"
-  "      <arg type='a(ssssbbusbbi)' name='state' direction='out'/>"
+  "      <arg type='"ENTRY_ARRAY_SIGNATURE"' name='state' direction='out'/>"
   "    </method>"
   ""
   "    <method name='SyncGeometries'>"
@@ -110,10 +111,6 @@
   "  </interface>"
   "</node>";
 
-#define S_NAME_DESKTOP "com.canonical.Unity.Panel.Service.Desktop"
-#define S_NAME_LOCKSCREEN "com.canonical.Unity.Panel.Service.LockScreen"
-#define S_PATH  "/com/canonical/Unity/Panel/Service"
-#define S_IFACE "com.canonical.Unity.Panel.Service"
 
 /* Forwards */
 static void
@@ -271,8 +268,8 @@
   GError *error = NULL;
   g_dbus_connection_emit_signal (connection,
                                  NULL,
-                                 S_PATH,
-                                 S_IFACE,
+                                 UPS_PATH,
+                                 UPS_IFACE,
                                  "ReSync",
                                  g_variant_new ("(s)", indicator_id),
                                  &error);
@@ -293,10 +290,13 @@
   GError *error = NULL;
   g_dbus_connection_emit_signal (connection,
                                  NULL,
-                                 S_PATH,
-                                 S_IFACE,
+                                 UPS_PATH,
+                                 UPS_IFACE,
                                  "EntryActivated",
-                                 g_variant_new ("(ss(iiuu))", panel_id, entry_id, x, y, w, h),
+                                 g_variant_new ("(ss(iiuu))",
+                                                panel_id ? panel_id : "",
+                                                entry_id ? entry_id : "",
+                                                x, y, w, h),
                                  &error);
 
   if (error)
@@ -316,8 +316,8 @@
 
   g_dbus_connection_emit_signal (connection,
                                  NULL,
-                                 S_PATH,
-                                 S_IFACE,
+                                 UPS_PATH,
+                                 UPS_IFACE,
                                  "EntryActivateRequest",
                                  g_variant_new ("(s)", entry_id),
                                  &error);
@@ -338,8 +338,8 @@
   GError *error = NULL;
   g_dbus_connection_emit_signal (connection,
                                  NULL,
-                                 S_PATH,
-                                 S_IFACE,
+                                 UPS_PATH,
+                                 UPS_IFACE,
                                  "EntryShowNowChanged",
                                  g_variant_new ("(sb)", entry_id, show_now_state),
                                  &error);
@@ -357,8 +357,8 @@
   GError *error = NULL;
   g_dbus_connection_emit_signal (connection,
                                  NULL,
-                                 S_PATH,
-                                 S_IFACE,
+                                 UPS_PATH,
+                                 UPS_IFACE,
                                  "IconPathsChanged",
                                  NULL,
                                  &error);
@@ -379,7 +379,7 @@
   guint         reg_id;
 
   reg_id = g_dbus_connection_register_object (connection,
-                                              S_PATH,
+                                              UPS_PATH,
                                               introspection_data->interfaces[0],
                                               &interface_vtable,
                                               service,
@@ -485,7 +485,7 @@
   service = panel_service_get_default ();
 
   owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
-                             !lockscreen_mode ? S_NAME_DESKTOP : S_NAME_LOCKSCREEN,
+                             !lockscreen_mode ? UPS_NAME_DESKTOP : UPS_NAME_LOCKSCREEN,
                              G_BUS_NAME_OWNER_FLAGS_NONE,
                              on_bus_acquired,
                              on_name_acquired,
 
=== modified file 'services/panel-service-private.h'
--- services/panel-service-private.h	2013-10-03 15:15:35 +0000
+++ services/panel-service-private.h	2015-02-19 19:24:14 +0000
@@ -21,9 +21,27 @@
 
 #include <X11/Xlib.h>
 #include <X11/keysym.h>
+#include <glib.h>
 
 G_BEGIN_DECLS
 
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#define UPS_NAME_DESKTOP "com.canonical.Unity.Panel.Service.Desktop"
+#define UPS_NAME_LOCKSCREEN "com.canonical.Unity.Panel.Service.LockScreen"
+#define UPS_PATH  "/com/canonical/Unity/Panel/Service"
+#define UPS_IFACE "com.canonical.Unity.Panel.Service"
+
+#define APPMENU_INDICATOR_NAME "libappmenu.so"
+
+#define ENTRY_SIGNATURE "(sssusbbusbbi)"
+#define ENTRY_ARRAY_SIGNATURE "a" ENTRY_SIGNATURE ""
+
+#define AltMask Mod1Mask
+#define SuperMask Mod4Mask
+
 typedef struct _KeyBinding
 {
   KeySym key;
@@ -31,11 +49,12 @@
   guint32 modifiers;
 } KeyBinding;
 
-#define AltMask Mod1Mask
-#define SuperMask Mod4Mask
-
 void parse_string_keybinding (const char *, KeyBinding *);
 
+#ifdef  __cplusplus
+}
+#endif
+
 G_END_DECLS
 
 #endif /* _PANEL_SERVICE_PRIVATE_H_ */
 
=== modified file 'services/panel-service.c'
--- services/panel-service.c	2014-11-28 12:55:58 +0000
+++ services/panel-service.c	2015-02-19 19:24:14 +0000
@@ -43,7 +43,7 @@
 
 #define NOTIFY_TIMEOUT 80
 #define N_TIMEOUT_SLOTS 50
-#define MAX_INDICATOR_ENTRIES 100
+#define MAX_INDICATOR_ENTRIES 500
 
 #define NUX_VERTICAL_SCROLL_DELTA 120
 #define NUX_HORIZONTAL_SCROLL_DELTA (NUX_VERTICAL_SCROLL_DELTA ^ 2)
@@ -61,10 +61,13 @@
 {
   GSList     *indicators;
   GSList     *dropdown_entries;
+  GSList     *removed_entries;
   GHashTable *id2entry_hash;
   GHashTable *panel2entries_hash;
+  IndicatorObject *appmenu_indicator;
 
-  gint32 timeouts[N_TIMEOUT_SLOTS];
+  guint timeouts[N_TIMEOUT_SLOTS];
+  guint remove_idle;
 
   IndicatorObjectEntry *last_entry;
   IndicatorObjectEntry *last_dropdown_entry;
@@ -104,14 +107,14 @@
 
 enum
 {
-  SYNC_WAITING = -1,
+  SYNC_WAITING = G_MAXUINT,
   SYNC_NEUTRAL = 0,
 };
 
 static guint32 _service_signals[LAST_SIGNAL] = { 0 };
 
 static const gchar * indicator_order[][2] = {
-  {"libappmenu.so", NULL},                    /* indicator-appmenu" */
+  {APPMENU_INDICATOR_NAME, NULL},             /* indicator-appmenu" */
   {"libapplication.so", NULL},                /* indicator-application" */
   {"floating-indicators", NULL},              /* position-less NG indicators */
   {"libprintersmenu.so", NULL},               /* indicator-printers */
@@ -136,6 +139,8 @@
 static void notify_object (IndicatorObject *object);
 static void update_keybinding (GSettings *, const gchar *, gpointer);
 static void emit_upstart_event (const gchar *);
+static gchar * get_indicator_entry_id_by_entry (IndicatorObjectEntry *entry);
+static IndicatorObjectEntry * get_indicator_entry_by_id (PanelService *self, const gchar *entry_id);
 static GdkFilterReturn event_filter (GdkXEvent *, GdkEvent *, PanelService *);
 
 /*
@@ -164,7 +169,7 @@
 
   for (i = 0; i < N_TIMEOUT_SLOTS; i++)
     {
-      if (priv->timeouts[i] > 0)
+      if (priv->timeouts[i] > 0 && priv->timeouts[i] != SYNC_WAITING)
         {
           g_source_remove (priv->timeouts[i]);
           priv->timeouts[i] = 0;
@@ -265,9 +270,10 @@
 }
 
 static gboolean
-is_point_in_rect (gint x, gint y, GdkRectangle* rect)
+rect_contains_point (GdkRectangle* rect, gint x, gint y)
 {
-  g_return_val_if_fail (rect, FALSE);
+  if (!rect)
+    return FALSE;
 
   return (x >= rect->x && x <= (rect->x + rect->width) &&
           y >= rect->y && y <= (rect->y + rect->height));
@@ -290,7 +296,7 @@
           IndicatorObjectEntry *entry = k;
           GdkRectangle *geo = v;
 
-          if (is_point_in_rect (x, y, geo))
+          if (rect_contains_point (geo, x, y))
             {
               return entry;
             }
@@ -321,8 +327,7 @@
       IndicatorObjectEntry *entry = key;
       GdkRectangle *geo = value;
 
-      if (x >= geo->x && x <= (geo->x + geo->width) &&
-          y >= geo->y && y <= (geo->y + geo->height))
+      if (rect_contains_point (geo, x, y))
         {
           return entry;
         }
@@ -332,7 +337,7 @@
 }
 
 static const gchar*
-get_panel_at (PanelService *self, gint x, gint y)
+get_panel_for_parent_at (PanelService *self, guint parent, gint x, gint y)
 {
   GHashTableIter panel_iter, entries_iter;
   gpointer key, value, k, v;
@@ -346,12 +351,20 @@
 
       while (g_hash_table_iter_next (&entries_iter, &k, &v))
         {
+          IndicatorObjectEntry *entry = k;
           GdkRectangle *geo = v;
 
-          if (x >= geo->x && x <= (geo->x + geo->width) &&
-              y >= geo->y && y <= (geo->y + geo->height))
+          /* The entry might be invalid at this point (as it could have been
+           * removed, but still not synced), so it's better to double check */
+          if (g_slist_find (self->priv->removed_entries, entry))
+            continue;
+
+          if (!parent || entry->parent_window == parent)
             {
-              return panel_id;
+              if (rect_contains_point (geo, x, y))
+                {
+                  return panel_id;
+                }
             }
         }
     }
@@ -414,7 +427,7 @@
       /* Unity might register some "fake" dropdown entries that it might use to
        * to present long menu bars (right now only for appmenu indicator) */
       entry = g_new0 (IndicatorObjectEntry, 1);
-      entry->parent_object = panel_service_get_indicator (self, "libappmenu.so");
+      entry->parent_object = self->priv->appmenu_indicator;
       entry->name_hint = g_strdup (entry_id);
       self->priv->dropdown_entries = g_slist_append (self->priv->dropdown_entries, entry);
       g_hash_table_insert (self->priv->id2entry_hash, (gpointer)entry->name_hint, entry);
@@ -424,6 +437,21 @@
 }
 
 static void
+ensure_entry_menu_is_closed (PanelService *self,
+                             const gchar *panel_id,
+                             IndicatorObjectEntry *entry)
+{
+  PanelServicePrivate  *priv = self->priv;
+
+  /* If the entry has been removed let's make sure that its menu is closed */
+  if (GTK_IS_MENU (priv->last_menu) && priv->last_menu == entry->menu)
+    {
+      if (!priv->last_panel || !panel_id || g_strcmp0 (priv->last_panel, panel_id) == 0)
+        gtk_menu_popdown (entry->menu);
+    }
+}
+
+static void
 reinject_key_event_to_root_window (XIDeviceEvent *ev)
 {
   XKeyEvent kev;
@@ -609,9 +637,7 @@
             {
               /* Middle clicks over an appmenu entry are considered just like
                * all other clicks */
-              IndicatorObject *obj = get_entry_parent_indicator (entry);
-
-              if (g_strcmp0 (g_object_get_data (G_OBJECT (obj), "id"), "libappmenu.so") == 0)
+              if (get_entry_parent_indicator (entry) == priv->appmenu_indicator)
                 {
                   event_is_a_click = TRUE;
                 }
@@ -677,7 +703,7 @@
 initial_resync (PanelService *self)
 {
   g_signal_emit (self, _service_signals[RE_SYNC], 0, "");
-  return FALSE;
+  return G_SOURCE_REMOVE;
 }
 
 static gboolean
@@ -686,7 +712,7 @@
   if (!lockscreen_mode)
     emit_upstart_event ("indicator-services-start");
 
-  return FALSE;
+  return G_SOURCE_REMOVE;
 }
 
 static void
@@ -850,10 +876,10 @@
   if (self->priv->indicators == NULL)
     {
       g_signal_emit (self, _service_signals[INDICATORS_CLEARED], 0);
-      return FALSE;
+      return G_SOURCE_REMOVE;
     }
 
-  return TRUE;
+  return G_SOURCE_CONTINUE;
 }
 
 static void
@@ -931,6 +957,9 @@
       g_object_ref_sink (G_OBJECT (indicator));
     }
 
+  if (self->priv->appmenu_indicator == indicator)
+    self->priv->appmenu_indicator = NULL;
+
   g_object_unref (G_OBJECT (indicator));
 }
 
@@ -1145,7 +1174,7 @@
     g_signal_emit (self, _service_signals[RE_SYNC],
                    0, g_object_get_data (G_OBJECT (object), "id"));
 
-  return FALSE;
+  return G_SOURCE_REMOVE;
 }
 
 static void
@@ -1204,6 +1233,7 @@
   g_return_if_fail (PANEL_IS_SERVICE (self));
   g_return_if_fail (entry != NULL);
 
+  self->priv->removed_entries = g_slist_remove (self->priv->removed_entries, entry);
   gchar *entry_id = get_indicator_entry_id_by_entry (entry);
   g_hash_table_insert (self->priv->id2entry_hash, entry_id, entry);
 
@@ -1243,6 +1273,42 @@
   notify_object (object);
 }
 
+static gboolean
+on_removed_idle (PanelService *self)
+{
+  GHashTableIter iter;
+  GHashTable *entry2geometry_hash;
+  IndicatorObjectEntry *entry;
+  gpointer value;
+  GSList *l;
+
+  for (l = self->priv->removed_entries; l; l = l->next)
+    {
+      entry = l->data;
+      ensure_entry_menu_is_closed (self, NULL, entry);
+
+      g_hash_table_iter_init (&iter, self->priv->panel2entries_hash);
+      while (g_hash_table_iter_next (&iter, NULL, &value))
+        {
+          if ((entry2geometry_hash = value))
+            {
+              g_hash_table_remove (entry2geometry_hash, entry);
+
+              if (g_hash_table_size (entry2geometry_hash) == 0)
+                {
+                  g_hash_table_iter_remove (&iter);
+                }
+            }
+        }
+
+    }
+
+  g_slist_free (self->priv->removed_entries);
+  self->priv->removed_entries = NULL;
+
+  return G_SOURCE_REMOVE;
+}
+
 static void
 on_entry_removed (IndicatorObject      *object,
                   IndicatorObjectEntry *entry,
@@ -1251,11 +1317,6 @@
   g_return_if_fail (PANEL_IS_SERVICE (self));
   g_return_if_fail (entry != NULL);
 
-  /* Don't remove here the value from panel2entries_hash, this should be
-   * done during the geometries sync, to avoid false positive.
-   * FIXME this in libappmenu.so to avoid to send an "entry-removed" signal
-   * when switching the focus from a window to one of its dialog children */
-
   gchar *entry_id = get_indicator_entry_id_by_entry (entry);
   g_hash_table_remove (self->priv->id2entry_hash, entry_id);
   g_free (entry_id);
@@ -1270,6 +1331,13 @@
       g_signal_handlers_disconnect_by_data (entry->image, object);
     }
 
+  self->priv->removed_entries = g_slist_append (self->priv->removed_entries, entry);
+
+  if (self->priv->remove_idle)
+    g_source_remove (self->priv->remove_idle);
+
+  self->priv->remove_idle = g_idle_add ((GSourceFunc) on_removed_idle, self);
+
   notify_object (object);
 }
 
@@ -1327,6 +1395,7 @@
   "unity",
   "unity-3d",
   "unity-panel-service",
+  "unity-all-menus",
   NULL
 };
 
@@ -1346,6 +1415,9 @@
 
   priv->indicators = g_slist_append (priv->indicators, object);
 
+  if (!priv->appmenu_indicator && g_strcmp0 (name, APPMENU_INDICATOR_NAME) == 0)
+    priv->appmenu_indicator = object;
+
   g_object_set_data_full (G_OBJECT (object), "id", g_strdup (name), g_free);
 
   g_signal_connect (object, INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED,
@@ -1607,10 +1679,11 @@
   guint32 image_type = 0;
   gchar *image_data = gtk_image_to_data (entry->image, &image_type);
 
-  g_variant_builder_add (b, "(ssssbbusbbi)",
+  g_variant_builder_add (b, ENTRY_SIGNATURE,
                          indicator_id,
                          id,
                          entry->name_hint ? entry->name_hint : "",
+                         entry->parent_window,
                          is_label ? gtk_label_get_label (entry->label) : "",
                          is_label ? gtk_widget_get_sensitive (GTK_WIDGET (entry->label)) : FALSE,
                          is_label ? gtk_widget_get_visible (GTK_WIDGET (entry->label)) : FALSE,
@@ -1627,14 +1700,15 @@
 indicator_entry_null_to_variant (const gchar     *indicator_id,
                                  GVariantBuilder *b)
 {
-  g_variant_builder_add (b, "(ssssbbusbbi)",
+  g_variant_builder_add (b, ENTRY_SIGNATURE,
                          indicator_id,
                          "",
                          "",
+                         0,
                          "",
                          FALSE,
                          FALSE,
-                         (guint32) 0,
+                         0,
                          "",
                          FALSE,
                          FALSE,
@@ -1642,15 +1716,20 @@
 }
 
 static void
-indicator_object_full_to_variant (IndicatorObject *object, const gchar *indicator_id, GVariantBuilder *b)
+indicator_object_full_to_variant (PanelService *self, IndicatorObject *object,
+                                  const gchar *indicator_id, GVariantBuilder *b)
 {
   GList *entries, *e;
+  GHashTable *index_hash = NULL;
   gint parent_prio = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (object), "priority"));
   entries = indicator_object_get_entries (object);
-  gint index = 0;
+  guint index = 0;
 
   if (entries)
     {
+      if (object == self->priv->appmenu_indicator)
+        index_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, NULL);
+
       for (e = entries; e; e = e->next)
         {
           gint prio = -1;
@@ -1664,14 +1743,29 @@
 
           if (prio < 0)
             {
+              if (index_hash)
+                {
+                  index = GPOINTER_TO_UINT (g_hash_table_lookup (index_hash,
+                                                                 GUINT_TO_POINTER (entry->parent_window)));
+                }
+
               prio = parent_prio + index;
               index++;
+
+              if (index_hash)
+                {
+                  g_hash_table_insert (index_hash, GUINT_TO_POINTER (entry->parent_window),
+                                                   GUINT_TO_POINTER (index));
+                }
             }
 
           indicator_entry_to_variant (entry, id, indicator_id, b, prio);
           g_free (id);
         }
 
+      if (index_hash)
+        g_hash_table_destroy (index_hash);
+
       g_list_free (entries);
     }
   else
@@ -1682,15 +1776,15 @@
 }
 
 static void
-indicator_object_to_variant (IndicatorObject *object, const gchar *indicator_id, GVariantBuilder *b)
+indicator_object_to_variant (PanelService *self, IndicatorObject *object,
+                             const gchar *indicator_id, GVariantBuilder *b)
 {
   if (!GPOINTER_TO_INT (g_object_get_data (G_OBJECT (object), "remove")))
     {
-      indicator_object_full_to_variant (object, indicator_id, b);
+      indicator_object_full_to_variant (self, object, indicator_id, b);
     }
   else
     {
-      PanelService *self = panel_service_get_default ();
       indicator_entry_null_to_variant (indicator_id, b);
       panel_service_actually_remove_indicator (self, object);
     }
@@ -1718,7 +1812,7 @@
           rect.height *= scale;
         }
 
-      if (is_point_in_rect (x, y, &rect))
+      if (rect_contains_point (&rect, x, y))
         {
           return i;
         }
@@ -1790,8 +1884,8 @@
   GSList *i;
   gint position;
 
-  g_variant_builder_init (&b, G_VARIANT_TYPE ("(a(ssssbbusbbi))"));
-  g_variant_builder_open (&b, G_VARIANT_TYPE ("a(ssssbbusbbi)"));
+  g_variant_builder_init (&b, G_VARIANT_TYPE ("("ENTRY_ARRAY_SIGNATURE")"));
+  g_variant_builder_open (&b, G_VARIANT_TYPE (ENTRY_ARRAY_SIGNATURE));
 
   for (i = self->priv->indicators; i;)
     {
@@ -1801,7 +1895,7 @@
 
       const gchar *indicator_id = g_object_get_data (G_OBJECT (indicator), "id");
       position = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (indicator), "position"));
-      indicator_object_to_variant (indicator, indicator_id, &b);
+      indicator_object_to_variant (self, indicator, indicator_id, &b);
 
       /* Set the sync back to neutral */
       self->priv->timeouts[position] = SYNC_NEUTRAL;
@@ -1817,8 +1911,8 @@
   GVariantBuilder b;
   GSList *i;
 
-  g_variant_builder_init (&b, G_VARIANT_TYPE ("(a(ssssbbusbbi))"));
-  g_variant_builder_open (&b, G_VARIANT_TYPE ("a(ssssbbusbbi)"));
+  g_variant_builder_init (&b, G_VARIANT_TYPE ("("ENTRY_ARRAY_SIGNATURE")"));
+  g_variant_builder_open (&b, G_VARIANT_TYPE (ENTRY_ARRAY_SIGNATURE));
 
   for (i = self->priv->indicators; i; i = i->next)
     {
@@ -1826,7 +1920,7 @@
                      g_object_get_data (G_OBJECT (i->data), "id")) == 0)
         {
           gint position = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (i->data), "position"));
-          indicator_object_to_variant (i->data, indicator_id, &b);
+          indicator_object_to_variant (self, i->data, indicator_id, &b);
 
           /* Set the sync back to neutral */
           self->priv->timeouts[position] = SYNC_NEUTRAL;
@@ -1850,6 +1944,7 @@
 {
   IndicatorObject *object;
   IndicatorObjectEntry *entry;
+  GHashTable *entry2geometry_hash;
   gboolean valid_entry = TRUE;
   PanelServicePrivate  *priv = self->priv;
 
@@ -1870,24 +1965,18 @@
 
   if (entry)
     {
-      GHashTable *entry2geometry_hash = g_hash_table_lookup (priv->panel2entries_hash, panel_id);
+      entry2geometry_hash = g_hash_table_lookup (priv->panel2entries_hash, panel_id);
 
       if (width < 0 || height < 0 || !valid_entry)
         {
-          /* If the entry has been removed let's make sure that its menu is closed */
-          if (valid_entry && GTK_IS_MENU (priv->last_menu) && priv->last_menu == entry->menu)
-            {
-              if (!priv->last_panel || g_strcmp0 (priv->last_panel, panel_id) == 0)
-                gtk_menu_popdown (entry->menu);
-            }
+          if (valid_entry)
+            ensure_entry_menu_is_closed (self, panel_id, entry);
 
           if (entry2geometry_hash)
             {
-              if (g_hash_table_size (entry2geometry_hash) > 1)
-                {
-                  g_hash_table_remove (entry2geometry_hash, entry);
-                }
-              else
+              g_hash_table_remove (entry2geometry_hash, entry);
+
+              if (g_hash_table_size (entry2geometry_hash) == 0)
                 {
                   g_hash_table_remove (priv->panel2entries_hash, panel_id);
                 }
@@ -2256,7 +2345,7 @@
       priv->last_x = x;
       priv->last_y = y;
       priv->last_menu_button = button;
-      priv->last_panel = get_panel_at (self, x, y);
+      priv->last_panel = get_panel_for_parent_at (self, xid, x, y);
 
       g_signal_connect (priv->last_menu, "hide", G_CALLBACK (on_active_menu_hidden), self);
       g_signal_connect_after (priv->last_menu, "move-current",
@@ -2462,10 +2551,9 @@
   GList                *entries;
 
   g_return_if_fail (PANEL_IS_SERVICE (self));
-
-  object = panel_service_get_indicator (self, "libappmenu.so");
-  g_return_if_fail (INDICATOR_IS_OBJECT (object));
-
+  g_return_if_fail (INDICATOR_IS_OBJECT (self->priv->appmenu_indicator));
+
+  object = self->priv->appmenu_indicator;
   entries = indicator_object_get_entries (object);
 
   if (entries)
 
=== modified file 'services/panel-service.h'
--- services/panel-service.h	2014-09-19 18:38:21 +0000
+++ services/panel-service.h	2015-02-19 19:24:14 +0000
@@ -56,14 +56,6 @@
 struct _PanelServiceClass
 {
   GObjectClass   parent_class;
-
-  /*< private >*/
-  void (*_view_padding1) (void);
-  void (*_view_padding2) (void);
-  void (*_view_padding3) (void);
-  void (*_view_padding4) (void);
-  void (*_view_padding5) (void);
-  void (*_view_padding6) (void);
 };
 
 GType             panel_service_get_type      (void) G_GNUC_CONST;
 
=== modified file 'shortcuts/ShortcutModel.h'
--- shortcuts/ShortcutModel.h	2013-01-19 00:25:07 +0000
+++ shortcuts/ShortcutModel.h	2015-02-19 19:24:14 +0000
@@ -21,7 +21,7 @@
 #define UNITYSHELL_SHORTCUS_MODEL_H
 
 #include <boost/noncopyable.hpp>
-#include <map>
+#include <unordered_map>
 #include <memory>
 #include <list>
 #include <string>
@@ -43,7 +43,7 @@
 
   nux::Property<int> categories_per_column;
   std::vector<std::string> const& categories() const { return categories_; }
-  std::map<std::string, std::list<AbstractHint::Ptr>> const& hints() const { return hints_; }
+  std::unordered_map<std::string, std::list<AbstractHint::Ptr>> const& hints() const { return hints_; }
 
   void Fill();
 
@@ -51,7 +51,7 @@
   void AddHint(AbstractHint::Ptr const& hint);
 
   std::vector<std::string> categories_;
-  std::map<std::string, std::list<AbstractHint::Ptr>> hints_;
+  std::unordered_map<std::string, std::list<AbstractHint::Ptr>> hints_;
 };
 
 }
 
=== modified file 'tests/autopilot/unity/emulators/panel.py'
--- tests/autopilot/unity/emulators/panel.py	2013-05-10 05:16:07 +0000
+++ tests/autopilot/unity/emulators/panel.py	2015-02-19 19:24:14 +0000
@@ -159,6 +159,10 @@
         return self.menus.panel_title
 
     @property
+    def focused(self):
+        return self.menus.focused
+
+    @property
     def desktop_is_active(self):
         return self.menus.desktop_active
 
 
=== modified file 'tests/autopilot/unity/tests/__init__.py'
--- tests/autopilot/unity/tests/__init__.py	2014-02-12 20:43:54 +0000
+++ tests/autopilot/unity/tests/__init__.py	2015-02-19 19:24:14 +0000
@@ -48,7 +48,7 @@
 from Xlib import display
 from Xlib import Xutil
 
-from gi.repository import Gio
+from gi.repository import GLib, Gio
 
 log = getLogger(__name__)
 
@@ -256,20 +256,19 @@
         atom_type = display.Display().intern_atom('CARDINAL')
         return bamf_window.x_win.get_property(atom, atom_type, 0, 1024).value[0]
 
-    def call_gsettings_cmd(self, command, schema, *args):
+    def call_gsettings_cmd(self, command, schema, key, value=None):
         """Set a desktop wide gsettings option
-
-        Using the gsettings command because there is a bug with importing
-        from gobject introspection and pygtk2 simultaneously, and the Xlib
-        keyboard layout bits are very unwieldy. This seems like the best
-        solution, even a little bit brutish.
         """
-        cmd = ['gsettings', command, schema] + list(args)
-        # strip to remove the trailing \n.
-        ret = check_output(cmd).strip()
-        time.sleep(5)
-        reset_display()
-        return ret
+        settings = Gio.Settings.new(schema)
+
+        if command == "get":
+            return settings.get_value(key).print_(type_annotate=False)
+        elif command == "set":
+            settings.set_value(key, GLib.Variant.parse(type=None, text=value))
+            settings.apply()
+            reset_display()
+        elif command == "reset":
+            settings.reset(key)
 
     def set_unity_option(self, option_name, option_value):
         """Set an option in the unity compiz plugin options.
 
=== modified file 'tests/autopilot/unity/tests/test_dash.py'
--- tests/autopilot/unity/tests/test_dash.py	2014-02-28 19:53:07 +0000
+++ tests/autopilot/unity/tests/test_dash.py	2015-02-19 19:24:14 +0000
@@ -164,7 +164,7 @@
 
         self.assertProperty(char_win, is_active=True)
 
-    def test_dash_does_not_open_when_fullscreen_window(self):
+    def test_dash_opens_when_fullscreen_window(self):
         """ The Dash must not open if a window is fullscreen. """
         gedit = self.process_manager.start_app("Text Editor")
         self.keyboard.press_and_release('F11')
@@ -175,7 +175,7 @@
         self.keybinding("dash/reveal")
         self.addCleanup(self.unity.dash.ensure_hidden)
 
-        self.assertThat(self.unity.dash.visible, Eventually(Equals(False)))
+        self.assertThat(self.unity.dash.visible, Eventually(Equals(True)))
 
 
 class DashRevealWithSpreadTests(DashTestCase):
 
=== modified file 'tests/autopilot/unity/tests/test_hud.py'
--- tests/autopilot/unity/tests/test_hud.py	2014-02-28 19:53:07 +0000
+++ tests/autopilot/unity/tests/test_hud.py	2015-02-19 19:24:14 +0000
@@ -512,7 +512,7 @@
         self.keyboard.type("e")
         self.assertThat(self.unity.hud.view.selected_button, Eventually(Equals(1)))
 
-    def test_hud_does_not_open_when_fullscreen_window(self):
+    def test_hud_opens_when_fullscreen_window(self):
         """ The Hud must not open if a window is fullscreen. """
         gedit = self.process_manager.start_app("Text Editor")
         self.keyboard.press_and_release('F11')
@@ -523,7 +523,7 @@
         self.keybinding("hud/reveal")
         self.addCleanup(self.unity.hud.ensure_hidden)
 
-        self.assertThat(self.unity.hud.visible, Eventually(Equals(False)))
+        self.assertThat(self.unity.hud.visible, Eventually(Equals(True)))
 
 
 class HudLauncherInteractionsTests(HudTestsBase):
 
=== modified file 'tests/autopilot/unity/tests/test_panel.py'
--- tests/autopilot/unity/tests/test_panel.py	2014-03-04 15:30:06 +0000
+++ tests/autopilot/unity/tests/test_panel.py	2015-02-19 19:24:14 +0000
@@ -12,6 +12,7 @@
 #from autopilot.emulators.bamf import BamfWindow
 from autopilot.process import Window
 from autopilot.matchers import Eventually
+from autopilot.testcase import multiply_scenarios
 import logging
 import os
 from testtools.matchers import Equals,  GreaterThan, NotEquals
@@ -25,6 +26,13 @@
 
 logger = logging.getLogger(__name__)
 
+def _make_scenarios():
+    return multiply_scenarios(_make_monitor_scenarios(),
+                              _make_menu_modes_scenarios())
+
+def _make_menu_modes_scenarios():
+    return [ ('Locally Integrated Menus', {'lim': True}),
+             ('Global Menus', {'lim': False}) ]
 
 def _make_monitor_scenarios():
     num_monitors = Display.create().get_num_screens()
@@ -38,17 +46,41 @@
 
     return scenarios
 
-
 class PanelTestsBase(UnityTestCase):
 
     panel_monitor = 0
+    lim = False
 
     def setUp(self):
         super(PanelTestsBase, self).setUp()
         self.panel = self.unity.panels.get_panel_for_monitor(self.panel_monitor)
+
+        old_lim = self.call_gsettings_cmd('get', 'com.canonical.Unity', 'integrated-menus')
+        self.call_gsettings_cmd('set', 'com.canonical.Unity', 'integrated-menus', str(self.lim).lower())
+        self.addCleanup(self.call_gsettings_cmd, 'set', 'com.canonical.Unity', 'integrated-menus', old_lim)
+
+        old_showmenus = self.call_gsettings_cmd('get', 'com.canonical.Unity', 'always-show-menus')
+        self.call_gsettings_cmd('set', 'com.canonical.Unity', 'always-show-menus', 'false')
+        self.addCleanup(self.call_gsettings_cmd, 'set', 'com.canonical.Unity', 'always-show-menus', old_showmenus)
+
         self.panel.move_mouse_below_the_panel()
         self.addCleanup(self.panel.move_mouse_below_the_panel)
 
+        self.assertThat(self.panel.menus.integrated_menus, Eventually(Equals(self.lim)))
+        if not self.lim:
+            self.assertThat(self.panel.focused, Eventually(Equals(True)))
+
+    def ensure_window_state(self, win, maximized=False):
+        if maximized and not win.is_maximized:
+            self.keybinding("window/maximize")
+            self.addCleanup(self.keybinding, "window/restore")
+        elif not maximized and win.is_maximized:
+            self.keybinding("window/restore")
+            self.addCleanup(self.keybinding, "window/maximize")
+
+        sleep(.25)
+        self.assertProperty(win, is_maximized=maximized)
+
     def open_new_application_window(self, app_name, maximized=False, move_to_monitor=True):
         """Opens a new instance of the requested application, ensuring that only
         one window is opened.
@@ -68,17 +100,8 @@
         if move_to_monitor:
             self.move_window_to_panel_monitor(app_win)
 
-        if maximized and not app_win.is_maximized:
-            self.keybinding("window/maximize")
-            self.addCleanup(self.keybinding, "window/restore")
-        elif not maximized and app_win.is_maximized:
-            self.keybinding("window/restore")
-            self.addCleanup(self.keybinding, "window/maximize")
-
         app_win.set_focus()
-        sleep(.25)
-
-        self.assertThat(app_win.is_maximized, Equals(maximized))
+        self.ensure_window_state(app_win, maximized)
 
         return app_win
 
@@ -137,9 +160,10 @@
 
     def sleep_menu_settle_period(self):
         """Sleep long enough for the menus to fade in and fade out again."""
-        sleep(self.panel.menus.fadein_duration / 1000.0)
-        sleep(self.panel.menus.discovery_duration)
-        sleep(self.panel.menus.fadeout_duration / 1000.0)
+        if not self.lim:
+            sleep(self.panel.menus.fadein_duration / 1000.0)
+            sleep(self.panel.menus.discovery_duration)
+            sleep(self.panel.menus.fadeout_duration / 1000.0)
 
     # Unable to exit SDM without any active apps, need a placeholder.
     # See bug LP:1079460
@@ -152,7 +176,7 @@
 
 class PanelTitleTests(PanelTestsBase):
 
-    scenarios = _make_monitor_scenarios()
+    scenarios = _make_scenarios()
 
     def setUp(self):
         super(PanelTitleTests, self).setUp()
@@ -174,13 +198,15 @@
         """Panel must display application name for a non-maximised application."""
         calc_win = self.open_new_application_window("Calculator", maximized=False)
 
-        self.assertThat(self.panel.title, Eventually(Equals(calc_win.application.name)))
+        expected = calc_win.application.name if not self.lim else ''
+        self.assertThat(self.panel.title, Eventually(Equals(expected)))
 
     def test_panel_title_with_maximized_application(self):
         """Panel must display application name for a maximised application."""
         text_win = self.open_new_application_window("Text Editor", maximized=True)
 
         self.assertThat(self.panel.title, Eventually(Equals(text_win.title)))
+        self.assertThat(self.panel.focused, Eventually(Equals(True)))
 
     def test_panel_title_with_maximized_window_restored_child(self):
         """Tests the title shown in the panel when opening the restored child of
@@ -194,14 +220,18 @@
 
         self.assertThat(lambda: len(text_win.application.get_windows()),
                         Eventually(Equals(2)))
-        self.assertThat(self.panel.title, Equals(text_win.application.name))
+        expected = text_win.application.name if not self.lim else text_win.title
+        self.assertThat(self.panel.title, Equals(expected))
+        self.assertThat(self.panel.focused, Eventually(Equals(not self.lim)))
 
     def test_panel_shows_app_title_with_maximised_app(self):
         """Tests app titles are shown in the panel with a non-focused maximized application."""
-        self.open_new_application_window("Text Editor", maximized=True)
+        text_win = self.open_new_application_window("Text Editor", maximized=True)
         calc_win = self.open_new_application_window("Calculator", maximized=False)
 
-        self.assertThat(self.panel.title, Eventually(Equals(calc_win.application.name)))
+        expected = calc_win.application.name if not self.lim else text_win.title
+        self.assertThat(self.panel.title, Eventually(Equals(expected)))
+        self.assertThat(self.panel.focused, Eventually(Equals(not self.lim)))
 
     def test_panel_title_updates_when_switching_to_maximized_app(self):
         """Switching to a maximised app from a restored one must update the panel title."""
@@ -242,13 +272,14 @@
 
 class PanelWindowButtonsTests(PanelTestsBase):
 
-    scenarios = _make_monitor_scenarios()
+    scenarios = _make_scenarios()
 
     def setUp(self):
         super(PanelWindowButtonsTests, self).setUp()
         # Locked Launchers on all monitors
         self.set_unity_option('num_launchers', 0)
         self.set_unity_option('launcher_hide_mode', 0)
+        self.always_visible = self.lim
 
     def test_window_buttons_dont_show_on_empty_desktop(self):
         """Tests that the window buttons are not shown on clean desktop."""
@@ -279,13 +310,14 @@
 
         self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
 
-    def test_window_buttons_dont_show_for_maximized_window_on_mouse_out(self):
-        """Window buttons must not show for a maximized window when the mouse is
-        outside the panel.
+    def test_window_buttons_show_for_maximized_window_on_mouse_out(self):
+        """Window buttons might show for a maximized window when the mouse is
+        outside the panel, depending on LIM setting.
         """
         self.open_new_application_window("Text Editor", maximized=True)
 
-        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
+        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(self.always_visible)))
+        self.assertThat(self.panel.window_buttons.focused, Eventually(Equals(True)))
 
     def test_window_buttons_show_for_maximized_window_on_mouse_in(self):
         """Window buttons must show when a maximized window is focused and the
@@ -296,8 +328,30 @@
         self.panel.move_mouse_over_window_buttons()
 
         self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(True)))
+        self.assertThat(self.panel.window_buttons.focused, Eventually(Equals(True)))
         self.assertWinButtonsInOverlayMode(False)
 
+    def test_window_buttons_show_for_maximized_unfocused_window_with_mouse_in_panel(self):
+        """Window buttons might show for an unfocused maximized window when the
+        mouse is over the panel, depending on LIM setting.
+        """
+        self.open_new_application_window("Text Editor", maximized=True)
+        self.open_new_application_window("Calculator")
+        self.panel.move_mouse_over_window_buttons()
+
+        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(self.always_visible)))
+        self.assertThat(self.panel.window_buttons.focused, Eventually(Equals(not self.lim)))
+
+    def test_window_buttons_show_for_maximized_unfocused_window_on_mouse_out(self):
+        """Window buttons might show for an unfocused maximized window when the
+        mouse is outside the panel, depending on LIM setting.
+        """
+        self.open_new_application_window("Text Editor", maximized=True)
+        self.open_new_application_window("Calculator")
+
+        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(self.always_visible)))
+        self.assertThat(self.panel.window_buttons.focused, Eventually(Equals(not self.lim)))
+
     def test_window_buttons_show_with_dash(self):
         """Window buttons must be shown when the dash is open."""
         self.unity.dash.ensure_visible()
@@ -340,122 +394,6 @@
             else:
                 self.assertThat(self.unity.hud.view.overlay_window_buttons_shown[monitor], Equals(False))
 
-    def test_window_buttons_update_visual_state(self):
-        """Window button must update its state in response to mouse events."""
-        self.open_new_application_window("Text Editor", maximized=True, move_to_monitor=True)
-        self.panel.move_mouse_over_window_buttons()
-        button = self.panel.window_buttons.unmaximize
-
-        self.assertThat(button.visual_state, Eventually(Equals("normal")))
-
-        button.mouse_move_to()
-        self.assertThat(button.visual_state, Eventually(Equals("prelight")))
-
-        self.mouse.press()
-        self.addCleanup(self.mouse.release)
-        self.assertThat(button.visual_state, Eventually(Equals("pressed")))
-
-    def test_window_buttons_cancel(self):
-        """Window buttons must ignore clicks when the mouse released outside
-        their area.
-        """
-        win = self.open_new_application_window("Text Editor", maximized=True, move_to_monitor=True)
-        self.panel.move_mouse_over_window_buttons()
-
-        button = self.panel.window_buttons.unmaximize
-        button.mouse_move_to()
-        self.mouse.press()
-        self.assertThat(button.visual_state, Eventually(Equals("pressed")))
-        self.panel.move_mouse_below_the_panel()
-        self.mouse.release()
-
-        self.assertThat(win.is_maximized, Equals(True))
-
-    def test_window_buttons_close_button_works_for_window(self):
-        """Close window button must actually closes a window."""
-        text_win = self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
-        win_xid = text_win.x_id
-
-        self.panel.window_buttons.close.mouse_click()
-        self.assertNoWindowOpenWithXid(win_xid)
-
-    def test_window_buttons_close_follows_fitts_law(self):
-        """Tests that the 'Close' button is activated when clicking at 0,0.
-
-        See bug #839690
-        """
-        text_win = self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
-        win_xid = text_win.x_id
-
-        self.panel.move_mouse_over_window_buttons()
-        screen_x, screen_y = self.display.get_screen_geometry(self.panel_monitor)[:2]
-        self.mouse.move(screen_x, screen_y)
-        self.mouse.click()
-
-        self.assertNoWindowOpenWithXid(win_xid)
-
-    def test_window_buttons_minimize_button_works_for_window(self):
-        """Tests that the window button 'Minimize' actually minimizes a window."""
-        text_win = self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
-
-        self.panel.window_buttons.minimize.mouse_click()
-
-        self.assertProperty(text_win, is_hidden=True)
-
-    def test_window_buttons_minimize_follows_fitts_law(self):
-        """Tests that the 'Minimize' button is conform to Fitts's Law.
-
-        See bug #839690
-        """
-        text_win = self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
-
-        self.panel.move_mouse_over_window_buttons()
-        button = self.panel.window_buttons.minimize
-        target_x = button.x + button.width / 2
-        target_y = self.display.get_screen_geometry(self.panel_monitor)[1]
-        self.mouse.move(target_x, target_y)
-        self.mouse.click()
-
-        self.assertProperty(text_win, is_hidden=True)
-
-    def test_window_buttons_unmaximize_button_works_for_window(self):
-        """Tests that the window button 'Unmaximize' actually unmaximizes a window."""
-        text_win = self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
-
-        self.panel.window_buttons.unmaximize.mouse_click()
-
-        self.assertProperties(text_win, is_maximized=False, is_focused=True)
-        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
-
-    def test_window_buttons_unmaximize_follows_fitts_law(self):
-        """Tests that the 'Unmaximize' button is conform to Fitts's Law.
-
-        See bug #839690
-        """
-        text_win = self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
-
-        button = self.panel.window_buttons.unmaximize
-        button.mouse_move_to()
-        target_x = button.x + button.width / 2
-        target_y = self.display.get_screen_geometry(self.panel_monitor)[1]
-        self.mouse.move(target_x, target_y)
-        sleep(1)
-        self.mouse.click()
-
-        self.assertProperty(text_win, is_maximized=False)
-
     def test_window_buttons_close_button_works_for_hud(self):
         """Tests that the window 'Close' actually closes the HUD."""
         self.unity.hud.ensure_visible()
@@ -604,9 +542,7 @@
 
     def test_minimize_button_disabled_for_non_minimizable_windows(self):
         """Minimize button must be disabled for windows that don't support minimization."""
-        text_win = self.open_new_application_window("Text Editor",
-            maximized=False,
-            move_to_monitor=True)
+        text_win = self.open_new_application_window("Text Editor", maximized=True)
 
         self.keyboard.press_and_release("Ctrl+S")
         self.addCleanup(self.keyboard.press_and_release, "Escape")
@@ -626,28 +562,24 @@
         """Window buttons must be shown when mouse is over panel area with an
         indicator open.
         """
-        self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
+        self.open_new_application_window("Text Editor", maximized=True)
 
         indicator = self.panel.indicators.get_indicator_by_name_hint("indicator-session")
         self.mouse_open_indicator(indicator)
-        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
+        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(self.always_visible)))
 
         self.panel.move_mouse_below_the_panel()
-        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
+        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(self.always_visible)))
 
         self.panel.move_mouse_over_grab_area()
         self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(True)))
 
     def test_window_buttons_show_when_holding_show_menu_key(self):
         """Window buttons must show when we press the show-menu keybinding."""
-        self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
+        self.open_new_application_window("Text Editor", maximized=True)
 
         self.sleep_menu_settle_period()
-        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
+        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(self.always_visible)))
 
         self.keybinding_hold("panel/show_menus")
         self.addCleanup(self.keybinding_release, "panel/show_menus")
@@ -657,7 +589,7 @@
         # Sleep a bit to avoid a race with the Hud showing
         sleep(0.5)
         self.keybinding_release("panel/show_menus")
-        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
+        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(self.always_visible)))
 
     def test_window_buttons_cant_accept_keynav_focus(self):
         """On a mouse down event over the window buttons
@@ -673,57 +605,149 @@
 
         self.assertThat(self.unity.hud.search_string, Eventually(Equals("HelloWorld")))
 
-    def test_double_click_unmaximize_window(self):
-        """Double clicking the grab area must unmaximize a maximized window."""
-        gedit_win = self.open_new_application_window("Text Editor", maximized=True)
-
-        self.panel.move_mouse_over_grab_area()
-        self.mouse.click()
-        self.mouse.click()
-
-        self.assertThat(self.panel.title, Eventually(Equals(gedit_win.application.name)))
+
+class PanelWindowButtonsActionsTests(PanelTestsBase):
+    """Test WindowButtons actions on windows, focused or not depending on LIM"""
+    restored_on_top = False
+    scenarios = multiply_scenarios(_make_monitor_scenarios(),
+                                   (_make_menu_modes_scenarios() +
+                                    [('Locally Integrated Menus with restored on Top',
+                                      {'lim': True, 'restored_on_top': True})]))
+
+    def setUp(self):
+        super(PanelWindowButtonsActionsTests, self).setUp()
+        self.text_win = self.open_new_application_window("Text Editor", maximized=True)
+
+        if self.restored_on_top:
+            self.open_new_application_window("Calculator")
+
+    def test_window_buttons_update_visual_state(self):
+        """Window button must update its state in response to mouse events."""
+        self.panel.move_mouse_over_window_buttons()
+        button = self.panel.window_buttons.unmaximize
+
+        self.assertThat(self.panel.window_buttons.focused, Eventually(Equals(not self.restored_on_top)))
+        self.assertThat(button.visual_state, Eventually(Equals("normal")))
+
+        button.mouse_move_to()
+        self.assertThat(button.visual_state, Eventually(Equals("prelight")))
+
+        self.mouse.press()
+        self.addCleanup(self.mouse.release)
+        self.assertThat(button.visual_state, Eventually(Equals("pressed")))
+
+    def test_window_buttons_cancel(self):
+        """Window buttons must ignore clicks when the mouse released outside
+        their area.
+        """
+        self.panel.move_mouse_over_window_buttons()
+
+        button = self.panel.window_buttons.unmaximize
+        button.mouse_move_to()
+        self.mouse.press()
+        self.assertThat(button.visual_state, Eventually(Equals("pressed")))
+        self.panel.move_mouse_below_the_panel()
+        self.mouse.release()
+
+        self.assertThat(self.text_win.is_maximized, Equals(True))
+
+    def test_window_buttons_close_button_works_for_window(self):
+        """Close window button must actually closes a window."""
+        win_xid = self.text_win.x_id
+
+        self.panel.window_buttons.close.mouse_click()
+        self.assertNoWindowOpenWithXid(win_xid)
+
+    def test_window_buttons_close_follows_fitts_law(self):
+        """Tests that the 'Close' button is activated when clicking at 0,0.
+
+        See bug #839690
+        """
+        win_xid = self.text_win.x_id
+
+        self.panel.move_mouse_over_window_buttons()
+        screen_x, screen_y = self.display.get_screen_geometry(self.panel_monitor)[:2]
+        self.mouse.move(screen_x, screen_y)
+        self.mouse.click()
+
+        self.assertNoWindowOpenWithXid(win_xid)
+
+    def test_window_buttons_minimize_button_works_for_window(self):
+        """Tests that the window button 'Minimize' actually minimizes a window."""
+        self.panel.window_buttons.minimize.mouse_click()
+        self.assertProperty(self.text_win, is_hidden=True)
+
+    def test_window_buttons_minimize_follows_fitts_law(self):
+        """Tests that the 'Minimize' button is conform to Fitts's Law.
+
+        See bug #839690
+        """
+        self.panel.move_mouse_over_window_buttons()
+        button = self.panel.window_buttons.minimize
+        target_x = button.x + button.width / 2
+        target_y = self.display.get_screen_geometry(self.panel_monitor)[1]
+        self.mouse.move(target_x, target_y)
+        self.mouse.click()
+
+        self.assertProperty(self.text_win, is_hidden=True)
+
+    def test_window_buttons_unmaximize_button_works_for_window(self):
+        """Tests that the window button 'Unmaximize' actually unmaximizes a window."""
+        self.panel.window_buttons.unmaximize.mouse_click()
+
+        self.assertProperties(self.text_win, is_maximized=False, is_focused=True)
+        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
+
+    def test_window_buttons_unmaximize_follows_fitts_law(self):
+        """Tests that the 'Unmaximize' button is conform to Fitts's Law.
+
+        See bug #839690
+        """
+        button = self.panel.window_buttons.unmaximize
+        button.mouse_move_to()
+        target_x = button.x + button.width / 2
+        target_y = self.display.get_screen_geometry(self.panel_monitor)[1]
+        self.mouse.move(target_x, target_y)
+        sleep(1)
+        self.mouse.click()
+
+        self.assertProperty(self.text_win, is_maximized=False)
 
 
 class PanelHoverTests(PanelTestsBase):
     """Tests with the mouse pointer hovering the panel area."""
 
-    scenarios = _make_monitor_scenarios()
+    scenarios = _make_scenarios()
 
     def test_only_menus_show_for_restored_window_on_mouse_in_window_btn_area(self):
         """Restored windows should only show menus when the mouse is in the window
         button area.
         """
-        self.open_new_application_window("Calculator",
-            maximized=False,
-            move_to_monitor=True)
+        self.open_new_application_window("Calculator")
         self.sleep_menu_settle_period()
 
         self.panel.move_mouse_over_window_buttons()
 
-        self.assertThat(self.panel.menus_shown, Eventually(Equals(True)))
+        self.assertThat(self.panel.menus_shown, Eventually(Equals(not self.lim)))
         self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
 
     def test_only_menus_show_for_restored_window_on_mouse_in_menu_area(self):
         """Restored windows should only show menus when the mouse is in the window
         menu area.
         """
-        self.open_new_application_window("Calculator",
-            maximized=False,
-            move_to_monitor=True)
+        self.open_new_application_window("Calculator")
         self.sleep_menu_settle_period()
 
         self.panel.move_mouse_over_menus()
 
-        self.assertThat(self.panel.menus_shown, Eventually(Equals(True)))
+        self.assertThat(self.panel.menus_shown, Eventually(Equals(not self.lim)))
         self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
 
     def test_only_menus_show_for_restored_window_on_mouse_in_grab_area(self):
         """Restored windows should only show menus when the mouse is in the panel
         grab area.
         """
-        self.open_new_application_window("Calculator",
-            maximized=False,
-            move_to_monitor=True)
+        self.open_new_application_window("Calculator")
         self.sleep_menu_settle_period()
 
         if self.panel.grab_area.width <= 0:
@@ -731,14 +755,12 @@
 
         self.panel.move_mouse_over_grab_area()
 
-        self.assertThat(self.panel.menus_shown, Eventually(Equals(True)))
+        self.assertThat(self.panel.menus_shown, Eventually(Equals(not self.lim)))
         self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
 
     def test_hovering_over_indicators_does_not_show_app_menus(self):
         """Hovering the mouse over the indicators must not show app menus."""
-        self.open_new_application_window("Calculator",
-            maximized=False,
-            move_to_monitor=True)
+        self.open_new_application_window("Text Editor", maximized=True)
         self.sleep_menu_settle_period()
 
         self.panel.move_mouse_over_menus()
@@ -754,9 +776,7 @@
         """Menus and window buttons must be shown when the mouse is in the window
         button area for a maximised application.
         """
-        self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
+        self.open_new_application_window("Text Editor", maximized=True)
         self.sleep_menu_settle_period()
 
         self.panel.move_mouse_over_window_buttons()
@@ -768,9 +788,7 @@
         """Menus and window buttons must be shown when the mouse is in the menu
         area for a maximised application.
         """
-        self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
+        self.open_new_application_window("Text Editor", maximized=True)
         self.sleep_menu_settle_period()
 
         self.panel.move_mouse_over_menus()
@@ -785,9 +803,7 @@
         if self.panel.grab_area.width <= 0:
             self.skipTest("Grab area is too small to run this test!")
 
-        self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
+        self.open_new_application_window("Text Editor", maximized=True)
         self.sleep_menu_settle_period()
 
         self.panel.move_mouse_over_grab_area()
@@ -799,9 +815,7 @@
         """Hovering the mouse over the indicators must hide the menus and window
         buttons.
         """
-        self.open_new_application_window("Text Editor",
-            maximized=True,
-            move_to_monitor=True)
+        self.open_new_application_window("Text Editor", maximized=True)
         self.sleep_menu_settle_period()
 
         self.panel.move_mouse_over_menus()
@@ -811,14 +825,14 @@
 
         self.panel.move_mouse_over_indicators()
 
-        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(False)))
+        self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(self.lim)))
         self.assertThat(self.panel.menus_shown, Eventually(Equals(False)))
 
     def test_hovering_indicators_open_menus(self):
         """Opening an indicator entry, and then hovering on other entries must
         open them.
         """
-        self.open_new_application_window("Text Editor")
+        self.open_new_application_window("Text Editor", maximized=self.lim)
         entries = self.panel.get_indicator_entries(include_hidden_menus=True)
 
         self.assertThat(len(entries), GreaterThan(0))
@@ -832,7 +846,7 @@
 
 class PanelMenuTests(PanelTestsBase):
 
-    scenarios = _make_monitor_scenarios()
+    scenarios = _make_scenarios()
 
     def start_test_app_with_menus(self):
         window_spec = {
@@ -846,7 +860,12 @@
                 {"Title": "&Quit"}
                 ]
         }
-        self.launch_test_window(window_spec)
+        test_win = self.launch_test_window(window_spec)
+        test_win.set_focus()
+        self.move_window_to_panel_monitor(test_win)
+        self.ensure_window_state(test_win, maximized=self.lim)
+
+        return test_win
 
     def test_menus_are_added_on_new_application(self):
         """Tests that menus are added when a new application is opened."""
@@ -872,10 +891,13 @@
             "Current panel entries are: %r" % self.panel.menus.get_entries())
 
         self.panel.move_mouse_over_grab_area()
-        self.assertThat(self.panel.title, Eventually(Equals(test_win.application.name)))
+        expected = test_win.application.name if not self.lim else ""
+        self.assertThat(self.panel.title, Eventually(Equals(expected)))
 
     def test_menus_shows_when_new_application_is_opened(self):
         """When starting a new application, menus must first show, then hide."""
+        if self.lim:
+            self.skipTest("Menu discovery is disabled when LIM are enabled.")
 
         # This test requires the window to be opened on the monitor that is being tested and
         # we cannot guarantee which monitor the window will open up on.
@@ -890,6 +912,9 @@
 
     def test_menus_dont_show_if_a_new_application_window_is_opened(self):
         """This tests the menu discovery feature on new window for a know application."""
+        if self.lim:
+            self.skipTest("Menu discovery is disabled when LIM are enabled.")
+
         self.open_new_application_window("Character Map")
         self.sleep_menu_settle_period()
 
@@ -917,7 +942,7 @@
 
         self.panel.move_mouse_over_menus()
 
-        self.assertThat(self.panel.menus_shown, Eventually(Equals(True)))
+        self.assertThat(self.panel.menus_shown, Eventually(Equals(not self.lim)))
 
     def test_menus_dont_show_for_maximized_window_on_mouse_out(self):
         """Maximized window menus must not show when the mouse is outside the
@@ -947,7 +972,7 @@
 
     def test_menus_dont_show_with_hud(self):
         """Tests that menus are not showing when opening the HUD."""
-        self.open_new_application_window("Text Editor", maximized=True)
+        self.open_new_application_window("Character Map", maximized=True)
         self.unity.hud.ensure_visible()
         self.addCleanup(self.unity.hud.ensure_hidden)
 
@@ -957,11 +982,13 @@
 class PanelIndicatorEntryTests(PanelTestsBase):
     """Tests for the indicator entries, including both menu and indicators."""
 
-    scenarios = _make_monitor_scenarios()
+    scenarios = _make_scenarios()
 
     def open_app_and_get_menu_entry(self):
         """Open the test app and wait for the menu entry to appear."""
-        self.open_new_application_window("Calculator")
+        self.open_new_application_window("Remmina" if self.lim else "Calculator",
+                                         maximized=self.lim)
+
         refresh_fn = lambda: len(self.panel.menus.get_entries())
         self.assertThat(refresh_fn, Eventually(GreaterThan(0)))
         menu_entry = self.panel.menus.get_entries()[0]
@@ -1033,7 +1060,7 @@
 
 class PanelKeyNavigationTests(PanelTestsBase):
 
-    scenarios = _make_monitor_scenarios()
+    scenarios = _make_scenarios()
 
     def get_active_indicator(self):
         """Get the active indicator in a safe manner.
@@ -1048,17 +1075,17 @@
         """Pressing the open-menus keybinding must open the first indicator."""
         self.open_new_application_window("Calculator")
         refresh_fn = lambda: len(self.panel.menus.get_entries())
-        self.assertThat(refresh_fn, Eventually(GreaterThan(0)))
+        self.assertThat(refresh_fn, Eventually(Equals(0) if self.lim else GreaterThan(0)))
         self.addCleanup(self.keyboard.press_and_release, "Escape")
         self.keybinding("panel/open_first_menu")
 
         open_indicator = self.get_active_indicator()
-        expected_indicator = self.panel.get_indicator_entries(include_hidden_menus=True)[0]
+        expected_indicator = self.panel.get_indicator_entries(include_hidden_menus=not self.lim)[0]
         self.assertThat(open_indicator.entry_id, Eventually(Equals(expected_indicator.entry_id)))
 
     def test_panel_hold_show_menu_works(self):
         """Holding the show menu key must reveal the menu with mnemonics."""
-        self.open_new_application_window("Text Editor")
+        self.open_new_application_window("Text Editor", maximized=self.lim)
         refresh_fn = lambda: len(self.panel.menus.get_entries())
         self.assertThat(refresh_fn, Eventually(GreaterThan(0)))
         self.addCleanup(self.keyboard.press_and_release, "Escape")
@@ -1073,7 +1100,7 @@
 
     def test_panel_menu_accelerators_work(self):
         """Pressing a valid menu accelerator must open the correct menu item."""
-        self.open_new_application_window("Text Editor")
+        self.open_new_application_window("Text Editor", maximized=self.lim)
         refresh_fn = lambda: len(self.panel.menus.get_entries())
         self.assertThat(refresh_fn, Eventually(GreaterThan(0)))
         self.addCleanup(self.keyboard.press_and_release, "Escape")
@@ -1087,7 +1114,7 @@
         calc_win = self.open_new_application_window("Calculator")
         self.assertProperty(calc_win, is_focused=True)
 
-        available_indicators = self.panel.get_indicator_entries(include_hidden_menus=True)
+        available_indicators = self.panel.get_indicator_entries(include_hidden_menus=not self.lim)
 
         self.keybinding("panel/open_first_menu")
         self.addCleanup(self.keyboard.press_and_release, "Escape")
@@ -1102,7 +1129,7 @@
         calc_win = self.open_new_application_window("Calculator")
         self.assertProperty(calc_win, is_focused=True)
 
-        available_indicators = self.panel.get_indicator_entries(include_hidden_menus=True)
+        available_indicators = self.panel.get_indicator_entries(include_hidden_menus=not self.lim)
 
         self.keybinding("panel/open_first_menu")
         self.addCleanup(self.keyboard.press_and_release, "Escape")
@@ -1118,14 +1145,12 @@
         opened with the keyboard.
         """
         self.open_new_application_window("Calculator")
-        available_indicators = self.panel.get_indicator_entries(include_hidden_menus=True)
+        available_indicators = self.panel.get_indicator_entries(include_hidden_menus=not self.lim)
 
         self.keybinding("panel/open_first_menu")
         self.addCleanup(self.keyboard.press_and_release, "Escape")
 
         available_indicators[2].mouse_move_to()
-        self.addCleanup(self.panel.move_mouse_below_the_panel)
-
         self.assertThat(available_indicators[2].active, Eventually(Equals(True)))
 
         self.keybinding("panel/prev_indicator")
@@ -1135,11 +1160,10 @@
 class PanelGrabAreaTests(PanelTestsBase):
     """Panel grab area tests."""
 
-    scenarios = _make_monitor_scenarios()
+    scenarios = _make_scenarios()
 
     def move_mouse_over_grab_area(self):
         self.panel.move_mouse_over_grab_area()
-        self.addCleanup(self.panel.move_mouse_below_the_panel)
         sleep(.1)
 
     def test_unmaximize_from_grab_area_works(self):
@@ -1192,6 +1216,29 @@
         self.assertThat(self.unity.hud.search_string, Eventually(Equals("HelloWorld")))
 
 
+class PanelLimTests(PanelTestsBase):
+
+    scenarios = _make_monitor_scenarios()
+
+    def setUp(self):
+        self.lim = True
+        super(PanelLimTests, self).setUp()
+
+    def test_title_focus_on_maximized_state_changes(self):
+        text_win = self.open_new_application_window("Text Editor", maximized=True)
+        self.assertThat(self.panel.focused, Eventually(Equals(True)))
+        self.assertThat(self.panel.title, Eventually(Equals(text_win.title)))
+
+        self.open_new_application_window("Calculator")
+        self.assertThat(self.panel.focused, Eventually(Equals(False)))
+        self.assertThat(self.panel.title, Eventually(Equals(text_win.title)))
+
+        text_win.set_focus()
+        self.assertProperty(text_win, is_focused=True)
+        self.assertThat(self.panel.focused, Eventually(Equals(True)))
+        self.assertThat(self.panel.title, Eventually(Equals(text_win.title)))
+
+
 class PanelCrossMonitorsTests(PanelTestsBase):
     """Multimonitor panel tests."""
 
 
=== modified file 'tests/autopilot/unity/tests/test_wm_keybindings.py'
--- tests/autopilot/unity/tests/test_wm_keybindings.py	2013-12-04 19:42:43 +0000
+++ tests/autopilot/unity/tests/test_wm_keybindings.py	2015-02-19 19:24:14 +0000
@@ -21,27 +21,24 @@
 
     def open_panel_menu(self):
         panel = self.unity.panels.get_panel_for_monitor(0)
-        self.assertThat(lambda: len(panel.menus.get_entries()), Eventually(GreaterThan(0)))
+        self.assertThat(lambda: len(panel.get_indicator_entries()), Eventually(GreaterThan(0)))
         self.addCleanup(self.keyboard.press_and_release, "Escape")
         self.keybinding("panel/open_first_menu")
         self.assertThat(self.unity.panels.get_active_indicator, Eventually(NotEquals(None)))
 
     def test_dash_shows_on_menus_opened(self):
-        self.process_manager.start_app_window("Calculator")
         self.open_panel_menu()
         self.addCleanup(self.unity.dash.ensure_hidden)
         self.unity.dash.ensure_visible()
         self.assertThat(self.unity.panels.get_active_indicator, Eventually(Equals(None)))
 
     def test_hud_shows_on_menus_opened(self):
-        self.process_manager.start_app_window("Calculator")
         self.open_panel_menu()
         self.addCleanup(self.unity.hud.ensure_hidden)
         self.unity.hud.ensure_visible()
         self.assertThat(self.unity.panels.get_active_indicator, Eventually(Equals(None)))
 
     def test_switcher_shows_on_menus_opened(self):
-        self.process_manager.start_app_window("Calculator")
         self.open_panel_menu()
         self.addCleanup(self.unity.switcher.terminate)
         self.unity.switcher.initiate()
@@ -49,7 +46,6 @@
         self.assertThat(self.unity.panels.get_active_indicator, Eventually(Equals(None)))
 
     def test_shortcut_hints_shows_on_menus_opened(self):
-        self.process_manager.start_app_window("Calculator")
         self.open_panel_menu()
         self.addCleanup(self.unity.shortcut_hint.ensure_hidden)
         self.unity.shortcut_hint.show()
@@ -57,7 +53,6 @@
         self.assertThat(self.unity.panels.get_active_indicator, Eventually(Equals(None)))
 
     def test_spread_shows_on_menus_opened(self):
-        self.process_manager.start_app_window("Calculator")
         self.open_panel_menu()
         self.addCleanup(self.unity.window_manager.terminate_spread)
         self.unity.window_manager.initiate_spread()
 
=== modified file 'tests/mock-application.h'
--- tests/mock-application.h	2014-03-21 04:40:12 +0000
+++ tests/mock-application.h	2015-02-19 19:24:14 +0000
@@ -20,7 +20,7 @@
 #ifndef TESTS_MOCK_APPLICATION_H
 #define TESTS_MOCK_APPLICATION_H
 
-#include <map>
+#include <unordered_map>
 #include <gmock/gmock.h>
 #include <gio/gdesktopappinfo.h>
 #include <UnityCore/GLibWrapper.h>
@@ -360,7 +360,7 @@
   }
 
 private:
-  typedef std::map<std::string, unity::ApplicationPtr> AppMap;
+  typedef std::unordered_map<std::string, unity::ApplicationPtr> AppMap;
   AppMap app_map_;
 };
 
 
=== modified file 'tests/test_dbus_indicators.cpp'
--- tests/test_dbus_indicators.cpp	2013-03-25 18:22:32 +0000
+++ tests/test_dbus_indicators.cpp	2015-02-19 19:24:14 +0000
@@ -5,6 +5,7 @@
 #include <UnityCore/GLibWrapper.h>
 #include <UnityCore/DBusIndicators.h>
 
+#include "panel-service-private.h"
 #include "test_utils.h"
 
 using namespace unity;
@@ -50,10 +51,8 @@
 
   GVariant* CallPanelMethod(std::string const& name) const
   {
-    return g_dbus_connection_call_sync(session,
-                                       "com.canonical.Unity.Test",
-                                       "/com/canonical/Unity/Panel/Service",
-                                       "com.canonical.Unity.Panel.Service",
+    return g_dbus_connection_call_sync(session, "com.canonical.Unity.Test",
+                                       UPS_PATH, UPS_IFACE,
                                        name.c_str(),
                                        NULL,
                                        NULL,
 
=== modified file 'tests/test_indicator.cpp'
--- tests/test_indicator.cpp	2014-01-27 17:31:30 +0000
+++ tests/test_indicator.cpp	2015-02-19 19:24:14 +0000
@@ -44,7 +44,7 @@
 
   MOCK_CONST_METHOD0(Updated, void());
   MOCK_CONST_METHOD1(EntryAdded, void(Entry::Ptr const&));
-  MOCK_CONST_METHOD1(EntryRemoved, void(std::string const&));
+  MOCK_CONST_METHOD1(EntryRemoved, void(Entry::Ptr const&));
   MOCK_CONST_METHOD5(ShowMenu, void(std::string const&, unsigned, int, int, unsigned));
   MOCK_CONST_METHOD1(SecondaryActivate, void(std::string const&));
   MOCK_CONST_METHOD2(Scroll, void(std::string const&, int));
@@ -57,7 +57,6 @@
   EXPECT_EQ(indicator.name(), "indicator-test");
   EXPECT_FALSE(indicator.IsAppmenu());
   EXPECT_EQ(indicator.GetEntry("test-entry"), nullptr);
-  EXPECT_EQ(indicator.EntryIndex("test-entry"), -1);
   EXPECT_TRUE(indicator.GetEntries().empty());
 }
 
@@ -69,17 +68,17 @@
   Indicator indicator("indicator-test");
   SigReceiver::Nice sig_receiver(indicator);
 
-  entry = new Entry("test-entry-1", "name-hint", "label", true, true, 0, "icon",
+  entry = new Entry("test-entry-1", "name-hint", 0, "label", true, true, 0, "icon",
                     true, true, -1);
   Entry::Ptr entry1(entry);
   sync_data.push_back(entry1);
 
-  entry = new Entry("test-entry-2", "name-hint", "label", true, true, 0, "icon",
+  entry = new Entry("test-entry-2", "name-hint", 0, "label", true, true, 0, "icon",
                     true, true, -1);
   Entry::Ptr entry2(entry);
   sync_data.push_back(entry2);
 
-  entry = new Entry("test-entry-3", "name-hint", "label", true, true, 0, "icon",
+  entry = new Entry("test-entry-3", "name-hint", 0, "label", true, true, 0, "icon",
                     true, true, -1);
   Entry::Ptr entry3(entry);
   sync_data.push_back(entry3);
@@ -97,31 +96,29 @@
   indicator.Sync(sync_data);
   EXPECT_EQ(indicator.GetEntries().size(), 3);
   EXPECT_EQ(indicator.GetEntry("test-entry-2"), entry2);
-  EXPECT_EQ(indicator.EntryIndex("test-entry-2"), 1);
   // Mock::VerifyAndClearExpectations(&sig_receiver);
 
   // Sync the indicator removing an entry
-  sync_data.remove(entry2);
+  sync_data.erase(std::remove(sync_data.begin(), sync_data.end(), entry2), sync_data.end());
   EXPECT_EQ(sync_data.size(), 2);
   EXPECT_CALL(sig_receiver, Updated());
   EXPECT_CALL(sig_receiver, EntryAdded(_)).Times(0);
-  EXPECT_CALL(sig_receiver, EntryRemoved(entry2->id()));
+  EXPECT_CALL(sig_receiver, EntryRemoved(entry2));
 
   indicator.Sync(sync_data);
   EXPECT_EQ(indicator.GetEntries().size(), 2);
   EXPECT_EQ(indicator.GetEntry("test-entry-2"), nullptr);
-  EXPECT_EQ(indicator.EntryIndex("test-entry-2"), -1);
 
   // Sync the indicator removing an entry and adding a new one
-  entry = new Entry("test-entry-4", "name-hint", "label", true, true, 0, "icon",
+  entry = new Entry("test-entry-4", "name-hint", 0, "label", true, true, 0, "icon",
                     true, true, -1);
   Entry::Ptr entry4(entry);
   sync_data.push_back(entry4);
-  sync_data.remove(entry3);
+  sync_data.erase(std::remove(sync_data.begin(), sync_data.end(), entry3), sync_data.end());
   EXPECT_EQ(sync_data.size(), 2);
 
   EXPECT_CALL(sig_receiver, EntryAdded(entry4));
-  EXPECT_CALL(sig_receiver, EntryRemoved(entry3->id()));
+  EXPECT_CALL(sig_receiver, EntryRemoved(entry3));
   EXPECT_CALL(sig_receiver, Updated());
   indicator.Sync(sync_data);
   EXPECT_EQ(indicator.GetEntries().size(), 2);
@@ -129,8 +126,8 @@
   // Remove all the indicators
 
   EXPECT_CALL(sig_receiver, EntryAdded(_)).Times(0);
-  EXPECT_CALL(sig_receiver, EntryRemoved(entry1->id()));
-  EXPECT_CALL(sig_receiver, EntryRemoved(entry4->id()));
+  EXPECT_CALL(sig_receiver, EntryRemoved(entry1));
+  EXPECT_CALL(sig_receiver, EntryRemoved(entry4));
   EXPECT_CALL(sig_receiver, Updated());
 
   sync_data.clear();
@@ -144,13 +141,13 @@
   SigReceiver::Nice sig_receiver(indicator);
   Indicator::Entries sync_data;
 
-  auto entry1 = std::make_shared<Entry>("test-entry-1", "name-hint", "label", true, true, 0, "icon", true, true, -1);
+  auto entry1 = std::make_shared<Entry>("test-entry-1", "name-hint", 0, "label", true, true, 0, "icon", true, true, -1);
   sync_data.push_back(entry1);
 
-  auto entry2 = std::make_shared<Entry>("test-entry-2", "name-hint", "label", true, true, 0, "icon", true, true, -1);
+  auto entry2 = std::make_shared<Entry>("test-entry-2", "name-hint", 0, "label", true, true, 0, "icon", true, true, -1);
   sync_data.push_back(entry2);
 
-  auto entry3 = std::make_shared<Entry>("test-entry-3", "name-hint", "label", true, true, 0, "icon", true, true, -1);
+  auto entry3 = std::make_shared<Entry>("test-entry-3", "name-hint", 0, "label", true, true, 0, "icon", true, true, -1);
   sync_data.push_back(entry3);
 
   EXPECT_CALL(sig_receiver, Updated());
@@ -162,7 +159,7 @@
   EXPECT_CALL(sig_receiver, Updated()).Times(0);
   indicator.Sync(sync_data);
 
-  sync_data.remove(entry3);
+  sync_data.erase(std::remove(sync_data.begin(), sync_data.end(), entry3), sync_data.end());
   EXPECT_CALL(sig_receiver, Updated());
   indicator.Sync(sync_data);
 
@@ -176,7 +173,7 @@
   Indicator indicator("indicator-test");
   SigReceiver::Nice sig_receiver(indicator);
 
-  auto entry = std::make_shared<Entry>("test-entry-1", "name-hint", "label", true, true, 0, "icon", true, true, -1);
+  auto entry = std::make_shared<Entry>("test-entry-1", "name-hint", 0, "label", true, true, 0, "icon", true, true, -1);
   indicator.Sync({entry});
 
   EXPECT_CALL(sig_receiver, ShowMenu(entry->id(), 123456789, 50, 100, 2));
@@ -194,7 +191,7 @@
   Indicator indicator("indicator-test");
   SigReceiver::Nice sig_receiver(indicator);
 
-  auto entry = std::make_shared<Entry>("test-entry-2", "name-hint", "label", true, true, 0, "icon", true, true, -1);
+  auto entry = std::make_shared<Entry>("test-entry-2", "name-hint", 0, "label", true, true, 0, "icon", true, true, -1);
   indicator.Sync({entry});
 
   EXPECT_CALL(sig_receiver, SecondaryActivate(entry->id()));
@@ -206,7 +203,7 @@
   Indicator indicator("indicator-test");
   SigReceiver::Nice sig_receiver(indicator);
 
-  auto entry = std::make_shared<Entry>("test-entry-2", "name-hint", "label", true, true, 0, "icon", true, true, -1);
+  auto entry = std::make_shared<Entry>("test-entry-2", "name-hint", 0, "label", true, true, 0, "icon", true, true, -1);
   indicator.Sync({entry});
 
   EXPECT_CALL(sig_receiver, Scroll(entry->id(), -5));
 
=== modified file 'tests/test_indicator_appmenu.cpp'
--- tests/test_indicator_appmenu.cpp	2012-12-04 00:33:18 +0000
+++ tests/test_indicator_appmenu.cpp	2015-02-19 19:24:14 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2012 Canonical Ltd
+ * Copyright (C) 2012-2015 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
@@ -18,15 +18,41 @@
  */
 
 #include <UnityCore/AppmenuIndicator.h>
-
-#include <gtest/gtest.h>
+#include <gmock/gmock.h>
 
 using namespace std;
 using namespace unity;
 using namespace indicator;
+using namespace testing;
 
 namespace
 {
+struct SigReceiver : sigc::trackable
+{
+  typedef NiceMock<SigReceiver> Nice;
+
+  SigReceiver(AppmenuIndicator const& const_indicator)
+  {
+    auto& indicator = const_cast<AppmenuIndicator&>(const_indicator);
+    indicator.updated.connect(sigc::mem_fun(this, &SigReceiver::Updated));
+    indicator.updated_win.connect(sigc::mem_fun(this, &SigReceiver::UpdatedWin));
+    indicator.on_entry_added.connect(sigc::mem_fun(this, &SigReceiver::EntryAdded));
+    indicator.on_entry_removed.connect(sigc::mem_fun(this, &SigReceiver::EntryRemoved));
+    indicator.on_show_menu.connect(sigc::mem_fun(this, &SigReceiver::ShowMenu));
+    indicator.on_show_appmenu.connect(sigc::mem_fun(this, &SigReceiver::ShowAppmenu));
+    indicator.on_secondary_activate.connect(sigc::mem_fun(this, &SigReceiver::SecondaryActivate));
+    indicator.on_scroll.connect(sigc::mem_fun(this, &SigReceiver::Scroll));
+  }
+
+  MOCK_CONST_METHOD0(Updated, void());
+  MOCK_CONST_METHOD1(UpdatedWin, void(uint32_t));
+  MOCK_CONST_METHOD1(EntryAdded, void(Entry::Ptr const&));
+  MOCK_CONST_METHOD1(EntryRemoved, void(Entry::Ptr const&));
+  MOCK_CONST_METHOD5(ShowMenu, void(std::string const&, unsigned, int, int, unsigned));
+  MOCK_CONST_METHOD3(ShowAppmenu, void(unsigned, int, int));
+  MOCK_CONST_METHOD1(SecondaryActivate, void(std::string const&));
+  MOCK_CONST_METHOD2(Scroll, void(std::string const&, int));
+};
 
 TEST(TestAppmenuIndicator, Construction)
 {
@@ -39,25 +65,160 @@
 TEST(TestAppmenuIndicator, ShowAppmenu)
 {
   AppmenuIndicator indicator("indicator-appmenu");
-
-  bool signal_emitted = false;
-  int show_x, show_y;
-  unsigned show_xid;
-
-  // Connecting to signals
-  indicator.on_show_appmenu.connect([&] (unsigned int xid, int x, int y) {
-    signal_emitted = true;
-    show_xid = xid;
-    show_x = x;
-    show_y = y;
-  });
-
+  SigReceiver::Nice sig_receiver(indicator);
+
+  EXPECT_CALL(sig_receiver, ShowAppmenu(123456789, 50, 100));
   indicator.ShowAppmenu(123456789, 50, 100);
-  EXPECT_TRUE(signal_emitted);
-
-  EXPECT_EQ(show_xid, 123456789);
-  EXPECT_EQ(show_x, 50);
-  EXPECT_EQ(show_y, 100);
+}
+
+TEST(TestAppmenuIndicator, Syncing)
+{
+  Indicator::Entries sync_data;
+
+  AppmenuIndicator indicator("indicator-appmenu");
+  SigReceiver::Nice sig_receiver(indicator);
+  const uint32_t parent_window1 = 12345;
+  const uint32_t parent_window2 = 54321;
+
+  auto entry1 = std::make_shared<Entry>("test-entry-1", "name-hint", parent_window1, "label", true, true, 0, "icon", true, true, -1);
+  sync_data.push_back(entry1);
+
+  auto entry2 = std::make_shared<Entry>("test-entry-2", "name-hint", parent_window1, "label", true, true, 0, "icon", true, true, -1);
+  sync_data.push_back(entry2);
+
+  auto entry3 = std::make_shared<Entry>("test-entry-3", "name-hint", parent_window2, "label", true, true, 0, "icon", true, true, -1);
+  sync_data.push_back(entry3);
+
+  // Sync the indicator, adding 3 entries
+  {
+    testing::InSequence s;
+    EXPECT_CALL(sig_receiver, EntryAdded(entry1));
+    EXPECT_CALL(sig_receiver, EntryAdded(entry2));
+    EXPECT_CALL(sig_receiver, EntryAdded(entry3));
+    EXPECT_CALL(sig_receiver, EntryRemoved(_)).Times(0);
+    EXPECT_CALL(sig_receiver, Updated());
+  }
+
+  EXPECT_CALL(sig_receiver, UpdatedWin(parent_window1));
+  EXPECT_CALL(sig_receiver, UpdatedWin(parent_window2));
+
+  indicator.Sync(sync_data);
+  EXPECT_EQ(indicator.GetEntriesForWindow(parent_window1), Indicator::Entries({entry1, entry2}));
+  EXPECT_EQ(indicator.GetEntriesForWindow(parent_window2), Indicator::Entries({entry3}));
+
+  // Sync the indicator removing an entry
+  sync_data.erase(std::remove(sync_data.begin(), sync_data.end(), entry2), sync_data.end());
+  ASSERT_EQ(sync_data.size(), 2);
+  EXPECT_CALL(sig_receiver, Updated());
+  EXPECT_CALL(sig_receiver, UpdatedWin(parent_window1));
+  EXPECT_CALL(sig_receiver, UpdatedWin(parent_window2)).Times(0);
+  EXPECT_CALL(sig_receiver, EntryAdded(_)).Times(0);
+  EXPECT_CALL(sig_receiver, EntryRemoved(entry2));
+
+  indicator.Sync(sync_data);
+  EXPECT_EQ(indicator.GetEntries().size(), 2);
+  EXPECT_EQ(indicator.GetEntry("test-entry-2"), nullptr);
+  EXPECT_EQ(indicator.GetEntriesForWindow(parent_window1), Indicator::Entries({entry1}));
+
+  // Sync the indicator removing an entry and adding a new one
+  auto entry4 = std::make_shared<Entry>("test-entry-4", "name-hint", parent_window2, "label", true, true, 0, "icon", true, true, -1);
+  sync_data.push_back(entry4);
+  sync_data.erase(std::remove(sync_data.begin(), sync_data.end(), entry3), sync_data.end());
+  EXPECT_EQ(sync_data.size(), 2);
+
+  EXPECT_CALL(sig_receiver, EntryAdded(entry4));
+  EXPECT_CALL(sig_receiver, EntryRemoved(entry3));
+  EXPECT_CALL(sig_receiver, Updated());
+  EXPECT_CALL(sig_receiver, UpdatedWin(parent_window1)).Times(0);
+  EXPECT_CALL(sig_receiver, UpdatedWin(parent_window2));
+  indicator.Sync(sync_data);
+  EXPECT_EQ(indicator.GetEntriesForWindow(parent_window1), Indicator::Entries({entry1}));
+  EXPECT_EQ(indicator.GetEntriesForWindow(parent_window2), Indicator::Entries({entry4}));
+
+  // Remove all the indicators
+  EXPECT_CALL(sig_receiver, EntryAdded(_)).Times(0);
+  EXPECT_CALL(sig_receiver, EntryRemoved(entry1));
+  EXPECT_CALL(sig_receiver, EntryRemoved(entry4));
+  EXPECT_CALL(sig_receiver, Updated());
+  EXPECT_CALL(sig_receiver, UpdatedWin(parent_window1));
+  EXPECT_CALL(sig_receiver, UpdatedWin(parent_window2));
+
+  sync_data.clear();
+  indicator.Sync(sync_data);
+
+  EXPECT_TRUE(indicator.GetEntriesForWindow(parent_window1).empty());
+  EXPECT_TRUE(indicator.GetEntriesForWindow(parent_window2).empty());
+}
+
+TEST(TestAppmenuIndicator, Updated)
+{
+  AppmenuIndicator indicator("indicator-test");
+  SigReceiver::Nice sig_receiver(indicator);
+  Indicator::Entries sync_data;
+  const uint32_t parent_window1 = 12345;
+  const uint32_t parent_window2 = 54321;
+
+  auto entry1 = std::make_shared<Entry>("test-entry-1", "name-hint", parent_window1, "label", true, true, 0, "icon", true, true, -1);
+  sync_data.push_back(entry1);
+
+  auto entry2 = std::make_shared<Entry>("test-entry-2", "name-hint", parent_window2, "label", true, true, 0, "icon", true, true, -1);
+  sync_data.push_back(entry2);
+
+  auto entry3 = std::make_shared<Entry>("test-entry-3", "name-hint", parent_window1, "label", true, true, 0, "icon", true, true, -1);
+  sync_data.push_back(entry3);
+
+  EXPECT_CALL(sig_receiver, Updated());
+
+  // Sync the indicator, adding 3 entries
+  indicator.Sync(sync_data);
+
+  // Readding the same entries, nothing is emitted
+  EXPECT_CALL(sig_receiver, Updated()).Times(0);
+  indicator.Sync(sync_data);
+
+  sync_data.erase(std::remove(sync_data.begin(), sync_data.end(), entry3), sync_data.end());
+  EXPECT_CALL(sig_receiver, Updated());
+  indicator.Sync(sync_data);
+
+  sync_data.push_back(entry3);
+  EXPECT_CALL(sig_receiver, Updated());
+  indicator.Sync(sync_data);
+}
+
+TEST(TestAppmenuIndicator, UpdatedWin)
+{
+  AppmenuIndicator indicator("indicator-test");
+  SigReceiver::Nice sig_receiver(indicator);
+  Indicator::Entries sync_data;
+  const uint32_t parent_window1 = 12345;
+  const uint32_t parent_window2 = 54321;
+
+  auto entry1 = std::make_shared<Entry>("test-entry-1", "name-hint", parent_window1, "label", true, true, 0, "icon", true, true, -1);
+  sync_data.push_back(entry1);
+
+  auto entry2 = std::make_shared<Entry>("test-entry-2", "name-hint", parent_window2, "label", true, true, 0, "icon", true, true, -1);
+  sync_data.push_back(entry2);
+
+  auto entry3 = std::make_shared<Entry>("test-entry-3", "name-hint", parent_window1, "label", true, true, 0, "icon", true, true, -1);
+  sync_data.push_back(entry3);
+
+  EXPECT_CALL(sig_receiver, UpdatedWin(parent_window1));
+  EXPECT_CALL(sig_receiver, UpdatedWin(parent_window2));
+
+  // Sync the indicator, adding 3 entries
+  indicator.Sync(sync_data);
+
+  // Readding the same entries, nothing is emitted
+  EXPECT_CALL(sig_receiver, UpdatedWin(_)).Times(0);
+  indicator.Sync(sync_data);
+
+  sync_data.erase(std::remove(sync_data.begin(), sync_data.end(), entry3), sync_data.end());
+  EXPECT_CALL(sig_receiver, UpdatedWin(entry3->parent_window()));
+  indicator.Sync(sync_data);
+
+  sync_data.push_back(entry3);
+  EXPECT_CALL(sig_receiver, UpdatedWin(entry3->parent_window()));
+  indicator.Sync(sync_data);
 }
 
 }
 
=== modified file 'tests/test_indicator_entry.cpp'
--- tests/test_indicator_entry.cpp	2014-02-07 23:54:15 +0000
+++ tests/test_indicator_entry.cpp	2015-02-19 19:24:14 +0000
@@ -36,11 +36,12 @@
 TEST(TestIndicatorEntry, TestConstruction)
 {
 
-  Entry entry("id", "name_hint", "label", true, true, 1, "some icon", false, true, -1);
+  Entry entry("id", "name_hint", 12345, "label", true, true, 1, "some icon", false, true, -1);
 
   EXPECT_EQ(entry.id(), "id");
+  EXPECT_EQ(entry.name_hint(), "name_hint");
+  EXPECT_EQ(entry.parent_window(), 12345);
   EXPECT_EQ(entry.label(), "label");
-  EXPECT_EQ(entry.name_hint(), "name_hint");
   EXPECT_TRUE(entry.label_sensitive());
   EXPECT_TRUE(entry.label_visible());
   EXPECT_FALSE(entry.image_sensitive());
@@ -55,10 +56,11 @@
 
 TEST(TestIndicatorEntry, TestConstructionEmpty)
 {
-  Entry entry("id", "name_hint");
+  Entry entry("id", "name_hint", 12345);
 
   EXPECT_EQ(entry.id(), "id");
   EXPECT_EQ(entry.name_hint(), "name_hint");
+  EXPECT_EQ(entry.parent_window(), 12345);
   EXPECT_TRUE(entry.label().empty());
   EXPECT_FALSE(entry.label_sensitive());
   EXPECT_FALSE(entry.label_visible());
@@ -74,8 +76,8 @@
 
 TEST(TestIndicatorEntry, TestAssignment)
 {
-  Entry entry("id", "name_hint", "label", true, true, 0, "some icon", false, true, 10);
-  Entry other_entry("other_id", "other_name_hint", "other_label", false, false, 2, "other icon", true, false, 5);
+  Entry entry("id", "name_hint", 12345, "label", true, true, 0, "some icon", false, true, 10);
+  Entry other_entry("other_id", "other_name_hint", 54321, "other_label", false, false, 2, "other icon", true, false, 5);
 
   SigReceiver sig_receiver(entry);
   EXPECT_CALL(sig_receiver, Updated());
@@ -83,6 +85,7 @@
 
   EXPECT_EQ(entry.id(), "other_id");
   EXPECT_EQ(entry.name_hint(), "other_name_hint");
+  EXPECT_EQ(entry.parent_window(), 54321);
   EXPECT_EQ(entry.label(), "other_label");
   EXPECT_FALSE(entry.label_sensitive());
   EXPECT_FALSE(entry.label_visible());
@@ -95,8 +98,8 @@
 
 TEST(TestIndicatorEntry, TestShowNowEvents)
 {
-  Entry entry("id", "name_hint", "label", true, true,
-                         0, "some icon", false, true, -1);
+  Entry entry("id", "name_hint", 0, "label", true, true,
+              0, "some icon", false, true, -1);
   SigReceiver sig_receiver(entry);
 
   // Setting show_now to the same value doesn't emit any events.
@@ -116,7 +119,7 @@
 
 TEST(TestIndicatorEntry, TestActiveEvents)
 {
-  Entry entry("id", "name_hint", "label", true, true, 0, "some icon", false, true, -1);
+  Entry entry("id", "name_hint", 0, "label", true, true, 0, "some icon", false, true, -1);
 
   SigReceiver sig_receiver(entry);
 
@@ -137,7 +140,7 @@
 
 TEST(TestIndicatorEntry, TestOnScroll)
 {
-  Entry entry("id", "name_hint", "label", true, true, 0, "some icon", false, true, -1);
+  Entry entry("id", "name_hint", 0, "label", true, true, 0, "some icon", false, true, -1);
   SigReceiver sig_receiver(entry);
 
   EXPECT_CALL(sig_receiver, OnScroll("id", 10));
@@ -149,16 +152,16 @@
 
 TEST(TestIndicatorEntry, TestOnShowMenu)
 {
-  Entry entry("id", "name_hint", "label", true, true, 0, "some icon", false, true, -1);
+  Entry entry("id", "name_hint", 123, "label", true, true, 0, "some icon", false, true, -1);
   SigReceiver sig_receiver(entry);
 
-  EXPECT_CALL(sig_receiver, OnShowMenu("id", 0, 10, 20, 1));
+  EXPECT_CALL(sig_receiver, OnShowMenu("id", 123, 10, 20, 1));
   entry.ShowMenu(10, 20, 1);
 }
 
 TEST(TestIndicatorEntry, TestOnShowMenuXid)
 {
-  Entry entry("xid", "name_hint", "label", true, true, 0, "some icon", false, true, -1);
+  Entry entry("xid", "name_hint", 0, "label", true, true, 0, "some icon", false, true, -1);
   SigReceiver sig_receiver(entry);
 
   EXPECT_CALL(sig_receiver, OnShowMenu("xid", 88492615, 15, 25, 2));
@@ -167,7 +170,7 @@
 
 TEST(TestIndicatorEntry, TestVisibility)
 {
-  Entry entry("id", "name_hint", "label", true, true, 0, "some icon", false, false, -1);
+  Entry entry("id", "name_hint", 0, "label", true, true, 0, "some icon", false, false, -1);
 
   EXPECT_TRUE(entry.visible());
 
@@ -208,7 +211,7 @@
 
 TEST(TestIndicatorEntry, TestGeometry)
 {
-  Entry entry("id", "name_hint", "label", true, true, 0, "some icon", false, true, -1);
+  Entry entry("id", "name_hint", 0, "label", true, true, 0, "some icon", false, true, -1);
   SigReceiver sig_receiver(entry);
 
   // Setting to the same value doesn't emit any events.
 
=== modified file 'tests/test_indicators.cpp'
--- tests/test_indicators.cpp	2014-02-11 03:11:47 +0000
+++ tests/test_indicators.cpp	2015-02-19 19:24:14 +0000
@@ -62,15 +62,15 @@
 
     Indicator::Ptr test_indicator_1 = indicators.AddIndicator("indicator-test-1");
 
-    entry = new Entry("indicator-test-1|entry-1", "name-hint-1", "label", true, true,
-                      0, "icon", true, true, -1);
-    sync_data.push_back(Entry::Ptr(entry));
-
-    entry = new Entry("indicator-test-1|entry-2", "name-hint-2", "label", true, true,
-                      0, "icon", true, true, -1);
-    sync_data.push_back(Entry::Ptr(entry));
-
-    entry = new Entry("indicator-test-1|entry-3", "name-hint-3", "label", true, true,
+    entry = new Entry("indicator-test-1|entry-1", "name-hint-1", 0, "label", true, true,
+                      0, "icon", true, true, -1);
+    sync_data.push_back(Entry::Ptr(entry));
+
+    entry = new Entry("indicator-test-1|entry-2", "name-hint-2", 0, "label", true, true,
+                      0, "icon", true, true, -1);
+    sync_data.push_back(Entry::Ptr(entry));
+
+    entry = new Entry("indicator-test-1|entry-3", "name-hint-3", 0, "label", true, true,
                       0, "icon", true, true, -1);
     sync_data.push_back(Entry::Ptr(entry));
 
@@ -83,11 +83,11 @@
     Indicator::Ptr test_indicator_2 = indicators.AddIndicator("indicator-test-2");
     sync_data.clear();
 
-    entry = new Entry("indicator-test-2|entry-1", "name-hint-1", "label", true, true,
+    entry = new Entry("indicator-test-2|entry-1", "name-hint-1", 0, "label", true, true,
                       0, "icon", true, true, -1);
     sync_data.push_back(Entry::Ptr(entry));
 
-    entry = new Entry("indicator-test-2|entry-2", "name-hint-2", "label", true, true,
+    entry = new Entry("indicator-test-2|entry-2", "name-hint-2", 0, "label", true, true,
                       0, "icon", true, true, -1);
     sync_data.push_back(Entry::Ptr(entry));
 
 
=== modified file 'tests/test_panel_menu_view.cpp'
--- tests/test_panel_menu_view.cpp	2014-03-21 04:40:12 +0000
+++ tests/test_panel_menu_view.cpp	2015-02-19 19:24:14 +0000
@@ -36,11 +36,22 @@
 
 struct TestPanelMenuView : public testing::Test
 {
+  TestPanelMenuView()
+    : menu_manager(std::make_shared<menu::MockManager>())
+    , menu_view(menu_manager)
+  {}
+
   struct MockPanelMenuView : public PanelMenuView
   {
-    MockPanelMenuView()
-      : PanelMenuView(std::make_shared<menu::MockManager>())
-    {}
+    MockPanelMenuView(menu::Manager::Ptr const& menu_manager)
+      : PanelMenuView(menu_manager)
+    {
+      view_opened_signal_.Disconnect();
+      active_win_changed_signal_.Disconnect();
+      active_app_changed_signal_.Disconnect();
+      view_closed_signal_.Disconnect();
+      maximized_wins_.clear();
+    }
 
     MOCK_METHOD0(QueueDraw, void());
     MOCK_CONST_METHOD1(GetActiveViewName, std::string(bool));
@@ -53,6 +64,7 @@
     using PanelMenuView::titlebar_grab_area_;
     using PanelMenuView::we_control_active_;
     using PanelMenuView::spread_showing_;
+    using PanelMenuView::maximized_wins_;
   };
 
   nux::ObjectPtr<nux::BaseWindow> AddPanelToWindow(int monitor)
@@ -69,6 +81,7 @@
     panel_win->ComputeContentSize();
 
     menu_view.SetMonitor(monitor);
+    menu_view.maximized_wins_.clear();
 
     return panel_win;
   }
@@ -79,6 +92,7 @@
   MockUScreen uscreen;
   panel::Style panelStyle;
   testwrapper::StandaloneWM WM;
+  menu::MockManager::Ptr menu_manager;
   testing::NiceMock<MockPanelMenuView> menu_view;
 };
 
@@ -91,6 +105,7 @@
 
 TEST_F(TestPanelMenuView, Escaping)
 {
+  menu_manager->integrated_menus = false;
   ON_CALL(menu_view, GetActiveViewName(testing::_)).WillByDefault(Return("<>'"));
   auto escapedText = "Panel d'Inici";
   ASSERT_TRUE(menu_view.GetCurrentTitle().empty());
@@ -136,6 +151,7 @@
 TEST_P(ProgressTester, RestoreOnGrabInBiggerWorkArea)
 {
   uscreen.SetupFakeMultiMonitor();
+  connection::Manager conn;
   unsigned monitor = uscreen.GetMonitors().size() - 1;
   auto const& monitor_geo = uscreen.GetMonitorGeometry(monitor);
   WM->SetWorkareaGeometry(monitor_geo);
 
=== modified file 'tests/test_panel_service.cpp'
--- tests/test_panel_service.cpp	2013-10-03 15:16:06 +0000
+++ tests/test_panel_service.cpp	2015-02-19 19:24:14 +0000
@@ -32,8 +32,8 @@
 {
 typedef std::tuple<glib::Object<GtkLabel>, glib::Object<GtkImage>> EntryObjects;
 
-const std::string SYNC_ENTRY_VARIANT_FORMAT = "(ssssbbusbbi)";
-const std::string SYNC_ENTRIES_VARIANT_FORMAT = "(a"+SYNC_ENTRY_VARIANT_FORMAT+")";
+const std::string SYNC_ENTRY_VARIANT_FORMAT = ENTRY_SIGNATURE;
+const std::string SYNC_ENTRIES_VARIANT_FORMAT = "(" ENTRY_ARRAY_SIGNATURE ")";
 
 struct TestPanelService : Test
 {
@@ -46,6 +46,7 @@
     std::string indicator_id;
     std::string entry_id;
     std::string entry_name_hint;
+    uint32_t parent_window;
     std::string label;
     bool label_sensitive;
     bool label_visible;
@@ -63,6 +64,7 @@
     gchar* indicator_id;
     gchar* entry_id;
     gchar* entry_name_hint;
+    guint32 parent_window;
     gchar* label;
     gboolean label_sensitive;
     gboolean label_visible;
@@ -77,6 +79,7 @@
                                &indicator_id,
                                &entry_id,
                                &entry_name_hint,
+                               &parent_window,
                                &label,
                                &label_sensitive,
                                &label_visible,
@@ -89,6 +92,7 @@
       results.push_back({ glib::gchar_to_string(indicator_id),
                           glib::gchar_to_string(entry_id),
                           glib::gchar_to_string(entry_name_hint),
+                          parent_window,
                           glib::gchar_to_string(label),
                           label_sensitive != FALSE,
                           label_visible != FALSE,
 
=== modified file 'tests/test_service_panel.cpp'
--- tests/test_service_panel.cpp	2013-03-02 22:44:29 +0000
+++ tests/test_service_panel.cpp	2015-02-19 19:24:14 +0000
@@ -1,4 +1,5 @@
 #include "test_service_panel.h"
+#include "panel-service-private.h"
 
 namespace unity
 {
@@ -9,11 +10,11 @@
 static const char * panel_interface =
 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
 "<node name=\"/\">\n"
-"    <interface name=\"com.canonical.Unity.Panel.Service\">\n"
+"    <interface name=\"" UPS_IFACE "\">\n"
 "\n"
 "<!-- Begin of real methods/signals -->\n"
 "    <method name='Sync'>"
-"      <arg type='a(ssssbbusbbi)' name='state' direction='out'/>"
+"      <arg type='" ENTRY_ARRAY_SIGNATURE "' name='state' direction='out'/>"
 "    </method>"
 "\n"
 "    <signal name='ReSync'>"
@@ -32,12 +33,13 @@
 "</node>\n"
 ;
 
-void add_entry_id(GVariantBuilder *b)
+void add_entry_id(GVariantBuilder *b, gint priority)
 {
-  g_variant_builder_add (b, "(ssssbbusbbi)",
+  g_variant_builder_add (b, ENTRY_SIGNATURE,
                          "test_indicator_id",
                          "test_entry_id",
                          "test_entry_name_hint",
+                         0, /* parent window */
                          "test_entry_label",
                          TRUE, /* label sensitive */
                          TRUE, /* label visible */
@@ -45,15 +47,16 @@
                          "", /* image_data */
                          TRUE, /* image sensitive */
                          TRUE, /* image visible */
-                         1 /* priority  */);
+                         priority);
 }
 
-void add_entry_id_2(GVariantBuilder *b)
+void add_entry_id_2(GVariantBuilder *b, gint priority)
 {
-  g_variant_builder_add (b, "(ssssbbusbbi)",
+  g_variant_builder_add (b, ENTRY_SIGNATURE,
                          "test_indicator_id",
                          "test_entry_id2",
                          "test_entry_name_hint2",
+                         12345, /* parent window */
                          "test_entry_label2",
                          TRUE, /* label sensitive */
                          TRUE, /* label visible */
@@ -61,7 +64,7 @@
                          "", /* image_data */
                          TRUE, /* image sensitive */
                          TRUE, /* image visible */
-                         1 /* priority  */);
+                         priority);
 }
 }
 
@@ -73,7 +76,7 @@
   auto object = glib::DBusObjectBuilder::GetObjectsForIntrospection(panel_interface).front();
   object->SetMethodsCallsHandler(sigc::mem_fun(this, &Panel::OnMethodCall));
 
-  server_.AddObject(object, "/com/canonical/Unity/Panel/Service");
+  server_.AddObject(object, UPS_PATH);
 }
 
 GVariant* Panel::OnMethodCall(std::string const& method, GVariant *parameters)
@@ -82,18 +85,18 @@
   {
     GVariantBuilder b;
 
-    g_variant_builder_init (&b, G_VARIANT_TYPE ("(a(ssssbbusbbi))"));
-    g_variant_builder_open (&b, G_VARIANT_TYPE ("a(ssssbbusbbi)"));
+    g_variant_builder_init (&b, G_VARIANT_TYPE ("(" ENTRY_ARRAY_SIGNATURE ")"));
+    g_variant_builder_open (&b, G_VARIANT_TYPE (ENTRY_ARRAY_SIGNATURE));
 
     if (sync_return_mode_ == 0)
     {
-      add_entry_id(&b);
-      add_entry_id_2(&b);
+      add_entry_id(&b, 1);
+      add_entry_id_2(&b, 2);
     }
     else if (sync_return_mode_ == 1)
     {
-      add_entry_id_2(&b);
-      add_entry_id(&b);
+      add_entry_id_2(&b, 1);
+      add_entry_id(&b, 2);
     }
 
     if (sync_return_mode_ == 1)
 
=== modified file 'unity-shared/IconLoader.cpp'
--- unity-shared/IconLoader.cpp	2015-01-15 14:33:03 +0000
+++ unity-shared/IconLoader.cpp	2015-02-19 19:24:14 +0000
@@ -799,7 +799,7 @@
   bool CoalesceTasksCb();
 
 private:
-  std::map<std::string, glib::Object<GdkPixbuf>> cache_;
+  std::unordered_map<std::string, glib::Object<GdkPixbuf>> cache_;
   /* FIXME: the reference counting of IconLoaderTasks with shared pointers
    * is currently somewhat broken, and the queued_tasks_ member is what keeps
    * it from crashing randomly.
@@ -807,7 +807,7 @@
    * tasks, but when they are being completed in a worker thread, the thread
    * should own them as well (yet it doesn't), this could cause trouble
    * in the future... You've been warned! */
-  std::map<std::string, IconLoaderTask::Ptr> queued_tasks_;
+  std::unordered_map<std::string, IconLoaderTask::Ptr> queued_tasks_;
   std::queue<IconLoaderTask::Ptr> tasks_;
   std::unordered_map<Handle, IconLoaderTask::Ptr> task_map_;
   std::vector<IconLoaderTask*> finished_tasks_;
 
=== modified file 'unity-shared/MenuManager.cpp'
--- unity-shared/MenuManager.cpp	2015-02-04 11:13:04 +0000
+++ unity-shared/MenuManager.cpp	2015-02-19 19:24:14 +0000
@@ -26,6 +26,7 @@
 #include <unordered_map>
 
 #include "MenuManager.h"
+#include "WindowManager.h"
 
 namespace unity
 {
@@ -48,16 +49,20 @@
     : parent_(parent)
     , indicators_(indicators)
     , key_grabber_(grabber)
+    , show_now_window_(0)
     , settings_(g_settings_new(SETTINGS_NAME.c_str()))
   {
     for (auto const& indicator : indicators_->GetIndicators())
       AddIndicator(indicator);
 
+    GrabMnemonicsForActiveWindow();
+
     parent_->show_menus.changed.connect(sigc::mem_fun(this, &Impl::ShowMenus));
     indicators_->on_object_added.connect(sigc::mem_fun(this, &Impl::AddIndicator));
     indicators_->on_object_removed.connect(sigc::mem_fun(this, &Impl::RemoveIndicator));
     indicators_->on_entry_activate_request.connect(sigc::mem_fun(this, &Impl::ActivateRequest));
     indicators_->icon_paths_changed.connect(sigc::mem_fun(this, &Impl::IconPathsChanged));
+    WindowManager::Default().window_focus_changed.connect(sigc::hide(sigc::mem_fun(this, &Impl::GrabMnemonicsForActiveWindow)));
 
     signals_.Add<void, GSettings*, const gchar*>(settings_, "changed::" + LIM_KEY, [this] (GSettings*, const gchar*) {
       parent_->integrated_menus = g_settings_get_boolean(settings_, LIM_KEY.c_str());