Merge lp:~3v1n0/unity/panel-p-cleanup into lp:unity

[Marco Trevisan (Treviño)]

A lot of panel fixes with code cleanup and improvements to the panel code.

This branch introduces a lot of code cleanup and improvements to the panel code.

A part the linked bugs fixed, this changes:
 - PanelStyle: used now to check all the panel related settings, including
   fonts and DPI. Emitting the changed signal when they get changed (so now
   when changing the title font, it gets updated immediately).
   Added better support for HighContrast themes and fallback buttons.
   Used ti everywhere to remove the "24" height magic number.

 - PanelIndicatorEntryView: code cleaned a lot to be more C++ conformant,
   and modified to be easily extendible in the near future. Also fixed issues
   with the indicator entries and Scale/Expo

 - PanelMenuView: the layout system has been rewritten and now it works
   natively without the workarounds we were using before,
   fixed the panel paddings to match design specs;
   Optimized the drawing operations, now the title texture is cached and
   rebuilt only if really needed.
   Fixed the panel title on Expo and Scale.
   Improved the detection of the panel used to draw the app title on
   multi-monitor (disabled otherwise), and the alt+tab/alt conflict.
   Maximized windows list is re-populated on startup or when adding a new
   screen.

 - PanelTitlebarGrabArea: rewritten to better handle the grabbing of the panel
   and clicks over it.

 - WindowButtons: rewritten using in a better way the subclass nux::Button
   features, factorizing some code for each button into WindowButtons. Also
   the handling of the controlled window is now done internally, not by the
   PanelMenuView.

A lot of panel fixes... Into one branch, because they should go together, but the single changes are shown on these single code reviews:

1) PanelStyle changes: http://go.3v1n0.net/Hs4YM6 [Tim: Approved]
2) Indicator Entry changes: http://go.3v1n0.net/Hp8VDp [Tim: Approved]
3) Indicators View changes: http://go.3v1n0.net/GXHKN3 [Tim: Approved]
4) Window buttons changes: http://go.3v1n0.net/GZHigm [Tim: Approved]
5) Grab area changes: http://go.3v1n0.net/H81Syb [Tim: Approved]
6) Tray changes: http://go.3v1n0.net/H6yqba [Tim: Approved]
7) Window Manager changes: http://go.3v1n0.net/H2GDwr [Tim: Approved]
8) Core changes: http://go.3v1n0.net/H1qokF [Tim: Approved]
9) Menu view changes: http://go.3v1n0.net/HwATeM [Tim: Approved]
10) Panel view changes: http://go.3v1n0.net/H8lwdB [Tim: Approved]

This branch introduces a lot of code cleanup and improvements to the panel code.

A part the linked bugs fixed, this changes:
 - PanelStyle: used now to check all the panel related settings, including
   fonts and DPI. Emitting the changed signal when they get changed (so now
   when changing the title font, it gets updated immediately).
   Added better support for HighContrast themes and fallback buttons.
   Used ti everywhere to remove the "24" height magic number.

 - PanelIndicatorEntryView: code cleaned a lot to be more C++ conformant,
   and modified to be easily extendible in the near future. Also fixed issues
   with the indicator entries and Scale/Expo

 - PanelMenuView: the layout system has been rewritten and now it works
   natively without the workarounds we were using before,
   fixed the panel paddings to match design specs;
   Optimized the drawing operations, now the title texture is cached and
   rebuilt only if really needed.
   Fixed the panel title on Expo and Scale.
   Improved the detection of the panel used to draw the app title on
   multi-monitor (disabled otherwise), and the alt+tab/alt conflict.
   Maximized windows list is re-populated on startup or when adding a new
   screen.

 - PanelTitlebarGrabArea: rewritten to better handle the grabbing of the panel
   and clicks over it.

 - WindowButtons: rewritten using in a better way the subclass nux::Button
   features, factorizing some code for each button into WindowButtons. Also
   the handling of the controlled window is now done internally, not by the
   PanelMenuView.

Testing:
 - All the panel items now are introspectable. And this allow AP testing.
 - The branch with all the brand new tests for the panel are at:
   lp:~3v1n0/unity/panel-p-tests

[Tim Penhey (thumper)]

OMG, WTF? 7.5k lines in the last week? This had better work :-)

[Tim Penhey (thumper)]

Also, in the breakup way, you should be using chained merge proposals using prerequisite branches.

[Tim Penhey (thumper)]

Reviews in progress on the others.

review: Needs Fixing

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

> Also, in the breakup way, you should be using chained merge proposals using
> prerequisite branches.

Yes, I know, but since I've splitted it later, I didn't want to cause temporary breakage in trunk when merging just partial changes, so I want to keep this top branch updated and make it go into trunk, while the partial changes are here only for reviewing (even if they reflect the reality since I'm updating them using bzr pipeline)

[Tim Penhey (thumper)]

You have a lot of bugs linked to this branch. Where are the tests confirming fixes?

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

> You have a lot of bugs linked to this branch. Where are the tests confirming
> fixes?

I'm currently writing them, considering the size of this branch I want to keep the tests in another branches, while this get reviewed.

[Brandon Schaefer (brandontschaefer)]

** Note, I couldn't test any bug that dealt with multi monitors. **

Ok, lots of code. Confirmed this branch fixes all of these bugs:

Bug #655184: Top bar - Menus should be condensed to fit panel/overlay of appmenu
Bug #839690: Topbar - window controls for maximised windows in the top bar should conform to Fitts's law
Bug #875932: window selected via ALT+F1 doesn't get focus in unity
Bug #934680: Window management - Dragging down a maximized window from the panel has not predictable results
Bug #936425: Not minimizable windows have an enabled "minimize" button on the unity panel
Bug #939054: HUD maximize button affects Dash
Bug #962410: Menu bar not transparent when invoking dash with super key whilst HUD enabled and vice versa
Bug #963118: Windows controls lost if dash is opened after HUD
Bug #963134: Opening HUD after dash shows window title in the panel
Bug #970420: Super+Tab, super, loses focus
Bug #971947: PanelMenuView causes gtk assertion to fail
Bug #940683: Panel opacity toggle doesn't quite work

When the test are done this branch will be look good :). Awesome work!

[Tim Penhey (thumper)]

The test branch landing is coming next, for some reason tarmac gets itself in a twist.

review: Approve

[Unity Merger (unity-merger)]

No commit message specified.

=== modified file 'UnityCore/Variant.cpp'
--- UnityCore/Variant.cpp	2012-03-21 12:31:11 +0000
+++ UnityCore/Variant.cpp	2012-04-05 23:42:20 +0000
@@ -142,15 +142,44 @@
   return *this;
 }
 
-BuilderWrapper& BuilderWrapper::add(char const* name, unsigned value)
+BuilderWrapper& BuilderWrapper::add(char const* name, long int value)
+{
+  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_int64(value));
+  return *this;
+}
+
+BuilderWrapper& BuilderWrapper::add(char const* name, long long int value)
+{
+  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_int64(value));
+  return *this;
+}
+
+BuilderWrapper& BuilderWrapper::add(char const* name, unsigned int value)
 {
   g_variant_builder_add(builder_, "{sv}", name, g_variant_new_uint32(value));
   return *this;
 }
 
+BuilderWrapper& BuilderWrapper::add(char const* name, long unsigned int value)
+{
+  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_uint64(value));
+  return *this;
+}
+
+BuilderWrapper& BuilderWrapper::add(char const* name, long long unsigned int value)
+{
+  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_uint64(value));
+  return *this;
+}
+
 BuilderWrapper& BuilderWrapper::add(char const* name, float value)
 {
-  // floats get promoted to doubles automatically
+  g_variant_builder_add(builder_, "{sv}", name, g_variant_new_double(value));
+  return *this;
+}
+
+BuilderWrapper& BuilderWrapper::add(char const* name, double value)
+{
   g_variant_builder_add(builder_, "{sv}", name, g_variant_new_double(value));
   return *this;
 }
 
=== modified file 'UnityCore/Variant.h'
--- UnityCore/Variant.h	2012-03-21 12:31:11 +0000
+++ UnityCore/Variant.h	2012-04-05 23:42:20 +0000
@@ -73,8 +73,13 @@
   BuilderWrapper& add(char const* name, char const* value);
   BuilderWrapper& add(char const* name, std::string const& value);
   BuilderWrapper& add(char const* name, int value);
-  BuilderWrapper& add(char const* name, unsigned value);
+  BuilderWrapper& add(char const* name, long int value);
+  BuilderWrapper& add(char const* name, long long int value);
+  BuilderWrapper& add(char const* name, unsigned int value);
+  BuilderWrapper& add(char const* name, long unsigned int value);
+  BuilderWrapper& add(char const* name, long long unsigned int value);
   BuilderWrapper& add(char const* name, float value);
+  BuilderWrapper& add(char const* name, double value);
   BuilderWrapper& add(char const* name, GVariant* value);
   BuilderWrapper& add(nux::Rect const& value);
 
 
=== modified file 'plugins/unityshell/src/DashController.cpp'
--- plugins/unityshell/src/DashController.cpp	2012-03-21 12:31:11 +0000
+++ plugins/unityshell/src/DashController.cpp	2012-04-05 23:42:20 +0000
@@ -40,6 +40,7 @@
 Controller::Controller()
   : launcher_width(64)
   , use_primary(false)
+  , monitor_(0)
   , window_(0)
   , visible_(false)
   , need_show_(false)
@@ -126,7 +127,7 @@
     g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING, &overlay_identity, &can_maximise, &overlay_monitor);
 
     // hide if something else is coming up
-    if (g_strcmp0(overlay_identity, "dash"))
+    if (overlay_identity.Str() != "dash")
     {
       HideDash(true);
     }
@@ -272,7 +273,8 @@
 
   StartShowHideTimeline();
 
-  GVariant* info = g_variant_new(UBUS_OVERLAY_FORMAT_STRING, "dash", TRUE, GetIdealMonitor());
+  monitor_ = GetIdealMonitor();
+  GVariant* info = g_variant_new(UBUS_OVERLAY_FORMAT_STRING, "dash", TRUE, monitor_);
   ubus_manager_.SendMessage(UBUS_OVERLAY_SHOWN, info);
 }
 
@@ -298,7 +300,7 @@
 
   StartShowHideTimeline();
 
-  GVariant* info = g_variant_new(UBUS_OVERLAY_FORMAT_STRING, "dash", TRUE, GetIdealMonitor());
+  GVariant* info = g_variant_new(UBUS_OVERLAY_FORMAT_STRING, "dash", TRUE, monitor_);
   ubus_manager_.SendMessage(UBUS_OVERLAY_HIDDEN, info);
 }
 
 
=== modified file 'plugins/unityshell/src/DashController.h'
--- plugins/unityshell/src/DashController.h	2012-03-27 22:34:53 +0000
+++ plugins/unityshell/src/DashController.h	2012-04-05 23:42:20 +0000
@@ -89,6 +89,7 @@
 private:
   glib::SignalManager sig_manager_;
   UBusManager ubus_manager_;
+  int monitor_;
 
   nux::BaseWindow* window_;
   bool visible_;
 
=== modified file 'plugins/unityshell/src/LauncherController.cpp'
--- plugins/unityshell/src/LauncherController.cpp	2012-04-05 00:32:14 +0000
+++ plugins/unityshell/src/LauncherController.cpp	2012-04-05 23:42:20 +0000
@@ -1101,9 +1101,9 @@
 void Controller::KeyNavGrab()
 {
   pimpl->ubus.SendMessage(UBUS_PLACE_VIEW_CLOSE_REQUEST);
+  pimpl->launcher_grabbed = true;
   KeyNavActivate();
   pimpl->keyboard_launcher_->GrabKeyboard();
-  pimpl->launcher_grabbed = true;
 
   pimpl->launcher_key_press_connection_ =
     pimpl->keyboard_launcher_->key_down.connect(sigc::mem_fun(pimpl, &Controller::Impl::ReceiveLauncherKeyPress));
@@ -1124,18 +1124,50 @@
   pimpl->keyboard_launcher_->EnterKeyNavMode();
   pimpl->model_->SetSelection(0);
 
-  pimpl->ubus.SendMessage(UBUS_LAUNCHER_START_KEY_SWTICHER, g_variant_new_boolean(true));
-  pimpl->ubus.SendMessage(UBUS_LAUNCHER_START_KEY_NAV, NULL);
+  if (pimpl->launcher_grabbed)
+  {
+    pimpl->ubus.SendMessage(UBUS_LAUNCHER_START_KEY_NAV,
+                            g_variant_new_int32(pimpl->keyboard_launcher_->monitor));
+  }
+  else
+  {
+    pimpl->ubus.SendMessage(UBUS_LAUNCHER_START_KEY_SWTICHER,
+                            g_variant_new_int32(pimpl->keyboard_launcher_->monitor));
+  }
+
+  AbstractLauncherIcon::Ptr const& selected = pimpl->model_->Selection();
+
+  if (selected)
+  {
+    pimpl->ubus.SendMessage(UBUS_LAUNCHER_SELECTION_CHANGED,
+                            g_variant_new_string(selected->tooltip_text().c_str()));
+  }
 }
 
 void Controller::KeyNavNext()
 {
   pimpl->model_->SelectNext();
+
+  AbstractLauncherIcon::Ptr const& selected = pimpl->model_->Selection();
+
+  if (selected)
+  {
+    pimpl->ubus.SendMessage(UBUS_LAUNCHER_SELECTION_CHANGED,
+                            g_variant_new_string(selected->tooltip_text().c_str()));
+  }
 }
 
 void Controller::KeyNavPrevious()
 {
   pimpl->model_->SelectPrevious();
+
+  AbstractLauncherIcon::Ptr const& selected = pimpl->model_->Selection();
+
+  if (selected)
+  {
+    pimpl->ubus.SendMessage(UBUS_LAUNCHER_SELECTION_CHANGED,
+                            g_variant_new_string(selected->tooltip_text().c_str()));
+  }
 }
 
 void Controller::KeyNavTerminate(bool activate)
@@ -1143,13 +1175,28 @@
   if (!pimpl->launcher_keynav)
     return;
 
+  if (activate && pimpl->keynav_restore_window_)
+  {
+    /* If the selected icon is running, we must not restore the input to the old */
+    AbstractLauncherIcon::Ptr const& icon = pimpl->model_->Selection();
+    pimpl->keynav_restore_window_ = !icon->GetQuirk(AbstractLauncherIcon::QUIRK_RUNNING);
+  }
+
   pimpl->keyboard_launcher_->ExitKeyNavMode();
+
   if (pimpl->launcher_grabbed)
   {
     pimpl->keyboard_launcher_->UnGrabKeyboard();
     pimpl->launcher_key_press_connection_.disconnect();
     pimpl->launcher_event_outside_connection_.disconnect();
     pimpl->launcher_grabbed = false;
+    pimpl->ubus.SendMessage(UBUS_LAUNCHER_END_KEY_NAV,
+                            g_variant_new_boolean(pimpl->keynav_restore_window_));
+  }
+  else
+  {
+    pimpl->ubus.SendMessage(UBUS_LAUNCHER_END_KEY_SWTICHER,
+                            g_variant_new_boolean(pimpl->keynav_restore_window_));
   }
 
   if (activate)
@@ -1158,9 +1205,6 @@
   pimpl->launcher_keynav = false;
   if (!pimpl->launcher_open)
     pimpl->keyboard_launcher_.Release();
-
-  pimpl->ubus.SendMessage(UBUS_LAUNCHER_END_KEY_SWTICHER, g_variant_new_boolean(true));
-  pimpl->ubus.SendMessage(UBUS_LAUNCHER_END_KEY_NAV, g_variant_new_boolean(pimpl->keynav_restore_window_));
 }
 
 bool Controller::KeyNavIsActive() const
@@ -1260,8 +1304,7 @@
       // <RETURN> (start/activate currently selected icon)
     case NUX_VK_ENTER:
     case NUX_KP_ENTER:
-    model_->Selection()->Activate(ActionArg(ActionArg::LAUNCHER, 0));
-    parent_->KeyNavTerminate(false);
+    parent_->KeyNavTerminate(true);
     break;
 
     default:
 
=== modified file 'plugins/unityshell/src/PanelController.cpp'
--- plugins/unityshell/src/PanelController.cpp	2012-03-22 19:33:10 +0000
+++ plugins/unityshell/src/PanelController.cpp	2012-04-05 23:42:20 +0000
@@ -26,6 +26,7 @@
 
 #include "UScreen.h"
 #include "PanelView.h"
+#include "PanelStyle.h"
 
 namespace unity
 {
@@ -46,8 +47,8 @@
   void FirstMenuShow();
   void QueueRedraw();
 
-  unsigned int GetTrayXid();
-  std::list <nux::Geometry> GetGeometries();
+  std::vector<Window> GetTrayXids() const;
+  std::vector<nux::Geometry> GetGeometries() const;
 
   // NOTE: nux::Property maybe?
   void SetOpacity(float opacity);
@@ -60,7 +61,7 @@
 
   void OnScreenChanged(int primary_monitor, std::vector<nux::Geometry>& monitors, Introspectable *iobj);
 private:
-  unity::PanelView* ViewForWindow(nux::BaseWindow* window);
+  unity::PanelView* ViewForWindow(nux::BaseWindow* window) const;
 
   static void WindowConfigureCallback(int            window_width,
                                       int            window_height,
@@ -98,17 +99,21 @@
   }
 }
 
-unsigned int Controller::Impl::GetTrayXid()
+std::vector<Window> Controller::Impl::GetTrayXids() const
 {
-  if (!windows_.empty())
-    return ViewForWindow(windows_.front())->GetTrayXid();
-  else
-    return 0;
+  std::vector<Window> xids;
+
+  for (auto window: windows_)
+  {
+    xids.push_back(ViewForWindow(window)->GetTrayXid());
+  }
+
+  return xids;
 }
 
-std::list<nux::Geometry> Controller::Impl::GetGeometries()
+std::vector<nux::Geometry> Controller::Impl::GetGeometries() const
 {
-  std::list<nux::Geometry> geometries;
+  std::vector<nux::Geometry> geometries;
 
   for (auto window : windows_)
   {
@@ -171,7 +176,7 @@
   }
 }
 
-PanelView* Controller::Impl::ViewForWindow(nux::BaseWindow* window)
+PanelView* Controller::Impl::ViewForWindow(nux::BaseWindow* window) const
 {
   nux::Layout* layout = window->GetLayout();
   std::list<nux::Area*>::iterator it = layout->GetChildren().begin();
@@ -198,8 +203,9 @@
       (*it)->InputWindowEnableStruts(false);
 
       nux::Geometry geo = monitors[i];
-      geo.height = 24;
+      geo.height = panel::Style::Instance().panel_height;
       (*it)->SetGeometry(geo);
+      (*it)->SetMinMaxSize(geo.width, geo.height);
 
       view = ViewForWindow(*it);
       view->SetPrimary(i == primary_monitor);
@@ -224,7 +230,7 @@
       nux::HLayout* layout = new nux::HLayout(NUX_TRACKER_LOCATION);
 
       PanelView* view = new PanelView();
-      view->SetMaximumHeight(24);
+      view->SetMaximumHeight(panel::Style::Instance().panel_height);
       view->SetOpacity(opacity_);
       view->SetOpacityMaximizedToggle(opacity_maximized_toggle_);
       view->SetMenuShowTimings(menus_fadein_, menus_fadeout_, menus_discovery_,
@@ -238,17 +244,18 @@
       layout->SetHorizontalExternalMargin(0);
 
       nux::BaseWindow* window = new nux::BaseWindow("");
+      nux::Geometry geo = monitors[i];
+      geo.height = panel::Style::Instance().panel_height;
+
       window->SinkReference();
       window->SetConfigureNotifyCallback(&Impl::WindowConfigureCallback, window);
-      window->SetLayout(layout);
       window->SetBackgroundColor(nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
       window->ShowWindow(true);
       window->EnableInputWindow(true, "panel", false, false);
       window->InputWindowEnableStruts(true);
-
-      nux::Geometry geo = monitors[i];
-      geo.height = 24;
       window->SetGeometry(geo);
+      window->SetMinMaxSize(geo.width, geo.height);
+      window->SetLayout(layout);
 
       windows_.push_back(window);
 
@@ -325,12 +332,12 @@
   pimpl->QueueRedraw();
 }
 
-unsigned int Controller::GetTrayXid()
+std::vector<Window> Controller::GetTrayXids() const
 {
-  return pimpl->GetTrayXid();
+  return pimpl->GetTrayXids();
 }
 
-std::list<nux::Geometry> Controller::GetGeometries()
+std::vector<nux::Geometry> Controller::GetGeometries() const
 {
   return pimpl->GetGeometries();
 }
 
=== modified file 'plugins/unityshell/src/PanelController.h'
--- plugins/unityshell/src/PanelController.h	2012-03-22 19:33:10 +0000
+++ plugins/unityshell/src/PanelController.h	2012-04-05 23:42:20 +0000
@@ -20,9 +20,7 @@
 #ifndef _PANEL_CONTROLLER_H_
 #define _PANEL_CONTROLLER_H_
 
-#include <list>
 #include <memory>
-
 #include <Nux/Nux.h>
 
 #include "Introspectable.h"
@@ -42,8 +40,8 @@
   void FirstMenuShow();
   void QueueRedraw();
 
-  unsigned int GetTrayXid ();
-  std::list<nux::Geometry> GetGeometries ();
+  std::vector<Window> GetTrayXids() const;
+  std::vector<nux::Geometry> GetGeometries() const;
 
   // NOTE: nux::Property maybe?
   void SetOpacity(float opacity);
 
=== modified file 'plugins/unityshell/src/PanelIndicatorEntryView.cpp'
--- plugins/unityshell/src/PanelIndicatorEntryView.cpp	2012-04-03 03:40:06 +0000
+++ plugins/unityshell/src/PanelIndicatorEntryView.cpp	2012-04-05 23:42:20 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2010 Canonical Ltd
+ * Copyright (C) 2010-2012 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
@@ -15,6 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Marco Trevisan (Treviño) <[e-mail]>
  */
 
 #include <Nux/Nux.h>
@@ -24,22 +25,18 @@
 #include <NuxGraphics/GLThread.h>
 #include <Nux/BaseWindow.h>
 #include <Nux/WindowCompositor.h>
-
-#include <boost/algorithm/string.hpp>
+#include <UnityCore/Variant.h>
 
 #include <glib.h>
-#include <pango/pangocairo.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <gtk/gtk.h>
 #include <time.h>
+#include <boost/algorithm/string.hpp>
 
 #include "CairoTexture.h"
-// TODO: this include should be at the top, but it fails :(
 #include "PanelIndicatorEntryView.h"
-
 #include "PanelStyle.h"
-#include <UnityCore/GLibWrapper.h>
-#include <UnityCore/Variant.h>
+#include "WindowManager.h"
 
 
 namespace unity
@@ -47,52 +44,45 @@
 
 namespace
 {
-void draw_menu_bg(cairo_t* cr, int width, int height);
-GdkPixbuf* make_pixbuf(int image_type, std::string const& image_data, bool dash_showing);
-const int PANEL_HEIGHT = 24;
-const int SPACING = 3;
+const int DEFAULT_SPACING = 3;
 }
 
+using namespace indicator;
 
-PanelIndicatorEntryView::PanelIndicatorEntryView(
-  indicator::Entry::Ptr const& proxy,
-  int padding,
-  IndicatorEntryType type)
+PanelIndicatorEntryView::PanelIndicatorEntryView(Entry::Ptr const& proxy, int padding,
+                                                 IndicatorEntryType type)
   : TextureArea(NUX_TRACKER_LOCATION)
   , proxy_(proxy)
+  , spacing_(DEFAULT_SPACING)
+  , left_padding_(padding < 0 ? 0 : padding)
+  , right_padding_(left_padding_)
   , type_(type)
-  , util_cg_(CAIRO_FORMAT_ARGB32, 1, 1)
-  , texture_layer_(NULL)
-  , padding_(padding < 0 ? 0 : padding)
+  , entry_texture_(nullptr)
   , opacity_(1.0f)
   , draw_active_(false)
-  , dash_showing_(false)
+  , overlay_showing_(false)
   , disabled_(false)
+  , focused_(true)
 {
-  on_indicator_activate_changed_connection_ = proxy_->active_changed.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnActiveChanged));
-  on_indicator_updated_connection_ = proxy_->updated.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::Refresh));
-
-  on_font_changed_connection_ = g_signal_connect(gtk_settings_get_default(), "notify::gtk-font-name", (GCallback) &PanelIndicatorEntryView::OnFontChanged, this);
+  proxy_->active_changed.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnActiveChanged));
+  proxy_->updated.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::Refresh));
 
   InputArea::mouse_down.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnMouseDown));
   InputArea::mouse_up.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnMouseUp));
 
   InputArea::SetAcceptMouseWheelEvent(true);
+
   if (type_ != MENU)
     InputArea::mouse_wheel.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnMouseWheel));
 
-  on_panelstyle_changed_connection_ = panel::Style::Instance().changed.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::Refresh));
+  panel::Style::Instance().changed.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::Refresh));
+
   Refresh();
 }
 
 PanelIndicatorEntryView::~PanelIndicatorEntryView()
 {
-  on_indicator_activate_changed_connection_.disconnect();
-  on_indicator_updated_connection_.disconnect();
-  on_panelstyle_changed_connection_.disconnect();
-  g_signal_handler_disconnect(gtk_settings_get_default(), on_font_changed_connection_);
-  if (texture_layer_)
-    delete texture_layer_;
+  // Nothing to do...
 }
 
 void PanelIndicatorEntryView::OnActiveChanged(bool is_active)
@@ -108,10 +98,15 @@
 
 void PanelIndicatorEntryView::ShowMenu(int button)
 {
-  proxy_->ShowMenu(GetAbsoluteX(),
-                   GetAbsoluteY() + PANEL_HEIGHT,
-                   button,
-                   time(NULL));
+  auto wm = WindowManager::Default();
+
+  if (!wm->IsExpoActive() && !wm->IsScaleActive())
+  {
+    proxy_->ShowMenu(GetAbsoluteX(),
+                     GetAbsoluteY() + panel::Style::Instance().panel_height,
+                     button,
+                     time(nullptr));
+  }
 }
 
 void PanelIndicatorEntryView::OnMouseDown(int x, int y, long button_flags, long key_flags)
@@ -119,8 +114,8 @@
   if (proxy_->active() || IsDisabled())
     return;
 
-  if (((proxy_->label_visible() && proxy_->label_sensitive()) ||
-       (proxy_->image_visible() && proxy_->image_sensitive())))
+  if (((IsLabelVisible() && IsLabelSensitive()) ||
+       (IsIconVisible() && IsIconSensitive())))
   {
     int button = nux::GetEventButton(button_flags);
 
@@ -144,12 +139,12 @@
   int px = geo.x + x;
   int py = geo.y + y;
 
-  if (((proxy_->label_visible() && proxy_->label_sensitive()) ||
-       (proxy_->image_visible() && proxy_->image_sensitive())) &&
-       button == 2 && type_ == INDICATOR)
+  if (((IsLabelVisible() && IsLabelSensitive()) ||
+       (IsIconVisible() && IsIconSensitive())) &&
+      button == 2 && type_ == INDICATOR)
   {
     if (geo.IsPointInside(px, py))
-      proxy_->SecondaryActivate(time(NULL));
+      proxy_->SecondaryActivate(time(nullptr));
 
     SetOpacity(1.0f);
   }
@@ -187,78 +182,290 @@
   }
 }
 
+glib::Object<GdkPixbuf> PanelIndicatorEntryView::MakePixbuf()
+{
+  glib::Object<GdkPixbuf> pixbuf;
+  GtkIconTheme* theme = gtk_icon_theme_get_default();
+  int image_type = proxy_->image_type();
+
+  if (image_type == GTK_IMAGE_PIXBUF)
+  {
+    gsize len = 0;
+    guchar* decoded = g_base64_decode(proxy_->image_data().c_str(), &len);
+
+    glib::Object<GInputStream> stream(g_memory_input_stream_new_from_data(decoded,
+                                                                          len,
+                                                                          nullptr));
+
+    pixbuf = gdk_pixbuf_new_from_stream(stream, nullptr, nullptr);
+
+    g_free(decoded);
+    g_input_stream_close(stream, nullptr, nullptr);
+  }
+  else if (image_type == GTK_IMAGE_STOCK ||
+           image_type == GTK_IMAGE_ICON_NAME)
+  {
+    pixbuf = gtk_icon_theme_load_icon(theme, proxy_->image_data().c_str(), 22,
+                                      (GtkIconLookupFlags)0, nullptr);
+  }
+  else if (image_type == GTK_IMAGE_GICON)
+  {
+    glib::Object<GIcon> icon(g_icon_new_for_string(proxy_->image_data().c_str(), nullptr));
+
+    GtkIconInfo* info = gtk_icon_theme_lookup_by_gicon(theme, icon, 22,
+                                                       (GtkIconLookupFlags)0);
+    if (info)
+    {
+      pixbuf = gtk_icon_info_load_icon(info, nullptr);
+      gtk_icon_info_free(info);
+    }
+  }
+
+  return pixbuf;
+}
+
+void PanelIndicatorEntryView::DrawEntryPrelight(cairo_t* cr, unsigned int width, unsigned int height)
+{
+  GtkStyleContext* style_context = panel::Style::Instance().GetStyleContext();
+
+  gtk_style_context_save(style_context);
+
+  GtkWidgetPath* widget_path = gtk_widget_path_new();
+  gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_BAR);
+  gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_ITEM);
+  gtk_widget_path_iter_set_name(widget_path, -1 , "UnityPanelWidget");
+
+  gtk_style_context_set_path(style_context, widget_path);
+  gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
+  gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
+  gtk_style_context_set_state(style_context, GTK_STATE_FLAG_PRELIGHT);
+
+  gtk_render_background(style_context, cr, 0, 0, width, height);
+  gtk_render_frame(style_context, cr, 0, 0, width, height);
+
+  gtk_widget_path_free(widget_path);
+
+  gtk_style_context_restore(style_context);
+}
+
+void PanelIndicatorEntryView::DrawEntryContent(cairo_t *cr, unsigned int width, unsigned int height, glib::Object<GdkPixbuf> const& pixbuf, glib::Object<PangoLayout> const& layout)
+{
+  int x = left_padding_;
+
+  if (IsActive())
+    DrawEntryPrelight(cr, width, height);
+
+  if (pixbuf && IsIconVisible())
+  {
+    GtkStyleContext* style_context = panel::Style::Instance().GetStyleContext();
+    unsigned int icon_width = gdk_pixbuf_get_width(pixbuf);
+
+    gtk_style_context_save(style_context);
+
+    GtkWidgetPath* widget_path = gtk_widget_path_new();
+    gint pos = gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_BAR);
+    pos = gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_ITEM);
+    gtk_widget_path_iter_set_name(widget_path, pos, "UnityPanelWidget");
+
+    gtk_style_context_set_path(style_context, widget_path);
+    gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
+    gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
+
+    if (!IsFocused())
+    {
+      gtk_style_context_set_state(style_context, GTK_STATE_FLAG_BACKDROP);
+    }
+    else if (IsActive())
+    {
+      gtk_style_context_set_state(style_context, GTK_STATE_FLAG_PRELIGHT);
+    }
+
+    int y = (int)((height - gdk_pixbuf_get_height(pixbuf)) / 2);
+    if (overlay_showing_ && !IsActive())
+    {
+      /* Most of the images we get are straight pixbufs (annoyingly), so when
+       * the Overlay opens, we use the pixbuf as a mask to punch out an icon from
+       * a white square. It works surprisingly well for most symbolic-type
+       * icon themes/icons.
+       */
+      cairo_save(cr);
+
+      cairo_push_group(cr);
+      gdk_cairo_set_source_pixbuf(cr, pixbuf, x, y);
+      cairo_paint_with_alpha(cr, (IsIconSensitive() && IsFocused()) ? 1.0 : 0.5);
+
+      cairo_pattern_t* pat = cairo_pop_group(cr);
+
+      cairo_set_source_rgba(cr, 1.0f, 1.0f, 1.0f, 1.0f);
+      cairo_rectangle(cr, x, y, width, height);
+      cairo_mask(cr, pat);
+
+      cairo_pattern_destroy(pat);
+      cairo_restore(cr);
+    }
+    else
+    {
+      cairo_push_group(cr);
+      gtk_render_icon(style_context, cr, pixbuf, x, y);
+      cairo_pop_group_to_source(cr);
+      cairo_paint_with_alpha(cr, (IsIconSensitive() && IsFocused()) ? 1.0 : 0.5);
+    }
+
+    gtk_widget_path_free(widget_path);
+
+    gtk_style_context_restore(style_context);
+
+    x += icon_width + spacing_;
+  }
+
+  if (layout)
+  {
+    PangoRectangle log_rect;
+    pango_layout_get_extents(layout, nullptr, &log_rect);
+    unsigned int text_height = log_rect.height / PANGO_SCALE;
+    unsigned int text_width = log_rect.width / PANGO_SCALE;
+
+    pango_cairo_update_layout(cr, layout);
+
+    GtkStyleContext* style_context = panel::Style::Instance().GetStyleContext();
+
+    gtk_style_context_save(style_context);
+
+    GtkWidgetPath* widget_path = gtk_widget_path_new();
+    gint pos = gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_BAR);
+    pos = gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_ITEM);
+    gtk_widget_path_iter_set_name(widget_path, pos, "UnityPanelWidget");
+
+    gtk_style_context_set_path(style_context, widget_path);
+    gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
+    gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
+
+    if (!IsFocused())
+    {
+      gtk_style_context_set_state(style_context, GTK_STATE_FLAG_BACKDROP);
+    }
+    else if (IsActive())
+    {
+      gtk_style_context_set_state(style_context, GTK_STATE_FLAG_PRELIGHT);
+    }
+
+    int y = (height - text_height) / 2;
+
+
+    unsigned int text_space = GetMaximumWidth() - x - right_padding_;
+
+    if (text_width > text_space)
+    {
+      cairo_pattern_t* linpat;
+      int out_pixels = text_width - text_space;
+      const int fading_pixels = 15;
+
+      int fading_width = out_pixels < fading_pixels ? out_pixels : fading_pixels;
+
+      cairo_push_group(cr);
+      if (overlay_showing_)
+      {
+        cairo_move_to(cr, x, y);
+        cairo_set_source_rgb(cr, 1.0f, 1.0f, 1.0f);
+        pango_cairo_show_layout(cr, layout);
+      }
+      else
+      {
+        gtk_render_layout(style_context, cr, x, y, layout);
+      }
+      cairo_pop_group_to_source(cr);
+
+      int right_margin = width - right_padding_;
+      linpat = cairo_pattern_create_linear(right_margin - fading_width, y, right_margin, y);
+      cairo_pattern_add_color_stop_rgba(linpat, 0, 0, 0, 0, 1);
+      cairo_pattern_add_color_stop_rgba(linpat, 1, 0, 0, 0, 0);
+      cairo_mask(cr, linpat);
+      cairo_pattern_destroy(linpat);
+    }
+    else
+    {
+      if (overlay_showing_)
+      {
+        cairo_move_to(cr, x, y);
+        cairo_set_source_rgb(cr, 1.0f, 1.0f, 1.0f);
+        pango_cairo_show_layout(cr, layout);
+      }
+      else
+      {
+        gtk_render_layout(style_context, cr, x, y, layout);
+      }
+    }
+
+    gtk_widget_path_free(widget_path);
+    gtk_style_context_restore(style_context);
+  }
+}
+
 // We need to do a couple of things here:
 // 1. Figure out our width
 // 2. Figure out if we're active
 // 3. Paint something
 void PanelIndicatorEntryView::Refresh()
 {
-  if (!IsVisible())
+  if (!proxy_->visible())
   {
     SetVisible(false);
+    // This will destroy the object texture. No need to manually delete the pointer
+    entry_texture_ = nullptr;
+    SetColor(nux::color::Transparent);
+
+    QueueDraw();
+    refreshed.emit(this);
+
     return;
   }
 
-  SetVisible(true);
-
-  PangoLayout*          layout = NULL;
-  PangoFontDescription* desc = NULL;
-  PangoAttrList*        attrs = NULL;
-  GtkSettings*          settings = gtk_settings_get_default();
-  cairo_t*              cr;
-  char*                 font_description = NULL;
-  GdkScreen*            screen = gdk_screen_get_default();
-  int                   dpi = 0;
-
-  std::string label = proxy_->label();
-  glib::Object<GdkPixbuf> pixbuf(make_pixbuf(proxy_->image_type(),
-                                             proxy_->image_data(),
-                                             dash_showing_));
-
-
-  int  x = 0;
-  int  width = 0;
-  int  height = PANEL_HEIGHT;
-  int  icon_width = 0;
-  int  text_width = 0;
-  int  text_height = 0;
-
-  if (proxy_->show_now())
-  {
-    if (!pango_parse_markup(label.c_str(),
-                            -1,
-                            '_',
-                            &attrs,
-                            NULL,
-                            NULL,
-                            NULL))
-    {
-      g_debug("pango_parse_markup failed");
-    }
-  }
-  boost::erase_all(label, "_");
+  glib::Object<PangoLayout> layout;
+  cairo_t* cr;
+
+  std::string label = GetLabel();
+  glib::Object<GdkPixbuf> const& pixbuf = MakePixbuf();
+
+  unsigned int width = 0;
+  unsigned int icon_width = 0;
+  unsigned int height = panel::Style::Instance().panel_height;
+  unsigned int text_width = 0;
 
   // First lets figure out our size
-  if (pixbuf && proxy_->image_visible())
+  if (pixbuf && IsIconVisible())
   {
     width = gdk_pixbuf_get_width(pixbuf);
     icon_width = width;
   }
 
-  if (!label.empty() && proxy_->label_visible())
+  if (!label.empty() && IsLabelVisible())
   {
+    using namespace panel;
     PangoContext* cxt;
+    PangoAttrList* attrs = nullptr;
     PangoRectangle log_rect;
-
-    cr = util_cg_.GetContext();
-
-    g_object_get(settings,
-                 "gtk-font-name", &font_description,
-                 "gtk-xft-dpi", &dpi,
-                 NULL);
-    desc = pango_font_description_from_string(font_description);
+    GdkScreen* screen = gdk_screen_get_default();
+    PangoFontDescription* desc = nullptr;
+    PanelItem panel_item = (type_ == MENU) ? PanelItem::MENU : PanelItem::INDICATOR;
+
+    Style& panel_style = Style::Instance();
+    std::string const& font_description = panel_style.GetFontDescription(panel_item);
+    int dpi = panel_style.GetTextDPI();
+
+    if (proxy_->show_now())
+    {
+      if (!pango_parse_markup(label.c_str(), -1, '_', &attrs, nullptr, nullptr, nullptr))
+      {
+        g_debug("pango_parse_markup failed");
+      }
+    }
+
+    desc = pango_font_description_from_string(font_description.c_str());
     pango_font_description_set_weight(desc, PANGO_WEIGHT_NORMAL);
 
+    nux::CairoGraphics cairo_graphics(CAIRO_FORMAT_ARGB32, 1, 1);
+    cr = cairo_graphics.GetContext();
+
     layout = pango_cairo_create_layout(cr);
     if (attrs)
     {
@@ -267,198 +474,90 @@
     }
 
     pango_layout_set_font_description(layout, desc);
+
+    boost::erase_all(label, "_");
     pango_layout_set_text(layout, label.c_str(), -1);
 
     cxt = pango_layout_get_context(layout);
     pango_cairo_context_set_font_options(cxt, gdk_screen_get_font_options(screen));
-    pango_cairo_context_set_resolution(cxt, (float)dpi / (float)PANGO_SCALE);
+    pango_cairo_context_set_resolution(cxt, dpi / static_cast<float>(PANGO_SCALE));
     pango_layout_context_changed(layout);
 
-    pango_layout_get_extents(layout, NULL, &log_rect);
+    pango_layout_get_extents(layout, nullptr, &log_rect);
     text_width = log_rect.width / PANGO_SCALE;
-    text_height = log_rect.height / PANGO_SCALE;
 
     if (icon_width)
-      width += SPACING;
+      width += spacing_;
     width += text_width;
 
     pango_font_description_free(desc);
-    g_free(font_description);
     cairo_destroy(cr);
   }
 
   if (width)
-    width += padding_ * 2;
+    width += left_padding_ + right_padding_;
 
+  width = std::min<int>(width, GetMaximumWidth());
   SetMinimumWidth(width);
 
-  nux::CairoGraphics cairo_graphics(CAIRO_FORMAT_ARGB32, width, height);
-  cr = cairo_graphics.GetContext();
+  nux::CairoGraphics cg(CAIRO_FORMAT_ARGB32, width, height);
+  cr = cg.GetContext();
   cairo_set_line_width(cr, 1);
-
   cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
   cairo_paint(cr);
 
   cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
-
-  if (IsActive())
-    draw_menu_bg(cr, width, height);
-
-  x = padding_;
-
-  if (pixbuf && proxy_->image_visible())
-  {
-    GtkStyleContext* style_context = panel::Style::Instance().GetStyleContext();
-
-    gtk_style_context_save(style_context);
-
-    GtkWidgetPath* widget_path = gtk_widget_path_new();
-    gint pos = gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_BAR);
-    pos = gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_ITEM);
-    gtk_widget_path_iter_set_name(widget_path, pos, "UnityPanelWidget");
-
-    gtk_style_context_set_path(style_context, widget_path);
-    gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
-    gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
-
-    if (IsActive())
-      gtk_style_context_set_state(style_context, GTK_STATE_FLAG_PRELIGHT);
-
-    int y = (int)((height - gdk_pixbuf_get_height(pixbuf)) / 2);
-    if (dash_showing_ && !IsActive())
-    {
-      /* Most of the images we get are straight pixbufs (annoyingly), so when
-       * the Dash opens, we use the pixbuf as a mask to punch out an icon from
-       * a white square. It works surprisingly well for most symbolic-type
-       * icon themes/icons.
-       */
-      cairo_save(cr);
-
-      cairo_push_group(cr);
-      gdk_cairo_set_source_pixbuf(cr, pixbuf, x, y);
-      cairo_paint_with_alpha(cr, proxy_->image_sensitive() ? 1.0 : 0.5);
-
-      cairo_pattern_t* pat = cairo_pop_group(cr);
-
-      cairo_set_source_rgba(cr, 1.0f, 1.0f, 1.0f, 1.0f);
-      cairo_rectangle(cr, x, y, width, height);
-      cairo_mask(cr, pat);
-
-      cairo_pattern_destroy(pat);
-      cairo_restore(cr);
-    }
-    else
-    {
-      cairo_push_group(cr);
-      gtk_render_icon(style_context, cr, pixbuf, x, y);
-      cairo_pop_group_to_source(cr);
-      cairo_paint_with_alpha(cr, proxy_->image_sensitive() ? 1.0 : 0.5);
-    }
-
-    gtk_widget_path_free(widget_path);
-
-    gtk_style_context_restore(style_context);
-
-    x += icon_width + SPACING;
-  }
-
-  if (!label.empty() && proxy_->label_visible())
-  {
-    pango_cairo_update_layout(cr, layout);
-
-    GtkStyleContext* style_context = panel::Style::Instance().GetStyleContext();
-
-    gtk_style_context_save(style_context);
-
-    GtkWidgetPath* widget_path = gtk_widget_path_new();
-    gint pos = gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_BAR);
-    pos = gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_ITEM);
-    gtk_widget_path_iter_set_name(widget_path, pos, "UnityPanelWidget");
-
-    gtk_style_context_set_path(style_context, widget_path);
-    gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
-    gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
-
-    if (IsActive())
-      gtk_style_context_set_state(style_context, GTK_STATE_FLAG_PRELIGHT);
-
-    int y = (int)((height - text_height) / 2);
-    if (dash_showing_)
-    {
-      cairo_move_to(cr, x, y);
-      cairo_set_source_rgb(cr, 1.0f, 1.0f, 1.0f);
-      pango_cairo_show_layout(cr, layout);
-    }
-    else
-    {
-      gtk_render_layout(style_context, cr, x, y, layout);
-    }
-
-    gtk_widget_path_free(widget_path);
-
-    gtk_style_context_restore(style_context);
-  }
-
+  DrawEntryContent(cr, width, height, pixbuf, layout);
+
+  entry_texture_ = texture_from_cairo_graphics(cg);
+  SetTexture(entry_texture_);
   cairo_destroy(cr);
-  if (layout)
-    g_object_unref(layout);
-
-  nux::BaseTexture* texture2D = texture_from_cairo_graphics(cairo_graphics);
-
-  nux::TexCoordXForm texxform;
-  texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
-  texxform.SetWrap(nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
-
-  nux::ROPConfig rop;
-  rop.Blend = true;
-  rop.SrcBlend = GL_ONE;
-  rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
-
-  if (texture_layer_)
-    delete texture_layer_;
-
-  texture_layer_ = new nux::TextureLayer(texture2D->GetDeviceTexture(), texxform,
-                                         nux::color::White, true, rop);
-  SetPaintLayer(texture_layer_);
-
-  texture2D->UnReference();
-
-  NeedRedraw();
-
+
+  SetVisible(true);
   refreshed.emit(this);
+  QueueDraw();
 }
 
 void PanelIndicatorEntryView::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
-  if (opacity_ == 1.0f)
-  {
-    TextureArea::Draw(GfxContext, force_draw);
-    return;
-  }
-
-  auto geo = GetGeometry();
+  nux::Geometry const& geo = GetGeometry();
   GfxContext.PushClippingRectangle(geo);
 
-  if (texture_layer_)
-  {
+  if (cached_geo_ != geo)
+  {
+    Refresh();
+    cached_geo_ = geo;
+  }
+
+  if (entry_texture_ && opacity_ > 0.0f)
+  {
+    /* "Clear" out the background */
+    nux::ROPConfig rop;
+    rop.Blend = true;
+    rop.SrcBlend = GL_ONE;
+    rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
+
+    nux::ColorLayer layer(nux::color::Transparent, true, rop);
+    nux::GetPainter().PushDrawLayer(GfxContext, geo, &layer);
+
     nux::TexCoordXForm texxform;
     GfxContext.QRP_1Tex(geo.x, geo.y, geo.width, geo.height,
-                        texture_layer_->GetDeviceTexture(), texxform,
+                        entry_texture_->GetDeviceTexture(), texxform,
                         nux::color::White * opacity_);
   }
 
   GfxContext.PopClippingRectangle();
 }
 
-void PanelIndicatorEntryView::DashShown()
+void PanelIndicatorEntryView::OverlayShown()
 {
-  dash_showing_ = true;
+  overlay_showing_ = true;
   Refresh();
 }
 
-void PanelIndicatorEntryView::DashHidden()
+void PanelIndicatorEntryView::OverlayHidden()
 {
-  dash_showing_ = false;
+  overlay_showing_ = false;
   Refresh();
 }
 
@@ -478,60 +577,131 @@
   return opacity_;
 }
 
+PanelIndicatorEntryView::IndicatorEntryType PanelIndicatorEntryView::GetType() const
+{
+  return type_;
+}
+
+std::string PanelIndicatorEntryView::GetLabel() const
+{
+  if (proxy_.get())
+  {
+    return proxy_->label();
+  }
+
+  return "";
+}
+
+bool PanelIndicatorEntryView::IsLabelVisible() const
+{
+  if (proxy_.get())
+  {
+    return proxy_->label_visible();
+  }
+
+  return false;
+}
+
+bool PanelIndicatorEntryView::IsLabelSensitive() const
+{
+  if (proxy_.get())
+  {
+    return proxy_->label_sensitive();
+  }
+
+  return false;
+}
+
+bool PanelIndicatorEntryView::IsIconVisible() const
+{
+  if (proxy_.get())
+  {
+    return proxy_->image_visible();
+  }
+
+  return false;
+}
+
+bool PanelIndicatorEntryView::IsIconSensitive() const
+{
+  if (proxy_.get())
+  {
+    return proxy_->image_sensitive();
+  }
+
+  return false;
+}
+
 std::string PanelIndicatorEntryView::GetName() const
 {
-  return proxy_->id();
+  return "IndicatorEntry";
 }
 
 void PanelIndicatorEntryView::AddProperties(GVariantBuilder* builder)
 {
   variant::BuilderWrapper(builder)
   .add(GetGeometry())
-  .add("label", proxy_->label())
-  .add("label_sensitive", proxy_->label_sensitive())
-  .add("label_visible", proxy_->label_visible())
-  .add("icon_sensitive", proxy_->image_sensitive())
-  .add("icon_visible", proxy_->image_visible())
+  .add("id", GetEntryID())
+  .add("name_hint", proxy_->name_hint())
+  .add("type", GetType())
+  .add("label", GetLabel())
+  .add("label_sensitive", IsLabelSensitive())
+  .add("label_visible", IsLabelVisible())
+  .add("icon_sensitive", IsIconSensitive())
+  .add("icon_visible", IsIconVisible())
+  .add("entry_visible", IsVisible())
   .add("active", proxy_->active())
-  .add("priority", proxy_->priority());
+  .add("priority", proxy_->priority())
+  .add("focused", IsFocused());
 }
 
-bool PanelIndicatorEntryView::GetShowNow()
+bool PanelIndicatorEntryView::GetShowNow() const
 {
   return proxy_.get() ? proxy_->show_now() : false;
 }
 
-void PanelIndicatorEntryView::GetGeometryForSync(indicator::EntryLocationMap& locations)
+void PanelIndicatorEntryView::GetGeometryForSync(EntryLocationMap& locations)
 {
   if (!IsVisible())
     return;
 
-  locations[proxy_->id()] = GetAbsoluteGeometry();
-}
-
-bool PanelIndicatorEntryView::IsEntryValid() const
-{
-  if (proxy_.get())
-  {
-    return proxy_->image_visible() || proxy_->label_visible();
-  }
-  return false;
+  locations[GetEntryID()] = GetAbsoluteGeometry();
 }
 
 bool PanelIndicatorEntryView::IsSensitive() const
 {
   if (proxy_.get())
   {
-    return proxy_->image_sensitive() || proxy_->label_sensitive();
+    return IsIconSensitive() || IsLabelSensitive();
   }
   return false;
 }
 
+bool PanelIndicatorEntryView::IsVisible()
+{
+  if (proxy_.get())
+  {
+    return TextureArea::IsVisible() && proxy_->visible();
+  }
+
+  return TextureArea::IsVisible();
+}
+
 bool PanelIndicatorEntryView::IsActive() const
 {
   return draw_active_;
 }
 
+std::string PanelIndicatorEntryView::GetEntryID() const
+{
+  if (proxy_.get())
+  {
+    return proxy_->id();
+  }
+
+  return "";
+}
+
 int PanelIndicatorEntryView::GetEntryPriority() const
 {
   if (proxy_.get())
@@ -551,95 +721,18 @@
   return (disabled_ || !proxy_.get() || !IsSensitive());
 }
 
-bool PanelIndicatorEntryView::IsVisible()
-{
-  if (proxy_.get())
-  {
-    return proxy_->visible();
-  }
-  return false;
-}
-
-void PanelIndicatorEntryView::OnFontChanged(GObject* gobject, GParamSpec* pspec,
-                                            gpointer data)
-{
-  PanelIndicatorEntryView* self = reinterpret_cast<PanelIndicatorEntryView*>(data);
-  self->Refresh();
-}
-
-namespace
-{
-
-void draw_menu_bg(cairo_t* cr, int width, int height)
-{
-  GtkStyleContext* style_context = panel::Style::Instance().GetStyleContext();
-
-  gtk_style_context_save(style_context);
-
-  GtkWidgetPath* widget_path = gtk_widget_path_new();
-  gint pos = gtk_widget_path_append_type(widget_path, GTK_TYPE_WINDOW);
-  gtk_widget_path_iter_set_name(widget_path, pos, "UnityPanelWidget");
-  gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_BAR);
-  gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_ITEM);
-
-  gtk_style_context_set_path(style_context, widget_path);
-  gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
-  gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
-  gtk_style_context_set_state(style_context, GTK_STATE_FLAG_PRELIGHT);
-
-  gtk_render_background(style_context, cr, 0, 0, width, height);
-  gtk_render_frame(style_context, cr, 0, 0, width, height);
-
-  gtk_widget_path_free(widget_path);
-
-  gtk_style_context_restore(style_context);
-}
-
-GdkPixbuf* make_pixbuf(int image_type, std::string const& image_data, bool dash_showing)
-{
-  GdkPixbuf* ret = NULL;
-  GtkIconTheme* theme = gtk_icon_theme_get_default();
-
-  if (image_type == GTK_IMAGE_PIXBUF)
-  {
-    gsize len = 0;
-    guchar* decoded = g_base64_decode(image_data.c_str(), &len);
-
-    GInputStream* stream = g_memory_input_stream_new_from_data(decoded,
-                                                               len, NULL);
-
-    ret = gdk_pixbuf_new_from_stream(stream, NULL, NULL);
-
-    g_free(decoded);
-    g_input_stream_close(stream, NULL, NULL);
-    g_object_unref(stream);
-  }
-  else if (image_type == GTK_IMAGE_STOCK ||
-           image_type == GTK_IMAGE_ICON_NAME)
-  {
-    ret = gtk_icon_theme_load_icon(theme,
-                                   image_data.c_str(),
-                                   22,
-                                   (GtkIconLookupFlags)0,
-                                   NULL);
-  }
-  else if (image_type == GTK_IMAGE_GICON)
-  {
-    glib::Object<GIcon> icon(g_icon_new_for_string(image_data.c_str(), NULL));
-
-    GtkIconInfo* info = gtk_icon_theme_lookup_by_gicon(
-                          theme, icon, 22, (GtkIconLookupFlags)0);
-    if (info)
-    {
-      ret = gtk_icon_info_load_icon(info, NULL);
-      gtk_icon_info_free(info);
-    }
-  }
-
-  return ret;
-}
-
-} // anon namespace
-
+void PanelIndicatorEntryView::SetFocusedState(bool focused)
+{
+  if (focused_ != focused)
+  {
+    focused_ = focused;
+    Refresh();
+  }
+}
+
+bool PanelIndicatorEntryView::IsFocused() const
+{
+  return focused_;
+}
 
 } // namespace unity
 
=== modified file 'plugins/unityshell/src/PanelIndicatorEntryView.h'
--- plugins/unityshell/src/PanelIndicatorEntryView.h	2012-03-21 12:31:11 +0000
+++ plugins/unityshell/src/PanelIndicatorEntryView.h	2012-04-05 23:42:20 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2010 Canonical Ltd
+ * Copyright (C) 2010-2012 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
@@ -15,6 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Marco Trevisan (Treviño) <[e-mail]>
  */
 
 #ifndef PANEL_INDICATOR_OBJECT_ENTRY_VIEW_H
@@ -26,78 +27,101 @@
 #include <NuxGraphics/GraphicsEngine.h>
 
 #include <UnityCore/IndicatorEntry.h>
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/GLibSignal.h>
+
+#include <gtk/gtk.h>
 
 #include "Introspectable.h"
 
 
 namespace unity
 {
-
-class PanelIndicatorEntryView : public nux::TextureArea, public unity::debug::Introspectable
+class PanelIndicatorEntryView : public nux::TextureArea, public debug::Introspectable
 {
 public:
-  typedef enum {
+  enum IndicatorEntryType {
     INDICATOR,
     MENU,
     OTHER
-  } IndicatorEntryType;
+  };
 
   PanelIndicatorEntryView(indicator::Entry::Ptr const& proxy, int padding = 5,
                           IndicatorEntryType type = INDICATOR);
-  ~PanelIndicatorEntryView();
-
-  void Refresh();
-
-  void Activate(int button = 1);
-  void Unactivate();
-  bool GetShowNow();
+
+  virtual ~PanelIndicatorEntryView();
+
+  IndicatorEntryType GetType() const;
+  std::string GetEntryID() const;
+  int GetEntryPriority() const;
+
+  virtual std::string GetLabel() const;
+  virtual bool IsLabelVisible() const;
+  virtual bool IsLabelSensitive() const;
+
+  virtual bool IsIconVisible() const;
+  virtual bool IsIconSensitive() const;
+
+  virtual void Activate(int button = 1);
+  virtual void Unactivate();
+
+  virtual void GetGeometryForSync(indicator::EntryLocationMap& locations);
+
+  bool GetShowNow() const;
+  bool IsSensitive() const;
+  bool IsActive() const;
+  bool IsVisible();
+
   void SetDisabled(bool disabled);
   bool IsDisabled();
+
   void SetOpacity(double alpha);
   double GetOpacity();
 
-  void GetGeometryForSync(indicator::EntryLocationMap& locations);
-  bool IsEntryValid() const;
-  bool IsSensitive() const;
-  bool IsActive() const;
-  bool IsVisible();
-  int  GetEntryPriority() const;
-
-  void DashShown();
-  void DashHidden();
-
+  void SetFocusedState(bool focused);
+  bool IsFocused() const;
+
+  void OverlayShown();
+  void OverlayHidden();
+
+  sigc::signal<void, PanelIndicatorEntryView*, bool> active_changed;
+  sigc::signal<void, PanelIndicatorEntryView*> refreshed;
+
+protected:
   std::string GetName() const;
-  void         AddProperties(GVariantBuilder* builder);
+  void AddProperties(GVariantBuilder* builder);
 
   virtual void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
-
-  sigc::signal<void, PanelIndicatorEntryView*, bool> active_changed;
-  sigc::signal<void, PanelIndicatorEntryView*> refreshed;
+  virtual void DrawEntryPrelight(cairo_t* cr, unsigned int w, unsigned int h);
+  virtual void DrawEntryContent(cairo_t* cr, unsigned int width, unsigned int height,
+                                glib::Object<GdkPixbuf> const& pixbuf,
+                                glib::Object<PangoLayout> const& layout);
+
+  void Refresh();
+  void SetActiveState(bool active, int button);
+  virtual void ShowMenu(int button = 1);
+
+  indicator::Entry::Ptr proxy_;
+  unsigned int spacing_;
+  unsigned int left_padding_;
+  unsigned int right_padding_;
 
 private:
-  unity::indicator::Entry::Ptr proxy_;
+  void OnMouseDown(int x, int y, long button_flags, long key_flags);
+  void OnMouseUp(int x, int y, long button_flags, long key_flags);
+  void OnMouseWheel(int x, int y, int delta, unsigned long mouse_state, unsigned long key_state);
+  void OnActiveChanged(bool is_active);
+
+  glib::Object<GdkPixbuf> MakePixbuf();
+
   IndicatorEntryType type_;
-  nux::CairoGraphics util_cg_;
-  nux::TextureLayer* texture_layer_;
-  int padding_;
+  nux::BaseTexture* entry_texture_;
+  nux::Geometry cached_geo_;
   double opacity_;
   bool draw_active_;
-  bool dash_showing_;
+  bool overlay_showing_;
   bool disabled_;
-  gulong on_font_changed_connection_;
-
-  static void OnFontChanged(GObject* gobject, GParamSpec* pspec, gpointer data);
-  void OnMouseDown(int x, int y, long button_flags, long key_flags);
-  void OnMouseUp(int x, int y, long button_flags, long key_flags);
-  void OnMouseWheel(int x, int y, int delta, unsigned long mouse_state, unsigned long key_state);
-  void OnActiveChanged(bool is_active);
-
-  void SetActiveState(bool active, int button);
-  void ShowMenu(int button);
-
-  sigc::connection on_indicator_activate_changed_connection_;
-  sigc::connection on_indicator_updated_connection_;
-  sigc::connection on_panelstyle_changed_connection_;
+  bool focused_;
 };
 
 }
 
=== modified file 'plugins/unityshell/src/PanelIndicatorsView.cpp'
--- plugins/unityshell/src/PanelIndicatorsView.cpp	2012-03-21 12:31:11 +0000
+++ plugins/unityshell/src/PanelIndicatorsView.cpp	2012-04-05 23:42:20 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2011 Canonical Ltd
+ * Copyright (C) 2011-2012 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
@@ -14,7 +14,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
- * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
  *              Neil Jagdish Patel <[e-mail]>
  */
 
@@ -36,6 +36,8 @@
 
 namespace unity
 {
+using namespace indicator;
+
 NUX_IMPLEMENT_OBJECT_TYPE(PanelIndicatorsView);
 
 PanelIndicatorsView::PanelIndicatorsView()
@@ -45,8 +47,9 @@
 {
   LOG_DEBUG(logger) << "Indicators View Added: ";
   layout_ = new nux::HLayout("", NUX_TRACKER_LOCATION);
+  layout_->SetContentDistribution(nux::eStackRight);
 
-  SetCompositionLayout(layout_);
+  SetLayout(layout_);
 }
 
 PanelIndicatorsView::~PanelIndicatorsView()
@@ -59,7 +62,7 @@
 }
 
 void
-PanelIndicatorsView::AddIndicator(indicator::Indicator::Ptr const& indicator)
+PanelIndicatorsView::AddIndicator(Indicator::Ptr const& indicator)
 {
   LOG_DEBUG(logger) << "IndicatorAdded: " << indicator->name();
   indicators_.push_back(indicator);
@@ -76,7 +79,7 @@
 }
 
 void
-PanelIndicatorsView::RemoveIndicator(indicator::Indicator::Ptr const& indicator)
+PanelIndicatorsView::RemoveIndicator(Indicator::Ptr const& indicator)
 {
   auto connections = indicators_connections_.find(indicator);
 
@@ -88,7 +91,7 @@
   }
 
   for (auto entry : indicator->GetEntries())
-    OnEntryRemoved (entry->id());
+    OnEntryRemoved(entry->id());
 
   for (auto i = indicators_.begin(); i != indicators_.end(); i++)
   {
@@ -102,6 +105,12 @@
   LOG_DEBUG(logger) << "IndicatorRemoved: " << indicator->name();
 }
 
+PanelIndicatorsView::Indicators
+PanelIndicatorsView::GetIndicators()
+{
+  return indicators_;
+}
+
 void
 PanelIndicatorsView::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
@@ -121,16 +130,45 @@
     entry.second->QueueDraw();
 }
 
+void
+PanelIndicatorsView::SetMaximumEntriesWidth(int max_width)
+{
+  unsigned int n_entries = 0;
+
+  for (auto entry : entries_)
+    if (entry.second->IsVisible())
+      n_entries++;
+
+  if (n_entries > 0)
+  {
+    for (auto entry : entries_)
+    {
+      if (entry.second->IsVisible() && n_entries > 0)
+      {
+        int max_entry_width = max_width / n_entries;
+
+        if (entry.second->GetBaseWidth() > max_entry_width)
+          entry.second->SetMaximumWidth(max_entry_width);
+
+        max_width -= entry.second->GetBaseWidth();
+        --n_entries;
+      }
+    }
+  }
+}
+
 PanelIndicatorEntryView*
-PanelIndicatorsView::ActivateEntry(std::string const& entry_id)
+PanelIndicatorsView::ActivateEntry(std::string const& entry_id, int button)
 {
   auto entry = entries_.find(entry_id);
 
-  if (entry != entries_.end() && entry->second->IsEntryValid())
+  if (entry != entries_.end())
   {
     PanelIndicatorEntryView* view = entry->second;
-    LOG_DEBUG(logger) << "Activating: " << entry_id;
-    view->Activate();
+
+    if (view->IsSensitive() && view->IsVisible())
+      view->Activate(button);
+
     return view;
   }
 
@@ -148,24 +186,27 @@
   for (auto entry : sorted_entries)
   {
     PanelIndicatorEntryView* view = entry.second;
-    if (view->IsSensitive())
+
+    if (view->IsSensitive() && view->IsVisible() && view->IsFocused())
     {
-      view->Activate();
+      /* Use the 0 button, it means it's a keyboard activation */
+      view->Activate(0);
       return true;
     }
   }
+
   return false;
 }
 
 void
-PanelIndicatorsView::GetGeometryForSync(indicator::EntryLocationMap& locations)
+PanelIndicatorsView::GetGeometryForSync(EntryLocationMap& locations)
 {
   for (auto entry : entries_)
     entry.second->GetGeometryForSync(locations);
 }
 
 PanelIndicatorEntryView*
-PanelIndicatorsView::ActivateEntryAt(int x, int y)
+PanelIndicatorsView::ActivateEntryAt(int x, int y, int button)
 {
   PanelIndicatorEntryView* target = nullptr;
   bool found_old_active = false;
@@ -180,9 +221,10 @@
   {
     PanelIndicatorEntryView* view = entry.second;
 
-    if (!target && view->IsVisible() && view->GetAbsoluteGeometry().IsPointInside(x, y))
+    if (!target && view->IsVisible() && view->IsFocused() &&
+        view->GetAbsoluteGeometry().IsPointInside(x, y))
     {
-      view->Activate(0);
+      view->Activate(button);
       target = view;
       break;
     }
@@ -219,11 +261,13 @@
   GfxContext.PopClippingRectangle();
 }
 
-PanelIndicatorEntryView *
-PanelIndicatorsView::AddEntry(indicator::Entry::Ptr const& entry, int padding,
-                              IndicatorEntryPosition pos, IndicatorEntryType type)
+void
+PanelIndicatorsView::AddEntryView(PanelIndicatorEntryView* view,
+                                  IndicatorEntryPosition pos)
 {
-  auto view = new PanelIndicatorEntryView(entry, padding, type);
+  if (!view)
+    return;
+
   int entry_pos = pos;
 
   view->SetOpacity(opacity_);
@@ -233,7 +277,7 @@
   {
     entry_pos = nux::NUX_LAYOUT_BEGIN;
 
-    if (entry->priority() > -1)
+    if (view->GetEntryPriority() > -1)
     {
       for (auto area : layout_->GetChildren())
       {
@@ -241,7 +285,7 @@
 
         if (en)
         {
-          if (en && entry->priority() <= en->GetEntryPriority())
+          if (en && view->GetEntryPriority() <= en->GetEntryPriority())
             break;
 
           entry_pos++;
@@ -251,20 +295,28 @@
   }
 
   layout_->AddView(view, 0, nux::eCenter, nux::eFull, 1.0, (nux::LayoutPosition) entry_pos);
-  layout_->SetContentDistribution(nux::eStackRight);
-  entries_[entry->id()] = view;
+
+  entries_[view->GetEntryID()] = view;
 
   AddChild(view);
   QueueRelayout();
   QueueDraw();
 
   on_indicator_updated.emit(view);
+}
+
+PanelIndicatorEntryView *
+PanelIndicatorsView::AddEntry(Entry::Ptr const& entry, int padding,
+                              IndicatorEntryPosition pos, IndicatorEntryType type)
+{
+  auto view = new PanelIndicatorEntryView(entry, padding, type);
+  AddEntryView(view, pos);
 
   return view;
 }
 
 void
-PanelIndicatorsView::OnEntryAdded(indicator::Entry::Ptr const& entry)
+PanelIndicatorsView::OnEntryAdded(Entry::Ptr const& entry)
 {
   AddEntry(entry);
 }
@@ -279,19 +331,25 @@
 }
 
 void
+PanelIndicatorsView::RemoveEntryView(PanelIndicatorEntryView* view)
+{
+  if (!view)
+    return;
+
+  std::string const& entry_id = view->GetEntryID();
+  RemoveChild(view);
+  on_indicator_updated.emit(view);
+  entries_.erase(entry_id);
+  layout_->RemoveChildObject(view);
+
+  QueueRelayout();
+  QueueDraw();
+}
+
+void
 PanelIndicatorsView::RemoveEntry(std::string const& entry_id)
 {
-  PanelIndicatorEntryView* view = entries_[entry_id];
-
-  if (view)
-  {
-    layout_->RemoveChildObject(view);
-    entries_.erase(entry_id);
-    on_indicator_updated.emit(view);
-
-    QueueRelayout();
-    QueueDraw();
-  }
+  RemoveEntryView(entries_[entry_id]);
 }
 
 void
@@ -301,17 +359,17 @@
 }
 
 void
-PanelIndicatorsView::DashShown()
+PanelIndicatorsView::OverlayShown()
 {
   for (auto entry: entries_)
-    entry.second->DashShown();
+    entry.second->OverlayShown();
 }
 
 void
-PanelIndicatorsView::DashHidden()
+PanelIndicatorsView::OverlayHidden()
 {
   for (auto entry: entries_)
-    entry.second->DashHidden();
+    entry.second->OverlayHidden();
 }
 
 double
@@ -337,13 +395,16 @@
 
 std::string PanelIndicatorsView::GetName() const
 {
-  return "IndicatorsView";
+  return "Indicators";
 }
 
 void
 PanelIndicatorsView::AddProperties(GVariantBuilder* builder)
 {
-  variant::BuilderWrapper(builder).add(GetGeometry());
+  variant::BuilderWrapper(builder)
+  .add(GetGeometry())
+  .add("entries", entries_.size())
+  .add("opacity", opacity_);
 }
 
 } // namespace unity
 
=== modified file 'plugins/unityshell/src/PanelIndicatorsView.h'
--- plugins/unityshell/src/PanelIndicatorsView.h	2012-03-21 12:31:11 +0000
+++ plugins/unityshell/src/PanelIndicatorsView.h	2012-04-05 23:42:20 +0000
@@ -42,11 +42,11 @@
   void AddIndicator(indicator::Indicator::Ptr const& indicator);
   void RemoveIndicator(indicator::Indicator::Ptr const& indicator);
 
-  typedef enum {
+  enum IndicatorEntryPosition {
     AUTO = -1,
     START = nux::NUX_LAYOUT_BEGIN,
     END = nux::NUX_LAYOUT_END,
-  } IndicatorEntryPosition;
+  };
 
   typedef PanelIndicatorEntryView::IndicatorEntryType IndicatorEntryType;
 
@@ -56,37 +56,46 @@
                                     IndicatorEntryType type = IndicatorEntryType::INDICATOR);
   void RemoveEntry(std::string const& entry_id);
 
-  PanelIndicatorEntryView* ActivateEntryAt(int x, int y);
-  PanelIndicatorEntryView* ActivateEntry(std::string const& entry_id);
+  PanelIndicatorEntryView* ActivateEntryAt(int x, int y, int button = 1);
+  PanelIndicatorEntryView* ActivateEntry(std::string const& entry_id, int button = 1);
   bool ActivateIfSensitive();
+
+  virtual void OverlayShown();
+  virtual void OverlayHidden();
+
+  void SetOpacity(double opacity);
+  double GetOpacity();
+
+  void SetMaximumEntriesWidth(int max_width);
   void GetGeometryForSync(indicator::EntryLocationMap& locations);
 
+  virtual void QueueDraw();
+
+  sigc::signal<void, PanelIndicatorEntryView*> on_indicator_updated;
+
+protected:
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
+  typedef std::vector<indicator::Indicator::Ptr> Indicators;
+  Indicators GetIndicators();
+
   virtual void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
   virtual void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw);
-  virtual void QueueDraw();
 
   virtual void OnEntryAdded(indicator::Entry::Ptr const& entry);
   virtual void OnEntryRefreshed(PanelIndicatorEntryView* view);
   virtual void OnEntryRemoved(std::string const& entry_id);
 
-  void DashShown();
-  void DashHidden();
-
-  void SetOpacity(double opacity);
-  double GetOpacity();
-
-  sigc::signal<void, PanelIndicatorEntryView*> on_indicator_updated;
-
-protected:
+  virtual void AddEntryView(PanelIndicatorEntryView* view,
+                            IndicatorEntryPosition pos = AUTO);
+  virtual void RemoveEntryView(PanelIndicatorEntryView* view);
+
   nux::HLayout* layout_;
   typedef std::map<std::string, PanelIndicatorEntryView*> Entries;
   Entries entries_;
 
-  std::string GetName() const;
-  void        AddProperties(GVariantBuilder* builder);
-
 private:
-  typedef std::vector<indicator::Indicator::Ptr> Indicators;
   Indicators indicators_;
   double opacity_;
 
 
=== modified file 'plugins/unityshell/src/PanelMenuView.cpp'
--- plugins/unityshell/src/PanelMenuView.cpp	2012-04-03 03:36:34 +0000
+++ plugins/unityshell/src/PanelMenuView.cpp	2012-04-05 23:42:20 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2010 Canonical Ltd
+ * Copyright (C) 2010-2012 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
@@ -15,61 +15,52 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
- *              Marco Trevisan <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
  */
-#include <glib.h>
-#include <pango/pangocairo.h>
-#include <gtk/gtk.h>
 
 #include <Nux/Nux.h>
-#include <Nux/HLayout.h>
-#include <Nux/VLayout.h>
-#include <Nux/TextureArea.h>
-
-#include <NuxGraphics/GLThread.h>
-#include <NuxGraphics/XInputWindow.h>
-#include <Nux/BaseWindow.h>
+#include <NuxCore/Logger.h>
 
 #include "CairoTexture.h"
 #include "PanelMenuView.h"
 #include "PanelStyle.h"
-#include <UnityCore/Variant.h>
-
-#include <gio/gdesktopappinfo.h>
-#include <gconf/gconf-client.h>
-
-#include <glib.h>
-#include <glib/gi18n-lib.h>
-
 #include "DashSettings.h"
-#include "ubus-server.h"
 #include "UBusMessages.h"
-
 #include "UScreen.h"
 
+#include <UnityCore/Variant.h>
+
+#include <glib/gi18n-lib.h>
+
 namespace unity
 {
 
 namespace
 {
-  const std::string WINDOW_TITLE_FONT_KEY = "/apps/metacity/general/titlebar_font";
+  nux::logging::Logger logger("unity.panel.menu");
+  const int MAIN_LEFT_PADDING = 4;
+  const int TITLE_PADDING = 2;
+  const int MENUBAR_PADDING = 4;
+  const int MENU_ENTRIES_PADDING = 6;
+  const int DEFAULT_MENUS_FADEIN = 100;
+  const int DEFAULT_MENUS_FADEOUT = 120;
+  const int DEFAULT_MENUS_DISCOVERY = 2;
+  const int DEFAULT_DISCOVERY_FADEIN = 200;
+  const int DEFAULT_DISCOVERY_FADEOUT = 300;
+
+  const std::string DESKTOP_NAME(_("Ubuntu Desktop"));
 }
 
-PanelMenuView::PanelMenuView(int padding)
+PanelMenuView::PanelMenuView()
   : _matcher(bamf_matcher_get_default()),
-    _title_layer(nullptr),
-    _util_cg(CAIRO_FORMAT_ARGB32, 1, 1),
-    _gradient_texture(nullptr),
     _is_inside(false),
     _is_grabbed(false),
     _is_maximized(false),
-    _is_own_window(false),
     _last_active_view(nullptr),
     _new_application(nullptr),
-    _last_width(0),
-    _last_height(0),
-    _places_showing(false),
+    _overlay_showing(false),
     _switcher_showing(false),
+    _launcher_keynav(false),
     _show_now_activated(false),
     _we_control_active(false),
     _new_app_menu_shown(false),
@@ -79,26 +70,19 @@
     _update_show_now_id(0),
     _new_app_show_id(0),
     _new_app_hide_id(0),
-    _menus_fadein(100),
-    _menus_fadeout(120),
-    _menus_discovery(2),
-    _menus_discovery_fadein(200),
-    _menus_discovery_fadeout(300),
-    _panel_title(nullptr),
-    _fade_in_animator(nullptr),
-    _fade_out_animator(nullptr)
+    _menus_fadein(DEFAULT_MENUS_FADEIN),
+    _menus_fadeout(DEFAULT_MENUS_FADEOUT),
+    _menus_discovery(DEFAULT_MENUS_DISCOVERY),
+    _menus_discovery_fadein(DEFAULT_DISCOVERY_FADEIN),
+    _menus_discovery_fadeout(DEFAULT_DISCOVERY_FADEOUT),
+    _fade_in_animator(_menus_fadein),
+    _fade_out_animator(_menus_fadeout)
 {
-  WindowManager* win_manager;
-
-  // TODO: kill _menu_layout - should just use the _layout defined
-  // in the base class.
-  _menu_layout = new nux::HLayout("", NUX_TRACKER_LOCATION);
-  _menu_layout->SetParentObject(this);
-
-  /* This is for our parent and for PanelView to read indicator entries, we
-   * shouldn't touch this again
-   */
-  layout_ = _menu_layout;
+  layout_->SetContentDistribution(nux::eStackLeft);
+
+  BamfWindow* active_win = bamf_matcher_get_active_window(_matcher);
+  if (BAMF_IS_WINDOW(active_win))
+    _active_xid = bamf_window_get_xid(active_win);
 
   _view_opened_signal.Connect(_matcher, "view-opened",
                               sigc::mem_fun(this, &PanelMenuView::OnViewOpened));
@@ -109,35 +93,35 @@
   _active_app_changed_signal.Connect(_matcher, "active-application-changed",
                                      sigc::mem_fun(this, &PanelMenuView::OnActiveAppChanged));
 
-  _padding = padding;
-
   _window_buttons = new WindowButtons();
+  _window_buttons->SetMonitor(_monitor);
+  _window_buttons->SetControlledWindow(_active_xid);
   _window_buttons->SetParentObject(this);
-  _window_buttons->NeedRedraw();
+  _window_buttons->SetLeftAndRightPadding(MAIN_LEFT_PADDING, MENUBAR_PADDING);
+  _window_buttons->SetMaximumHeight(panel::Style::Instance().panel_height);
+  _window_buttons->ComputeContentSize();
 
-  _window_buttons->close_clicked.connect(sigc::mem_fun(this, &PanelMenuView::OnCloseClicked));
-  _window_buttons->minimize_clicked.connect(sigc::mem_fun(this, &PanelMenuView::OnMinimizeClicked));
-  _window_buttons->restore_clicked.connect(sigc::mem_fun(this, &PanelMenuView::OnRestoreClicked));
   _window_buttons->mouse_enter.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseEnter));
   _window_buttons->mouse_leave.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseLeave));
   //_window_buttons->mouse_move.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseMove));
-
-  _panel_titlebar_grab_area = new PanelTitlebarGrabArea();
-  _panel_titlebar_grab_area->SetParentObject(this);
-  _panel_titlebar_grab_area->mouse_down.connect(sigc::mem_fun(this, &PanelMenuView::OnMouseClicked));
-  _panel_titlebar_grab_area->mouse_down.connect(sigc::mem_fun(this, &PanelMenuView::OnMouseMiddleClicked));
-  _panel_titlebar_grab_area->mouse_down.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedGrabStart));
-  _panel_titlebar_grab_area->mouse_drag.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedGrabMove));
-  _panel_titlebar_grab_area->mouse_up.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedGrabEnd));
-  _panel_titlebar_grab_area->mouse_double_click.connect(sigc::mem_fun(this, &PanelMenuView::OnMouseDoubleClicked));
-
-  win_manager = WindowManager::Default();
-
+  AddChild(_window_buttons);
+
+  layout_->SetLeftAndRightPadding(_window_buttons->GetContentWidth(), 0);
+  layout_->SetBaseHeight(panel::Style::Instance().panel_height);
+
+  _titlebar_grab_area = new PanelTitlebarGrabArea();
+  _titlebar_grab_area->SetParentObject(this);
+  _titlebar_grab_area->activate_request.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedActivate));
+  _titlebar_grab_area->restore_request.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedRestore));
+  _titlebar_grab_area->lower_request.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedLower));
+  _titlebar_grab_area->grab_started.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedGrabStart));
+  _titlebar_grab_area->grab_move.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedGrabMove));
+  _titlebar_grab_area->grab_end.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedGrabEnd));
+  AddChild(_titlebar_grab_area);
+
+  WindowManager* win_manager = WindowManager::Default();
   win_manager->window_minimized.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowMinimized));
   win_manager->window_unminimized.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowUnminimized));
-  //win_manager->initiate_spread.connect(sigc::mem_fun(this, &PanelMenuView::OnSpreadInitiate));
-  //win_manager->terminate_spread.connect(sigc::mem_fun(this, &PanelMenuView::OnSpreadTerminate));
-
   win_manager->window_maximized.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowMaximized));
   win_manager->window_restored.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowRestored));
   win_manager->window_unmapped.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowUnmapped));
@@ -146,39 +130,40 @@
   win_manager->window_resized.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowMoved));
   win_manager->window_decorated.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowDecorated));
   win_manager->window_undecorated.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowUndecorated));
-
-  panel::Style::Instance().changed.connect(sigc::mem_fun(this, &PanelMenuView::Refresh));
+  win_manager->initiate_spread.connect(sigc::mem_fun(this, &PanelMenuView::OnSpreadInitiate));
+  win_manager->terminate_spread.connect(sigc::mem_fun(this, &PanelMenuView::OnSpreadTerminate));
+  win_manager->initiate_expo.connect(sigc::mem_fun(this, &PanelMenuView::OnExpoInitiate));
+  win_manager->terminate_expo.connect(sigc::mem_fun(this, &PanelMenuView::OnExpoTerminate));
+  win_manager->compiz_screen_viewport_switch_ended.connect(sigc::mem_fun(this, &PanelMenuView::OnExpoTerminate));
+
+  _style_changed_connection = panel::Style::Instance().changed.connect([&] {
+    _window_buttons->ComputeContentSize();
+    layout_->SetLeftAndRightPadding(_window_buttons->GetContentWidth(), 0);
+
+    Refresh(true);
+    FullRedraw();
+  });
 
   mouse_enter.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseEnter));
   mouse_leave.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseLeave));
   //mouse_move.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseMove));
 
-  _panel_titlebar_grab_area->mouse_enter.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseEnter));
-  _panel_titlebar_grab_area->mouse_leave.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseLeave));
-
-  // Register for all the interesting events
-  UBusServer* ubus = ubus_server_get_default();
-  _ubus_interests.push_back(ubus_server_register_interest(ubus, UBUS_OVERLAY_SHOWN,
-                                                          (UBusCallback)PanelMenuView::OnPlaceViewShown,
-                                                          this));
-  _ubus_interests.push_back(ubus_server_register_interest(ubus, UBUS_OVERLAY_HIDDEN,
-                                                          (UBusCallback)PanelMenuView::OnPlaceViewHidden,
-                                                          this));
-
-  _ubus_interests.push_back(ubus_server_register_interest(ubus, UBUS_SWITCHER_SHOWN,
-                                                          (UBusCallback)PanelMenuView::OnSwitcherShown,
-                                                          this));
-  _ubus_interests.push_back(ubus_server_register_interest(ubus, UBUS_SWITCHER_SELECTION_CHANGED,
-                                                          (UBusCallback)PanelMenuView::OnSwitcherSelectionChanged,
-                                                          this));
-
-  _fade_in_animator = new Animator(_menus_fadein);
-  _fade_out_animator = new Animator(_menus_fadeout);
-
-  _fade_in_animator->animation_updated.connect(sigc::mem_fun(this, &PanelMenuView::OnFadeInChanged));
-  _fade_in_animator->animation_ended.connect(sigc::mem_fun(this, &PanelMenuView::FullRedraw));
-  _fade_out_animator->animation_updated.connect(sigc::mem_fun(this, &PanelMenuView::OnFadeOutChanged));
-  _fade_out_animator->animation_ended.connect(sigc::mem_fun(this, &PanelMenuView::FullRedraw));
+  _titlebar_grab_area->mouse_enter.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseEnter));
+  _titlebar_grab_area->mouse_leave.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseLeave));
+
+  _ubus_manager.RegisterInterest(UBUS_SWITCHER_SHOWN, sigc::mem_fun(this, &PanelMenuView::OnSwitcherShown));
+  _ubus_manager.RegisterInterest(UBUS_SWITCHER_SELECTION_CHANGED, sigc::mem_fun(this, &PanelMenuView::OnSwitcherSelectionChanged));
+
+  _ubus_manager.RegisterInterest(UBUS_LAUNCHER_START_KEY_NAV, sigc::mem_fun(this, &PanelMenuView::OnLauncherKeyNavStarted));
+  _ubus_manager.RegisterInterest(UBUS_LAUNCHER_END_KEY_NAV, sigc::mem_fun(this, &PanelMenuView::OnLauncherKeyNavEnded));
+  _ubus_manager.RegisterInterest(UBUS_LAUNCHER_START_KEY_SWTICHER, sigc::mem_fun(this, &PanelMenuView::OnLauncherKeyNavStarted));
+  _ubus_manager.RegisterInterest(UBUS_LAUNCHER_END_KEY_SWTICHER, sigc::mem_fun(this, &PanelMenuView::OnLauncherKeyNavEnded));
+  _ubus_manager.RegisterInterest(UBUS_LAUNCHER_SELECTION_CHANGED, sigc::mem_fun(this, &PanelMenuView::OnLauncherSelectionChanged));
+
+  _fade_in_animator.animation_updated.connect(sigc::mem_fun(this, &PanelMenuView::OnFadeInChanged));
+  _fade_in_animator.animation_ended.connect(sigc::mem_fun(this, &PanelMenuView::FullRedraw));
+  _fade_out_animator.animation_updated.connect(sigc::mem_fun(this, &PanelMenuView::OnFadeOutChanged));
+  _fade_out_animator.animation_ended.connect(sigc::mem_fun(this, &PanelMenuView::FullRedraw));
 
   SetOpacity(0.0f);
   _window_buttons->SetOpacity(0.0f);
@@ -198,41 +183,48 @@
   if (_new_app_hide_id)
     g_source_remove(_new_app_hide_id);
 
-  if (_title_layer)
-    delete _title_layer;
-
-  if (_fade_in_animator)
-    delete _fade_in_animator;
-
-  if (_fade_out_animator)
-    delete _fade_out_animator;
-
-  _menu_layout->UnReference();
   _window_buttons->UnReference();
-  _panel_titlebar_grab_area->UnReference();
-
-  UBusServer* ubus = ubus_server_get_default();
-  for (auto interest : _ubus_interests)
+  _titlebar_grab_area->UnReference();
+
+  _style_changed_connection.disconnect();
+}
+
+void PanelMenuView::OverlayShown()
+{
+  _overlay_showing = true;
+  QueueDraw();
+}
+
+void PanelMenuView::OverlayHidden()
+{
+  _overlay_showing = false;
+  QueueDraw();
+}
+
+void PanelMenuView::AddIndicator(indicator::Indicator::Ptr const& indicator)
+{
+  if (!GetIndicators().empty())
   {
-    if (interest != 0)
-      ubus_server_unregister_interest(ubus, interest);
+    LOG_ERROR(logger) << "PanelMenuView has already an indicator!";
+    return;
   }
+
+  PanelIndicatorsView::AddIndicator(indicator);
 }
 
-void
-PanelMenuView::SetMenuShowTimings(int fadein, int fadeout, int discovery,
-                                  int discovery_fadein, int discovery_fadeout)
+void PanelMenuView::SetMenuShowTimings(int fadein, int fadeout, int discovery,
+                                       int discovery_fadein, int discovery_fadeout)
 {
   if (fadein > -1)
   {
     _menus_fadein = fadein;
-    _fade_in_animator->SetDuration(_menus_fadein);
+    _fade_in_animator.SetDuration(_menus_fadein);
   }
 
   if (fadeout > -1)
   {
     _menus_fadeout = fadeout;
-    _fade_out_animator->SetDuration(_menus_fadeout);
+    _fade_out_animator.SetDuration(_menus_fadeout);
   }
 
   if (discovery > -1)
@@ -245,16 +237,13 @@
     _menus_discovery_fadeout = discovery_fadeout;
 }
 
-void
-PanelMenuView::FullRedraw()
+void PanelMenuView::FullRedraw()
 {
-  _menu_layout->NeedRedraw();
-  _window_buttons->NeedRedraw();
-  NeedRedraw();
+  QueueDraw();
+  _window_buttons->QueueDraw();
 }
 
-nux::Area*
-PanelMenuView::FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type)
+nux::Area* PanelMenuView::FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type)
 {
   bool mouse_inside = TestMousePointerInclusionFilterMouseWheel(mouse_position, event_type);
 
@@ -262,80 +251,59 @@
     return nullptr;
 
   Area* found_area = nullptr;
+
+  if (_overlay_showing)
+  {
+    if (_window_buttons)
+      return _window_buttons->FindAreaUnderMouse(mouse_position, event_type);
+  }
+
   if (!_we_control_active)
   {
-    found_area = _panel_titlebar_grab_area->FindAreaUnderMouse(mouse_position, event_type);
-    NUX_RETURN_VALUE_IF_NOTNULL(found_area, found_area);
+    /* When the current panel is not active, it all behaves like a grab-area */
+    if (GetAbsoluteGeometry().IsInside(mouse_position))
+      return _titlebar_grab_area;
   }
 
-  if (_is_maximized || _places_showing)
+  if (_is_maximized)
   {
     if (_window_buttons)
     {
       found_area = _window_buttons->FindAreaUnderMouse(mouse_position, event_type);
       NUX_RETURN_VALUE_IF_NOTNULL(found_area, found_area);
     }
-
-    if (_panel_titlebar_grab_area)
-    {
-      found_area = _panel_titlebar_grab_area->FindAreaUnderMouse(mouse_position, event_type);
-      NUX_RETURN_VALUE_IF_NOTNULL(found_area, found_area);
-    }
-  }
-
-  if (_panel_titlebar_grab_area)
-  {
-    found_area = _panel_titlebar_grab_area->FindAreaUnderMouse(mouse_position, event_type);
-    NUX_RETURN_VALUE_IF_NOTNULL(found_area, found_area);
-  }
-
-  if (!_is_own_window)
-  {
-    found_area = _menu_layout->FindAreaUnderMouse(mouse_position, event_type);
-    NUX_RETURN_VALUE_IF_NOTNULL(found_area, found_area);
-  }
-
-  return View::FindAreaUnderMouse(mouse_position, event_type);
+  }
+
+  if (_titlebar_grab_area && !_overlay_showing)
+  {
+    found_area = _titlebar_grab_area->FindAreaUnderMouse(mouse_position, event_type);
+    NUX_RETURN_VALUE_IF_NOTNULL(found_area, found_area);
+  }
+
+  return PanelIndicatorsView::FindAreaUnderMouse(mouse_position, event_type);
 }
 
-long PanelMenuView::PostLayoutManagement(long LayoutResult)
+void PanelMenuView::PreLayoutManagement()
 {
-  long res = View::PostLayoutManagement(LayoutResult);
-  int old_window_buttons_w, new_window_buttons_w;
-  int old_menu_area_w, new_menu_area_w;
-
-  nux::Geometry geo = GetGeometry();
-
-  int h_padding = _padding - 2;
-  int v_padding = 1;
-
-  old_window_buttons_w = _window_buttons->GetContentWidth();
-  _window_buttons->SetGeometry(geo.x + h_padding, geo.y + v_padding, old_window_buttons_w, geo.height);
+  PanelIndicatorsView::PreLayoutManagement();
+  nux::Geometry const& geo = GetGeometry();
+
   _window_buttons->ComputeContentSize();
-  new_window_buttons_w = _window_buttons->GetContentWidth();
-
-  /* Explicitly set the size and position of the widgets */
-  geo.x += h_padding + new_window_buttons_w + h_padding;
-  geo.width -= h_padding + new_window_buttons_w + h_padding;
-
-  old_menu_area_w = _menu_layout->GetContentWidth();
-  _menu_layout->SetGeometry(geo.x, geo.y, old_menu_area_w, geo.height);
-  _menu_layout->ComputeContentSize();
-  new_menu_area_w = _menu_layout->GetContentWidth();
-
-  geo.x += new_menu_area_w;
-  geo.width -= new_menu_area_w;
-
-  _panel_titlebar_grab_area->SetGeometry(geo.x, geo.y, geo.width, geo.height);
-
-  if (_is_inside)
-    NeedRedraw();
-
-  return res;
+  int buttons_diff = geo.height - _window_buttons->GetContentHeight();
+  _window_buttons->SetBaseY(buttons_diff > 0 ? std::ceil(buttons_diff/2.0f) : 0);
+
+  layout_->ComputeContentSize();
+  int layout_width = layout_->GetContentWidth();
+
+  _titlebar_grab_area->SetBaseX(layout_width);
+  _titlebar_grab_area->SetBaseHeight(geo.height);
+  _titlebar_grab_area->SetMinimumWidth(geo.width - layout_width);
+  _titlebar_grab_area->SetMaximumWidth(geo.width - layout_width);
+
+  SetMaximumEntriesWidth(geo.width - _window_buttons->GetContentWidth());
 }
 
-void
-PanelMenuView::OnFadeInChanged(double opacity)
+void PanelMenuView::OnFadeInChanged(double opacity)
 {
   if (DrawMenus() && GetOpacity() != 1.0f)
     SetOpacity(opacity);
@@ -343,11 +311,10 @@
   if (DrawWindowButtons() && _window_buttons->GetOpacity() != 1.0f)
     _window_buttons->SetOpacity(opacity);
 
-  NeedRedraw();
+  QueueDraw();
 }
 
-void
-PanelMenuView::OnFadeOutChanged(double progress)
+void PanelMenuView::OnFadeOutChanged(double progress)
 {
   double opacity = CLAMP(1.0f - progress, 0.0f, 1.0f);
 
@@ -357,13 +324,16 @@
   if (!DrawWindowButtons() && _window_buttons->GetOpacity() != 0.0f)
     _window_buttons->SetOpacity(opacity);
 
-  NeedRedraw();
+  QueueDraw();
 }
 
-bool
-PanelMenuView::DrawMenus()
+bool PanelMenuView::DrawMenus() const
 {
-  if (!_is_own_window && !_places_showing && _we_control_active && !_switcher_showing)
+  auto wm = WindowManager::Default();
+  bool screen_grabbed = (wm->IsExpoActive() || wm->IsScaleActive());
+
+  if (_we_control_active && !_overlay_showing && !screen_grabbed &&
+      !_switcher_showing && !_launcher_keynav)
   {
     if (_is_inside || _last_active_view || _show_now_activated || _new_application)
     {
@@ -374,13 +344,16 @@
   return false;
 }
 
-bool
-PanelMenuView::DrawWindowButtons()
+bool PanelMenuView::DrawWindowButtons() const
 {
-  if (_places_showing)
+  auto wm = WindowManager::Default();
+  bool screen_grabbed = (wm->IsExpoActive() || wm->IsScaleActive());
+
+  if (_overlay_showing)
     return true;
 
-  if (!_is_own_window && _we_control_active && _is_maximized && !_switcher_showing)
+  if (_we_control_active && _is_maximized && !screen_grabbed &&
+      !_launcher_keynav && !_switcher_showing)
   {
     if (_is_inside || _show_now_activated || _new_application)
     {
@@ -391,19 +364,18 @@
   return false;
 }
 
-void
-PanelMenuView::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+void PanelMenuView::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
-  nux::Geometry geo = GetGeometry();
-  int button_width = _padding + _window_buttons->GetContentWidth() + _padding;
-  float factor = 4;
+  nux::Geometry const& geo = GetGeometry();
+  int button_width = _window_buttons->GetContentWidth();
+  const float factor = 4;
   button_width /= factor;
 
-  if (geo.width != _last_width || geo.height != _last_height)
+  if (geo != _last_geo)
   {
-    _last_width = geo.width;
-    _last_height = geo.height;
-    Refresh();
+    _last_geo = geo;
+    QueueRelayout();
+    Refresh(true);
   }
 
   GfxContext.PushClippingRectangle(geo);
@@ -417,7 +389,7 @@
   nux::ColorLayer layer(nux::Color(0x00000000), true, rop);
   nux::GetPainter().PushDrawLayer(GfxContext, GetGeometry(), &layer);
 
-  if (_title_layer && !_is_own_window)
+  if (_title_texture)
   {
     guint blend_alpha = 0, blend_src = 0, blend_dest = 0;
     bool draw_menus = DrawMenus();
@@ -429,7 +401,7 @@
 
     for (auto entry : entries_)
     {
-      if (entry.second->IsEntryValid())
+      if (entry.second->IsVisible())
       {
         has_menu = true;
         break;
@@ -542,20 +514,22 @@
                              geo.width, geo.height,
                              _gradient_texture, texxform0,
                              nux::color::White,
-                             _title_layer->GetDeviceTexture(),
+                             _title_texture->GetDeviceTexture(),
                              texxform1,
                              nux::color::White);
     }
-    else if (!_places_showing)
+    else if (!_overlay_showing)
     {
+      double title_opacity = 0.0f;
+
       if (_we_control_active && _window_buttons->GetOpacity() == 0.0 &&
           (!has_menu || (has_menu && GetOpacity() == 0.0)))
       {
-        nux::GetPainter().PushDrawLayer(GfxContext, geo, _title_layer);
+        title_opacity = 1.0f;
       }
       else
       {
-        double title_opacity = 1.0f;
+        title_opacity = 1.0f;
 
         if (has_menu)
           title_opacity -= MAX(GetOpacity(), _window_buttons->GetOpacity());
@@ -572,10 +546,13 @@
           // If we're fading-in the buttons/menus, let's fade-out quickly the title
           title_opacity = CLAMP(title_opacity - 0.2f, 0.0f, 1.0f);
         }
+      }
 
+      if (title_opacity > 0.0f)
+      {
         nux::TexCoordXForm texxform;
         GfxContext.QRP_1Tex(geo.x, geo.y, geo.width, geo.height,
-                            _title_layer->GetDeviceTexture(), texxform,
+                            _title_texture->GetDeviceTexture(), texxform,
                             nux::color::White * title_opacity);
       }
     }
@@ -588,10 +565,9 @@
   GfxContext.PopClippingRectangle();
 }
 
-void
-PanelMenuView::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
+void PanelMenuView::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
-  nux::Geometry geo = GetGeometry();
+  nux::Geometry const& geo = GetGeometry();
   bool draw_menus = DrawMenus();
   bool draw_buttons = DrawWindowButtons();
 
@@ -602,17 +578,17 @@
     for (auto entry : entries_)
       entry.second->SetDisabled(false);
 
-    _menu_layout->ProcessDraw(GfxContext, true);
+    layout_->ProcessDraw(GfxContext, true);
 
-    _fade_out_animator->Stop();
+    _fade_out_animator.Stop();
 
     if (_new_application && !_is_inside)
     {
-      _fade_in_animator->Start(_menus_discovery_fadein, GetOpacity());
+      _fade_in_animator.Start(_menus_discovery_fadein, GetOpacity());
     }
     else
     {
-      _fade_in_animator->Start(GetOpacity());
+      _fade_in_animator.Start(GetOpacity());
       _new_app_menu_shown = false;
     }
   }
@@ -622,19 +598,19 @@
       entry.second->SetDisabled(true);
   }
 
-  if (GetOpacity() != 0.0f && !draw_menus)
+  if (GetOpacity() != 0.0f && !draw_menus && !_overlay_showing)
   {
-    _menu_layout->ProcessDraw(GfxContext, true);
+    layout_->ProcessDraw(GfxContext, true);
 
-    _fade_in_animator->Stop();
+    _fade_in_animator.Stop();
 
     if (!_new_app_menu_shown)
     {
-      _fade_out_animator->Start(1.0f - GetOpacity());
+      _fade_out_animator.Start(1.0f - GetOpacity());
     }
     else
     {
-      _fade_out_animator->Start(_menus_discovery_fadeout, 1.0f - GetOpacity());
+      _fade_out_animator.Start(_menus_discovery_fadeout, 1.0f - GetOpacity());
     }
   }
 
@@ -642,299 +618,260 @@
   {
     _window_buttons->ProcessDraw(GfxContext, true);
 
-    _fade_out_animator->Stop();
-    _fade_in_animator->Start(_window_buttons->GetOpacity());
+    if (_window_buttons->GetOpacity() != 1.0f)
+    {
+      _fade_out_animator.Stop();
+      _fade_in_animator.Start(_window_buttons->GetOpacity());
+    }
   }
 
   if (_window_buttons->GetOpacity() != 0.0f && !draw_buttons)
   {
     _window_buttons->ProcessDraw(GfxContext, true);
-    _fade_in_animator->Stop();
+    _fade_in_animator.Stop();
 
     /* If we try to hide only the buttons, then use a faster fadeout */
-    if (!_fade_out_animator->IsRunning())
+    if (!_fade_out_animator.IsRunning())
     {
-      _fade_out_animator->Start(_menus_fadeout/3, 1.0f - _window_buttons->GetOpacity());
+      _fade_out_animator.Start(_menus_fadeout/3, 1.0f - _window_buttons->GetOpacity());
     }
   }
 
   GfxContext.PopClippingRectangle();
 }
 
-gchar*
-PanelMenuView::GetActiveViewName()
+std::string PanelMenuView::GetActiveViewName(bool use_appname) const
 {
-  gchar*         label = nullptr;
-  BamfWindow*    window;
-
-  _is_own_window = false;
+  std::string label;
+  BamfWindow* window;
 
   window = bamf_matcher_get_active_window(_matcher);
+
   if (BAMF_IS_WINDOW(window))
   {
+    BamfView *view = reinterpret_cast<BamfView*>(window);
     std::vector<Window> const& our_xids = nux::XInputWindow::NativeHandleList();
-    guint32 window_xid = bamf_window_get_xid(BAMF_WINDOW(window));
+    Window window_xid = bamf_window_get_xid(window);
 
     if (std::find(our_xids.begin(), our_xids.end(), window_xid) != our_xids.end())
     {
-      _is_own_window = true;
-      return g_strdup("");
-    }
-
-    if (BAMF_IS_WINDOW(window) &&
-        bamf_window_get_window_type(window) == BAMF_WINDOW_DESKTOP)
-    {
-      label = g_strdup(_("Ubuntu Desktop"));
-    }
-    else if (!WindowManager::Default()->IsWindowOnCurrentDesktop(window_xid) ||
-        WindowManager::Default()->IsWindowObscured(window_xid))
-    {
-       return g_strdup("");
-    }
-
-    if (_is_maximized)
-      label = bamf_view_get_name(BAMF_VIEW(window));
-  }
-
-  if (!label)
-  {
-    BamfApplication* app = bamf_matcher_get_active_application(_matcher);
-    if (BAMF_IS_APPLICATION(app))
-    {
-      const gchar*     filename;
-
-      filename = bamf_application_get_desktop_file(app);
-
-      if (filename && g_strcmp0(filename, "") != 0)
-      {
-        GDesktopAppInfo* info;
-
-        info = g_desktop_app_info_new_from_filename(bamf_application_get_desktop_file(app));
-
-        if (info)
-        {
-          label = g_strdup(g_app_info_get_display_name(G_APP_INFO(info)));
-          g_object_unref(info);
-        }
-        else
-        {
-          g_warning("Unable to get GDesktopAppInfo for %s",
-                    bamf_application_get_desktop_file(app));
-        }
-      }
-
-      if (label == nullptr)
-      {
-        BamfView* active_view;
-
-        active_view = (BamfView*)bamf_matcher_get_active_window(_matcher);
-        if (BAMF_IS_VIEW(active_view))
-          label = bamf_view_get_name(active_view);
-        else
-          label = g_strdup("");
-      }
-    }
-    else
-    {
-      label = g_strdup(" ");
-    }
-  }
-
-  char *escaped = g_markup_escape_text(label, -1);
-  g_free(label);
-  label = g_strdup_printf("<b>%s</b>", escaped);
-  g_free(escaped);
+      /* 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)
+    {
+      label = DESKTOP_NAME;
+    }
+    else if (!IsValidWindow(window_xid))
+    {
+       return "";
+    }
+
+    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();
+    }
+  }
 
   return label;
 }
 
-void PanelMenuView::DrawText(cairo_t *cr_real,
-                             int &x, int y, int width, int height,
-                             const char* font_desc,
-                             const char* label,
-                             int increase_size
-                             )
+void PanelMenuView::DrawTitle(cairo_t *cr_real, nux::Geometry const& geo, std::string const& label) const
 {
-  PangoLayout*          layout = nullptr;
-  PangoFontDescription* desc = nullptr;
-  GtkSettings*          settings = gtk_settings_get_default();
-  cairo_t*              cr;
-  cairo_pattern_t*      linpat;
-  GdkScreen*            screen = gdk_screen_get_default();
-  int                   dpi = 0;
-  const int             fading_pixels = 35;
-  char                 *font_description = g_strdup(font_desc);
-
-  int  text_width = 0;
-  int  text_height = 0;
-  int  text_space = 0;
-
-  {  // Find out dimensions first
-    GConfClient* client = gconf_client_get_default();
-    PangoContext* cxt;
-    PangoRectangle log_rect;
-
-    cr = _util_cg.GetContext();
-
-    g_object_get(settings, "gtk-xft-dpi", &dpi, nullptr);
-
-    font_description = gconf_client_get_string(client, WINDOW_TITLE_FONT_KEY.c_str(), nullptr);
-    desc = pango_font_description_from_string(font_description);
-
-    if (font_desc)
-    {
-      int size = pango_font_description_get_size(desc);
-      size /= pango_font_description_get_size_is_absolute(desc) ? 1 : PANGO_SCALE;
-
-      // Adjust y depending on size of the font
-      y -= ((unsigned int)(size - 9)) / 2;
-
-      size += increase_size;
-
-      char* description = g_strdup_printf("%s %d", font_desc, size);
-      pango_font_description_free(desc);
-      desc = pango_font_description_from_string(description);
-      g_free(description);
-    }
-
-    layout = pango_cairo_create_layout(cr);
-    pango_layout_set_font_description(layout, desc);
-    pango_layout_set_markup(layout, label, -1);
-
-    cxt = pango_layout_get_context(layout);
-    pango_cairo_context_set_font_options(cxt, gdk_screen_get_font_options(screen));
-    pango_cairo_context_set_resolution(cxt, (float)dpi / (float)PANGO_SCALE);
-    pango_layout_context_changed(layout);
-
-    pango_layout_get_extents(layout, nullptr, &log_rect);
-    text_width = log_rect.width / PANGO_SCALE;
-    text_height = log_rect.height / PANGO_SCALE;
-
-    pango_font_description_free(desc);
-    g_free(font_description);
-    cairo_destroy(cr);
-    g_object_unref(client);
-  }
-
-  { // Draw the text
-    GtkStyleContext* style_context = panel::Style::Instance().GetStyleContext();
-    text_space = width - x;
-    cr = cr_real;
-
-    gtk_style_context_save(style_context);
-
-    GtkWidgetPath* widget_path = gtk_widget_path_new();
-    gint pos = gtk_widget_path_append_type(widget_path, GTK_TYPE_WINDOW);
-    gtk_widget_path_iter_set_name(widget_path, pos, "UnityPanelWidget");
-    gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_BAR);
-    gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_ITEM);
-
-    gtk_style_context_set_path(style_context, widget_path);
-    gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
-    gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
-
-    y += (height - text_height) / 2;
-
-    pango_cairo_update_layout(cr, layout);
-
-    if (text_width > text_space)
-    {
-      int out_pixels = text_width - text_space;
-      int fading_width = out_pixels < fading_pixels ? out_pixels : fading_pixels;
-
-      cairo_push_group(cr);
-      gtk_render_layout(style_context, cr, x, y, layout);
-      cairo_pop_group_to_source(cr);
-
-      linpat = cairo_pattern_create_linear(width - fading_width, y, width, y);
-      cairo_pattern_add_color_stop_rgba(linpat, 0, 0, 0, 0, 1);
-      cairo_pattern_add_color_stop_rgba(linpat, 1, 0, 0, 0, 0);
-      cairo_mask(cr, linpat);
-
-      cairo_pattern_destroy(linpat);
-    }
-    else
-    {
-      gtk_render_layout(style_context, cr, x, y, layout);
-    }
-
-    x += text_width;
-
-    gtk_widget_path_free(widget_path);
-    gtk_style_context_restore(style_context);
-  }
-
-  if (layout)
-    g_object_unref(layout);
+  using namespace panel;
+  cairo_t* cr;
+  cairo_pattern_t* linpat;
+  const int fading_pixels = 35;
+  int x = MAIN_LEFT_PADDING + TITLE_PADDING + geo.x;
+  int y = geo.y;
+
+  int text_width = 0;
+  int text_height = 0;
+  int text_space = 0;
+
+  // Find out dimensions first
+  GdkScreen* screen = gdk_screen_get_default();
+  PangoContext* cxt;
+  PangoRectangle log_rect;
+  PangoFontDescription* desc;
+
+  nux::CairoGraphics util_cg(CAIRO_FORMAT_ARGB32, 1, 1);
+  cr = util_cg.GetContext();
+
+  int dpi = Style::Instance().GetTextDPI();
+
+  std::string font_description(Style::Instance().GetFontDescription(PanelItem::TITLE));
+  desc = pango_font_description_from_string(font_description.c_str());
+
+  glib::Object<PangoLayout> layout(pango_cairo_create_layout(cr));
+  pango_layout_set_font_description(layout, desc);
+  pango_layout_set_markup(layout, label.c_str(), -1);
+
+  cxt = pango_layout_get_context(layout);
+  pango_cairo_context_set_font_options(cxt, gdk_screen_get_font_options(screen));
+  pango_cairo_context_set_resolution(cxt, dpi / static_cast<float>(PANGO_SCALE));
+  pango_layout_context_changed(layout);
+
+  pango_layout_get_extents(layout, nullptr, &log_rect);
+  text_width = log_rect.width / PANGO_SCALE;
+  text_height = log_rect.height / PANGO_SCALE;
+
+  pango_font_description_free(desc);
+  cairo_destroy(cr);
+
+  // Draw the text
+  GtkStyleContext* style_context = Style::Instance().GetStyleContext();
+  text_space = geo.width - x;
+  cr = cr_real;
+  cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
+
+  gtk_style_context_save(style_context);
+
+  GtkWidgetPath* widget_path = gtk_widget_path_new();
+  gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_BAR);
+  gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_ITEM);
+  gtk_widget_path_iter_set_name(widget_path, -1 , "UnityPanelWidget");
+
+  gtk_style_context_set_path(style_context, widget_path);
+  gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
+  gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
+
+  y += (geo.height - text_height) / 2;
+
+  pango_cairo_update_layout(cr, layout);
+
+  if (text_width > text_space)
+  {
+    int out_pixels = text_width - text_space;
+    int fading_width = out_pixels < fading_pixels ? out_pixels : fading_pixels;
+
+    cairo_push_group(cr);
+    gtk_render_layout(style_context, cr, x, y, layout);
+    cairo_pop_group_to_source(cr);
+
+    linpat = cairo_pattern_create_linear(geo.width - fading_width, y, geo.width, y);
+    cairo_pattern_add_color_stop_rgba(linpat, 0, 0, 0, 0, 1);
+    cairo_pattern_add_color_stop_rgba(linpat, 1, 0, 0, 0, 0);
+    cairo_mask(cr, linpat);
+
+    cairo_pattern_destroy(linpat);
+  }
+  else
+  {
+    gtk_render_layout(style_context, cr, x, y, layout);
+  }
+
+  x += text_width;
+
+  gtk_widget_path_free(widget_path);
+  gtk_style_context_restore(style_context);
 }
 
-void
-PanelMenuView::Refresh()
+void PanelMenuView::Refresh(bool force)
 {
-  nux::Geometry         geo = GetGeometry();
+  nux::Geometry const& geo = GetGeometry();
 
   // We can get into a race that causes the geometry to be wrong as there hasn't been a
   // layout cycle before the first callback. This is to protect from that.
   if (geo.width > _monitor_geo.width)
     return;
 
-  int  x = 0;
-  int  y = 0;
-  int  width = geo.width;
-  int  height = geo.height;
-
-  nux::CairoGraphics cairo_graphics(CAIRO_FORMAT_ARGB32, width, height);
+  auto win_manager = WindowManager::Default();
+  std::string new_title;
+
+  if (win_manager->IsScaleActive())
+  {
+    if (win_manager->IsScaleActiveForGroup())
+      new_title = GetActiveViewName(true);
+    else if (_we_control_active)
+      new_title = DESKTOP_NAME;
+  }
+  else if (win_manager->IsExpoActive())
+  {
+    new_title = DESKTOP_NAME;
+  }
+  else if (!_we_control_active)
+  {
+    new_title = "";
+  }
+  else if (!_switcher_showing && !_launcher_keynav)
+  {
+    new_title = GetActiveViewName();
+    _window_buttons->SetControlledWindow(_active_xid);
+  }
+
+  if (!_switcher_showing && !_launcher_keynav)
+  {
+    if (_panel_title != new_title)
+    {
+      _panel_title = new_title;
+    }
+    else if (!force && _last_geo == geo && _title_texture)
+    {
+      // No need to redraw the title, let's save some CPU time!
+      return;
+    }
+  }
+
+  if (_panel_title.empty())
+  {
+    _title_texture = nullptr;
+    return;
+  }
+
+  nux::CairoGraphics cairo_graphics(CAIRO_FORMAT_ARGB32, geo.width, geo.height);
   cairo_t* cr = cairo_graphics.GetContext();
-  cairo_set_line_width(cr, 1);
 
   cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
   cairo_paint(cr);
 
-  cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
-
-  x = _padding;
-  y = 0;
-
-  if (_panel_title)
-  {
-    DrawText(cr, x, y, width, height, nullptr, _panel_title);
-  }
-  else
-  {
-    char* title = GetActiveViewName();
-    DrawText(cr, x, y, width, height, nullptr, title);
-    g_free(title);
-  }
+  glib::String escaped(g_markup_escape_text(_panel_title.c_str(), -1));
+
+  std::ostringstream bold_label;
+  bold_label << "<b>" << escaped.Str() << "</b>";
+
+  DrawTitle(cr, geo, bold_label.str());
 
   cairo_destroy(cr);
 
-  nux::BaseTexture* texture2D = texture_from_cairo_graphics(cairo_graphics);
-
-  if (_title_layer)
-    delete _title_layer;
-
-  nux::TexCoordXForm texxform;
-  texxform.SetTexCoordType(nux::TexCoordXForm::OFFSET_COORD);
-  texxform.SetWrap(nux::TEXWRAP_REPEAT, nux::TEXWRAP_REPEAT);
-
-  nux::ROPConfig rop;
-  rop.Blend = true;
-  rop.SrcBlend = GL_ONE;
-  rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
-  _title_layer = new nux::TextureLayer(texture2D->GetDeviceTexture(),
-                                       texxform,
-                                       nux::color::White,
-                                       true,
-                                       rop);
-  texture2D->UnReference();
+  _title_texture = texture_ptr_from_cairo_graphics(cairo_graphics);
 }
 
-void
-PanelMenuView::OnActiveChanged(PanelIndicatorEntryView* view,
-                               bool                           is_active)
+void PanelMenuView::OnActiveChanged(PanelIndicatorEntryView* view, bool is_active)
 {
   if (is_active)
+  {
     _last_active_view = view;
+  }
   else
   {
     if (_last_active_view == view)
@@ -947,37 +884,36 @@
   FullRedraw();
 }
 
-void
-PanelMenuView::OnEntryAdded(unity::indicator::Entry::Ptr const& entry)
+void PanelMenuView::OnEntryAdded(indicator::Entry::Ptr const& entry)
 {
-  auto view = AddEntry(entry, 6, IndicatorEntryPosition::END, IndicatorEntryType::MENU);
+  PanelIndicatorEntryView* view;
+
+  view = new PanelIndicatorEntryView(entry, MENU_ENTRIES_PADDING, IndicatorEntryType::MENU);
+  view->mouse_enter.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseEnter));
+  view->mouse_leave.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseLeave));
 
   entry->show_now_changed.connect(sigc::mem_fun(this, &PanelMenuView::UpdateShowNow));
-
   view->active_changed.connect(sigc::mem_fun(this, &PanelMenuView::OnActiveChanged));
-  view->mouse_enter.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseEnter));
-  view->mouse_leave.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseLeave));
+
+  AddEntryView(view, IndicatorEntryPosition::END);
 }
 
-void
-PanelMenuView::AllMenusClosed()
+void PanelMenuView::NotifyAllMenusClosed()
 {
-  auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-  _is_inside = GetAbsoluteGeometry().IsPointInside(mouse.x, mouse.y);
   _last_active_view = nullptr;
 
+  auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
+  _is_inside = GetAbsoluteGeometry().IsInside(mouse);
   FullRedraw();
 }
 
-void
-PanelMenuView::OnNameChanged(BamfView* bamf_view, gchar* new_name, gchar* old_name)
+void PanelMenuView::OnNameChanged(BamfView* bamf_view, gchar* new_name, gchar* old_name)
 {
   Refresh();
   FullRedraw();
 }
 
-gboolean
-PanelMenuView::OnNewAppShow(PanelMenuView* self)
+gboolean PanelMenuView::OnNewAppShow(PanelMenuView* self)
 {
   BamfApplication* active_app = bamf_matcher_get_active_application(self->_matcher);
   self->_new_application = glib::Object<BamfApplication>(active_app, glib::AddRef());
@@ -998,10 +934,9 @@
   return FALSE;
 }
 
-gboolean
-PanelMenuView::OnNewAppHide(PanelMenuView* self)
+gboolean PanelMenuView::OnNewAppHide(PanelMenuView* self)
 {
-  self->OnViewClosed(self->_matcher, BAMF_VIEW(self->_new_application.RawPtr()));
+  self->OnApplicationClosed(self->_new_application);
   self->_new_app_hide_id = 0;
   self->_new_app_menu_shown = true;
   self->QueueDraw();
@@ -1009,8 +944,7 @@
   return FALSE;
 }
 
-void
-PanelMenuView::OnViewOpened(BamfMatcher *matcher, BamfView *view)
+void PanelMenuView::OnViewOpened(BamfMatcher *matcher, BamfView *view)
 {
   /* 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
@@ -1021,27 +955,48 @@
   _new_apps.push_front(glib::Object<BamfApplication>(BAMF_APPLICATION(view), glib::AddRef()));
 }
 
-void
-PanelMenuView::OnViewClosed(BamfMatcher *matcher, BamfView *view)
+void PanelMenuView::OnApplicationClosed(BamfApplication* app)
 {
-  if (!BAMF_IS_APPLICATION(view))
-    return;
-
-  BamfApplication* app = BAMF_APPLICATION(view);
-
-  if (std::find(_new_apps.begin(), _new_apps.end(), app) != _new_apps.end())
+  if (BAMF_IS_APPLICATION(app))
   {
-    _new_apps.remove(glib::Object<BamfApplication>(app, glib::AddRef()));
-
-    if (_new_application == app || _new_apps.empty())
+    if (std::find(_new_apps.begin(), _new_apps.end(), app) != _new_apps.end())
+    {
+      _new_apps.remove(glib::Object<BamfApplication>(app, glib::AddRef()));
+    }
+    else if (_new_apps.empty())
+    {
       _new_application = nullptr;
-  }
-}
-
-void
-PanelMenuView::OnActiveAppChanged(BamfMatcher *matcher,
-                                  BamfApplication* old_app,
-                                  BamfApplication* new_app)
+    }
+  }
+
+  if (app == _new_application)
+  {
+    _new_application = nullptr;
+  }
+}
+
+void PanelMenuView::OnViewClosed(BamfMatcher *matcher, BamfView *view)
+{
+  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))
   {
@@ -1078,15 +1033,14 @@
       }
 
       if (_new_application)
-        OnViewClosed(matcher, BAMF_VIEW(_new_application.RawPtr()));
+        OnApplicationClosed(_new_application);
     }
   }
 }
 
-void
-PanelMenuView::OnActiveWindowChanged(BamfMatcher *matcher,
-                                     BamfView* old_view,
-                                     BamfView* new_view)
+void PanelMenuView::OnActiveWindowChanged(BamfMatcher *matcher,
+                                          BamfView* old_view,
+                                          BamfView* new_view)
 {
   _show_now_activated = false;
   _is_maximized = false;
@@ -1100,15 +1054,16 @@
 
   if (BAMF_IS_WINDOW(new_view))
   {
-    BamfWindow* window = BAMF_WINDOW(new_view);
-    guint32 xid = _active_xid = bamf_window_get_xid(window);
-    _is_maximized = WindowManager::Default()->IsWindowMaximized(xid);
-    nux::Geometry geo = WindowManager::Default()->GetWindowGeometry(xid);
+    WindowManager *wm = WindowManager::Default();
+    BamfWindow* window = reinterpret_cast<BamfWindow*>(new_view);
+    guint32 xid = bamf_window_get_xid(window);
+    _active_xid = xid;
+    _is_maximized = wm->IsWindowMaximized(xid);
 
     if (bamf_window_get_window_type(window) == BAMF_WINDOW_DESKTOP)
       _we_control_active = true;
     else
-      _we_control_active = UScreen::GetDefault()->GetMonitorGeometry(_monitor).IsPointInside(geo.x + (geo.width / 2), geo.y);
+      _we_control_active = IsWindowUnderOurControl(xid);
 
     if (_decor_map.find(xid) == _decor_map.end())
     {
@@ -1117,9 +1072,9 @@
       // if we've just started tracking this window and it is maximized, let's
       // make sure it's undecorated just in case it slipped by us earlier
       // (I'm looking at you, Chromium!)
-      if (_is_maximized && WindowManager::Default ()->IsWindowDecorated(xid))
+      if (_is_maximized && wm->IsWindowDecorated(xid))
       {
-        WindowManager::Default()->Undecorate(xid);
+        wm->Undecorate(xid);
         _maximized_set.insert(xid);
       }
     }
@@ -1130,103 +1085,128 @@
     // register callback for new view
     _view_name_changed_signal.Connect(new_view, "name-changed",
                                       sigc::mem_fun(this, &PanelMenuView::OnNameChanged));
+
+    _window_buttons->SetControlledWindow(_is_maximized ? _active_xid : 0);
   }
 
   Refresh();
   FullRedraw();
 }
 
-void
-PanelMenuView::OnSpreadInitiate()
-{
-  /*foreach (guint32 &xid, windows)
-  {
-    if (WindowManager::Default ()->IsWindowMaximized (xid))
-      WindowManager::Default ()->Decorate (xid);
-  }*/
-}
-
-void
-PanelMenuView::OnSpreadTerminate()
-{
-  /*foreach (guint32 &xid, windows)
-  {
-    if (WindowManager::Default ()->IsWindowMaximized (xid))
-      WindowManager::Default ()->Undecorate (xid);
-  }*/
-}
-
-void
-PanelMenuView::OnWindowMinimized(guint32 xid)
-{
-  if (WindowManager::Default()->IsWindowMaximized(xid))
-  {
-    WindowManager::Default()->Decorate(xid);
-    _maximized_set.erase(xid);
-  }
-}
-
-void
-PanelMenuView::OnWindowUnminimized(guint32 xid)
-{
-  if (WindowManager::Default()->IsWindowMaximized(xid))
-  {
-    WindowManager::Default()->Undecorate(xid);
-    _maximized_set.insert(xid);
-  }
-}
-
-void
-PanelMenuView::OnWindowUnmapped(guint32 xid)
-{
-  if (WindowManager::Default()->IsWindowMaximized(xid))
-  {
-    WindowManager::Default()->Decorate(xid);
-    _maximized_set.erase(xid);
-  }
-}
-
-void
-PanelMenuView::OnWindowMapped(guint32 xid)
-{
-  if (WindowManager::Default()->IsWindowMaximized(xid))
-  {
-    WindowManager::Default()->Undecorate(xid);
-    _maximized_set.insert(xid);
-  }
-}
-
-void
-PanelMenuView::OnWindowDecorated(guint32 xid)
+void PanelMenuView::OnSpreadInitiate()
+{
+  /*foreach (guint32 &xid, windows)
+  {
+    if (WindowManager::Default()->IsWindowMaximized(xid))
+      WindowManager::Default()->Decorate(xid);
+  }*/
+
+  Refresh();
+  QueueDraw();
+}
+
+void PanelMenuView::OnSpreadTerminate()
+{
+  /*foreach (guint32 &xid, windows)
+  {
+    if (WindowManager::Default()->IsWindowMaximized(xid))
+      WindowManager::Default()->Undecorate(xid);
+  }*/
+
+  Refresh();
+  QueueDraw();
+}
+
+void PanelMenuView::OnExpoInitiate()
+{
+  Refresh();
+  QueueDraw();
+}
+
+void PanelMenuView::OnExpoTerminate()
+{
+  Refresh();
+  QueueDraw();
+}
+
+void PanelMenuView::OnWindowMinimized(guint32 xid)
+{
+  if (WindowManager::Default()->IsWindowMaximized(xid))
+  {
+    WindowManager::Default()->Decorate(xid);
+    _maximized_set.erase(xid);
+
+    Refresh();
+    QueueDraw();
+  }
+}
+
+void PanelMenuView::OnWindowUnminimized(guint32 xid)
+{
+  if (WindowManager::Default()->IsWindowMaximized(xid))
+  {
+    WindowManager::Default()->Undecorate(xid);
+    _maximized_set.insert(xid);
+
+    Refresh();
+    QueueDraw();
+  }
+}
+
+void PanelMenuView::OnWindowUnmapped(guint32 xid)
+{
+  // FIXME: compiz doesn't give us a valid xid (is always 0 on unmap)
+  // we need to do this again on BamfView closed signal.
+  if (_maximized_set.find(xid) != _maximized_set.end())
+  {
+    WindowManager::Default()->Decorate(xid);
+    _maximized_set.erase(xid);
+    _decor_map.erase(xid);
+
+    Refresh();
+    QueueDraw();
+  }
+}
+
+void PanelMenuView::OnWindowMapped(guint32 xid)
+{
+  if (WindowManager::Default()->IsWindowMaximized(xid))
+  {
+    WindowManager::Default()->Undecorate(xid);
+    _maximized_set.insert(xid);
+
+    Refresh();
+    QueueDraw();
+  }
+}
+
+void PanelMenuView::OnWindowDecorated(guint32 xid)
 {
   _decor_map[xid] = true;
 
   if (_maximized_set.find(xid) != _maximized_set.end ())
   {
-    WindowManager::Default ()->Undecorate(xid);
+    WindowManager::Default()->Undecorate(xid);
   }
 }
 
-void
-PanelMenuView::OnWindowUndecorated(guint32 xid)
+void PanelMenuView::OnWindowUndecorated(guint32 xid)
 {
   _decor_map[xid] = false;
 }
 
-void
-PanelMenuView::OnWindowMaximized(guint xid)
+void PanelMenuView::OnWindowMaximized(guint xid)
 {
-  BamfWindow* window;
   bool updated = false;
+  bool is_active = (_active_xid == xid);
 
-  window = bamf_matcher_get_active_window(_matcher);
-  if (BAMF_IS_WINDOW(window) && bamf_window_get_xid(window) == xid)
+  if (is_active)
   {
+    // We need to update the _is_inside state in the case of maximization by grab
+    auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
+    _is_inside = GetAbsoluteGeometry().IsInside(mouse);
+
     _is_maximized = true;
-
-    // We need to update the _is_inside state in the case of maximization by grab
-    auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-    _is_inside = GetAbsoluteGeometry().IsPointInside(mouse.x, mouse.y);
     updated = true;
   }
 
@@ -1245,16 +1225,12 @@
   }
 }
 
-void
-PanelMenuView::OnWindowRestored(guint xid)
+void PanelMenuView::OnWindowRestored(guint xid)
 {
-  BamfWindow* window;
-
   if (_maximized_set.find(xid) == _maximized_set.end())
     return;
 
-  window = bamf_matcher_get_active_window(_matcher);
-  if (BAMF_IS_WINDOW(window) && bamf_window_get_xid(window) == xid)
+  if (_active_xid == xid)
   {
     _is_maximized = false;
     _is_grabbed = false;
@@ -1269,193 +1245,272 @@
   FullRedraw();
 }
 
-gboolean
-PanelMenuView::UpdateActiveWindowPosition(PanelMenuView* self)
+gboolean PanelMenuView::UpdateActiveWindowPosition(PanelMenuView* self)
 {
-  auto window_geo = WindowManager::Default()->GetWindowGeometry(self->_active_xid);
-  auto monitor_geo = UScreen::GetDefault()->GetMonitorGeometry(self->_monitor);
-  auto intersect = monitor_geo.Intersect(window_geo);
-
-  self->_we_control_active = (intersect.width > window_geo.width/4 &&
-                              intersect.height > window_geo.height/4);
+  bool we_control_window = self->IsWindowUnderOurControl(self->_active_xid);
+
+  if (we_control_window != self->_we_control_active)
+  {
+    self->_we_control_active = we_control_window;
+
+    self->Refresh();
+    self->QueueDraw();
+  }
 
   self->_active_moved_id = 0;
-  self->QueueDraw();
 
   return FALSE;
 }
 
-void
-PanelMenuView::OnWindowMoved(guint xid)
+void PanelMenuView::OnWindowMoved(guint xid)
 {
   if (_active_xid == xid)
   {
-    if (_active_moved_id)
-      g_source_remove(_active_moved_id);
-
-    if (!_we_control_active)
-      UpdateActiveWindowPosition(this);
-    else
-      _active_moved_id = g_timeout_add(250, (GSourceFunc)PanelMenuView::UpdateActiveWindowPosition, this);
-  }
-}
-
-void
-PanelMenuView::OnCloseClicked()
-{
-  if (_places_showing)
-  {
-    ubus_server_send_message(ubus_server_get_default(), UBUS_PLACE_VIEW_CLOSE_REQUEST, nullptr);
-  }
-  else
-  {
-    BamfWindow* window;
-
-    window = bamf_matcher_get_active_window(_matcher);
-    if (BAMF_IS_WINDOW(window))
-    {
-      WindowManager::Default()->Close(bamf_window_get_xid(window));
-      NeedRedraw();
-    }
-  }
-}
-
-void
-PanelMenuView::OnMinimizeClicked()
-{
-  if (_places_showing)
-  {
-    // no action when dash is opened, LP bug #838875
-    return;
-  }
-  else
-  {
-    BamfWindow* window;
-
-    window = bamf_matcher_get_active_window(_matcher);
-    if (BAMF_IS_WINDOW(window))
-    {
-      WindowManager::Default()->Minimize(bamf_window_get_xid(window));
-      NeedRedraw();
-    }
-  }
-}
-
-void
-PanelMenuView::OnRestoreClicked()
-{
-  if (_places_showing)
-  {
-    if (dash::Settings::Instance().GetFormFactor() == dash::FormFactor::DESKTOP)
-      dash::Settings::Instance().SetFormFactor(dash::FormFactor::NETBOOK);
-    else
-      dash::Settings::Instance().SetFormFactor(dash::FormFactor::DESKTOP);
-  }
-  else
-  {
-    BamfWindow* window;
-
-    window = bamf_matcher_get_active_window(_matcher);
-    if (BAMF_IS_WINDOW(window))
-    {
-      WindowManager::Default()->Restore(bamf_window_get_xid(window));
-      NeedRedraw();
-    }
-  }
-}
-
-guint32
-PanelMenuView::GetMaximizedWindow()
-{
-  guint32 window_xid = 0;
-  nux::Geometry monitor =  UScreen::GetDefault()->GetMonitorGeometry(_monitor);
+    /* 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
+     * every few millisecond we check the new window position */
+
+    unsigned int timeout = 250;
+
+    if (_we_control_active)
+    {
+      if (_active_moved_id)
+        g_source_remove(_active_moved_id);
+    }
+    else
+    {
+      timeout = 60;
+
+      if (_active_moved_id)
+        return;
+    }
+
+    _active_moved_id = g_timeout_add(timeout, (GSourceFunc)UpdateActiveWindowPosition, this);
+  }
+}
+
+bool PanelMenuView::IsWindowUnderOurControl(Window xid) const
+{
+  if (UScreen::GetDefault()->GetMonitors().size() > 1)
+  {
+    auto wm = WindowManager::Default();
+    nux::Geometry const& window_geo = wm->GetWindowGeometry(xid);
+    nux::Geometry const& intersect = _monitor_geo.Intersect(window_geo);
+
+    /* We only care of the horizontal window portion */
+    return (intersect.width > window_geo.width/2 && intersect.height > 0);
+  }
+
+  return true;
+}
+
+bool PanelMenuView::IsValidWindow(Window xid) const
+{
+  auto wm = WindowManager::Default();
+  std::vector<Window> const& our_xids = nux::XInputWindow::NativeHandleList();
+
+  if (wm->IsWindowOnCurrentDesktop(xid) && !wm->IsWindowObscured(xid) &&
+      wm->IsWindowVisible(xid) && IsWindowUnderOurControl(xid) &&
+      std::find(our_xids.begin(), our_xids.end(), xid) == our_xids.end())
+  {
+    return true;
+  }
+
+  return false;
+}
+
+Window PanelMenuView::GetMaximizedWindow() const
+{
+  Window window_xid = 0;
 
   // Find the front-most of the maximized windows we are controlling
   for (auto xid : _maximized_set)
   {
     // We can safely assume only the front-most is visible
-    if (WindowManager::Default()->IsWindowOnCurrentDesktop(xid)
-        && !WindowManager::Default()->IsWindowObscured(xid))
-    {
-      nux::Geometry geo = WindowManager::Default()->GetWindowGeometry(xid);
-      if (monitor.IsPointInside(geo.x + (geo.width / 2), geo.y))
+    if (IsValidWindow(xid))
+    {
+      window_xid = xid;
+      break;
+    }
+  }
+
+  return window_xid;
+}
+
+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)
+  {
+    if (!BAMF_IS_WINDOW(l->data))
+      continue;
+
+    Window xid = bamf_window_get_xid(static_cast<BamfWindow*>(l->data));
+    bool visible = bamf_view_user_visible(static_cast<BamfView*>(l->data));
+
+    if (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_xid = xid;
+        window = win;
         break;
       }
     }
-  }
-  return window_xid;
-}
-
-void
-PanelMenuView::OnMaximizedGrabStart(int x, int y, unsigned long button_flags, unsigned long)
-{
-  Window maximized_win;
-  if (nux::GetEventButton(button_flags) != 1 || _places_showing)
-    return;
-
-  // When Start dragging the panelmenu of a maximized window, change cursor
-  // to simulate the dragging, waiting to go out of the panel area.
-  //
-  // This is a workaround to avoid that the grid plugin would be fired
-  // showing the window shape preview effect. See bug #838923
-
-  maximized_win = GetMaximizedWindow ();
-
-  if (maximized_win != 0)
+
+    g_list_free(windows);
+  }
+
+  return window;
+}
+
+void PanelMenuView::OnMaximizedActivate(int x, int y)
+{
+  Window maximized = GetMaximizedWindow();
+
+  if (maximized != 0)
+  {
+    WindowManager::Default()->Activate(maximized);
+  }
+}
+
+void PanelMenuView::OnMaximizedRestore(int x, int y)
+{
+  if (_overlay_showing)
+    return;
+
+  Window maximized = GetMaximizedWindow();
+
+  if (maximized != 0)
+  {
+    WindowManager::Default()->Restore(maximized);
+    _is_inside = true;
+  }
+}
+
+void PanelMenuView::OnMaximizedLower(int x, int y)
+{
+  if (_overlay_showing)
+    return;
+
+  Window maximized = GetMaximizedWindow();
+
+  if (maximized != 0)
+  {
+    WindowManager::Default()->Lower(maximized);
+  }
+}
+
+void PanelMenuView::OnMaximizedGrabStart(int x, int y)
+{
+  /* When Start dragging the panelmenu of a maximized window, change cursor
+   * to simulate the dragging, waiting to go out of the panel area.
+   *
+   * 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();
+
+  if (maximized != 0)
   {
     /* Always activate the window in case it is on another monitor */
-    WindowManager::Default ()->Activate (maximized_win);
-    _panel_titlebar_grab_area->SetGrabbed(true);
+    WindowManager::Default()->Activate(maximized);
+    _titlebar_grab_area->SetGrabbed(true);
   }
 }
 
-void
-PanelMenuView::OnMaximizedGrabMove(int x, int y, int, int, unsigned long button_flags, unsigned long)
+void PanelMenuView::OnMaximizedGrabMove(int x, int y)
 {
-//  FIXME nux doesn't export it with drag event.
-//  if (nux::GetEventButton(button_flags) != 1)
-//    return;
-
-  // We use this, due to the problem above
-  if (!_panel_titlebar_grab_area->IsGrabbed())
-    return;
-
   auto panel = static_cast<nux::BaseWindow*>(GetTopLevelViewWindow());
 
   if (!panel)
     return;
 
-  x += _panel_titlebar_grab_area->GetAbsoluteX();
-  y += _panel_titlebar_grab_area->GetAbsoluteY();
-
-  guint32 window_xid = GetMaximizedWindow();
-
-  // When the drag goes out from the Panel, start the real movement.
-  //
-  // This is a workaround to avoid that the grid plugin would be fired
-  // showing the window shape preview effect. See bug #838923
-  if (window_xid != 0 && panel && !panel->GetAbsoluteGeometry().IsPointInside(x, y))
+  /* Adjusting the x, y coordinates to get the absolute values */
+  x += _titlebar_grab_area->GetAbsoluteX();
+  y += _titlebar_grab_area->GetAbsoluteY();
+
+  Window maximized = GetMaximizedWindow();
+
+  /* When the drag goes out from the Panel, start the real movement.
+   *
+   * This is a workaround to avoid that the grid plugin would be fired
+   * showing the window shape preview effect. See bug #838923 */
+  if (maximized != 0 && panel)
   {
-    _panel_titlebar_grab_area->SetGrabbed(false);
-
-    WindowManager::Default()->Activate(window_xid);
-    _is_inside = true;
-    _is_grabbed = true;
-    Refresh();
-    FullRedraw();
-    WindowManager::Default()->StartMove(window_xid, x, y);
+    nux::Geometry const& panel_geo = panel->GetAbsoluteGeometry();
+
+    if (!panel_geo.IsPointInside(x, y))
+    {
+      auto wm = WindowManager::Default();
+      nux::Geometry const& restored_geo = wm->GetWindowSavedGeometry(maximized);
+      nux::Geometry const& workarea_geo = wm->GetWorkAreaGeometry(maximized);
+
+      /* By default try to restore the window horizontally-centered respect to the
+       * pointer position, if it doesn't fit on that area try to keep it into the
+       * current workarea as much as possible, but giving priority to the left border
+       * that shouldn't be never put out of the workarea */
+      int restore_x = x - (restored_geo.width * x / panel_geo.width);
+      int restore_y = y;
+
+      if (restore_x + restored_geo.width > workarea_geo.x + workarea_geo.width)
+      {
+        restore_x = workarea_geo.x + workarea_geo.width - restored_geo.width;
+      }
+
+      if (restore_x < workarea_geo.x)
+      {
+        restore_x = workarea_geo.x;
+      }
+
+      wm->Activate(maximized);
+      wm->RestoreAt(maximized, restore_x, restore_y);
+
+      _is_inside = true;
+      _is_grabbed = true;
+      Refresh();
+      FullRedraw();
+
+      /* Ungrab the pointer and start the X move, to make the decorator handle it */
+      _titlebar_grab_area->SetGrabbed(false);
+      wm->StartMove(maximized, x, y);
+    }
   }
 }
 
-void
-PanelMenuView::OnMaximizedGrabEnd(int x, int y, unsigned long, unsigned long)
+void PanelMenuView::OnMaximizedGrabEnd(int x, int y)
 {
-  _panel_titlebar_grab_area->SetGrabbed(false);
+  _titlebar_grab_area->SetGrabbed(false);
 
-  x += _panel_titlebar_grab_area->GetAbsoluteX();
-  y += _panel_titlebar_grab_area->GetAbsoluteY();
+  x += _titlebar_grab_area->GetAbsoluteX();
+  y += _titlebar_grab_area->GetAbsoluteY();
   _is_inside = GetAbsoluteGeometry().IsPointInside(x, y);
 
   if (!_is_inside)
@@ -1465,115 +1520,108 @@
   FullRedraw();
 }
 
-void
-PanelMenuView::OnMouseDoubleClicked(int x, int y, unsigned long button_flags, unsigned long)
-{
-  if (nux::GetEventButton(button_flags) != 1 || _places_showing)
-    return;
-
-  guint32 window_xid = GetMaximizedWindow();
-
-  if (window_xid != 0)
-  {
-    WindowManager::Default()->Restore(window_xid);
-    _is_inside = true;
-  }
-}
-
-void
-PanelMenuView::OnMouseClicked(int x, int y, unsigned long button_flags, unsigned long)
-{
-  if (nux::GetEventButton(button_flags) != 1 || _places_showing)
-    return;
-
-  guint32 window_xid = GetMaximizedWindow();
-
-  if (window_xid != 0)
-  {
-    WindowManager::Default()->Raise(window_xid);
-  }
-}
-
-void
-PanelMenuView::OnMouseMiddleClicked(int x, int y, unsigned long button_flags, unsigned long)
-{
-  if (nux::GetEventButton(button_flags) != 2 || _places_showing)
-    return;
-
-  guint32 window_xid = GetMaximizedWindow();
-
-  if (window_xid != 0)
-  {
-    WindowManager::Default()->Lower(window_xid);
-  }
-}
-
 // Introspectable
 std::string
 PanelMenuView::GetName() const
 {
-  return "";
+  return "MenuView";
 }
 
 void PanelMenuView::AddProperties(GVariantBuilder* builder)
 {
-}
-
-void PanelMenuView::OnPlaceViewShown(GVariant* data, PanelMenuView* self)
-{
-  self->_places_showing = true;
-  self->QueueDraw();
-}
-
-void PanelMenuView::OnPlaceViewHidden(GVariant* data, PanelMenuView* self)
-{
-  self->_places_showing = false;
-  self->QueueDraw();
-}
-
-void PanelMenuView::OnSwitcherShown(GVariant* data, PanelMenuView* self)
-{
-  if (!self || !data)
-    return;
-
-  self->_switcher_showing = g_variant_get_boolean(data);
-
-  if (!self->_switcher_showing)
+  PanelIndicatorsView::AddProperties(builder);
+
+  variant::BuilderWrapper(builder)
+  .add("mouse_inside", _is_inside)
+  .add("grabbed", _is_grabbed)
+  .add("active_win_maximized", _is_maximized)
+  .add("panel_title", _panel_title)
+  .add("monitor", _monitor)
+  .add("active_window", _active_xid)
+  .add("draw_menus", DrawMenus())
+  .add("draw_window_buttons", DrawWindowButtons())
+  .add("controls_active_window", _we_control_active);
+}
+
+void PanelMenuView::OnSwitcherShown(GVariant* data)
+{
+  if (!data)
+    return;
+
+  bool switcher_shown;
+  int monitor;
+  g_variant_get(data, "(bi)", &switcher_shown, &monitor);
+
+  if (switcher_shown == _switcher_showing || monitor != _monitor)
+    return;
+
+  _switcher_showing = switcher_shown;
+
+  if (!_switcher_showing)
   {
     auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-    self->_is_inside = self->GetAbsoluteGeometry().IsPointInside(mouse.x, mouse.y);
-
-    if (self->_panel_title)
-    {
-      g_free(self->_panel_title);
-      self->_panel_title = nullptr;
-    }
+    _is_inside = GetAbsoluteGeometry().IsInside(mouse);
   }
   else
   {
-    self->_show_now_activated = false;
-  }
-
-  self->Refresh();
-  self->QueueDraw();
-}
-
-void PanelMenuView::OnSwitcherSelectionChanged(GVariant* data, PanelMenuView* self)
-{
-  if (!self || !data)
-    return;
-
-  if (self->_panel_title)
-    g_free(self->_panel_title);
-
-  self->_panel_title = g_strdup(g_variant_get_string(data, 0));
-
-  self->Refresh();
-  self->QueueDraw();
-}
-
-gboolean
-PanelMenuView::UpdateShowNowWithDelay(PanelMenuView *self)
+    _show_now_activated = false;
+  }
+
+  Refresh();
+  QueueDraw();
+}
+
+void PanelMenuView::OnSwitcherSelectionChanged(GVariant* data)
+{
+  if (!data || !_switcher_showing)
+    return;
+
+  const gchar *title = g_variant_get_string(data, 0);
+  _panel_title = (title ? title : "");
+
+  Refresh();
+  QueueDraw();
+}
+
+void PanelMenuView::OnLauncherKeyNavStarted(GVariant* data)
+{
+  if (_launcher_keynav)
+    return;
+
+
+  if (!data || (data && g_variant_get_int32(data) == _monitor))
+  {
+    _launcher_keynav = true;
+  }
+}
+
+void PanelMenuView::OnLauncherKeyNavEnded(GVariant* data)
+{
+  if (!_launcher_keynav)
+    return;
+
+  _launcher_keynav = false;
+
+  auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
+  _is_inside = GetAbsoluteGeometry().IsInside(mouse);
+
+  Refresh();
+  QueueDraw();
+}
+
+void PanelMenuView::OnLauncherSelectionChanged(GVariant* data)
+{
+  if (!data || !_launcher_keynav)
+    return;
+
+  const gchar *title = g_variant_get_string(data, 0);
+  _panel_title = (title ? title : "");
+
+  Refresh();
+  QueueDraw();
+}
+
+gboolean PanelMenuView::UpdateShowNowWithDelay(PanelMenuView *self)
 {
   bool active = false;
 
@@ -1597,8 +1645,7 @@
   return FALSE;
 }
 
-void
-PanelMenuView::UpdateShowNow(bool status)
+void PanelMenuView::UpdateShowNow(bool status)
 {
   /* When we get a show now event, if we are requested to show the menus,
    * we take the last incoming event and we wait for small delay (to avoid the
@@ -1610,6 +1657,7 @@
   {
     _show_now_activated = false;
     QueueDraw();
+    return;
   }
 
   if (_update_show_now_id != 0)
@@ -1626,27 +1674,55 @@
   }
 }
 
-void
-PanelMenuView::SetMonitor(int monitor)
+void PanelMenuView::SetMonitor(int monitor)
 {
   _monitor = monitor;
   _monitor_geo = UScreen::GetDefault()->GetMonitorGeometry(_monitor);
+
+  _maximized_set.clear();
+  GList* windows = bamf_matcher_get_window_stack_for_monitor(_matcher, _monitor);
+
+  for (GList* l = windows; l; l = l->next)
+  {
+    if (!BAMF_IS_WINDOW(l->data))
+      continue;
+
+    auto window = static_cast<BamfWindow*>(l->data);
+    auto view = static_cast<BamfView*>(l->data);
+
+    if (bamf_view_is_active(view))
+    {
+      _active_xid = bamf_window_get_xid(window);
+    }
+
+    if (bamf_window_maximized(window) == BAMF_WINDOW_MAXIMIZED)
+    {
+      Window xid = bamf_window_get_xid(window);
+
+      _decor_map[xid] = WindowManager::Default()->IsWindowDecorated(xid);
+
+      if (_decor_map[xid])
+        WindowManager::Default()->Undecorate(xid);
+
+      _maximized_set.insert(xid);
+    }
+  }
+
+  Window maximized = GetMaximizedWindow();
+  Window buttons_win = (maximized == _active_xid) ? maximized : 0;
+
+  _window_buttons->SetMonitor(_monitor);
+  _window_buttons->SetControlledWindow(buttons_win);
+
+  g_list_free(windows);
 }
 
-bool
-PanelMenuView::GetControlsActive()
+bool PanelMenuView::GetControlsActive() const
 {
   return _we_control_active;
 }
 
-bool
-PanelMenuView::HasOurWindowFocused()
-{
-  return _is_own_window;
-}
-
-void
-PanelMenuView::OnPanelViewMouseEnter(int x, int y, unsigned long mouse_button_state, unsigned long special_keys_state)
+void PanelMenuView::OnPanelViewMouseEnter(int x, int y, unsigned long mouse_button_state, unsigned long special_keys_state)
 {
   if (!_is_inside)
   {
@@ -1659,8 +1735,7 @@
   }
 }
 
-void
-PanelMenuView::OnPanelViewMouseLeave(int x, int y, unsigned long mouse_button_state, unsigned long special_keys_state)
+void PanelMenuView::OnPanelViewMouseLeave(int x, int y, unsigned long mouse_button_state, unsigned long special_keys_state)
 {
   if (_is_inside)
   {
 
=== modified file 'plugins/unityshell/src/PanelMenuView.h'
--- plugins/unityshell/src/PanelMenuView.h	2012-03-21 12:31:11 +0000
+++ plugins/unityshell/src/PanelMenuView.h	2012-04-05 23:42:20 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2010 Canonical Ltd
+ * Copyright (C) 2010-2012 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
@@ -15,14 +15,15 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Marco Trevisan <[e-mail]>
  */
 
 #ifndef PANEL_MENU_VIEW_H
 #define PANEL_MENU_VIEW_H
 
-#include <Nux/View.h>
-#include <map>
-#include <set>
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/GLibSignal.h>
+#include <libbamf/libbamf.h>
 
 #include "PanelIndicatorsView.h"
 #include "StaticCairoText.h"
@@ -30,10 +31,7 @@
 #include "PanelTitlebarGrabAreaView.h"
 #include "PluginAdapter.h"
 #include "Animator.h"
-
-#include <UnityCore/GLibWrapper.h>
-#include <UnityCore/GLibSignal.h>
-#include <libbamf/libbamf.h>
+#include "UBusWrapper.h"
 
 namespace unity
 {
@@ -41,41 +39,50 @@
 class PanelMenuView : public PanelIndicatorsView
 {
 public:
-  // This contains all the menubar logic for the Panel. Mainly it contains
-  // the following states:
-  // 1. Unmaximized window + no mouse hover
-  // 2. Unmaximized window + mouse hover
-  // 3. Unmaximized window + active menu (Alt+F/arrow key nav)
-  // 4. Maximized window + no mouse hover
-  // 5. Maximized window + mouse hover
-  // 6. Maximized window + active menu
-  //
-  // It also deals with undecorating maximized windows (and redecorating them
-  // on unmaximize)
-
-  PanelMenuView(int padding = 6);
+  PanelMenuView();
   ~PanelMenuView();
 
   void SetMenuShowTimings(int fadein, int fadeout, int discovery,
                           int discovery_fadein, int discovery_fadeout);
 
-  void FullRedraw();
+  void SetMousePosition(int x, int y);
+  void SetMonitor(int monitor);
+
+  Window GetTopWindow() const;
+  Window GetMaximizedWindow() const;
+  bool GetControlsActive() const;
+
+  void NotifyAllMenusClosed();
+
+  virtual void AddIndicator(indicator::Indicator::Ptr const& indicator);
+
+  virtual void OverlayShown();
+  virtual void OverlayHidden();
+
+protected:
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
 
   virtual void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
   virtual void DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw);
-  virtual long PostLayoutManagement(long LayoutResult);
-
-  void SetMousePosition(int x, int y);
-
+  virtual void PreLayoutManagement();
+  virtual nux::Area* FindAreaUnderMouse(const nux::Point& mouse_position,
+                                        nux::NuxEventType event_type);
+  virtual void OnEntryAdded(indicator::Entry::Ptr const& entry);
+
+private:
   void OnActiveChanged(PanelIndicatorEntryView* view, bool is_active);
   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 OnSpreadInitiate();
   void OnSpreadTerminate();
+  void OnExpoInitiate();
+  void OnExpoTerminate();
   void OnWindowMinimized(guint32 xid);
   void OnWindowUnminimized(guint32 xid);
   void OnWindowUnmapped(guint32 xid);
@@ -86,42 +93,30 @@
   void OnWindowDecorated(guint32 xid);
   void OnWindowUndecorated(guint32 xid);
 
-  guint32 GetMaximizedWindow();
-
-  void OnMaximizedGrabStart(int, int, unsigned long, unsigned long);
-  void OnMaximizedGrabMove(int, int, int, int, unsigned long, unsigned long);
-  void OnMaximizedGrabEnd(int, int, unsigned long, unsigned long);
-  void OnMouseDoubleClicked(int, int, unsigned long, unsigned long);
-  void OnMouseClicked(int, int, unsigned long, unsigned long);
-  void OnMouseMiddleClicked(int, int, unsigned long, unsigned long);
-
-  void Refresh();
-  void AllMenusClosed();
-
-  void OnCloseClicked();
-  void OnMinimizeClicked();
-  void OnRestoreClicked();
-  void SetMonitor(int monitor);
-  bool GetControlsActive();
-
-  bool HasOurWindowFocused();
-
-protected:
-  std::string GetName() const;
-  void          AddProperties(GVariantBuilder* builder);
-
-  virtual nux::Area* FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type);
+  void OnMaximizedActivate(int x, int y);
+  void OnMaximizedRestore(int x, int y);
+  void OnMaximizedLower(int x, int y);
+  void OnMaximizedGrabStart(int x, int y);
+  void OnMaximizedGrabMove(int x, int y);
+  void OnMaximizedGrabEnd(int x, int y);
+
+  void FullRedraw();
+  void Refresh(bool force = false);
+  void DrawTitle(cairo_t *cr_real, nux::Geometry const& geo, std::string const& label) const;
+
   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);
   void OnPanelViewMouseMove(int x, int y, int dx, int dy, unsigned long mouse_button_state, unsigned long special_keys_state);
-  virtual void OnEntryAdded(unity::indicator::Entry::Ptr const& entry);
-
-private:
-  gchar* GetActiveViewName();
-  static void OnPlaceViewShown(GVariant* data, PanelMenuView* self);
-  static void OnPlaceViewHidden(GVariant* data, PanelMenuView* self);
-  static void OnSwitcherShown(GVariant* data, PanelMenuView* self);
-  static void OnSwitcherSelectionChanged(GVariant* data, PanelMenuView* self);
+
+  BamfWindow* GetBamfWindowForXid(Window xid) const;
+
+  std::string GetActiveViewName(bool use_appname = false) const;
+
+  void OnSwitcherShown(GVariant* data);
+  void OnSwitcherSelectionChanged(GVariant* data);
+  void OnLauncherKeyNavStarted(GVariant* data);
+  void OnLauncherKeyNavEnded(GVariant* data);
+  void OnLauncherSelectionChanged(GVariant* data);
 
   void UpdateShowNow(bool ignore);
 
@@ -130,53 +125,47 @@
   static gboolean OnNewAppShow(PanelMenuView* self);
   static gboolean OnNewAppHide(PanelMenuView* self);
 
-  void DrawText(cairo_t *cr_real,
-                int &x, int y, int width, int height,
-                const char* font_desc,
-                const char* label,
-                int increase_size=0
-                );
+  bool IsValidWindow(Window xid) const;
+  bool IsWindowUnderOurControl(Window xid) const;
 
-  bool DrawMenus();
-  bool DrawWindowButtons();
+  bool DrawMenus() const;
+  bool DrawWindowButtons() const;
 
   void OnFadeInChanged(double);
   void OnFadeOutChanged(double);
 
-private:
   glib::Object<BamfMatcher> _matcher;
 
-  nux::TextureLayer*       _title_layer;
-  nux::HLayout*            _menu_layout;
-  nux::CairoGraphics       _util_cg;
+  nux::TextureLayer* _title_layer;
+  nux::HLayout* _menu_layout;
+  nux::ObjectPtr<nux::BaseTexture> _title_texture;
   nux::ObjectPtr<nux::IOpenGLBaseTexture> _gradient_texture;
 
   bool _is_inside;
   bool _is_grabbed;
   bool _is_maximized;
-  bool _is_own_window;
+
   PanelIndicatorEntryView* _last_active_view;
+  WindowButtons* _window_buttons;
+  PanelTitlebarGrabArea* _titlebar_grab_area;
   glib::Object<BamfApplication> _new_application;
 
-  WindowButtons* _window_buttons;
-  PanelTitlebarGrabArea* _panel_titlebar_grab_area;
-
-  std::map<guint32, bool> _decor_map;
-  std::set<guint32> _maximized_set;
+  std::map<Window, bool> _decor_map;
+  std::set<Window> _maximized_set;
   std::list<glib::Object<BamfApplication>> _new_apps;
-
-  int _padding;
-  int _last_width;
-  int _last_height;
-
-  bool _places_showing;
+  std::string _panel_title;
+  nux::Geometry _last_geo;
+
+  bool _overlay_showing;
   bool _switcher_showing;
+  bool _launcher_keynav;
   bool _show_now_activated;
   bool _we_control_active;
   bool _new_app_menu_shown;
 
-  int  _monitor;
-  guint32 _active_xid;
+  int _monitor;
+  Window _active_xid;
+
   guint32 _active_moved_id;
   guint32 _update_show_now_id;
   guint32 _new_app_show_id;
@@ -188,8 +177,9 @@
   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;
+  sigc::connection _style_changed_connection;
 
-  std::vector<unsigned int> _ubus_interests;
+  UBusManager _ubus_manager;
 
   int _menus_fadein;
   int _menus_fadeout;
@@ -197,10 +187,8 @@
   int _menus_discovery_fadein;
   int _menus_discovery_fadeout;
 
-  gchar* _panel_title;
-
-  Animator* _fade_in_animator;
-  Animator* _fade_out_animator;
+  Animator _fade_in_animator;
+  Animator _fade_out_animator;
 };
 
 }
 
=== modified file 'plugins/unityshell/src/PanelTitlebarGrabAreaView.cpp'
--- plugins/unityshell/src/PanelTitlebarGrabAreaView.cpp	2012-02-25 16:19:39 +0000
+++ plugins/unityshell/src/PanelTitlebarGrabAreaView.cpp	2012-04-05 23:42:20 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2010-2011 Canonical Ltd
+ * Copyright (C) 2010-2012 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
@@ -27,17 +27,41 @@
 #include <UnityCore/Variant.h>
 #include <X11/cursorfont.h>
 
+namespace unity
+{
+namespace
+{
+  unsigned int MOUSE_DOWN_TIMEOUT = 150;
+  unsigned int MOUSE_MOVEMENT_TOLERANCE = 4;
+}
+
 PanelTitlebarGrabArea::PanelTitlebarGrabArea()
   : InputArea(NUX_TRACKER_LOCATION)
-  , _grab_cursor(None)
+  , grab_cursor_(None)
+  , grab_started_(false)
+  , mouse_down_timer_(0)
+  , mouse_down_button_(0)
 {
   EnableDoubleClick(true);
+
+  mouse_down.connect(sigc::mem_fun(this, &PanelTitlebarGrabArea::OnMouseDown));
+  mouse_up.connect(sigc::mem_fun(this, &PanelTitlebarGrabArea::OnMouseUp));
+  mouse_drag.connect(sigc::mem_fun(this, &PanelTitlebarGrabArea::OnGrabMove));
+
+  mouse_double_click.connect([&] (int x, int y, unsigned long button_flags, unsigned long)
+  {
+    if (nux::GetEventButton(button_flags) == 1)
+      restore_request.emit(x, y);
+  });
 }
 
 PanelTitlebarGrabArea::~PanelTitlebarGrabArea()
 {
-  if (_grab_cursor)
-    XFreeCursor(nux::GetGraphicsDisplay()->GetX11Display(), _grab_cursor);
+  if (grab_cursor_)
+    XFreeCursor(nux::GetGraphicsDisplay()->GetX11Display(), grab_cursor_);
+
+  if (mouse_down_timer_)
+    g_source_remove(mouse_down_timer_);
 }
 
 void PanelTitlebarGrabArea::SetGrabbed(bool enabled)
@@ -48,32 +72,120 @@
   if (!panel_window || !display)
     return;
 
-  if (enabled && !_grab_cursor)
+  if (enabled && !grab_cursor_)
   {
-    _grab_cursor = XCreateFontCursor(display, XC_fleur);
-    XDefineCursor(display, panel_window->GetInputWindowId(), _grab_cursor);
+    grab_cursor_ = XCreateFontCursor(display, XC_fleur);
+    XDefineCursor(display, panel_window->GetInputWindowId(), grab_cursor_);
   }
-  else if (!enabled && _grab_cursor)
+  else if (!enabled && grab_cursor_)
   {
     XUndefineCursor(display, panel_window->GetInputWindowId());
-    XFreeCursor(display, _grab_cursor);
-    _grab_cursor = None;
+    XFreeCursor(display, grab_cursor_);
+    grab_cursor_ = None;
   }
 }
 
 bool PanelTitlebarGrabArea::IsGrabbed()
 {
-  return (_grab_cursor != None);
+  return (grab_cursor_ != None);
+}
+
+void PanelTitlebarGrabArea::OnMouseDown(int x, int y, unsigned long button_flags, unsigned long)
+{
+  mouse_down_button_ = nux::GetEventButton(button_flags);
+
+  if (mouse_down_button_ == 2)
+  {
+    lower_request.emit(x, y);
+  }
+  else if (mouse_down_button_ == 1)
+  {
+    mouse_down_point_.x = x;
+    mouse_down_point_.y = y;
+
+    mouse_down_timer_ =
+      g_timeout_add(MOUSE_DOWN_TIMEOUT, [] (gpointer data) -> gboolean {
+        auto self = static_cast<PanelTitlebarGrabArea*>(data);
+
+        if (!self->grab_started_)
+        {
+          nux::Point const& mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
+          self->grab_started.emit(mouse.x - self->GetAbsoluteX(), mouse.y - self->GetAbsoluteY());
+          self->grab_started_ = true;
+        }
+
+        self->mouse_down_timer_ = 0;
+        return FALSE;
+      }, this);
+  }
+}
+
+void PanelTitlebarGrabArea::OnMouseUp(int x, int y, unsigned long button_flags, unsigned long)
+{
+  int button = nux::GetEventButton(button_flags);
+
+  if (button == 1)
+  {
+    if (mouse_down_timer_)
+    {
+      g_source_remove(mouse_down_timer_);
+      mouse_down_timer_ = 0;
+
+      activate_request.emit(x, y);
+    }
+
+    if (grab_started_)
+    {
+      grab_end.emit(x, y);
+      grab_started_ = false;
+    }
+  }
+
+  mouse_down_button_ = 0;
+  mouse_down_point_.x = 0;
+  mouse_down_point_.y = 0;
+}
+
+void PanelTitlebarGrabArea::OnGrabMove(int x, int y, int, int, unsigned long button_flags, unsigned long)
+{
+  if (mouse_down_button_ != 1)
+    return;
+
+  if (mouse_down_timer_)
+  {
+    if (abs(mouse_down_point_.x - x) <= MOUSE_MOVEMENT_TOLERANCE &&
+        abs(mouse_down_point_.y - y) <= MOUSE_MOVEMENT_TOLERANCE)
+    {
+      return;
+    }
+
+    g_source_remove(mouse_down_timer_);
+    mouse_down_timer_ = 0;
+  }
+
+  if (!grab_started_)
+  {
+    grab_started.emit(x, y);
+    grab_started_ = true;
+  }
+  else
+  {
+    grab_move.emit(x, y);
+  }
 }
 
 std::string
 PanelTitlebarGrabArea::GetName() const
 {
-  return "panel-titlebar-grab-area";
+  return "GrabArea";
 }
 
 void
 PanelTitlebarGrabArea::AddProperties(GVariantBuilder* builder)
 {
-  unity::variant::BuilderWrapper(builder).add(GetGeometry());
+  unity::variant::BuilderWrapper(builder)
+  .add(GetGeometry())
+  .add("grabbed", IsGrabbed());
+}
+
 }
 
=== modified file 'plugins/unityshell/src/PanelTitlebarGrabAreaView.h'
--- plugins/unityshell/src/PanelTitlebarGrabAreaView.h	2012-02-25 16:19:39 +0000
+++ plugins/unityshell/src/PanelTitlebarGrabAreaView.h	2012-04-05 23:42:20 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2010-2011 Canonical Ltd
+ * Copyright (C) 2010-2012 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
@@ -27,10 +27,13 @@
 
 #include "Introspectable.h"
 
+namespace unity
+{
+
 class PanelTitlebarGrabArea : public nux::InputArea, public unity::debug::Introspectable
 {
-  /* This acts a bit like a titlebar, it can be grabbed (such that we can pull
-   * the window down)                                                         */
+  /* This acts a bit like a decorator, it can be clicked or grabbed (such that
+   * we can pull the window down) */
 
 public:
   PanelTitlebarGrabArea();
@@ -39,11 +42,29 @@
   void SetGrabbed(bool enabled);
   bool IsGrabbed();
 
+  sigc::signal<void, int, int> lower_request;
+  sigc::signal<void, int, int> activate_request;
+  sigc::signal<void, int, int> restore_request;
+  sigc::signal<void, int, int> grab_started;
+  sigc::signal<void, int, int> grab_move;
+  sigc::signal<void, int, int> grab_end;
+
+protected:
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
 private:
-  std::string GetName() const;
-  void         AddProperties(GVariantBuilder* builder);
+  void OnMouseDown(int x, int y, unsigned long button_flags, unsigned long);
+  void OnMouseUp(int x, int y, unsigned long button_flags, unsigned long);
+  void OnGrabMove(int x, int y, int, int, unsigned long button_flags, unsigned long);
 
-  Cursor _grab_cursor;
+  Cursor grab_cursor_;
+  bool grab_started_;
+  guint mouse_down_timer_;
+  nux::Point mouse_down_point_;
+  unsigned int mouse_down_button_;
 };
 
+} // NAMESPACE
+
 #endif
 
=== modified file 'plugins/unityshell/src/PanelTray.cpp'
--- plugins/unityshell/src/PanelTray.cpp	2012-03-21 12:31:11 +0000
+++ plugins/unityshell/src/PanelTray.cpp	2012-04-05 23:42:20 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 Canonical Ltd
+ * Copyright (C) 2010-2012 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
@@ -14,11 +14,14 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Neil Jagdish Patel <[e-mail]>
+ *              Marco Trevisan (Treviño) <[e-mail]>
  */
 
 #include "PanelTray.h"
+#include "PanelStyle.h"
 
 #include <NuxCore/Logger.h>
+#include <UnityCore/Variant.h>
 
 namespace
 {
@@ -31,137 +34,118 @@
 {
 
 PanelTray::PanelTray()
-  : View(NUX_TRACKER_LOCATION),
-    _window(0),
-    _tray(NULL),
-    _last_x(0),
-    _last_y(0),
-    _tray_icon_added_id(0)
-{
-  _settings = g_settings_new(SETTINGS_NAME.c_str());
-  _whitelist = g_settings_get_strv(_settings, "systray-whitelist");
-
-  RealInit();
-}
-
-unsigned int
-PanelTray::xid ()
-{
-  if (!_window)
-    return 0;
-
-  return gdk_x11_window_get_xid (gtk_widget_get_window (_window));
-}
-
-void PanelTray::RealInit()
-{
-  _window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
-  gtk_window_set_type_hint(GTK_WINDOW(_window), GDK_WINDOW_TYPE_HINT_DOCK);
-  gtk_window_set_has_resize_grip(GTK_WINDOW(_window), FALSE);
-  gtk_window_set_keep_above(GTK_WINDOW(_window), TRUE);
-  gtk_window_set_skip_pager_hint(GTK_WINDOW(_window), TRUE);
-  gtk_window_set_skip_taskbar_hint(GTK_WINDOW(_window), TRUE);
-  gtk_window_resize(GTK_WINDOW(_window), 1, 24);
-  gtk_window_move(GTK_WINDOW(_window), -24,-24);
-  gtk_widget_set_name(_window, "UnityPanelApplet");
-
-  gtk_widget_set_visual(_window, gdk_screen_get_rgba_visual(gdk_screen_get_default()));
-  gtk_widget_realize(_window);
-  gtk_widget_set_app_paintable(_window, TRUE);
-  _tray_expose_id = g_signal_connect(_window, "draw", G_CALLBACK(PanelTray::OnTrayDraw), this);
+  : View(NUX_TRACKER_LOCATION)
+  , settings_(g_settings_new(SETTINGS_NAME.c_str()))
+  , window_(gtk_window_new(GTK_WINDOW_TOPLEVEL))
+  , whitelist_(g_settings_get_strv(settings_, "systray-whitelist"))
+{
+  int panel_height = panel::Style::Instance().panel_height;
+
+  whitelist_changed_.Connect(settings_, "changed::systray-whitelist", [&] (GSettings*, gchar*) {
+    g_strfreev(whitelist_);
+    whitelist_ = g_settings_get_strv(settings_, "systray-whitelist");
+  });
+
+  auto gtkwindow = glib::object_cast<GtkWindow>(window_);
+  gtk_window_set_type_hint(gtkwindow, GDK_WINDOW_TYPE_HINT_DOCK);
+  gtk_window_set_has_resize_grip(gtkwindow, FALSE);
+  gtk_window_set_keep_above(gtkwindow, TRUE);
+  gtk_window_set_skip_pager_hint(gtkwindow, TRUE);
+  gtk_window_set_skip_taskbar_hint(gtkwindow, TRUE);
+  gtk_window_resize(gtkwindow, 1, panel_height);
+  gtk_window_move(gtkwindow, -panel_height,-panel_height);
+  gtk_widget_set_name(window_, "UnityPanelApplet");
+
+  gtk_widget_set_visual(window_, gdk_screen_get_rgba_visual(gdk_screen_get_default()));
+  gtk_widget_realize(window_);
+  gtk_widget_set_app_paintable(window_, TRUE);
+  draw_signal_.Connect(window_, "draw", sigc::mem_fun(this, &PanelTray::OnTrayDraw));
 
   if (!g_getenv("UNITY_PANEL_TRAY_DISABLE"))
   {
-    _tray = na_tray_new_for_screen(gdk_screen_get_default(),
+    tray_ = na_tray_new_for_screen(gdk_screen_get_default(),
                                    GTK_ORIENTATION_HORIZONTAL,
                                    (NaTrayFilterCallback)FilterTrayCallback,
                                    this);
-    na_tray_set_icon_size(_tray, 24);
-
-    _tray_icon_added_id = g_signal_connect(na_tray_get_manager(_tray), "tray_icon_removed",
-                                           G_CALLBACK(PanelTray::OnTrayIconRemoved), this);
-
-    gtk_container_add(GTK_CONTAINER(_window), GTK_WIDGET(_tray));
-    gtk_widget_show(GTK_WIDGET(_tray));
+    na_tray_set_icon_size(tray_, panel_height);
+
+    icon_removed_signal_.Connect(na_tray_get_manager(tray_), "tray_icon_removed",
+                                 sigc::mem_fun(this, &PanelTray::OnTrayIconRemoved));
+
+    gtk_container_add(GTK_CONTAINER(window_.RawPtr()), GTK_WIDGET(tray_.RawPtr()));
+    gtk_widget_show(GTK_WIDGET(tray_.RawPtr()));
   }
 
-  SetMinMaxSize(1, 24);
-
+  SetMinMaxSize(1, panel_height);
 }
 
 PanelTray::~PanelTray()
 {
-  if (_tray)
-  {
-    g_signal_handler_disconnect(na_tray_get_manager(_tray), _tray_icon_added_id);
-    _tray = NULL;
-  }
-
   g_idle_remove_by_data(this);
-
-  if (_tray_expose_id)
-    g_signal_handler_disconnect(_window, _tray_expose_id);
-
-  gtk_widget_destroy(_window);
-  g_strfreev(_whitelist);
-  g_object_unref(_settings);
-}
-
-void
-PanelTray::Draw(nux::GraphicsEngine& gfx_context, bool force_draw)
-{
-  nux::Geometry geo(GetAbsoluteGeometry());
+  g_strfreev(whitelist_);
+
+  if (gtk_widget_get_realized(window_))
+    gtk_widget_destroy(window_);
+}
+
+Window PanelTray::xid()
+{
+  if (!window_)
+    return 0;
+
+  return gdk_x11_window_get_xid(gtk_widget_get_window(window_));
+}
+
+void PanelTray::Draw(nux::GraphicsEngine& gfx_context, bool force_draw)
+{
+  nux::Geometry const& geo = GetAbsoluteGeometry();
 
   gfx_context.PushClippingRectangle(geo);
   nux::GetPainter().PaintBackground(gfx_context, geo);
   gfx_context.PopClippingRectangle();
 
-  if (geo.x != _last_x || geo.y != _last_y)
+  if (geo != last_geo_)
   {
-    _last_x = geo.x;
-    _last_y = geo.y;
-
-    gtk_window_move(GTK_WINDOW(_window), geo.x + PADDING, geo.y);
+    last_geo_ = geo;
+    gtk_window_move(GTK_WINDOW(window_.RawPtr()), geo.x + PADDING, geo.y);
   }
 }
 
-void
-PanelTray::Sync()
+void PanelTray::Sync()
 {
-  if (_tray)
+  if (tray_)
   {
-    SetMinMaxSize(WidthOfTray() + (PADDING * 2), 24);
+    SetMinMaxSize(WidthOfTray() + (PADDING * 2), panel::Style::Instance().panel_height);
     QueueRelayout();
     QueueDraw();
 
-    if (_children.size())
-      gtk_widget_show(_window);
+    if (!children_.empty())
+      gtk_widget_show(window_);
     else