Merge lp:~3v1n0/unity/application-manager-new into lp:unity

[Marco Trevisan (Treviño)]

ApplicationManager: add missing features, keep a copy of views around

Use this in PanelMenuView, getting rid of the BAMF internal at this level.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

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

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3972
http://jenkins.qa.ubuntu.com/job/unity-ci/1153/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/41/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/40/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/40/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3973
http://jenkins.qa.ubuntu.com/job/unity-ci/1154/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/42/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/41/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/41/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3975
http://jenkins.qa.ubuntu.com/job/unity-ci/1155/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/43
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/42
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/42

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

review: Approve (continuous-integration)

[Christopher Townsend (townsend)]

LGTM

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3976
http://jenkins.qa.ubuntu.com/job/unity-ci/1164/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-vivid-amd64-ci/52
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-vivid-armhf-ci/51
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-vivid-i386-ci/51

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

review: Approve (continuous-integration)

[Stephen M. Webb (bregma)]

One of the commits made after this MP was reviewd and approved cause unit test failures.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3982
http://jenkins.qa.ubuntu.com/job/unity-ci/1229/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/5/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3982
http://jenkins.qa.ubuntu.com/job/unity-ci/1230/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/6/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/6/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3982
http://jenkins.qa.ubuntu.com/job/unity-ci/1231/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-wily-amd64-ci/9
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-wily-armhf-ci/7
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-wily-i386-ci/7

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

review: Approve (continuous-integration)

[Christopher Townsend (townsend)]

Ok, all good now.

review: Approve

=== modified file 'launcher/ApplicationLauncherIcon.cpp'
--- launcher/ApplicationLauncherIcon.cpp	2015-03-25 14:59:04 +0000
+++ launcher/ApplicationLauncherIcon.cpp	2015-05-22 16:04:25 +0000
@@ -156,13 +156,14 @@
 {
   // Lambda functions should be fine here because when the application the icon
   // is only ever removed when the application is closed.
-  signals_conn_.Add(app_->window_opened.connect([this](ApplicationWindow const&) {
+  signals_conn_.Add(app_->window_opened.connect([this](ApplicationWindowPtr const&) {
     EnsureWindowState();
     UpdateIconGeometries(GetCenters());
   }));
 
-  signals_conn_.Add(app_->window_closed.connect(sigc::mem_fun(this, &ApplicationLauncherIcon::EnsureWindowState)));
-  signals_conn_.Add(app_->window_moved.connect(sigc::hide(sigc::mem_fun(this, &ApplicationLauncherIcon::EnsureWindowState))));
+  auto ensure_windows_cb = sigc::hide(sigc::mem_fun(this, &ApplicationLauncherIcon::EnsureWindowState));
+  signals_conn_.Add(app_->window_closed.connect(ensure_windows_cb));
+  signals_conn_.Add(app_->window_moved.connect(ensure_windows_cb));
 
   signals_conn_.Add(app_->urgent.changed.connect([this](bool const& urgent) {
     LOG_DEBUG(logger) << tooltip_text() << " urgent now " << (urgent ? "true" : "false");
@@ -235,7 +236,7 @@
     if (!SimpleLauncherIcon::GetQuirk(Quirk::ACTIVE, monitor))
       return false;
 
-    if (app_->type() == "webapp")
+    if (app_->type() == AppType::WEBAPP)
       return true;
 
     // Sometimes BAMF is not fast enough to update the active application
@@ -702,7 +703,7 @@
     if (window->Focus())
       return;
   }
-  else if (app_->type() == "webapp")
+  else if (app_->type() == AppType::WEBAPP)
   {
     // Webapps are again special.
     OpenInstanceLauncherIcon(arg.timestamp);
@@ -837,8 +838,6 @@
   if (windows.size() < 2)
     return;
 
-  Window active = WindowManager::Default().GetActiveWindow();
-
   // add menu items for all open windows
   for (auto const& w : windows)
   {
@@ -862,7 +861,7 @@
         wm.Raise(xid);
     });
 
-    if (xid == active)
+    if (w->active())
     {
       dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE, DBUSMENU_MENUITEM_TOGGLE_RADIO);
       dbusmenu_menuitem_property_set_int(menu_item, DBUSMENU_MENUITEM_PROP_TOGGLE_STATE, DBUSMENU_MENUITEM_TOGGLE_STATE_CHECKED);
@@ -1113,7 +1112,7 @@
 
 void ApplicationLauncherIcon::UpdateIconGeometries(std::vector<nux::Point3> const& centers)
 {
-  if (app_->type() == "webapp")
+  if (app_->type() == AppType::WEBAPP)
     return;
 
   nux::Geometry geo(0, 0, icon_size, icon_size);
@@ -1189,6 +1188,7 @@
   auto const& desktop_file = DesktopFile();
 
   return boost::algorithm::ends_with(desktop_file, "org.gnome.Nautilus.desktop") ||
+         boost::algorithm::ends_with(desktop_file, "nautilus.desktop") ||
          boost::algorithm::ends_with(desktop_file, "nautilus-folder-handler.desktop") ||
          boost::algorithm::ends_with(desktop_file, "nautilus-home.desktop");
 }
@@ -1264,14 +1264,14 @@
 
 bool ApplicationLauncherIcon::AllowDetailViewInSwitcher() const
 {
-  return app_->type() != "webapp";
+  return app_->type() != AppType::WEBAPP;
 }
 
 uint64_t ApplicationLauncherIcon::SwitcherPriority()
 {
   uint64_t result = 0;
   // Webapps always go at the back.
-  if (app_->type() == "webapp")
+  if (app_->type() == AppType::WEBAPP)
     return result;
 
   for (auto& window : app_->GetWindows())
 
=== modified file 'launcher/MockLauncherIcon.h'
--- launcher/MockLauncherIcon.h	2015-03-20 16:23:04 +0000
+++ launcher/MockLauncherIcon.h	2015-05-22 16:04:25 +0000
@@ -52,7 +52,7 @@
     icon.SetGetterFunction([this] { return ""; });
   }
 
-  virtual std::string type() const { return "mock"; }
+  virtual WindowType type() const { return WindowType::UNKNOWN; }
 
   virtual Window window_id() const { return xid_; }
   virtual int monitor() const { return -1; }
 
=== modified file 'panel/CMakeLists.txt'
--- panel/CMakeLists.txt	2014-02-12 07:13:01 +0000
+++ panel/CMakeLists.txt	2015-05-22 16:04:25 +0000
@@ -36,4 +36,4 @@
 #
 add_executable (panel StandalonePanel.cpp)
 find_library (COMPIZ_LIB compiz_core ${COMPIZ_LIBDIR})
-target_link_libraries (panel panel-lib unity-shared unity-shared-standalone ${COMPIZ_LIB})
+target_link_libraries (panel panel-lib unity-shared unity-shared-standalone unity-shared-bamf ${COMPIZ_LIB})
 
=== modified file 'panel/PanelMenuView.cpp'
--- panel/PanelMenuView.cpp	2015-02-19 14:19:44 +0000
+++ panel/PanelMenuView.cpp	2015-05-22 16:04:25 +0000
@@ -20,6 +20,7 @@
 
 #include <Nux/Nux.h>
 #include <NuxCore/Logger.h>
+#include <UnityCore/GLibWrapper.h>
 #include <boost/algorithm/string/erase.hpp>
 
 #include "PanelMenuView.h"
@@ -87,13 +88,11 @@
   , maximized_window(0)
   , focused(true)
   , menu_manager_(menus)
-  , matcher_(bamf_matcher_get_default())
   , is_inside_(false)
   , is_grabbed_(false)
   , is_maximized_(false)
   , is_desktop_focused_(false)
   , last_active_view_(nullptr)
-  , new_application_(nullptr)
   , switcher_showing_(false)
   , spread_showing_(false)
   , launcher_keynav_(false)
@@ -105,9 +104,8 @@
   , always_show_menus_(menu_manager_->always_show_menus())
   , desktop_name_(get_current_desktop())
 {
-  BamfWindow* active_win = bamf_matcher_get_active_window(matcher_);
-  if (BAMF_IS_WINDOW(active_win))
-    active_window = bamf_window_get_xid(active_win);
+  if (ApplicationWindowPtr const& win = ApplicationManager::Default().GetActiveWindow())
+    active_window = win->window_id();
 
   SetupWindowButtons();
   SetupTitlebarGrabArea();
@@ -117,8 +115,7 @@
 
   opacity = 0.0f;
 
-  if (Refresh())
-    FullRedraw();
+  RefreshAndRedraw();
 }
 
 PanelMenuView::~PanelMenuView()
@@ -144,14 +141,11 @@
 
 void PanelMenuView::SetupPanelMenuViewSignals()
 {
-  active_win_changed_signal_.Connect(matcher_, "active-window-changed",
-                                     sigc::mem_fun(this, &PanelMenuView::OnActiveWindowChanged));
-  active_app_changed_signal_.Connect(matcher_, "active-application-changed",
-                                     sigc::mem_fun(this, &PanelMenuView::OnActiveAppChanged));
-  view_opened_signal_.Connect(matcher_, "view-opened",
-                              sigc::mem_fun(this, &PanelMenuView::OnViewOpened));
-  view_closed_signal_.Connect(matcher_, "view-closed",
-                              sigc::mem_fun(this, &PanelMenuView::OnViewClosed));
+  auto& am = ApplicationManager::Default();
+  am.active_window_changed.connect(sigc::mem_fun(this, &PanelMenuView::OnActiveWindowChanged));
+  am.active_application_changed.connect(sigc::mem_fun(this, &PanelMenuView::OnActiveAppChanged));
+  am.application_started.connect(sigc::mem_fun(this, &PanelMenuView::OnApplicationStarted));
+  am.application_stopped.connect(sigc::mem_fun(this, &PanelMenuView::OnApplicationClosed));
 
   mouse_enter.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseEnter));
   mouse_leave.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseLeave));
@@ -232,9 +226,9 @@
   wm.window_resized.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowMoved));
   wm.initiate_spread.connect(sigc::mem_fun(this, &PanelMenuView::OnSpreadInitiate));
   wm.terminate_spread.connect(sigc::mem_fun(this, &PanelMenuView::OnSpreadTerminate));
-  wm.initiate_expo.connect(sigc::mem_fun(this, &PanelMenuView::OnExpoInitiate));
-  wm.terminate_expo.connect(sigc::mem_fun(this, &PanelMenuView::OnExpoTerminate));
-  wm.screen_viewport_switch_ended.connect(sigc::mem_fun(this, &PanelMenuView::OnExpoTerminate));
+  wm.initiate_expo.connect(sigc::mem_fun(this, &PanelMenuView::RefreshAndRedraw));
+  wm.terminate_expo.connect(sigc::mem_fun(this, &PanelMenuView::RefreshAndRedraw));
+  wm.screen_viewport_switch_ended.connect(sigc::mem_fun(this, &PanelMenuView::RefreshAndRedraw));
 }
 
 void PanelMenuView::SetupUBusManagerInterests()
@@ -300,7 +294,7 @@
 void PanelMenuView::OnLIMChanged(bool lim)
 {
   integrated_menus_ = lim;
-  new_application_ = nullptr;
+  new_application_.reset();
 
   if (!integrated_menus_)
   {
@@ -321,7 +315,7 @@
   if (!always_show_menus_)
     CheckMouseInside();
 
-  FullRedraw();
+  QueueDraw();
 }
 
 nux::Area* PanelMenuView::FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type)
@@ -762,41 +756,13 @@
 std::string PanelMenuView::GetActiveViewName(bool use_appname) const
 {
   std::string label;
-  BamfWindow* window;
-
-  window = bamf_matcher_get_active_window(matcher_);
-
-  if (BAMF_IS_WINDOW(window))
+  auto& am = ApplicationManager::Default();
+
+  if (ApplicationWindowPtr const& window = am.GetActiveWindow())
   {
-    BamfView *view = reinterpret_cast<BamfView*>(window);
-    Window window_xid = bamf_window_get_xid(window);
-
-    if (bamf_window_get_window_type(window) == BAMF_WINDOW_DOCK)
-    {
-      auto panel = const_cast<PanelMenuView*>(this)->GetTopLevelViewWindow();
-      if (static_cast<nux::BaseWindow*>(panel)->GetInputWindowId() == window_xid)
-        return desktop_name_;
-
-      std::vector<Window> const& our_xids = nux::XInputWindow::NativeHandleList();
-
-      if (std::find(our_xids.begin(), our_xids.end(), window_xid) != our_xids.end())
-      {
-        /* If the active window is an unity window, we need to fallback to the
-         * top one, anyway we should always avoid to focus unity internal windows */
-        BamfWindow* top_win = GetBamfWindowForXid(GetTopWindow());
-
-        if (top_win && top_win != window)
-        {
-          window = top_win;
-        }
-        else
-        {
-          return "";
-        }
-      }
-    }
-
-    if (bamf_window_get_window_type(window) == BAMF_WINDOW_DESKTOP)
+    Window window_xid = window->window_id();
+
+    if (window->type() == WindowType::DESKTOP)
     {
       label = desktop_name_;
     }
@@ -806,27 +772,16 @@
     }
 
     if (WindowManager::Default().IsWindowMaximized(window_xid) && !use_appname)
-    {
-      label = glib::String(bamf_view_get_name(view)).Str();
-    }
-
-    if (label.empty())
-    {
-      BamfApplication* app;
-      app = bamf_matcher_get_application_for_window(matcher_, window);
-
-      if (BAMF_IS_APPLICATION(app))
-      {
-        view = reinterpret_cast<BamfView*>(app);
-        label = glib::String(bamf_view_get_name(view)).Str();
-      }
-    }
-
-    if (label.empty())
-    {
-      view = reinterpret_cast<BamfView*>(window);
-      label = glib::String(bamf_view_get_name(view)).Str();
-    }
+      label = window->title();
+
+    if (label.empty())
+    {
+      if (ApplicationPtr const& app = am.GetActiveApplication())
+        label = app->title();
+    }
+
+    if (label.empty())
+      label = window->title();
   }
 
   return label;
@@ -835,24 +790,16 @@
 std::string PanelMenuView::GetMaximizedViewName(bool use_appname) const
 {
   Window maximized = maximized_window();
-  BamfWindow* window = nullptr;
   std::string label;
 
-  window = GetBamfWindowForXid(maximized);
-
-  if (BAMF_IS_WINDOW(window))
+  if (ApplicationWindowPtr const& window = ApplicationManager::Default().GetWindowForId(maximized))
   {
-    BamfView* view = reinterpret_cast<BamfView*>(window);
-    label = glib::String(bamf_view_get_name(view)).Str();
+    label = window->title();
 
     if (use_appname || label.empty())
     {
-      BamfApplication* app = bamf_matcher_get_application_for_window(matcher_, window);
-
-      if (BAMF_IS_APPLICATION(app))
-        view = reinterpret_cast<BamfView*>(app);
-
-      label = glib::String(bamf_view_get_name(view)).Str();
+      if (ApplicationPtr const& app = window->application())
+        label = app->title();
     }
   }
 
@@ -963,6 +910,12 @@
   return true;
 }
 
+void PanelMenuView::RefreshAndRedraw()
+{
+  if (Refresh())
+    QueueDraw();
+}
+
 void PanelMenuView::OnActiveChanged(PanelIndicatorEntryView* view, bool is_active)
 {
   if (is_active)
@@ -977,8 +930,7 @@
     }
   }
 
-  if (Refresh())
-    FullRedraw();
+  RefreshAndRedraw();
 }
 
 void PanelMenuView::OnEntryAdded(indicator::Entry::Ptr const& entry)
@@ -1012,22 +964,13 @@
   }
 }
 
-void PanelMenuView::OnNameChanged(BamfView* bamf_view, gchar* new_name, gchar* old_name)
-{
-  if (Refresh())
-    FullRedraw();
-}
-
 bool PanelMenuView::OnNewAppShow()
 {
-  BamfApplication* active_app = bamf_matcher_get_active_application(matcher_);
-  new_application_ = glib::Object<BamfApplication>(active_app, glib::AddRef());
+  new_application_ = ApplicationManager::Default().GetActiveApplication();
   QueueDraw();
 
   if (sources_.GetSource(NEW_APP_HIDE_TIMEOUT))
-  {
     new_app_menu_shown_ = false;
-  }
 
   auto cb_func = sigc::mem_fun(this, &PanelMenuView::OnNewAppHide);
   sources_.AddTimeoutSeconds(menu_manager_->discovery(), cb_func, NEW_APP_HIDE_TIMEOUT);
@@ -1044,69 +987,51 @@
   return false;
 }
 
-void PanelMenuView::OnViewOpened(BamfMatcher *matcher, BamfView *view)
+void PanelMenuView::OnApplicationStarted(ApplicationPtr const& app)
 {
   /* FIXME: here we should also check for if the view is also user_visible
    * but it seems that BAMF doesn't handle this correctly after some
    * stress tests (repeated launches). */
-  if (!BAMF_IS_APPLICATION(view) || integrated_menus_)
+  if (integrated_menus_)
     return;
 
-  new_apps_.push_front(glib::Object<BamfApplication>(BAMF_APPLICATION(view), glib::AddRef()));
+  new_apps_.push_front(app);
 }
 
-void PanelMenuView::OnApplicationClosed(BamfApplication* app)
+void PanelMenuView::OnApplicationClosed(ApplicationPtr const& app)
 {
-  if (BAMF_IS_APPLICATION(app) && !integrated_menus_)
+  if (app && !integrated_menus_)
   {
     if (std::find(new_apps_.begin(), new_apps_.end(), app) != new_apps_.end())
     {
-      new_apps_.remove(glib::Object<BamfApplication>(app, glib::AddRef()));
+      new_apps_.remove(app);
     }
     else if (new_apps_.empty())
     {
-      new_application_ = nullptr;
+      new_application_.reset();
     }
   }
 
   if (app == new_application_)
   {
-    new_application_ = nullptr;
-  }
-}
-
-void PanelMenuView::OnViewClosed(BamfMatcher *matcher, BamfView *view)
-{
-  if (reinterpret_cast<BamfView*>(view_name_changed_signal_.object()) == view)
-  {
-    view_name_changed_signal_.Disconnect();
-  }
-
-  if (BAMF_IS_APPLICATION(view))
-  {
-    OnApplicationClosed(reinterpret_cast<BamfApplication*>(view));
-  }
-  else if (reinterpret_cast<BamfApplication*>(view) == new_application_)
-  {
-    new_application_ = nullptr;
-  }
-  else if (BAMF_IS_WINDOW(view))
-  {
-    /* FIXME, this can be removed when window_unmapped WindowManager signal
-     * will emit the proper xid */
-    Window xid = bamf_window_get_xid(reinterpret_cast<BamfWindow*>(view));
-    OnWindowUnmapped(xid);
-  }
-}
-
-void PanelMenuView::OnActiveAppChanged(BamfMatcher *matcher,
-                                       BamfApplication* old_app,
-                                       BamfApplication* new_app)
-{
-  if (BAMF_IS_APPLICATION(new_app))
-  {
-    app_name_changed_signal_.Connect(BAMF_VIEW(new_app), "name-changed",
-                                     sigc::mem_fun(this, &PanelMenuView::OnNameChanged));
+    new_application_.reset();
+  }
+}
+
+void PanelMenuView::OnWindowClosed(ApplicationWindowPtr const& win)
+{
+  /* FIXME, this can be removed when window_unmapped WindowManager signal
+   * will emit the proper xid */
+  OnWindowUnmapped(win->window_id());
+}
+
+void PanelMenuView::OnActiveAppChanged(ApplicationPtr const& new_app)
+{
+  if (new_app)
+  {
+    app_name_changed_conn_ = new_app->title.changed.connect([this] (std::string const&t) {
+      RefreshAndRedraw();
+    });
 
     if (integrated_menus_ || always_show_menus_)
       return;
@@ -1140,7 +1065,7 @@
   }
 }
 
-void PanelMenuView::OnActiveWindowChanged(BamfMatcher *matcher, BamfView* old_view, BamfView* new_view)
+void PanelMenuView::OnActiveWindowChanged(ApplicationWindowPtr const& new_win)
 {
   show_now_activated_ = false;
   is_maximized_ = false;
@@ -1149,13 +1074,12 @@
 
   sources_.Remove(WINDOW_MOVED_TIMEOUT);
 
-  if (BAMF_IS_WINDOW(new_view))
+  if (new_win)
   {
-    BamfWindow* window = reinterpret_cast<BamfWindow*>(new_view);
-    active_xid = bamf_window_get_xid(window);
-    is_maximized_ = (bamf_window_maximized(window) == BAMF_WINDOW_MAXIMIZED);
+    active_xid = new_win->window_id();
+    is_maximized_ = new_win->maximized();
 
-    if (bamf_window_get_window_type(window) == BAMF_WINDOW_DESKTOP)
+    if (new_win->type() == WindowType::DESKTOP)
     {
       is_desktop_focused_ = !maximized_window();
       we_control_active_ = true;
@@ -1173,14 +1097,13 @@
     }
 
     // register callback for new view
-    view_name_changed_signal_.Connect(new_view, "name-changed",
-                                      sigc::mem_fun(this, &PanelMenuView::OnNameChanged));
+    win_name_changed_conn_ = new_win->title.changed.connect([this] (std::string const& t) {
+      RefreshAndRedraw();
+    });
   }
 
   active_window = active_xid;
-
-  if (Refresh())
-    FullRedraw();
+  RefreshAndRedraw();
 }
 
 void PanelMenuView::OnSpreadInitiate()
@@ -1195,18 +1118,6 @@
   QueueDraw();
 }
 
-void PanelMenuView::OnExpoInitiate()
-{
-  if (Refresh())
-    QueueDraw();
-}
-
-void PanelMenuView::OnExpoTerminate()
-{
-  if (Refresh())
-    QueueDraw();
-}
-
 void PanelMenuView::OnWindowMinimized(Window xid)
 {
   maximized_wins_.erase(std::remove(maximized_wins_.begin(), maximized_wins_.end(), xid), maximized_wins_.end());
@@ -1214,13 +1125,11 @@
 
   if (xid == active_window())
   {
-    if (Refresh())
-      QueueDraw();
+    RefreshAndRedraw();
   }
   else if (integrated_menus_ && window_buttons_->controlled_window == xid)
   {
-    if (Refresh())
-      QueueDraw();
+    RefreshAndRedraw();
   }
 }
 
@@ -1234,8 +1143,7 @@
       UpdateMaximizedWindow();
     }
 
-    if (Refresh())
-      QueueDraw();
+    RefreshAndRedraw();
   }
   else
   {
@@ -1247,8 +1155,7 @@
 
     if (integrated_menus_ && IsWindowUnderOurControl(xid))
     {
-      if (Refresh())
-        QueueDraw();
+      RefreshAndRedraw();
     }
   }
 }
@@ -1262,13 +1169,11 @@
 
   if (xid == active_window())
   {
-    if (Refresh())
-      QueueDraw();
+    RefreshAndRedraw();
   }
   else if (integrated_menus_ && window_buttons_->controlled_window == xid)
   {
-    if (Refresh())
-      QueueDraw();
+    RefreshAndRedraw();
   }
 }
 
@@ -1281,8 +1186,7 @@
       maximized_wins_.push_front(xid);
       UpdateMaximizedWindow();
 
-      if (Refresh())
-        QueueDraw();
+      RefreshAndRedraw();
     }
     else
     {
@@ -1303,8 +1207,7 @@
     CheckMouseInside();
     is_maximized_ = true;
 
-    if (Refresh())
-      FullRedraw();
+    RefreshAndRedraw();
   }
   else
   {
@@ -1313,8 +1216,7 @@
 
     if (integrated_menus_ && IsWindowUnderOurControl(xid))
     {
-      if (Refresh())
-        QueueDraw();
+      RefreshAndRedraw();
     }
   }
 }
@@ -1328,14 +1230,11 @@
   {
     is_maximized_ = false;
     is_grabbed_ = false;
-
-    if (Refresh())
-      FullRedraw();
+    RefreshAndRedraw();
   }
   else if (integrated_menus_ && window_buttons_->controlled_window == xid)
   {
-    if (Refresh())
-      QueueDraw();
+    RefreshAndRedraw();
   }
 }
 
@@ -1350,8 +1249,7 @@
     if (HasVisibleMenus())
       on_indicator_updated.emit();
 
-    if (Refresh())
-      QueueDraw();
+    RefreshAndRedraw();
   }
 
   return false;
@@ -1436,55 +1334,20 @@
 Window PanelMenuView::GetTopWindow() const
 {
   Window window_xid = 0;
-  GList* windows = bamf_matcher_get_window_stack_for_monitor(matcher_, monitor_);
 
-  for (GList* l = windows; l; l = l->next)
+  for (auto const& win : ApplicationManager::Default().GetWindowsForMonitor(monitor_))
   {
-    if (!BAMF_IS_WINDOW(l->data))
-      continue;
-
-    Window xid = bamf_window_get_xid(static_cast<BamfWindow*>(l->data));
-    bool visible = bamf_view_is_user_visible(static_cast<BamfView*>(l->data));
-
-    if (visible && IsValidWindow(xid))
+    Window xid = win->window_id();
+
+    if (win->visible() && IsValidWindow(xid))
     {
       window_xid = xid;
     }
   }
 
-  g_list_free(windows);
-
   return window_xid;
 }
 
-BamfWindow* PanelMenuView::GetBamfWindowForXid(Window xid) const
-{
-  BamfWindow* window = nullptr;
-
-  if (xid != 0)
-  {
-    GList* windows = bamf_matcher_get_windows(matcher_);
-
-    for (GList* l = windows; l; l = l->next)
-    {
-      if (!BAMF_IS_WINDOW(l->data))
-        continue;
-
-      auto win = static_cast<BamfWindow*>(l->data);
-
-      if (bamf_window_get_xid(win) == xid)
-      {
-        window = win;
-        break;
-      }
-    }
-
-    g_list_free(windows);
-  }
-
-  return window;
-}
-
 void PanelMenuView::ActivateIntegratedMenus(nux::Point const& click)
 {
   if (!layout_->GetAbsoluteGeometry().IsInside(click))
@@ -1679,8 +1542,7 @@
 
       is_inside_ = true;
       is_grabbed_ = true;
-      if (Refresh())
-        FullRedraw();
+      RefreshAndRedraw();
 
       /* Ungrab the pointer and start the X move, to make the decorator handle it */
       titlebar_grab_area_->SetGrabbed(false);
@@ -1700,8 +1562,7 @@
   if (!is_inside_)
     is_grabbed_ = false;
 
-  if (Refresh())
-    FullRedraw();
+  RefreshAndRedraw();
 }
 
 // Introspectable
@@ -1763,8 +1624,7 @@
     show_now_activated_ = false;
   }
 
-  if (Refresh())
-    QueueDraw();
+  RefreshAndRedraw();
 }
 
 void PanelMenuView::OnLauncherKeyNavStarted(GVariant* data)
@@ -1785,9 +1645,7 @@
 
   launcher_keynav_ = false;
   CheckMouseInside();
-
-  if (Refresh())
-    QueueDraw();
+  RefreshAndRedraw();
 }
 
 void PanelMenuView::OnLauncherSelectionChanged(GVariant* data)
@@ -1854,23 +1712,17 @@
 
   maximized_wins_.clear();
   monitor_geo_ = UScreen::GetDefault()->GetMonitorGeometry(monitor_);
-  GList* windows = bamf_matcher_get_window_stack_for_monitor(matcher_, monitor_);
 
-  for (GList* l = windows; l; l = l->next)
+  for (auto const& win : ApplicationManager::Default().GetWindowsForMonitor(monitor_))
   {
-    if (!BAMF_IS_WINDOW(l->data))
-      continue;
-
-    auto window = static_cast<BamfWindow*>(l->data);
-    auto view = static_cast<BamfView*>(l->data);
-    auto xid = bamf_window_get_xid(window);
-
-    if (bamf_view_is_active(view))
+    auto xid = win->window_id();
+
+    if (win->active())
       active_window = xid;
 
-    if (bamf_window_maximized(window) == BAMF_WINDOW_MAXIMIZED)
+    if (win->maximized())
     {
-      if (xid == active_window())
+      if (win->active())
         maximized_wins_.push_front(xid);
       else
         maximized_wins_.push_back(xid);
@@ -1881,7 +1733,6 @@
   UpdateMaximizedWindow();
 
   OnStyleChanged();
-  g_list_free(windows);
 }
 
 bool PanelMenuView::HasMenus() const
 
=== modified file 'panel/PanelMenuView.h'
--- panel/PanelMenuView.h	2015-02-04 09:54:49 +0000
+++ panel/PanelMenuView.h	2015-05-22 16:04:25 +0000
@@ -22,12 +22,11 @@
 #define PANEL_MENU_VIEW_H
 
 #include <NuxCore/Animation.h>
-#include <UnityCore/GLibWrapper.h>
 #include <UnityCore/GLibSignal.h>
-#include <libbamf/libbamf.h>
 
 #include "PanelIndicatorsView.h"
 #include "PanelTitlebarGrabAreaView.h"
+#include "unity-shared/ApplicationManager.h"
 #include "unity-shared/MenuManager.h"
 #include "unity-shared/StaticCairoText.h"
 #include "unity-shared/WindowButtons.h"
@@ -88,20 +87,17 @@
 
   void OnActiveChanged(PanelIndicatorEntryView* view, bool is_active);
   void OnEntryViewAdded(PanelIndicatorEntryView* view);
-  void OnViewOpened(BamfMatcher* matcher, BamfView* view);
-  void OnViewClosed(BamfMatcher* matcher, BamfView* view);
-  void OnApplicationClosed(BamfApplication* app);
-  void OnActiveWindowChanged(BamfMatcher* matcher, BamfView* old_view, BamfView* new_view);
-  void OnActiveAppChanged(BamfMatcher* matcher, BamfApplication* old_app, BamfApplication* new_app);
-  void OnNameChanged(BamfView* bamf_view, gchar* new_name, gchar* old_name);
+  void OnApplicationStarted(ApplicationPtr const&);
+  void OnApplicationClosed(ApplicationPtr const&);
+  void OnWindowClosed(ApplicationWindowPtr const&);
+  void OnActiveWindowChanged(ApplicationWindowPtr const&);
+  void OnActiveAppChanged(ApplicationPtr const&);
   void OnStyleChanged();
   void OnLIMChanged(bool);
   void OnAlwaysShowMenusChanged(bool);
 
   void OnSpreadInitiate();
   void OnSpreadTerminate();
-  void OnExpoInitiate();
-  void OnExpoTerminate();
   void OnWindowMinimized(Window xid);
   void OnWindowUnminimized(Window xid);
   void OnWindowUnmapped(Window xid);
@@ -122,6 +118,7 @@
   void FullRedraw();
   std::string GetCurrentTitle() const;
   bool Refresh(bool force = false);
+  void RefreshAndRedraw();
 
   void UpdateTitleTexture(nux::Geometry const&, std::string const& label);
   void UpdateLastGeometry(nux::Geometry const& geo);
@@ -131,8 +128,6 @@
   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);
 
-  BamfWindow* GetBamfWindowForXid(Window xid) const;
-
   void OnSwitcherShown(GVariant* data);
   void OnLauncherKeyNavStarted(GVariant* data);
   void OnLauncherKeyNavEnded(GVariant* data);
@@ -164,7 +159,6 @@
   void ActivateIntegratedMenus(nux::Point const&);
 
   menu::Manager::Ptr menu_manager_;
-  glib::Object<BamfMatcher> matcher_;
 
   nux::TextureLayer* title_layer_;
   nux::ObjectPtr<WindowButtons> window_buttons_;
@@ -179,8 +173,8 @@
 
   PanelIndicatorEntryView* last_active_view_;
   std::deque<Window> maximized_wins_;
-  glib::Object<BamfApplication> new_application_;
-  std::list<glib::Object<BamfApplication>> new_apps_;
+  ApplicationPtr new_application_;
+  std::list<ApplicationPtr> new_apps_;
   std::string panel_title_;
   nux::Geometry last_geo_;
   nux::Geometry title_geo_;
@@ -198,12 +192,8 @@
   nux::Geometry monitor_geo_;
   const std::string desktop_name_;
 
-  glib::Signal<void, BamfMatcher*, BamfView*> view_opened_signal_;
-  glib::Signal<void, BamfMatcher*, BamfView*> view_closed_signal_;
-  glib::Signal<void, BamfMatcher*, BamfView*, BamfView*> active_win_changed_signal_;
-  glib::Signal<void, BamfMatcher*, BamfApplication*, BamfApplication*> active_app_changed_signal_;
-  glib::Signal<void, BamfView*, gchar*, gchar*> view_name_changed_signal_;
-  glib::Signal<void, BamfView*, gchar*, gchar*> app_name_changed_signal_;
+  connection::Wrapper app_name_changed_conn_;
+  connection::Wrapper win_name_changed_conn_;
 
   UBusManager ubus_manager_;
   glib::SourceManager sources_;
 
=== modified file 'tests/mock-application.h'
--- tests/mock-application.h	2015-02-03 09:46:48 +0000
+++ tests/mock-application.h	2015-05-22 16:04:25 +0000
@@ -40,8 +40,8 @@
   MockApplicationWindow(Window xid)
     : xid_(xid)
     , monitor_(0)
+    , type_(unity::WindowType::MOCK)
     , title_("MockApplicationWindow "+std::to_string(xid_))
-    , type_("window")
     , visible_(true)
     , active_(false)
     , urgent_(false)
@@ -61,26 +61,28 @@
 
   Window xid_;
   int monitor_;
+  unity::WindowType type_;
   std::string title_;
   std::string icon_;
-  std::string type_;
 
   bool visible_;
   bool active_;
   bool urgent_;
 
-  MOCK_CONST_METHOD0(type, std::string());
+  MOCK_CONST_METHOD0(type, unity::WindowType());
   MOCK_CONST_METHOD0(window_id, Window());
   MOCK_CONST_METHOD0(monitor, int());
   MOCK_CONST_METHOD0(application, unity::ApplicationPtr());
   MOCK_CONST_METHOD0(Focus, bool());
   MOCK_CONST_METHOD0(Quit, void());
 
-  virtual bool LocalFocus() const
+  bool LocalFocus()
   {
     auto& wm = unity::WindowManager::Default();
     wm.Raise(xid_);
     wm.Activate(xid_);
+    active_ = true;
+    active.changed.emit(active_);
     return true;
   }
 
@@ -124,7 +126,7 @@
     , active_(false)
     , running_(false)
     , urgent_(false)
-    , type_("mock")
+    , type_(unity::AppType::MOCK)
     {
       seen.SetSetterFunction(sigc::mem_fun(this, &MockApplication::SetSeen));
       sticky.SetSetterFunction(sigc::mem_fun(this, &MockApplication::SetSticky));
@@ -159,10 +161,10 @@
   bool running_;
   bool urgent_;
   unity::WindowList windows_;
-  std::string type_;
+  unity::AppType type_;
   std::vector<std::pair<unity::ApplicationEventType, unity::ApplicationSubjectPtr>> actions_log_;
 
-  MOCK_CONST_METHOD0(type, std::string());
+  MOCK_CONST_METHOD0(type, unity::AppType());
   MOCK_CONST_METHOD0(repr, std::string());
   MOCK_CONST_METHOD0(desktop_id, std::string());
   MOCK_CONST_METHOD0(GetWindows, unity::WindowList());
@@ -306,6 +308,9 @@
     ON_CALL(*this, GetActiveWindow()).WillByDefault(Invoke([this] { return unity::ApplicationWindowPtr(); } ));
     ON_CALL(*this, GetRunningApplications()).WillByDefault(Invoke([this] { return unity::ApplicationList(); } ));
     ON_CALL(*this, GetApplicationForWindow(_)).WillByDefault(Invoke([this] (Window) { return unity::ApplicationPtr(); } ));
+    ON_CALL(*this, GetActiveApplication()).WillByDefault(Invoke([this] { return unity::ApplicationPtr(); } ));
+    ON_CALL(*this, GetWindowsForMonitor(_)).WillByDefault(Invoke([this] (Window) { return unity::WindowList(); } ));
+    ON_CALL(*this, GetWindowForId(_)).WillByDefault(Invoke([this] (int) { return unity::ApplicationWindowPtr(); } ));
   }
 
   static void StartApp(std::string const& desktop_file)
@@ -322,6 +327,9 @@
   MOCK_CONST_METHOD1(GetApplicationForDesktopFile, unity::ApplicationPtr(std::string const&));
   MOCK_CONST_METHOD0(GetRunningApplications, unity::ApplicationList());
   MOCK_CONST_METHOD1(GetApplicationForWindow, unity::ApplicationPtr(Window));
+  MOCK_CONST_METHOD0(GetActiveApplication, unity::ApplicationPtr());
+  MOCK_CONST_METHOD1(GetWindowsForMonitor, unity::WindowList(int));
+  MOCK_CONST_METHOD1(GetWindowForId, unity::ApplicationWindowPtr(Window));
 
   unity::ApplicationPtr LocalGetApplicationForDesktopFile(std::string const& desktop_file)
   {
 
=== modified file 'tests/test_application_launcher_icon.cpp'
--- tests/test_application_launcher_icon.cpp	2015-03-30 15:48:38 +0000
+++ tests/test_application_launcher_icon.cpp	2015-05-22 16:04:25 +0000
@@ -775,7 +775,10 @@
   mock_app->windows_ = { win1, win2 };
   WM->AddStandaloneWindow(wm_win1);
   WM->AddStandaloneWindow(wm_win2);
+
+  win2->Focus();
   ASSERT_TRUE(wm_win2->active());
+  ASSERT_TRUE(win2->active());
 
   auto const& menus = mock_icon->Menus();
   auto const& menu1 = GetMenuItemWithLabel(menus, win1->title());
@@ -1121,10 +1124,10 @@
 
 TEST_F(TestApplicationLauncherIcon, AllowDetailViewInSwitcher)
 {
-  mock_app->type_ = "mock";
+  mock_app->type_ = AppType::NORMAL;
   EXPECT_TRUE(mock_icon->AllowDetailViewInSwitcher());
 
-  mock_app->type_ = "webapp";
+  mock_app->type_ = AppType::WEBAPP;
   EXPECT_FALSE(mock_icon->AllowDetailViewInSwitcher());
 }
 
 
=== modified file 'tests/test_panel_menu_view.cpp'
--- tests/test_panel_menu_view.cpp	2015-03-13 13:49:16 +0000
+++ tests/test_panel_menu_view.cpp	2015-05-22 16:04:25 +0000
@@ -45,13 +45,7 @@
   {
     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));
@@ -81,7 +75,6 @@
     panel_win->ComputeContentSize();
 
     menu_view.SetMonitor(monitor);
-    menu_view.maximized_wins_.clear();
 
     return panel_win;
   }
 
=== modified file 'tests/test_switcher_controller.h'
--- tests/test_switcher_controller.h	2014-03-21 04:40:12 +0000
+++ tests/test_switcher_controller.h	2015-05-22 16:04:25 +0000
@@ -54,7 +54,7 @@
   FakeApplicationWindow(Window xid, uint64_t active_number = 0);
   ~FakeApplicationWindow();
 
-  virtual std::string type() const;
+  virtual WindowType type() const;
 
   virtual Window window_id() const;
   virtual int monitor() const;
 
=== modified file 'tests/test_switcher_controller_class.cpp'
--- tests/test_switcher_controller_class.cpp	2013-10-14 17:36:51 +0000
+++ tests/test_switcher_controller_class.cpp	2015-05-22 16:04:25 +0000
@@ -41,7 +41,7 @@
   testwrapper::StandaloneWM::Get()->Close(xid_);
 }
 
-std::string FakeApplicationWindow::type() const { return "mock"; }
+WindowType FakeApplicationWindow::type() const { return WindowType::MOCK; }
 
 Window FakeApplicationWindow::window_id() const { return xid_; }
 int FakeApplicationWindow::monitor() const { return -1; }
 
=== modified file 'unity-shared/ApplicationManager.cpp'
--- unity-shared/ApplicationManager.cpp	2012-11-29 09:25:50 +0000
+++ unity-shared/ApplicationManager.cpp	2015-05-22 16:04:25 +0000
@@ -33,6 +33,25 @@
   return *instance;
 }
 
+bool operator==(ApplicationPtr const& lhs, ApplicationPtr const& rhs)
+{
+  return (lhs.get() == rhs.get() || (lhs && rhs && *lhs == *rhs));
+}
+
+bool operator!=(ApplicationPtr const& lhs, ApplicationPtr const& rhs)
+{
+  return !(lhs == rhs);
+}
+
+bool operator==(ApplicationWindowPtr const& lhs, ApplicationWindowPtr const& rhs)
+{
+  return (lhs.get() == rhs.get() || (lhs && rhs && *lhs == *rhs));
+}
+
+bool operator!=(ApplicationWindowPtr const& lhs, ApplicationWindowPtr const& rhs)
+{
+  return !(lhs == rhs);
+}
 
 // This method is needed to create an unresolved external for the
 // WindowManager::Default method.  This is because it is highly likely that
 
=== modified file 'unity-shared/ApplicationManager.h'
--- unity-shared/ApplicationManager.h	2013-09-11 09:11:30 +0000
+++ unity-shared/ApplicationManager.h	2015-05-22 16:04:25 +0000
@@ -50,13 +50,35 @@
   LEAVE
 };
 
+enum class AppType
+{
+  NORMAL,
+  WEBAPP,
+  MOCK,
+  UNKNOWN
+};
+
+enum class WindowType
+{
+  NORMAL,
+  DESKTOP,
+  DOCK,
+  DIALOG,
+  TOOLBAR,
+  MENU,
+  UTILITY,
+  SPLASHSCREEN,
+  TAB,
+  MOCK,
+  UNKNOWN
+};
+
 class ApplicationWindow
 {
 public:
   virtual ~ApplicationWindow() = default;
 
-  virtual std::string type() const = 0; // 'window' or 'tab'
-
+  virtual WindowType type() const = 0;
   virtual Window window_id() const = 0;
   virtual int monitor() const = 0;
 
@@ -69,20 +91,32 @@
   // Closes the window, or the browser tab if a webapp.
   virtual void Quit() const = 0;
 
+  virtual bool operator==(ApplicationWindow const& other) const
+  {
+    return (window_id() == other.window_id());
+  }
+
+  virtual bool operator!=(ApplicationWindow const& other) const
+  {
+    return !(operator==(other));
+  }
+
   nux::ROProperty<std::string> title;
   nux::ROProperty<std::string> icon;
 
   nux::ROProperty<bool> visible;
   nux::ROProperty<bool> active;
   nux::ROProperty<bool> urgent;
+  nux::ROProperty<bool> maximized;
 };
 
+
 class Application
 {
 public:
   virtual ~Application() = default;
 
-  virtual std::string type() const = 0;
+  virtual AppType type() const = 0;
 
   // A string representation of the object.
   virtual std::string repr() const = 0;
@@ -102,6 +136,17 @@
   virtual void LogEvent(ApplicationEventType, ApplicationSubjectPtr const&) const = 0;
 
   virtual std::string desktop_id() const = 0;
+
+  virtual bool operator==(Application const& other) const
+  {
+    return (!desktop_id().empty() && (desktop_id() == other.desktop_id()));
+  }
+
+  virtual bool operator!=(Application const& other) const
+  {
+    return !(operator==(other));
+  }
+
   nux::ROProperty<std::string> desktop_file;
   nux::ROProperty<std::string> title;
   nux::ROProperty<std::string> icon;
@@ -117,11 +162,12 @@
 
   sigc::signal<void> closed;
 
-  sigc::signal<void, ApplicationWindow const&> window_opened;
-  sigc::signal<void, ApplicationWindow const&> window_moved;
-  sigc::signal<void> window_closed;
+  sigc::signal<void, ApplicationWindowPtr const&> window_opened;
+  sigc::signal<void, ApplicationWindowPtr const&> window_moved;
+  sigc::signal<void, ApplicationWindowPtr const&> window_closed;
 };
 
+
 class ApplicationSubject
 {
 public:
@@ -165,16 +211,28 @@
   static ApplicationManager& Default();
 
   virtual ApplicationPtr GetUnityApplication() const = 0;
+  virtual ApplicationPtr GetActiveApplication() const = 0;
   virtual ApplicationWindowPtr GetActiveWindow() const = 0;
   virtual ApplicationPtr GetApplicationForDesktopFile(std::string const& desktop_file) const = 0;
   virtual ApplicationList GetRunningApplications() const = 0;
+  virtual WindowList GetWindowsForMonitor(int monitor = -1) const = 0;
   virtual ApplicationPtr GetApplicationForWindow(Window xid) const = 0;
+  virtual ApplicationWindowPtr GetWindowForId(Window xid) const = 0;
 
   sigc::signal<void, ApplicationPtr const&> application_started;
+  sigc::signal<void, ApplicationPtr const&> application_stopped;
   sigc::signal<void, ApplicationPtr const&> active_application_changed;
+  sigc::signal<void, ApplicationWindowPtr const&> window_opened;
+  sigc::signal<void, ApplicationWindowPtr const&> window_closed;
   sigc::signal<void, ApplicationWindowPtr const&> active_window_changed;
 };
 
+
+bool operator==(ApplicationPtr const&, ApplicationPtr const&);
+bool operator!=(ApplicationPtr const&, ApplicationPtr const&);
+bool operator==(ApplicationWindowPtr const&, ApplicationWindowPtr const&);
+bool operator!=(ApplicationWindowPtr const&, ApplicationWindowPtr const&);
+
 }
 
 #endif // UNITYSHARED_APPLICATION_MANAGER_H
 
=== modified file 'unity-shared/BamfApplicationManager.cpp'
--- unity-shared/BamfApplicationManager.cpp	2013-10-03 22:39:01 +0000
+++ unity-shared/BamfApplicationManager.cpp	2015-05-22 16:04:25 +0000
@@ -34,7 +34,47 @@
 namespace
 {
 const char* UNSEEN_QUARK = "unity-unseen";
-}
+
+namespace pool
+{
+// We keep a cache on views here, it would be nice to clean these on BAMF reload
+std::unordered_map<BamfView*, ApplicationPtr> apps_;
+std::unordered_map<BamfView*, ApplicationWindowPtr> wins_;
+
+ApplicationPtr EnsureApplication(ApplicationManager const& manager, BamfView* view)
+{
+  if (!BAMF_IS_APPLICATION(view))
+    return nullptr;
+
+  auto it = apps_.find(view);
+
+  if (it != apps_.end())
+    return it->second;
+
+  glib::Object<BamfApplication> bamfapp(reinterpret_cast<BamfApplication*>(view), glib::AddRef());
+  auto const& app = std::make_shared<Application>(manager, bamfapp);
+  apps_.insert({view, app});
+  return app;
+}
+
+ApplicationWindowPtr EnsureWindow(ApplicationManager const& manager, BamfView* view)
+{
+  if (!BAMF_IS_WINDOW(view))
+    return nullptr;
+
+  auto it = wins_.find(view);
+
+  if (it != wins_.end())
+    return it->second;
+
+  glib::Object<BamfWindow> bamfwin(reinterpret_cast<BamfWindow*>(view), glib::AddRef());
+  auto const& win = std::make_shared<AppWindow>(manager, bamfwin);
+  wins_.insert({view, win});
+  return win;
+}
+
+} // pool namespace
+} // anonymous namespace
 
 
 // Due to the way glib handles object inheritance, we need to cast between pointer types.
@@ -54,11 +94,6 @@
   return glib::String(bamf_view_get_icon(bamf_view_)).Str();
 }
 
-std::string View::type() const
-{
-  return glib::gchar_to_string(bamf_view_get_view_type(bamf_view_));
-}
-
 bool View::GetVisible() const
 {
   return bamf_view_is_user_visible(bamf_view_);
@@ -80,11 +115,6 @@
 }
 
 
-std::string WindowBase::type() const
-{
-  return View::type();
-}
-
 WindowBase::WindowBase(ApplicationManager const& manager,
                        glib::Object<BamfView> const& window)
   : View(manager, window)
@@ -122,13 +152,10 @@
   Window xid = window_id();
   if (xid)
   {
-    std::vector<Window> windows = { xid };
-    // TODO: we should simplify the use case of focusing one window.
-    // Somewhat outside the scope of these changes however.
-    WindowManager::Default().FocusWindowGroup(
-      windows,
-      WindowManager::FocusVisibility::ForceUnminimizeInvisible,
-      monitor(),true);
+    auto& wm = WindowManager::Default();
+    wm.UnMinimize(xid);
+    wm.Raise(xid);
+    wm.Activate(xid);
     return true;
   }
   return false;
@@ -136,14 +163,25 @@
 
 
 AppWindow::AppWindow(ApplicationManager const& manager, glib::Object<BamfWindow> const& window)
-  : WindowBase(manager, glib::object_cast<BamfView>(window))
-  , bamf_window_(window)
+  : AppWindow(manager, glib::object_cast<BamfView>(window))
 {}
 
 AppWindow::AppWindow(ApplicationManager const& manager, glib::Object<BamfView> const& window)
   : WindowBase(manager, window)
   , bamf_window_(glib::object_cast<BamfWindow>(window))
-{}
+{
+  maximized.SetGetterFunction(std::bind(&AppWindow::GetMaximized, this));
+  signals_.Add<void, BamfWindow*, gint, gint>(bamf_window_, "maximized-changed",
+  [this] (BamfWindow*, gint old_state, gint state) {
+    if ((old_state == BAMF_WINDOW_MAXIMIZED) != (state == BAMF_WINDOW_MAXIMIZED))
+      this->maximized.changed.emit(state == BAMF_WINDOW_MAXIMIZED);
+  });
+}
+
+bool AppWindow::GetMaximized() const
+{
+  return bamf_window_maximized(bamf_window_) == BAMF_WINDOW_MAXIMIZED;
+}
 
 Window AppWindow::window_id() const
 {
@@ -155,6 +193,31 @@
   return bamf_window_get_monitor(bamf_window_);
 }
 
+WindowType AppWindow::type() const
+{
+  switch (bamf_window_get_window_type(bamf_window_))
+  {
+    case BAMF_WINDOW_NORMAL:
+      return WindowType::NORMAL;
+    case BAMF_WINDOW_DESKTOP:
+      return WindowType::DESKTOP;
+    case BAMF_WINDOW_DOCK:
+      return WindowType::DOCK;
+    case BAMF_WINDOW_DIALOG:
+      return WindowType::DIALOG;
+    case BAMF_WINDOW_TOOLBAR:
+      return WindowType::TOOLBAR;
+    case BAMF_WINDOW_MENU:
+      return WindowType::MENU;
+    case BAMF_WINDOW_UTILITY:
+      return WindowType::UTILITY;
+    case BAMF_WINDOW_SPLASHSCREEN:
+      return WindowType::SPLASHSCREEN;
+    default:
+      return WindowType::UNKNOWN;
+  }
+}
+
 ApplicationPtr AppWindow::application() const
 {
   // Moderately evil, but better than changing the method to non-const.
@@ -183,6 +246,11 @@
   return bamf_tab_get_xid(bamf_tab_);
 }
 
+WindowType Tab::type() const
+{
+  return WindowType::TAB;
+}
+
 int Tab::monitor() const
 {
   // TODO, we could find the real window for the window_id, and get the monitor for that.
@@ -208,37 +276,14 @@
   bamf_tab_close(bamf_tab_);
 }
 
-// Being brutal with this function.
-ApplicationWindowPtr create_window(ApplicationManager const& manager, glib::Object<BamfView> const& view)
-{
-  if (view.IsType(BAMF_TYPE_WINDOW))
-  {
-    return std::make_shared<AppWindow>(manager, view);
-  }
-  else if (view.IsType(BAMF_TYPE_TAB))
-  {
-    return std::make_shared<Tab>(manager, view);
-  }
-  // We don't handle applications here.
-  return nullptr;
-}
-
 Application::Application(ApplicationManager const& manager, glib::Object<BamfView> const& app)
-  : View(manager, app)
-  , bamf_app_(glib::object_cast<BamfApplication>(app))
-{
-  HookUpEvents();
-}
+  : Application(manager, glib::object_cast<BamfApplication>(app))
+{}
 
 Application::Application(ApplicationManager const& manager, glib::Object<BamfApplication> const& app)
   : View(manager, glib::object_cast<BamfView>(app))
   , bamf_app_(app)
 {
-  HookUpEvents();
-}
-
-void Application::HookUpEvents()
-{
   // Hook up the property set/get functions
   using namespace std::placeholders;
   desktop_file.SetGetterFunction(std::bind(&Application::GetDesktopFile, this));
@@ -292,24 +337,21 @@
   signals_.Add<void, BamfView*, BamfView*>(bamf_view_, "child-added",
   [this] (BamfView*, BamfView* child) {
     // Ownership is not passed on signals
-    glib::Object<BamfView> view(child, glib::AddRef());
-    ApplicationWindowPtr const& win = create_window(this->manager_, view);
-    if (win)
-      this->window_opened.emit(*win);
+    if (ApplicationWindowPtr const& win = pool::EnsureWindow(manager_, child))
+      this->window_opened.emit(win);
   });
 
   signals_.Add<void, BamfView*, BamfView*>(bamf_view_, "child-removed",
   [this] (BamfView*, BamfView* child) {
-    this->window_closed.emit();
+    if (ApplicationWindowPtr const& win = pool::EnsureWindow(manager_, child))
+      this->window_closed.emit(win);
   });
 
   signals_.Add<void, BamfView*, BamfView*>(bamf_view_, "child-moved",
   [this] (BamfView*, BamfView* child) {
     // Ownership is not passed on signals
-    glib::Object<BamfView> view(child, glib::AddRef());
-    ApplicationWindowPtr const& win = create_window(this->manager_, view);
-    if (win)
-      this->window_moved.emit(*win);
+    if (ApplicationWindowPtr const& win = pool::EnsureWindow(manager_, child))
+      this->window_moved.emit(win);
   });
 }
 
@@ -318,16 +360,21 @@
   return glib::gchar_to_string(bamf_application_get_desktop_file(bamf_app_));
 }
 
-std::string Application::type() const
+AppType Application::type() const
 {
   // Can't determine the type of a non-running app.
-  std::string result = "unknown";
   if (running())
   {
-    const gchar* type = bamf_application_get_application_type(bamf_app_);
-    if (type) result = type;
+    auto type = glib::gchar_to_string(bamf_application_get_application_type(bamf_app_));
+
+    if (type == "system")
+      return AppType::NORMAL;
+
+    if (type == "webapp")
+      return AppType::WEBAPP;
   }
-  return result;
+
+  return AppType::UNKNOWN;
 }
 
 std::string Application::repr() const
@@ -347,9 +394,7 @@
   std::shared_ptr<GList> children(bamf_view_get_children(bamf_view_), g_list_free);
   for (GList* l = children.get(); l; l = l->next)
   {
-    glib::Object<BamfView> view(BAMF_VIEW(l->data), glib::AddRef());
-    ApplicationWindowPtr const& window(create_window(manager_, view));
-    if (window)
+    if (ApplicationWindowPtr const& window = pool::EnsureWindow(manager_, static_cast<BamfView*>(l->data)))
       result.push_back(window);
   }
   return result;
@@ -389,9 +434,7 @@
 
 ApplicationWindowPtr Application::GetFocusableWindow() const
 {
-  glib::Object<BamfView> view(bamf_application_get_focusable_child(bamf_app_),
-                              glib::AddRef());
-  return create_window(manager_, view);
+  return pool::EnsureWindow(manager_, bamf_application_get_focusable_child(bamf_app_));
 }
 
 void Application::Focus(bool show_only_visible, int monitor) const
@@ -507,29 +550,19 @@
   LOG_TRACE(logger) << "Create BAMF Application Manager";
   signals_.Add<void, BamfMatcher*, BamfView*> (matcher_, "view-opened",
     sigc::mem_fun(this, &Manager::OnViewOpened));
+  signals_.Add<void, BamfMatcher*, BamfView*> (matcher_, "view-closed",
+    sigc::mem_fun(this, &Manager::OnViewClosed));
 
   signals_.Add<void, BamfMatcher*, BamfView*, BamfView*>(matcher_, "active-window-changed",
   [this](BamfMatcher*, BamfView* /* from */, BamfView* to) {
-    // Ownership is not passed on signals
-    glib::Object<BamfView> view(to, glib::AddRef());
-    ApplicationWindowPtr const& win = create_window(*this, view);
-    if (win)
+    if (ApplicationWindowPtr const& win = pool::EnsureWindow(*this, to))
       this->active_window_changed.emit(win);
   });
 
   signals_.Add<void, BamfMatcher*, BamfApplication*, BamfApplication*> (matcher_, "active-application-changed",
   [this](BamfMatcher*, BamfApplication* /* from */, BamfApplication* to) {
-    if (to)
-    {
-      // Ownership is not passed on signals
-      glib::Object<BamfApplication> bamf_app(to, glib::AddRef());
-      auto app = std::make_shared<Application>(*this, bamf_app);
-      this->active_application_changed.emit(app);
-    }
-    else
-    {
-      this->active_application_changed.emit(nullptr);
-    }
+    auto const& app = pool::EnsureApplication(*this, reinterpret_cast<BamfView*>(to));
+    this->active_application_changed.emit(app);
   });
 }
 
@@ -546,81 +579,79 @@
   {
     auto *app_ptr = bamf_matcher_get_application_for_xid(matcher_, xid);
 
-    if (BAMF_IS_APPLICATION(app_ptr))
-    {
-      glib::Object<BamfApplication> app(app_ptr, glib::AddRef());
-      return std::make_shared<Application>(*this, app);
-    }
+    if (ApplicationPtr const& app = pool::EnsureApplication(*this, reinterpret_cast<BamfView*>(app_ptr)))
+      return app;
   }
 
   return GetApplicationForDesktopFile(DesktopUtilities::GetDesktopPathById("compiz.desktop"));
 }
 
+ApplicationPtr Manager::GetActiveApplication() const
+{
+  auto *app_ptr = bamf_matcher_get_active_application(matcher_);
+  return pool::EnsureApplication(*this, reinterpret_cast<BamfView*>(app_ptr));
+}
+
 ApplicationWindowPtr Manager::GetActiveWindow() const
 {
-  // No transfer of ownership for bamf_matcher_get_active_window.
-  BamfWindow* active_win = bamf_matcher_get_active_window(matcher_);
-
-  if (!active_win)
-    return nullptr;
+  if (BamfWindow* active_win = bamf_matcher_get_active_window(matcher_))
+  {
+    if (bamf_window_get_window_type(active_win) != BAMF_WINDOW_DOCK)
+      return pool::EnsureWindow(*this, reinterpret_cast<BamfView*>(active_win));
+  }
 
   // If the active window is a dock type, then we want the first visible, non-dock type.
-  if (bamf_window_get_window_type(active_win) == BAMF_WINDOW_DOCK)
+  LOG_DEBUG(logger) << "Is a dock, looking at the window stack.";
+
+  auto const& wins = GetWindowsForMonitor();
+  WindowManager& wm = WindowManager::Default();
+
+  for (auto it = wins.rbegin(); it != wins.rend(); ++it)
   {
-    LOG_DEBUG(logger) << "Is a dock, looking at the window stack.";
-
-    std::shared_ptr<GList> windows(bamf_matcher_get_window_stack_for_monitor(matcher_, -1), g_list_free);
-    WindowManager& wm = WindowManager::Default();
-    active_win = nullptr;
-
-    for (GList *l = windows.get(); l; l = l->next)
+    auto const& win = *it;
+    auto xid = win->window_id();
+
+    if (win->visible() &&
+        win->type() != WindowType::DOCK &&
+        wm.IsWindowOnCurrentDesktop(xid) &&
+        wm.IsWindowVisible(xid))
     {
-      if (!BAMF_IS_WINDOW(l->data))
-      {
-        LOG_DEBUG(logger) << "Window stack returned something not a window, WTF?";
-        continue;
-      }
-
-      auto win = static_cast<BamfWindow*>(l->data);
-      auto view = static_cast<BamfView*>(l->data);
-      auto xid = bamf_window_get_xid(win);
-
-      if (bamf_view_is_user_visible(view) &&
-          bamf_window_get_window_type(win) != BAMF_WINDOW_DOCK &&
-          wm.IsWindowOnCurrentDesktop(xid) &&
-          wm.IsWindowVisible(xid))
-      {
-        active_win = win;
-      }
+      return win;
     }
   }
 
-  if (active_win)
-  {
-    glib::Object<BamfWindow> win(active_win, glib::AddRef());
-    return std::make_shared<AppWindow>(*this, win);
-  }
-
   return nullptr;
 }
 
 ApplicationPtr Manager::GetApplicationForDesktopFile(std::string const& desktop_file) const
 {
-  glib::Object<BamfApplication> app(bamf_matcher_get_application_for_desktop_file(
-    matcher_, desktop_file.c_str(), TRUE), glib::AddRef());
-
-  if (app)
-    return std::make_shared<Application>(*this, app);
-
-  return nullptr;
+  auto* app = bamf_matcher_get_application_for_desktop_file(matcher_, desktop_file.c_str(), TRUE);
+  return pool::EnsureApplication(*this, reinterpret_cast<BamfView*>(app));
 }
 
 ApplicationPtr Manager::GetApplicationForWindow(Window xid) const
 {
-  glib::Object<BamfApplication> app(bamf_matcher_get_application_for_xid(matcher_, xid),
-                                    glib::AddRef());
-  if (app)
-    return std::make_shared<Application>(*this, app);
+  auto* app = bamf_matcher_get_application_for_xid(matcher_, xid);
+  return pool::EnsureApplication(*this, reinterpret_cast<BamfView*>(app));
+}
+
+ApplicationWindowPtr Manager::GetWindowForId(Window xid) const
+{
+  if (xid == 0)
+    return nullptr;
+
+  std::shared_ptr<GList> windows(bamf_matcher_get_windows(matcher_), g_list_free);
+
+  for (GList* l = windows.get(); l; l = l->next)
+  {
+    if (!BAMF_IS_WINDOW(l->data))
+      continue;
+
+    auto win = static_cast<BamfWindow*>(l->data);
+
+    if (bamf_window_get_xid(win) == xid)
+      return pool::EnsureWindow(*this, static_cast<BamfView*>(l->data));
+  }
 
   return nullptr;
 }
@@ -638,26 +669,65 @@
       continue;
     }
 
-    glib::Object<BamfApplication> bamf_app(static_cast<BamfApplication*>(l->data), glib::AddRef());
-    auto app = std::make_shared<Application>(*this, bamf_app);
-    result.push_back(app);
-    LOG_DEBUG(logger) << "Running app: " << app->title();
+    result.push_back(pool::EnsureApplication(*this, static_cast<BamfView*>(l->data)));
   }
   return result;
 }
 
+WindowList Manager::GetWindowsForMonitor(int monitor) const
+{
+  WindowList wins;
+  std::shared_ptr<GList> windows(bamf_matcher_get_window_stack_for_monitor(matcher_, monitor), g_list_free);
+
+  for (GList *l = windows.get(); l; l = l->next)
+  {
+    if (!BAMF_IS_WINDOW(l->data))
+    {
+      LOG_DEBUG(logger) << "Window stack returned something not a window, WTF?";
+      continue;
+    }
+
+    auto bamf_win = static_cast<BamfWindow*>(l->data);
+
+    if (bamf_window_get_window_type(bamf_win) != BAMF_WINDOW_DOCK)
+      wins.push_back(pool::EnsureWindow(*this, static_cast<BamfView*>(l->data)));
+  }
+
+  return wins;
+}
 
 void Manager::OnViewOpened(BamfMatcher* matcher, BamfView* view)
 {
   LOG_TRACE_BLOCK(logger);
-  if (!BAMF_IS_APPLICATION(view))
-  {
-    LOG_DEBUG(logger) << "view is not an app";
-    return;
-  }
-
-  glib::Object<BamfView> app(view, glib::AddRef());
-  application_started.emit(std::make_shared<Application>(*this, app));
+  if (BAMF_IS_APPLICATION(view))
+  {
+    if (ApplicationPtr const& app = pool::EnsureApplication(*this, view))
+      application_started.emit(app);
+  }
+  else if (BAMF_IS_WINDOW(view))
+  {
+    if (ApplicationWindowPtr const& win = pool::EnsureWindow(*this, view))
+      window_opened.emit(win);
+  }
+}
+
+void Manager::OnViewClosed(BamfMatcher* matcher, BamfView* view)
+{
+  LOG_TRACE_BLOCK(logger);
+  if (BAMF_IS_APPLICATION(view))
+  {
+    if (ApplicationPtr const& app = pool::EnsureApplication(*this, view))
+      application_stopped.emit(app);
+
+    pool::apps_.erase(view);
+  }
+  else if (BAMF_IS_WINDOW(view))
+  {
+    if (ApplicationWindowPtr const& win = pool::EnsureWindow(*this, view))
+      window_closed.emit(win);
+
+    pool::wins_.erase(view);
+  }
 }
 
 } // namespace bamf
 
=== modified file 'unity-shared/BamfApplicationManager.h'
--- unity-shared/BamfApplicationManager.h	2013-09-04 19:38:19 +0000
+++ unity-shared/BamfApplicationManager.h	2015-05-22 16:04:25 +0000
@@ -20,6 +20,7 @@
 #ifndef UNITYSHARED_BAMF_APPLICATION_MANAGER_H
 #define UNITYSHARED_BAMF_APPLICATION_MANAGER_H
 
+#include <unordered_map>
 #include <libbamf/libbamf.h>
 #include <UnityCore/GLibWrapper.h>
 #include <UnityCore/GLibSignal.h>
@@ -39,7 +40,6 @@
 
   std::string GetTitle() const;
   std::string GetIcon() const;
-  std::string type() const;
 
   bool GetVisible() const;
   bool GetActive() const;
@@ -59,11 +59,15 @@
              glib::Object<BamfView> const& window);
 
 public:
-  virtual std::string type() const; // 'window' or 'tab'
-
-  virtual bool Focus() const;
-
-private:
+  bool Focus() const override;
+
+  bool operator==(unity::ApplicationWindow const& other) const override
+  {
+    return static_cast<WindowBase const*>(this)->bamf_view_ == static_cast<WindowBase  const&>(other).bamf_view_;
+  }
+  bool operator!=(unity::ApplicationWindow const& other) const override { return !(operator==(other)); }
+
+protected:
   glib::SignalManager signals_;
 };
 
@@ -76,10 +80,12 @@
   AppWindow(ApplicationManager const& manager,
             glib::Object<BamfView> const& window);
 
-  virtual Window window_id() const;
-  virtual int monitor() const;
-  virtual ApplicationPtr application() const;
-  virtual void Quit() const;
+  WindowType type() const override;
+  Window window_id() const override;
+  int monitor() const override;
+  ApplicationPtr application() const override;
+  void Quit() const override;
+  bool GetMaximized() const;
 
 private:
   glib::Object<BamfWindow> bamf_window_;
@@ -93,11 +99,12 @@
   Tab(ApplicationManager const& manager,
       glib::Object<BamfView> const& tab);
 
-  virtual Window window_id() const;
-  virtual int monitor() const;
-  virtual ApplicationPtr application() const;
-  virtual bool Focus() const;
-  virtual void Quit() const;
+  WindowType type() const override;
+  Window window_id() const override;
+  int monitor() const override;
+  ApplicationPtr application() const override;
+  bool Focus() const override;
+  void Quit() const override;
 
 private:
   glib::Object<BamfTab> bamf_tab_;
@@ -112,7 +119,7 @@
   Application(ApplicationManager const& manager,
               glib::Object<BamfView> const& app);
 
-  virtual std::string type() const;
+  virtual AppType type() const;
 
   virtual WindowList GetWindows() const;
   virtual bool OwnsWindow(Window window_id) const;
@@ -128,9 +135,13 @@
 
   virtual std::string repr() const;
 
+  bool operator==(unity::Application const& other) const override
+  {
+    return static_cast<Application const*>(this)->bamf_app_ == static_cast<Application const&>(other).bamf_app_;
+  }
+  bool operator!=(unity::Application const& other) const override { return !(operator==(other)); }
+
 private: // Property getters and setters
-  void HookUpEvents();
-
   std::string GetDesktopFile() const;
 
   bool GetSeen() const;
@@ -152,13 +163,20 @@
   ~Manager();
 
   ApplicationPtr GetUnityApplication() const override;
+  ApplicationPtr GetActiveApplication() const override;
   ApplicationWindowPtr GetActiveWindow() const override;
   ApplicationPtr GetApplicationForDesktopFile(std::string const& desktop_file) const override;
   ApplicationList GetRunningApplications() const override;
+  WindowList GetWindowsForMonitor(int monitor = -1) const override;
   ApplicationPtr GetApplicationForWindow(Window xid) const override;
+  ApplicationWindowPtr GetWindowForId(Window xid) const override;
+
+  ApplicationPtr EnsureApplication(BamfView*) const;
+  ApplicationWindowPtr EnsureWindow(BamfView*) const;
 
 private:
   void OnViewOpened(BamfMatcher* matcher, BamfView* view);
+  void OnViewClosed(BamfMatcher* matcher, BamfView* view);
 
 private:
   glib::Object<BamfMatcher> matcher_;
 
=== modified file 'unity-shared/StandaloneAppManager.cpp'
--- unity-shared/StandaloneAppManager.cpp	2014-07-30 00:49:35 +0000
+++ unity-shared/StandaloneAppManager.cpp	2015-05-22 16:04:25 +0000
@@ -33,6 +33,54 @@
 
 GMainLoop *loop;
 
+std::ostream& operator<<(std::ostream &os, AppType at)
+{
+  switch (at)
+  {
+    case AppType::NORMAL:
+      return os << "NORMAL";
+    case AppType::WEBAPP:
+      return os << "WEBAPP";
+    case AppType::MOCK:
+      return os << "MOCK";
+    case AppType::UNKNOWN:
+      return os << "UNKNOWN";
+  }
+
+  return os;
+}
+
+std::ostream& operator<<(std::ostream &os, WindowType wt)
+{
+  switch (wt)
+  {
+    case WindowType::NORMAL:
+      return os << "NORMAL";
+    case WindowType::DESKTOP:
+      return os << "DESKTOP";
+    case WindowType::DOCK:
+      return os << "DOCK";
+    case WindowType::DIALOG:
+      return os << "DIALOG";
+    case WindowType::TOOLBAR:
+      return os << "TOOLBAR";
+    case WindowType::MENU:
+      return os << "MENU";
+    case WindowType::UTILITY:
+      return os << "UTILITY";
+    case WindowType::SPLASHSCREEN:
+      return os << "SPLASHSCREEN";
+    case WindowType::TAB:
+      return os << "TAB";
+    case WindowType::MOCK:
+      return os << "MOCK";
+    case WindowType::UNKNOWN:
+      return os << "UNKNOWN";
+  }
+
+  return os;
+}
+
 void dump_app(ApplicationPtr const& app, std::string const& prefix = "")
 {
   if (app)
@@ -55,6 +103,7 @@
       std::cout << "  Window: " << win->title()
                 << ", window_id: " << win->window_id()
                 << ", monitor: " << win->monitor()
+                << ", maximized: " << win->maximized()
                 << ", type: " << win->type()
                 << endl;
     }
@@ -65,6 +114,8 @@
   }
 }
 
+std::vector<std::string> names;
+
 void connect_events(ApplicationPtr const& app)
 {
   if (app->seen())
@@ -72,42 +123,57 @@
     cout << "Already seen " << app->title() << ", skipping event connection.\n";
     return;
   }
-  std::string app_name = app->title();
-  app->title.changed.connect([&app_name](std::string const& value) {
-    cout << app_name << " changed name to: " << value << endl;
-    app_name = value;
-  });
-  app->icon.changed.connect([&app_name](std::string const& value) {
-    cout << app_name << " icon changed: " << value << endl;
-  });
-  app->desktop_file.changed.connect([&app_name](std::string const& value) {
-    cout << app_name << " desktop file changed: " << value << endl;
-  });
-  app->visible.changed.connect([&app_name](bool value) {
-    cout << app_name << " visibility changed: " << (value ? "yes" : "no") << endl;
-  });
-  app->running.changed.connect([&app_name](bool value) {
-    cout << app_name << " running changed: " << (value ? "yes" : "no") << endl;
-  });
-  app->active.changed.connect([&app_name](bool value) {
-    cout << app_name << " active changed: " << (value ? "yes" : "no") << endl;
-  });
-  app->urgent.changed.connect([&app_name](bool value) {
-    cout << app_name << " urgent changed: " << (value ? "yes" : "no") << endl;
-  });
-  app->closed.connect([&app_name]() {
-    cout << app_name << " closed." << endl;
-  });
-  app->window_opened.connect([&app_name](ApplicationWindow const& window) {
-    cout << "** " << app_name << " window opened: " << window.title() << endl;
-  });
-  app->window_closed.connect([&app_name]() {
-    cout << "** " << app_name << " window closed" << endl;
-  });
-  app->window_moved.connect([&app_name](ApplicationWindow const& window) {
-    cout << "** " << app_name << " window moved: " << window.title() << endl;
+
+  auto idx = names.empty() ? 0 : names.size()-1;
+  names.push_back(app->title());
+  app->title.changed.connect([idx](std::string const& value) {
+    cout << names[idx] << " changed name to: " << value << endl;
+    names[idx] = value;
+  });
+  app->icon.changed.connect([idx](std::string const& value) {
+    cout << names[idx] << " icon changed: " << value << endl;
+  });
+  app->desktop_file.changed.connect([idx](std::string const& value) {
+    cout << names[idx] << " desktop file changed: " << value << endl;
+  });
+  app->visible.changed.connect([idx](bool value) {
+    cout << names[idx] << " visibility changed: " << (value ? "yes" : "no") << endl;
+  });
+  app->running.changed.connect([idx](bool value) {
+    cout << names[idx] << " running changed: " << (value ? "yes" : "no") << endl;
+  });
+  app->active.changed.connect([idx](bool value) {
+    cout << names[idx] << " active changed: " << (value ? "yes" : "no") << endl;
+  });
+  app->urgent.changed.connect([idx](bool value) {
+    cout << names[idx] << " urgent changed: " << (value ? "yes" : "no") << endl;
+  });
+  app->closed.connect([idx]() {
+    cout << names[idx] << " closed." << endl;
+  });
+  app->window_opened.connect([idx](ApplicationWindowPtr const& window) {
+    cout << "** " << names[idx] << " window opened: " << window->title() << endl;
+  });
+  app->window_closed.connect([idx](ApplicationWindowPtr const& window) {
+    cout << "** " << names[idx] << " window closed: " << window->title() << endl;
+  });
+  app->window_moved.connect([idx](ApplicationWindowPtr const& window) {
+    cout << "** " << names[idx] << " window moved: " << window->title() << endl;
   });
   app->seen = true;
+
+  for (auto win : app->GetWindows())
+    {
+      win->title.changed.connect([win] (std::string const& t) {
+        std::cout << "Window "<< win->window_id()<< " title changed to "<< t << endl;
+      });
+      win->maximized.changed.connect([win] (bool m) {
+        std::cout << "Window "<< win->window_id()<< " maximized changed to "<< m << endl;
+      });
+      win->active.changed.connect([win] (bool a) {
+        std::cout << "Window "<< win->window_id()<< " active changed to "<< a << endl;
+      });
+    }
 }