Merge lp:~unity-team/unity/fix-lp1309778-trusty into lp:unity/7.2

[Christopher Townsend]

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.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3832
http://jenkins.qa.ubuntu.com/job/unity-7.2-ci/20/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-7.2-trusty-amd64-ci/20/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-7.2-trusty-armhf-ci/20/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-7.2-trusty-i386-ci/20/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3833
http://jenkins.qa.ubuntu.com/job/unity-7.2-ci/22/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-7.2-trusty-amd64-ci/22
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-7.2-trusty-armhf-ci/22
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-7.2-trusty-i386-ci/22

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

review: Approve (continuous-integration)

Unmerged revisions

3833. By Christopher Townsend on 2015-07-15

Merge lp:unity/7.2.

3832. By Marco Trevisan (Treviño) on 2015-05-28

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.

=== modified file 'UnityCore/AppmenuIndicator.cpp'
--- UnityCore/AppmenuIndicator.cpp	2015-03-12 00:57:05 +0000
+++ UnityCore/AppmenuIndicator.cpp	2015-07-15 14:19:40 +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	2015-03-12 00:57:05 +0000
+++ UnityCore/AppmenuIndicator.h	2015-07-15 14:19:40 +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-07-15 14:19:40 +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-12-09 15:41:53 +0000
+++ UnityCore/DBusIndicators.cpp	2015-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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	2015-03-12 00:57:05 +0000
+++ com.canonical.Unity.gschema.xml	2015-07-15 14:19:40 +0000
@@ -158,5 +158,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-24 13:49:53 +0000
+++ dash/DashView.h	2015-07-15 14:19:40 +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-08-06 14:09:30 +0000
+++ dash/ScopeView.h	2015-07-15 14:19:40 +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	2015-03-11 18:11:24 +0000
+++ debian/control	2015-07-15 14:19:40 +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	2015-03-12 00:57:05 +0000
+++ decorations/DecoratedWindow.cpp	2015-07-15 14:19:40 +0000
@@ -52,17 +52,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();
   });
 
@@ -703,7 +699,7 @@
 
 void Window::Impl::SetupAppMenu()
 {
-  if (!active() || !top_layout_)
+  if (!top_layout_)
     return;
 
   auto const& menu_manager = manager_->impl_->menu_manager_;
@@ -718,8 +714,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();
@@ -761,13 +760,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();
 }
@@ -780,7 +784,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	2015-03-12 00:57:05 +0000
+++ decorations/DecorationsManager.cpp	2015-07-15 14:19:40 +0000
@@ -144,27 +144,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();
   }
 }
 
@@ -268,9 +265,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)
@@ -311,6 +305,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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-12-16 19:35:06 +0000
+++ decorations/DecorationsPriv.h	2015-07-15 14:19:40 +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	2015-03-12 00:57:05 +0000
+++ decorations/DecorationsSlidingLayout.cpp	2015-07-15 14:19:40 +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-12-08 22:38:02 +0000
+++ decorations/DecorationsWidgets.cpp	2015-07-15 14:19:40 +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-07-15 14:19:40 +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 'launcher/XdndStartStopNotifierImp.h'
--- launcher/XdndStartStopNotifierImp.h	2012-11-15 16:05:35 +0000
+++ launcher/XdndStartStopNotifierImp.h	2015-07-15 14:19:40 +0000
@@ -27,7 +27,7 @@
 
 namespace unity {
 
-class XdndStartStopNotifierImp : public XdndStartStopNotifier {
+class XdndStartStopNotifierImp : public XdndStartStopNotifier, public sigc::trackable {
 public:
   XdndStartStopNotifierImp();
 
 
=== modified file 'lockscreen/LockScreenPanel.cpp'
--- lockscreen/LockScreenPanel.cpp	2014-12-15 19:12:07 +0000
+++ lockscreen/LockScreenPanel.cpp	2015-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-12-08 19:50:13 +0000
+++ panel/PanelIndicatorEntryView.cpp	2015-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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	2015-03-12 00:57:05 +0000
+++ panel/PanelMenuView.cpp	2015-07-15 14:19:40 +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	2015-03-12 00:57:05 +0000
+++ panel/PanelMenuView.h	2015-07-15 14:19:40 +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-03-06 16:26:34 +0000
+++ panel/PanelView.cpp	2015-07-15 14:19:40 +0000
@@ -519,7 +519,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;
@@ -676,7 +676,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
@@ -693,7 +693,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-06-03 12:46:12 +0000
+++ plugins/unityshell/src/unityshell.cpp	2015-07-15 14:19:40 +0000
@@ -156,6 +156,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)
@@ -278,9 +279,6 @@
      ScaleScreenInterface::setHandler(sScreen);
      screen->updateSupportedWmHints();
 
-     PluginAdapter::Initialize(screen);
-     AddChild(&WindowManager::Default());
-
      StartupNotifyService::Default()->SetSnDisplay(screen->snDisplay(), screen->screenNum());
 
      nux::NuxInitialize(0);
@@ -441,13 +439,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();
@@ -686,7 +684,7 @@
   if (sources_.GetSource(local::RELAYOUT_TIMEOUT))
     return;
 
-  if (WindowManager::Default().IsExpoActive())
+  if (WM.IsExpoActive())
     return;
 
   CompOutput* output = _last_output;
@@ -947,7 +945,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);
 }
@@ -960,7 +958,7 @@
          hud_controller_->IsVisible() ||
          session_controller_->Visible() ||
           ((switcher_controller_->Visible() ||
-            WindowManager::Default().IsExpoActive())
+            WM.IsExpoActive())
            && !fullscreen_windows_.empty () && (!(screen->grabbed () && !screen->otherGrabExist (NULL))));
 }
 
@@ -2218,7 +2216,7 @@
                                          CompAction::State state,
                                          CompOption::Vector& options)
 {
-  WindowManager::Default().ShowDesktop();
+  WM.ShowDesktop();
   return true;
 }
 
@@ -2322,7 +2320,7 @@
                                         CompAction::State state,
                                         CompOption::Vector& options)
 {
-  if (WindowManager::Default().IsWallActive())
+  if (WM.IsWallActive())
     return false;
   else if (switcher_controller_->Visible())
     switcher_controller_->Next();
@@ -2520,11 +2518,9 @@
   }
   else
   {
-    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] {
@@ -2663,7 +2659,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()
@@ -2672,7 +2668,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()
@@ -2925,7 +2921,7 @@
     }
   }
 
-  if (WindowManager::Default().IsScaleActive() &&
+  if (uScreen->WM.IsScaleActive() &&
       uScreen->sScreen->getSelectedWindow() == window->id())
   {
     nux::Geometry const& scaled_geo = GetScaledGeometry();
@@ -3030,9 +3026,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))
           {
@@ -3670,8 +3665,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)
       {
@@ -3787,13 +3781,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();
 }
@@ -3892,24 +3884,24 @@
   auto 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>();
@@ -3918,14 +3910,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
@@ -3936,7 +3928,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);
@@ -4122,7 +4114,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);
@@ -4139,8 +4131,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))
@@ -4376,9 +4368,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	2015-06-03 12:46:12 +0000
+++ plugins/unityshell/src/unityshell.h	2015-07-15 14:19:40 +0000
@@ -333,6 +333,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-12-09 15:41:53 +0000
+++ services/panel-main.c	2015-07-15 14:19:40 +0000
@@ -26,20 +26,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'>"
@@ -109,10 +110,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
@@ -270,8 +267,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);
@@ -292,10 +289,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)
@@ -315,8 +315,8 @@
 
   g_dbus_connection_emit_signal (connection,
                                  NULL,
-                                 S_PATH,
-                                 S_IFACE,
+                                 UPS_PATH,
+                                 UPS_IFACE,
                                  "EntryActivateRequest",
                                  g_variant_new ("(s)", entry_id),
                                  &error);
@@ -337,8 +337,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);
@@ -356,8 +356,8 @@
   GError *error = NULL;
   g_dbus_connection_emit_signal (connection,
                                  NULL,
-                                 S_PATH,
-                                 S_IFACE,
+                                 UPS_PATH,
+                                 UPS_IFACE,
                                  "IconPathsChanged",
                                  NULL,
                                  &error);
@@ -378,7 +378,7 @@
   guint         reg_id;
 
   reg_id = g_dbus_connection_register_object (connection,
-                                              S_PATH,
+                                              UPS_PATH,
                                               introspection_data->interfaces[0],
                                               &interface_vtable,
                                               service,
@@ -489,7 +489,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-07-15 14:19:40 +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	2015-07-15 14:19:40 +0000
+++ services/panel-service.c	2015-07-15 14:19:40 +0000
@@ -42,7 +42,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)
@@ -60,10 +60,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;
@@ -103,14 +106,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 */
@@ -135,6 +138,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 *);
 
 /*
@@ -163,7 +168,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;
@@ -264,9 +269,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));
@@ -289,7 +295,7 @@
           IndicatorObjectEntry *entry = k;
           GdkRectangle *geo = v;
 
-          if (is_point_in_rect (x, y, geo))
+          if (rect_contains_point (geo, x, y))
             {
               return entry;
             }
@@ -320,8 +326,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;
         }
@@ -331,7 +336,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;
@@ -345,12 +350,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;
+                }
             }
         }
     }
@@ -413,7 +426,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);
@@ -423,6 +436,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;
@@ -542,9 +570,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;
                 }
@@ -609,7 +635,7 @@
 initial_resync (PanelService *self)
 {
   g_signal_emit (self, _service_signals[RE_SYNC], 0, "");
-  return FALSE;
+  return G_SOURCE_REMOVE;
 }
 
 static gboolean
@@ -618,7 +644,7 @@
   if (!lockscreen_mode)
     emit_upstart_event ("indicator-services-start");
 
-  return FALSE;
+  return G_SOURCE_REMOVE;
 }
 
 static void
@@ -782,10 +808,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
@@ -863,6 +889,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));
 }
 
@@ -1077,7 +1106,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
@@ -1136,6 +1165,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);
 
@@ -1175,6 +1205,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,
@@ -1183,11 +1249,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);
@@ -1202,6 +1263,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);
 }
 
@@ -1259,6 +1327,7 @@
   "unity",
   "unity-3d",
   "unity-panel-service",
+  "unity-all-menus",
   NULL
 };
 
@@ -1278,6 +1347,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,
@@ -1539,10 +1611,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,
@@ -1559,14 +1632,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,
@@ -1574,15 +1648,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;
@@ -1596,14 +1675,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
@@ -1614,15 +1708,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);
     }
@@ -1650,7 +1744,7 @@
           rect.height *= scale;
         }
 
-      if (is_point_in_rect (x, y, &rect))
+      if (rect_contains_point (&rect, x, y))
         {
           return i;
         }
@@ -1722,8 +1816,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;)
     {
@@ -1733,7 +1827,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;
@@ -1749,8 +1843,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)
     {
@@ -1758,7 +1852,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;
@@ -1782,6 +1876,7 @@
 {
   IndicatorObject *object;
   IndicatorObjectEntry *entry;
+  GHashTable *entry2geometry_hash;
   gboolean valid_entry = TRUE;
   PanelServicePrivate  *priv = self->priv;
 
@@ -1802,24 +1897,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);
                 }
@@ -2188,7 +2277,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",
@@ -2394,10 +2483,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-12-09 15:41:53 +0000
+++ services/panel-service.h	2015-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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-07-15 14:19:40 +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	2014-03-21 01:49:22 +0000
+++ unity-shared/IconLoader.cpp	2015-07-15 14:19:40 +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-03-12 00:57:05 +0000
+++ unity-shared/MenuManager.cpp	2015-07-15 14:19:40 +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));