Merge lp:~3v1n0/unity/switcher-glowing-decorations into lp:unity

[Marco Trevisan (Treviño)]

UnityWindow: draw fake decorations on spread windows in switcher

Implemented the fake decorations in applications switcher spread, to match design specifications: now the selected window draws a decoration with full-size title and uses real glow.

To do this, I had to refactor a little the unityshell's UnityWindow code to allow to reuse the scale decoration code for both the scale and the switcher. This fixes also a redraw issue in scale, correctly damaging the changed areas.

Some cleanup and refactor of the PluginAdapter code that now has two different functions to check if a window is generally decorated (HasDecorations) and if it is actually decorated (IsDecorated). It also saves the decoration extents values in an Atom for maximized windows, so that we're always able to get the decoration size of a window (all this is needed to draw a correct decoration on maximized windows).

Added new unit tests for the layout system (this required some rework of StandaloneWindowManager), added new and updated autopilot tests.

Result: http://i.imgur.com/SuTo4.png

[Andrea Azzarone (azzar1)]

3026 lines (+1085/-455) 26 files modified

I hate you :)

1893 + typedef std::vector<LayoutWindow::Ptr> List;

You call it List but it's a vector. I really don't like it.

868 + if (launcher->Hidden() || launcher_hide_mode == LAUNCHER_HIDE_NEVER || launcher_hide_mode == LAUNCHER_HIDE_AUTOHIDE)

Does it makes sense? launcher_hide_mode can be LAUNCHER_HIDE_NEVER or LAUNCHER_HIDE_AUTOHIDE so this expression evaluates always true, right?

Bookmark: line 1068 (I'll continue the review later)

Please next time consider to have a different branch for style changes :)

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

> 3026 lines (+1085/-455) 26 files modified
>
> I hate you :)

:-P

> 1893 + typedef std::vector<LayoutWindow::Ptr> List;
>
> You call it List but it's a vector. I really don't like it.

It was already called List, so I kept the name it had... But I can change it to vector if you prefer.

> 868 + if (launcher->Hidden() || launcher_hide_mode == LAUNCHER_HIDE_NEVER
> || launcher_hide_mode == LAUNCHER_HIDE_AUTOHIDE)
>
> Does it makes sense? launcher_hide_mode can be LAUNCHER_HIDE_NEVER or
> LAUNCHER_HIDE_AUTOHIDE so this expression evaluates always true, right?

Yeah, you're right... I just did a replacement of the old variable, but this seems to be wrong, I guess that the logic should just be: continue if (launcher->options()->hide_mode == LAUNCHER_HIDE_AUTOHIDE && launcher->Hidden())... Fixing it.

> Please next time consider to have a different branch for style changes :)

You know, it was all mixed... It was hard to split.

[John Lea (johnlea)]

review: Approve (design)

[Andrea Azzarone (azzar1)]

LGTM. Works here.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/unity-mbs-autolanding/119/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mbs-autolanding/./build=pbuilder,distribution=quantal,flavor=amd64/119/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mbs-autolanding/./build=pbuilder,distribution=quantal,flavor=i386/119/console

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
Unapproved changes made after approval.
http://jenkins.qa.ubuntu.com/job/unity-mbs-autolanding/124/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mbs-autolanding/./build=pbuilder,distribution=quantal,flavor=amd64/124/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mbs-autolanding/./build=pbuilder,distribution=quantal,flavor=i386/124/console

review: Needs Fixing (continuous-integration)

=== modified file 'launcher/CMakeLists.txt'
--- launcher/CMakeLists.txt	2012-11-13 22:39:49 +0000
+++ launcher/CMakeLists.txt	2012-11-15 18:52:31 +0000
@@ -91,7 +91,6 @@
       SwitcherController.cpp
       SwitcherModel.cpp
       SwitcherView.cpp
-      LayoutSystem.cpp
     )
 
 add_library (switcher-lib STATIC ${SWITCHER_SOURCES})

=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2012-11-13 22:39:49 +0000
+++ launcher/Launcher.cpp	2012-11-15 18:52:31 +0000
@@ -1369,7 +1369,7 @@
 bool Launcher::OnUpdateDragManagerTimeout()
 {
 #ifdef USE_X11
-  if (display() == 0)
+  if (!display())
     return false;
 
   if (!_selection_atom)

=== modified file 'launcher/StandaloneSwitcher.cpp'
--- launcher/StandaloneSwitcher.cpp	2012-11-08 09:12:24 +0000
+++ launcher/StandaloneSwitcher.cpp	2012-11-15 18:52:31 +0000
@@ -34,6 +34,7 @@
 #include "SwitcherController.h"
 #include "MockLauncherIcon.h"
 #include "unity-shared/BackgroundEffectHelper.h"
+#include "unity-shared/UnitySettings.h"
 
 using namespace unity::switcher;
 using namespace unity::ui;
@@ -277,7 +278,7 @@
 
   layout->SetContentDistribution(nux::MAJOR_POSITION_CENTER);
 
-  nux::BaseTexture *background = nux::CreateTexture2DFromFile("/usr/share/backgrounds/Grey_day_by_Drew__.jpg", -1, true);
+  nux::BaseTexture *background = nux::CreateTexture2DFromFile("/usr/share/backgrounds/warty-final-ubuntu.png", -1, true);
   nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = background->GetDeviceTexture();
 
 
@@ -290,6 +291,7 @@
   gtk_init(&argc, &argv);
   nux::NuxInitialize(0);
 
+  unity::Settings settings;
   BackgroundEffectHelper::blur_type = unity::BLUR_ACTIVE;
   nux::WindowThread* wt = nux::CreateGUIThread(TEXT("Unity Switcher"), 1200, 600, 0, &ThreadWidgetInit, 0);
 

=== modified file 'launcher/SwitcherController.cpp'
--- launcher/SwitcherController.cpp	2012-11-06 18:19:09 +0000
+++ launcher/SwitcherController.cpp	2012-11-15 18:52:31 +0000
@@ -30,7 +30,7 @@
 {
 using launcher::AbstractLauncherIcon;
 using launcher::ActionArg;
-using ui::LayoutWindowList;
+using ui::LayoutWindow;
 
 namespace
 {
@@ -398,11 +398,11 @@
   }
 }
 
-LayoutWindowList Controller::ExternalRenderTargets()
+LayoutWindow::Vector Controller::ExternalRenderTargets()
 {
   if (!view_)
   {
-    LayoutWindowList result;
+    LayoutWindow::Vector result;
     return result;
   }
   return view_->ExternalTargets();

=== modified file 'launcher/SwitcherController.h'
--- launcher/SwitcherController.h	2012-11-06 18:19:09 +0000
+++ launcher/SwitcherController.h	2012-11-15 18:52:31 +0000
@@ -90,7 +90,7 @@
 
   SwitcherView * GetView ();
 
-  ui::LayoutWindowList ExternalRenderTargets ();
+  ui::LayoutWindow::Vector ExternalRenderTargets ();
 
   guint GetSwitcherInputWindowId() const;
 

=== modified file 'launcher/SwitcherView.cpp'
--- launcher/SwitcherView.cpp	2012-11-06 18:19:09 +0000
+++ launcher/SwitcherView.cpp	2012-11-15 18:52:31 +0000
@@ -17,19 +17,13 @@
  */
 
 #include "config.h"
-
 #include "SwitcherView.h"
 #include "unity-shared/IconRenderer.h"
-#include "LayoutSystem.h"
-
 #include "unity-shared/TimeUtil.h"
 
+#include <Nux/Nux.h>
 #include <UnityCore/Variant.h>
 
-#include <NuxCore/Object.h>
-#include <Nux/Nux.h>
-#include <Nux/WindowCompositor.h>
-
 namespace unity
 {
 using namespace ui;
@@ -41,36 +35,27 @@
 NUX_IMPLEMENT_OBJECT_TYPE(SwitcherView);
 
 SwitcherView::SwitcherView()
-  : UnityWindowView()
+  : render_boxes(false)
+  , border_size(50)
+  , flat_spacing(10)
+  , icon_size(128)
+  , minimum_spacing(10)
+  , tile_size(150)
+  , vertical_size(tile_size + 80)
+  , text_size(15)
+  , animation_length(250)
+  , monitor(-1)
+  , spread_size(3.5f)
+  , icon_renderer_(std::make_shared<IconRenderer>())
+  , text_view_(new nux::StaticCairoText(""))
+  , animation_draw_(false)
   , target_sizes_set_(false)
 {
-  icon_renderer_ = AbstractIconRenderer::Ptr(new IconRenderer());
   icon_renderer_->pip_style = OVER_TILE;
-
-  layout_system_ = LayoutSystem::Ptr (new LayoutSystem ());
-  border_size = 50;
-  flat_spacing = 10;
-  icon_size = 128;
-  minimum_spacing = 10;
-  tile_size = 150;
-  vertical_size = tile_size + 80;
-  text_size = 15;
-  animation_length = 250;
-  monitor = -1;
-  spread_size = 3.5f;
-  render_boxes = false;
-
-  animation_draw_ = false;
-
   save_time_.tv_sec = 0;
   save_time_.tv_nsec = 0;
 
-  render_targets_.clear ();
-
-  rounding_texture_.Adopt(nux::CreateTexture2DFromFile(PKGDATADIR"/switcher_round_rect.png", -1, true));
-
-  text_view_ = new nux::StaticCairoText("Testing");
-  text_view_->SetMaximumWidth ((int) (tile_size * spread_size));
+  text_view_->SetMaximumWidth(tile_size * spread_size);
   text_view_->SetLines(1);
   text_view_->SetTextColor(nux::color::White);
   text_view_->SetFont("Ubuntu Bold 10");
@@ -99,15 +84,13 @@
   .add("text-size", text_size)
   .add("animation-length", animation_length)
   .add("spread-size", (float)spread_size)
-  .add("label", text_view_->GetText());
+  .add("label", text_view_->GetText())
+  .add("label_visible", text_view_->IsVisible());
 }
 
-
-
-LayoutWindowList SwitcherView::ExternalTargets ()
+LayoutWindow::Vector SwitcherView::ExternalTargets ()
 {
-  LayoutWindowList result = render_targets_;
-  return result;
+  return render_targets_;
 }
 
 void SwitcherView::SetModel(SwitcherModel::Ptr model)
@@ -120,15 +103,10 @@
   if (!model->Selection())
     return;
 
-  if (model->detail_selection)
-  {
-    Window detail_window = model->DetailSelectionWindow();
-    text_view_->SetText(model->Selection()->NameForWindow(detail_window));
-  }
-  else
-  {
+  text_view_->SetVisible(!model->detail_selection);
+
+  if (!model->detail_selection)
     text_view_->SetText(model->Selection()->tooltip_text());
-  }
 }
 
 void SwitcherView::OnIconSizeChanged (int size)
@@ -149,37 +127,28 @@
   clock_gettime(CLOCK_MONOTONIC, &save_time_);
 }
 
-void SwitcherView::OnDetailSelectionIndexChanged (unsigned int index)
+void SwitcherView::OnDetailSelectionIndexChanged(unsigned int index)
 {
-  if (model_->detail_selection)
-  {
-    Window detail_window = model_->DetailSelectionWindow();
-    text_view_->SetText(model_->Selection()->NameForWindow(detail_window));
-  }
   QueueDraw ();
 }
 
-void SwitcherView::OnDetailSelectionChanged (bool detail)
+void SwitcherView::OnDetailSelectionChanged(bool detail)
 {
+  text_view_->SetVisible(!detail);
 
-  if (detail)
-  {
-    Window detail_window = model_->DetailSelectionWindow();
-    text_view_->SetText(model_->Selection()->NameForWindow(detail_window));
-  }
-  else
-  {
+  if (!detail)
     text_view_->SetText(model_->Selection()->tooltip_text());
-  }
-  SaveLast ();
-  QueueDraw ();
+
+  SaveLast();
+  QueueDraw();
 }
 
 void SwitcherView::OnSelectionChanged(AbstractLauncherIcon::Ptr const& selection)
 {
   if (selection)
     text_view_->SetText(selection->tooltip_text());
-  SaveLast ();
+
+  SaveLast();
   QueueDraw();
 }
 
@@ -250,43 +219,52 @@
   return result;
 }
 
-nux::Geometry SwitcherView::UpdateRenderTargets (nux::Point const& center, timespec const& current)
+nux::Geometry SwitcherView::UpdateRenderTargets(nux::Point const& center, timespec const& current)
 {
-  std::vector<Window> xids = model_->DetailXids ();
+  std::vector<Window> const& xids = model_->DetailXids();
 
   int ms_since_change = TimeUtil::TimeDelta(&current, &save_time_);
-  float progress = MIN (1.0f, (float) ms_since_change / (float) animation_length());
+  float progress = std::min<float>(1.0f, ms_since_change / static_cast<float>(animation_length()));
 
   for (Window window : xids)
   {
-    LayoutWindow::Ptr layout_window (new LayoutWindow (window));
-
-    if (window == model_->DetailSelectionWindow ())
-      layout_window->alpha = 1.0f * progress;
-    else
-      layout_window->alpha = 0.9f * progress;
-
-    render_targets_.push_back (layout_window);
+    auto layout_window = std::make_shared<LayoutWindow>(window);
+    bool selected = (window == model_->DetailSelectionWindow());
+    layout_window->selected = selected;
+    layout_window->alpha = (selected ? 1.0f : 0.9f) * progress;
+
+    render_targets_.push_back(layout_window);
   }
 
   nux::Geometry max_bounds;
-
-  nux::Geometry absolute = GetAbsoluteGeometry ();
-  nux::Size spread_size = SpreadSize();
+  nux::Geometry const& absolute = GetAbsoluteGeometry();
+  nux::Size const& spread_size = SpreadSize();
   max_bounds.x = absolute.x + center.x - spread_size.width / 2;
   max_bounds.y = absolute.y + center.y - spread_size.height / 2;
   max_bounds.width = spread_size.width;
   max_bounds.height = spread_size.height;
 
   nux::Geometry final_bounds;
-  layout_system_->LayoutWindows (render_targets_, max_bounds, final_bounds);
+  layout_system_.LayoutWindows(render_targets_, max_bounds, final_bounds);
+
+  if (progress < 1.0f)
+  {
+    // Animate the windows thumbnail sizes to make them grow with the switcher
+    for (LayoutWindow::Ptr const& win : render_targets_)
+    {
+      auto old_geo = win->result;
+      win->result = old_geo * progress;
+      win->result.x += (old_geo.width - win->result.width) / 4;
+      win->result.y += (old_geo.height - win->result.height) / 4;
+    }
+  }
 
   return final_bounds;
 }
 
 void SwitcherView::OffsetRenderTargets (int x, int y)
 {
-  for (LayoutWindow::Ptr target : render_targets_)
+  for (LayoutWindow::Ptr const& target : render_targets_)
   {
     target->result.x += x;
     target->result.y += y;
@@ -295,14 +273,11 @@
 
 nux::Size SwitcherView::SpreadSize()
 {
-  nux::Geometry base = GetGeometry();
-  nux::Size result (base.width - border_size * 2, base.height - border_size * 2);
+  nux::Geometry const& base = GetGeometry();
+  nux::Size result(base.width - border_size * 2, base.height - border_size * 2);
 
   int width_padding = std::max(model_->Size() - 1, 0) * minimum_spacing + tile_size;
-  int height_padding = text_size;
-
   result.width -= width_padding;
-  result.height -= height_padding;
 
   return result;
 }
@@ -384,33 +359,33 @@
 std::list<RenderArg> SwitcherView::RenderArgsFlat(nux::Geometry& background_geo, int selection, timespec const& current)
 {
   std::list<RenderArg> results;
-  nux::Geometry base = GetGeometry();
+  nux::Geometry const& base = GetGeometry();
 
   render_targets_.clear ();
 
   bool detail_selection = model_->detail_selection;
 
   background_geo.y = base.y + base.height / 2 - (vertical_size / 2);
-  background_geo.height = vertical_size + text_size;
+  background_geo.height = vertical_size;
 
+  if (text_view_->IsVisible())
+    background_geo.height += text_size;
 
   if (model_)
   {
-
     int size = model_->Size();
     int padded_tile_size = tile_size + flat_spacing * 2;
     int max_width = base.width - border_size * 2;
 
-    nux::Geometry spread_bounds;
     int spread_padded_width = 0;
     if (detail_selection)
     {
-      spread_bounds = UpdateRenderTargets (nux::Point (0, 0), current);
+      nux::Geometry const& spread_bounds = UpdateRenderTargets(nux::Point(), current);
       // remove extra space consumed by spread
       spread_padded_width = spread_bounds.width + 100;
       max_width -= spread_padded_width - tile_size;
 
-      int expansion = MAX (0, spread_bounds.height - icon_size);
+      int expansion = std::max(0, spread_bounds.height - icon_size);
       background_geo.y -= expansion / 2;
       background_geo.height += expansion;
     }
@@ -445,13 +420,12 @@
 
     GetFlatIconPositions (n_flat_icons, size, selection, first_flat, last_flat, half_fold_left, half_fold_right);
 
-    SwitcherModel::iterator it;
     int i = 0;
     int y = base.y + base.height / 2;
     x += border_size;
-    for (it = model_->begin(); it != model_->end(); ++it)
+    for (auto const& icon : *model_)
     {
-      RenderArg arg = CreateBaseArgForIcon(*it);
+      RenderArg arg = CreateBaseArgForIcon(icon);
 
       float scalar = partial_overflow_scalar;
 
@@ -559,13 +533,13 @@
   nux::Geometry base = GetGeometry();
 
   GfxContext.GetRenderStates().SetPremultipliedBlend(nux::SRC_OVER);
-  std::list<RenderArg>::iterator it;
-  for (it = last_args_.begin(); it != last_args_.end(); ++it)
+
+  for (auto const& arg : last_args_)
   {
-    if (model_->Selection() == it->icon)
+    if (text_view_->IsVisible() && model_->Selection() == arg.icon)
     {
       int view_width = text_view_->GetBaseWidth();
-      int start_x = it->render_center.x - view_width / 2;
+      int start_x = arg.render_center.x - view_width / 2;
 
       internal_clip.Expand (-10, -10);
       if (start_x < internal_clip.x)
@@ -575,12 +549,12 @@
 
       text_view_->SetBaseX(start_x);
     }
-    if (it->y_rotation < 0)
-      icon_renderer_->RenderIcon(GfxContext, *it, base, base);
+
+    if (arg.y_rotation < 0)
+      icon_renderer_->RenderIcon(GfxContext, arg, base, base);
   }
 
-  std::list<RenderArg>::reverse_iterator rit;
-  for (rit = last_args_.rbegin(); rit != last_args_.rend(); ++rit)
+  for (auto rit = last_args_.rbegin(); rit != last_args_.rend(); ++rit)
   {
     if (rit->y_rotation >= 0)
       icon_renderer_->RenderIcon(GfxContext, *rit, base, base);
@@ -589,7 +563,7 @@
   if (render_boxes)
   {
     float val = 0.1f;
-    for (LayoutWindow::Ptr layout : ExternalTargets())
+    for (LayoutWindow::Ptr const& layout : ExternalTargets())
     {
       gPainter.Paint2DQuadColor(GfxContext, layout->result, nux::Color(val, val, val ,val));
       val += 0.1f;
@@ -598,36 +572,24 @@
         val = 0.1f;
     }
 
-    for (rit = last_args_.rbegin(); rit != last_args_.rend(); ++rit)
+    for (auto rit = last_args_.rbegin(); rit != last_args_.rend(); ++rit)
     {
       nux::Geometry tmp (rit->render_center.x - 1, rit->render_center.y - 1, 2, 2);
       gPainter.Paint2DQuadColor(GfxContext, tmp, nux::color::Red);
     }
   }
 
-  // render orange box that will encirlce active item(s)
-  for (LayoutWindow::Ptr window : ExternalTargets())
+  if (text_view_->IsVisible())
   {
-    nux::Geometry const& geo_absolute = GetAbsoluteGeometry();
-    if (window->alpha >= 1.0f)
-    {
-      nux::Geometry orange_box = window->result;
-      orange_box.Expand(5, 5);
-      orange_box.x -= geo_absolute.x;
-      orange_box.y -= geo_absolute.y;
-
-      gPainter.PaintTextureShape(GfxContext, orange_box, rounding_texture_.GetPointer(), 6, 6, 6, 6, false);
-    }
+    text_view_->SetBaseY(last_background_.y + last_background_.height - 45);
+    text_view_->Draw(GfxContext, force_draw);
   }
 
-  text_view_->SetBaseY(last_background_.y + last_background_.height - 45);
-  text_view_->Draw(GfxContext, force_draw);
-
   int ms_since_change = TimeUtil::TimeDelta(&current_, &save_time_);
 
   if (ms_since_change < animation_length && !redraw_idle_)
   {
-    redraw_idle_.reset(new glib::Idle([&] () {
+    redraw_idle_.reset(new glib::Idle([this] () {
       QueueDraw();
       animation_draw_ = true;
       redraw_idle_.reset();
@@ -649,7 +611,7 @@
   // implementation is enough.
 
   int i = 0;
-  for (auto arg : last_args_)
+  for (auto const& arg : last_args_)
   {
     if (x < (arg.logical_center.x - half_size)
         || x > (arg.logical_center.x + half_size))

=== modified file 'launcher/SwitcherView.h'
--- launcher/SwitcherView.h	2012-11-06 18:19:09 +0000
+++ launcher/SwitcherView.h	2012-11-15 18:52:31 +0000
@@ -23,7 +23,7 @@
 #include "SwitcherModel.h"
 #include "unity-shared/AbstractIconRenderer.h"
 #include "unity-shared/StaticCairoText.h"
-#include "LayoutSystem.h"
+#include "unity-shared/LayoutSystem.h"
 #include "unity-shared/BackgroundEffectHelper.h"
 #include "unity-shared/UnityWindowView.h"
 
@@ -50,7 +50,7 @@
 
   SwitcherView();
 
-  ui::LayoutWindowList ExternalTargets ();
+  ui::LayoutWindow::Vector ExternalTargets();
 
   void SetModel(SwitcherModel::Ptr model);
   SwitcherModel::Ptr GetModel();
@@ -109,13 +109,14 @@
 
   void SaveLast ();
 
-  ui::LayoutSystem::Ptr layout_system_;
+  SwitcherModel::Ptr model_;
+  ui::LayoutSystem layout_system_;
   ui::AbstractIconRenderer::Ptr icon_renderer_;
-  SwitcherModel::Ptr model_;
+  nux::ObjectPtr<nux::StaticCairoText> text_view_;
+
+  bool animation_draw_;
   bool target_sizes_set_;
 
-  nux::ObjectPtr<nux::BaseTexture> rounding_texture_;
-  nux::ObjectPtr<nux::StaticCairoText> text_view_;
 
   std::list<ui::RenderArg> last_args_;
   std::list<ui::RenderArg> saved_args_;
@@ -123,13 +124,11 @@
   nux::Geometry last_background_;
   nux::Geometry saved_background_;
 
-  ui::LayoutWindowList render_targets_;
+  ui::LayoutWindow::Vector render_targets_;
 
   timespec current_;
   timespec save_time_;
 
-  bool animation_draw_;
-
   glib::Source::UniquePtr redraw_idle_;
 };
 

=== modified file 'panel/PanelMenuView.cpp'
--- panel/PanelMenuView.cpp	2012-11-12 16:23:54 +0000
+++ panel/PanelMenuView.cpp	2012-11-15 18:52:31 +0000
@@ -743,13 +743,6 @@
   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);
 
@@ -781,7 +774,6 @@
 
   x += text_width;
 
-  gtk_widget_path_free(widget_path);
   gtk_style_context_restore(style_context);
 }
 
@@ -1054,7 +1046,7 @@
       // 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 && wm.IsWindowDecorated(xid))
+      if (_is_maximized && wm.HasWindowDecorations(xid))
       {
         wm.Undecorate(xid);
         _maximized_set.insert(xid);
@@ -1185,7 +1177,7 @@
 
   // update the state of the window in the _decor_map
   WindowManager& wm = WindowManager::Default();
-  _decor_map[xid] = wm.IsWindowDecorated(xid);
+  _decor_map[xid] = wm.HasWindowDecorations(xid);
 
   if (_decor_map[xid])
     wm.Undecorate(xid);
@@ -1659,7 +1651,7 @@
     {
       Window xid = bamf_window_get_xid(window);
 
-      _decor_map[xid] = wm.IsWindowDecorated(xid);
+      _decor_map[xid] = wm.HasWindowDecorations(xid);
 
       if (_decor_map[xid])
         wm.Undecorate(xid);

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-11-06 18:19:09 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-11-15 18:52:31 +0000
@@ -77,7 +77,6 @@
 using launcher::AbstractLauncherIcon;
 using launcher::Launcher;
 using ui::LayoutWindow;
-using ui::LayoutWindowList;
 using util::Timer;
 
 DECLARE_LOGGER(logger, "unity.shell.compiz");
@@ -104,17 +103,17 @@
 const std::string RELAYOUT_TIMEOUT = "relayout-timeout";
 } // namespace local
 
-namespace scale
+namespace win
 {
 namespace decoration
 {
 const unsigned CLOSE_SIZE = 19;
 const unsigned ITEMS_PADDING = 5;
 const unsigned RADIUS = 8;
-const unsigned GLOW = 30;
+const unsigned GLOW = 5;
 const nux::Color GLOW_COLOR(221, 72, 20);
 } // decoration namespace
-} // scale namespace
+} // win namespace
 
 } // anon namespace
 
@@ -403,6 +402,10 @@
         sigc::mem_fun(this, &UnityScreen::OnMinimizeDurationChanged)
     );
 
+    WindowManager& wm = WindowManager::Default();
+    wm.initiate_spread.connect(sigc::mem_fun(this, &UnityScreen::OnInitiateSpread));
+    wm.terminate_spread.connect(sigc::mem_fun(this, &UnityScreen::OnTerminateSpread));
+
     AddChild(&screen_introspection_);
   }
 }
@@ -463,6 +466,22 @@
 
 }
 
+void UnityScreen::OnInitiateSpread()
+{
+  UnityWindow::SetupSharedTextures();
+
+  for (auto const& swin : ScaleScreen::get(screen)->getWindows())
+    UnityWindow::get(swin->window)->OnInitiateSpread();
+}
+
+void UnityScreen::OnTerminateSpread()
+{
+  for (auto const& swin : ScaleScreen::get(screen)->getWindows())
+    UnityWindow::get(swin->window)->OnTerminateSpread();
+
+  UnityWindow::CleanupSharedTextures();
+}
+
 void UnityScreen::EnsureSuperKeybindings()
 {
   for (auto action : _shortcut_actions)
@@ -700,12 +719,12 @@
   // Reload the windows themed textures
   UnityWindow::CleanupSharedTextures();
 
-  if (WindowManager::Default().IsScaleActive())
+  if (!fake_decorated_windows_.empty())
   {
     UnityWindow::SetupSharedTextures();
 
-    for (auto const& swin : ScaleScreen::get(screen)->getWindows())
-      UnityWindow::get(swin->window)->CleanupCachedTextures();
+    for (UnityWindow* uwin : fake_decorated_windows_)
+      uwin->CleanupCachedTextures();
   }
 }
 
@@ -778,18 +797,18 @@
     }
   }
 
- if (switcher_controller_->Visible ())
+  if (switcher_controller_->Visible())
   {
-    LayoutWindowList targets = switcher_controller_->ExternalRenderTargets ();
+    LayoutWindow::Vector const& targets = switcher_controller_->ExternalRenderTargets();
 
-    for (LayoutWindow::Ptr target : targets)
+    for (LayoutWindow::Ptr const& target : targets)
     {
-      CompWindow* window = screen->findWindow(target->xid);
-      if (window)
+      if (CompWindow* window = screen->findWindow(target->xid))
       {
-        UnityWindow *unity_window = UnityWindow::get (window);
-
-        unity_window->paintThumbnail (target->result, target->alpha);
+        UnityWindow *unity_window = UnityWindow::get(window);
+        double scale = target->result.width / static_cast<double>(target->geo.width);
+        unity_window->paintThumbnail(target->result, target->alpha, scale,
+                                     target->decoration_height, target->selected);
       }
     }
   }
@@ -853,28 +872,6 @@
        && !fullscreen_windows_.empty () && (!(screen->grabbed () && !screen->otherGrabExist (NULL))));
 }
 
-void UnityWindow::paintThumbnail (nux::Geometry const& bounding, float alpha)
-{
-  GLMatrix matrix;
-  matrix.toScreenSpace (UnityScreen::get (screen)->_last_output, -DEFAULT_Z_CAMERA);
-
-  nux::Geometry geo = bounding;
-  last_bound = geo;
-
-  GLWindowPaintAttrib attrib = gWindow->lastPaintAttrib ();
-  attrib.opacity = (GLushort) (alpha * G_MAXUSHORT);
-
-  paintThumb (attrib,
-              matrix,
-              0,
-              geo.x,
-              geo.y,
-              geo.width,
-              geo.height,
-              geo.width,
-              geo.height);
-}
-
 void UnityScreen::EnableCancelAction(CancelActionTarget target, bool enabled, int modifiers)
 {
   if (enabled)
@@ -1172,7 +1169,10 @@
         }
 
         if (old_state != close_icon_state_)
-          DoAddDamage();
+        {
+          auto const& g = close_button_geo_;
+          cWindow->addDamageRect(CompRect(g.x, g.y, g.width, g.height));
+        }
       }
       break;
 
@@ -1181,7 +1181,8 @@
           close_button_geo_.IsPointInside(event->xbutton.x_root, event->xbutton.y_root))
       {
         close_icon_state_ = panel::WindowState::PRESSED;
-        DoAddDamage();
+        auto const& g = close_button_geo_;
+        cWindow->addDamageRect(CompRect(g.x, g.y, g.width, g.height));
         handled = true;
       }
       else if (event->xbutton.button == Button2 &&
@@ -1199,7 +1200,8 @@
         if (close_icon_state_ != panel::WindowState::NORMAL)
         {
           close_icon_state_ = panel::WindowState::NORMAL;
-          DoAddDamage();
+          auto const& g = close_button_geo_;
+          cWindow->addDamageRect(CompRect(g.x, g.y, g.width, g.height));
         }
 
         if (was_pressed)
@@ -1424,6 +1426,7 @@
   if (qm)
   {
     QuicklistView* view = qm->Current();
+
     if (view)
     {
       nux::Geometry const& geo = view->GetAbsoluteGeometry();
@@ -1433,6 +1436,20 @@
         view->QueueDraw();
     }
   }
+
+  if (switcher_controller_ && switcher_controller_->Visible())
+  {
+    unity::switcher::SwitcherView* view = switcher_controller_->GetView();
+
+    if (G_LIKELY(view))
+    {
+      nux::Geometry const& geo = view->GetAbsoluteGeometry();
+      CompRegion switcher_region(geo.x, geo.y, geo.width, geo.height);
+
+      if (damage.intersects(switcher_region))
+        view->QueueDraw();
+    }
+  }
 }
 
 /* Grab changed nux regions and add damage rects for them */
@@ -1879,6 +1896,7 @@
       show_mode = switcher::ShowMode::CURRENT_VIEWPORT;
   }
 
+  UnityWindow::SetupSharedTextures();
   SetUpAndShowSwitcher(show_mode);
 
   return true;
@@ -2110,27 +2128,29 @@
 void UnityScreen::OnSwitcherStart(GVariant* data)
 {
   if (switcher_controller_->Visible())
+  {
     SaveInputThenFocus(switcher_controller_->GetSwitcherInputWindowId());
+    UnityWindow::SetupSharedTextures();
+  }
 }
 
 void UnityScreen::OnSwitcherEnd(GVariant* data)
 {
   RestoreWindow(data);
+  UnityWindow::CleanupSharedTextures();
+
+  for (UnityWindow* uwin : fake_decorated_windows_)
+    uwin->CleanupCachedTextures();
 }
 
 void UnityScreen::RestoreWindow(GVariant* data)
 {
-  bool preserve_focus = false;
-
-  if (data)
-  {
-    preserve_focus = g_variant_get_boolean(data);
-  }
+  bool preserve_focus = data ? g_variant_get_boolean(data) : false;
 
   // Return input-focus to previously focused window (before key-nav-mode was
   // entered)
   if (preserve_focus)
-    PluginAdapter::Default().RestoreInputFocus ();
+    PluginAdapter::Default().RestoreInputFocus();
 }
 
 bool UnityScreen::SaveInputThenFocus(const guint xid)
@@ -2446,11 +2466,8 @@
 
   if (WindowManager::Default().IsScaleActive() && ScaleScreen::get(screen)->getSelectedWindow() == window->id())
   {
-    nux::Geometry scaled_geo = GetScaledGeometry();
-    int inside_glow = scale::decoration::RADIUS/4;
-    scaled_geo.Expand(-inside_glow, -inside_glow);
-    glow::Quads const& quads = computeGlowQuads(scaled_geo, glow_texture_, scale::decoration::GLOW);
-    paintGlow(matrix, attrib, region, quads, glow_texture_, scale::decoration::GLOW_COLOR, mask);
+    nux::Geometry const& scaled_geo = GetScaledGeometry();
+    paintInnerGlow(scaled_geo, matrix, attrib, mask);
   }
 
   return gWindow->glPaint(wAttrib, matrix, region, mask);
@@ -2759,8 +2776,8 @@
   nux::Point result(pos.x(), pos.y());
 
   // seriously why does compiz not track monitors XRandR style???
-  auto monitors = UScreen::GetDefault()->GetMonitors();
-  for (auto monitor : monitors)
+  auto const& monitors = UScreen::GetDefault()->GetMonitors();
+  for (auto const& monitor : monitors)
   {
     if (monitor.IsInside(result))
     {
@@ -2769,12 +2786,13 @@
     }
   }
 
-  auto launchers = us->launcher_controller_->launchers();
-  for (auto launcher : launchers)
+  auto const& launchers = us->launcher_controller_->launchers();
+
+  for (auto const& launcher : launchers)
   {
     nux::Geometry geo = launcher->GetAbsoluteGeometry();
 
-    if (launcher->Hidden() || launcher->options()->hide_mode == LAUNCHER_HIDE_NEVER || launcher->options()->hide_mode == LAUNCHER_HIDE_AUTOHIDE)
+    if (launcher->options()->hide_mode == LAUNCHER_HIDE_AUTOHIDE && launcher->Hidden())
       continue;
 
     if (geo.IsInside(result))
@@ -2786,7 +2804,7 @@
     }
   }
 
-  for (nux::Geometry &geo : us->panel_controller_->GetGeometries ())
+  for (nux::Geometry const& geo : us->panel_controller_->GetGeometries())
   {
     if (geo.IsInside(result))
     {
@@ -3543,9 +3561,6 @@
       }
     }
   }
-  WindowManager& wm = WindowManager::Default();
-  wm.initiate_spread.connect(sigc::mem_fun(this, &UnityWindow::OnInitiateSpread));
-  wm.terminate_spread.connect(sigc::mem_fun(this, &UnityWindow::OnTerminateSpread));
 }
 
 
@@ -3560,6 +3575,7 @@
     .add(scaled ? GetScaledGeometry() : wm.GetWindowGeometry(xid))
     .add("xid", xid)
     .add("title", wm.GetWindowName(xid))
+    .add("fake_decorated", uScreen->fake_decorated_windows_.find(this) != uScreen->fake_decorated_windows_.end())
     .add("scaled", scaled)
     .add("scaled_close_x", close_button_geo_.x)
     .add("scaled_close_y", close_button_geo_.y)
@@ -3618,7 +3634,7 @@
   cairo_pop_group_to_source(context.cr_);
 
   // Round window decoration top border
-  const double radius = scale::decoration::RADIUS * aspect;
+  const double radius = win::decoration::RADIUS * aspect;
 
   cairo_new_sub_path(context.cr_);
   cairo_line_to(context.cr_, 0, context.h_);
@@ -3653,6 +3669,7 @@
   pango_layout_context_changed(layout);
 
   decoration_title_ = WindowManager::Default().GetWindowName(window->id());
+
   pango_layout_set_height(layout, height);
   pango_layout_set_width(layout, -1); //avoid wrap lines
   pango_layout_set_auto_dir(layout, false);
@@ -3663,13 +3680,6 @@
 
   GtkStyleContext* style_context = style.GetStyleContext();
   gtk_style_context_save(style_context);
-
-  std::shared_ptr<GtkWidgetPath> widget_path(gtk_widget_path_new(), gtk_widget_path_free);
-  gtk_widget_path_append_type(widget_path.get(), GTK_TYPE_MENU_BAR);
-  gtk_widget_path_append_type(widget_path.get(), GTK_TYPE_MENU_ITEM);
-  gtk_widget_path_iter_set_name(widget_path.get(), -1 , "UnityPanelWidget");
-
-  gtk_style_context_set_path(style_context, widget_path.get());
   gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
   gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
 
@@ -3680,7 +3690,6 @@
   int text_height = lRect.height / PANGO_SCALE;
   int text_space = width - x;
   y += (height - text_height) / 2.0f;
-
   if (text_width > text_space)
   {
     // Cut the text with fade
@@ -3711,11 +3720,12 @@
   if (decoration_tex_)
     return;
 
-  auto const& border_extents = window->border();
+  auto& wm = WindowManager::Default();
+  auto const& deco_size = wm.GetWindowDecorationSize(window->id(), WindowManager::Edge::TOP);
 
-  if (WindowManager::Default().IsWindowDecorated(window->id()) && border_extents.top > 0)
+  if (deco_size.height)
   {
-    CairoContext context(window->borderRect().width(), window->border().top);
+    CairoContext context(deco_size.width, deco_size.height);
     RenderDecoration(context);
     decoration_tex_ = context.pixmap_texture_;
   }
@@ -3733,7 +3743,7 @@
   for (std::string const& file : files)
   {
     CompString file_name = file;
-    CompSize size(scale::decoration::CLOSE_SIZE, scale::decoration::CLOSE_SIZE);
+    CompSize size(win::decoration::CLOSE_SIZE, win::decoration::CLOSE_SIZE);
     texture = GLTexture::readImageToTexture(file_name, plugin, size);
     if (!texture.empty())
       break;
@@ -3748,7 +3758,7 @@
       suffix = "_pressed";
 
     CompString file_name(PKGDATADIR"/close_dash" + suffix + ".png");
-    CompSize size(scale::decoration::CLOSE_SIZE, scale::decoration::CLOSE_SIZE);
+    CompSize size(win::decoration::CLOSE_SIZE, win::decoration::CLOSE_SIZE);
     texture = GLTexture::readImageToTexture(file_name, plugin, size);
   }
 }
@@ -3781,30 +3791,8 @@
   decoration_title_.clear();
 }
 
-void UnityWindow::scalePaintDecoration(GLWindowPaintAttrib const& attrib,
-                                       GLMatrix const& transform,
-                                       CompRegion const& region,
-                                       unsigned int mask)
+void UnityWindow::paintFakeDecoration(nux::Geometry const& geo, GLWindowPaintAttrib const& attrib, GLMatrix const& transform, unsigned int mask, bool highlighted, double scale)
 {
-  ScaleWindow* scale_win = ScaleWindow::get(window);
-  scale_win->scalePaintDecoration(attrib, transform, region, mask);
-
-  if (!scale_win->hasSlot()) // animation not finished
-    return;
-
-  ScaleScreen* ss = ScaleScreen::get(screen);
-  auto state = ss->getState();
-
-  if (state != ScaleScreen::Wait && state != ScaleScreen::Out)
-    return;
-
-  auto const& scaled_geo = GetScaledGeometry();
-  auto const& pos = scale_win->getCurrentPosition();
-
-  const bool highlighted = (ss->getSelectedWindow() == window->id());
-  int x = scaled_geo.x;
-  int y = scaled_geo.y;
-
   mask |= PAINT_WINDOW_BLEND_MASK;
 
   if (!highlighted)
@@ -3812,22 +3800,24 @@
     BuildDecorationTexture();
 
     if (decoration_tex_)
-      DrawTexture(decoration_tex_->texture_, attrib, transform, mask, x, y, pos.scale);
+      DrawTexture(decoration_tex_->texture_, attrib, transform, mask, geo.x, geo.y, scale);
 
     close_button_geo_.Set(0, 0, 0, 0);
   }
   else
   {
-    auto const& decoration_extents = window->border();
-    unsigned width = scaled_geo.width;
-    unsigned height = decoration_extents.top;
+    Window xid = window->id();
+    auto& wm = WindowManager::Default();
+    auto const& deco_top = wm.GetWindowDecorationSize(xid, WindowManager::Edge::TOP);
+    unsigned width = geo.width;
+    unsigned height = deco_top.height;
     bool redraw_decoration = true;
 
     if (decoration_selected_tex_)
     {
       if (decoration_selected_tex_->w_ == width && decoration_selected_tex_->h_ == height)
       {
-        if (decoration_title_ == WindowManager::Default().GetWindowName(window->id()))
+        if (decoration_title_ == wm.GetWindowName(xid))
           redraw_decoration = false;
       }
     }
@@ -3837,24 +3827,26 @@
       if (width != 0 && height != 0)
       {
         CairoContext context(width, height);
-        RenderDecoration(context, pos.scale);
+        RenderDecoration(context, scale);
 
         // Draw window title
-        int text_x = scale::decoration::ITEMS_PADDING * 2 + scale::decoration::CLOSE_SIZE;
-        RenderText(context, text_x, 0.0, width - scale::decoration::ITEMS_PADDING, height);
+        int text_x = win::decoration::ITEMS_PADDING * 2 + win::decoration::CLOSE_SIZE;
+        RenderText(context, text_x, 0.0, width - win::decoration::ITEMS_PADDING, height);
         decoration_selected_tex_ = context.pixmap_texture_;
+        uScreen->damageRegion(CompRegion(geo.x, geo.y, width, height));
       }
       else
       {
         decoration_selected_tex_.reset();
+        redraw_decoration = false;
       }
     }
 
     if (decoration_selected_tex_)
-      DrawTexture(decoration_selected_tex_->texture_, attrib, transform, mask, x, y);
+      DrawTexture(decoration_selected_tex_->texture_, attrib, transform, mask, geo.x, geo.y);
 
-    x += scale::decoration::ITEMS_PADDING;
-    y += (height - scale::decoration::CLOSE_SIZE) / 2.0f;
+    int x = geo.x + win::decoration::ITEMS_PADDING;
+    int y = geo.y + (height - win::decoration::CLOSE_SIZE) / 2.0f;
 
     switch (close_icon_state_)
     {
@@ -3872,8 +3864,34 @@
         break;
     }
 
-    close_button_geo_.Set(x, y, scale::decoration::CLOSE_SIZE, scale::decoration::CLOSE_SIZE);
+    close_button_geo_.Set(x, y, win::decoration::CLOSE_SIZE, win::decoration::CLOSE_SIZE);
   }
+
+  uScreen->fake_decorated_windows_.insert(this);
+}
+
+void UnityWindow::scalePaintDecoration(GLWindowPaintAttrib const& attrib,
+                                       GLMatrix const& transform,
+                                       CompRegion const& region,
+                                       unsigned int mask)
+{
+  ScaleWindow* scale_win = ScaleWindow::get(window);
+  scale_win->scalePaintDecoration(attrib, transform, region, mask);
+
+  if (!scale_win->hasSlot()) // animation not finished
+    return;
+
+  ScaleScreen* ss = ScaleScreen::get(screen);
+  auto state = ss->getState();
+
+  if (state != ScaleScreen::Wait && state != ScaleScreen::Out)
+    return;
+
+  auto const& scaled_geo = GetScaledGeometry();
+  auto const& pos = scale_win->getCurrentPosition();
+
+  bool highlighted = (ss->getSelectedWindow() == window->id());
+  paintFakeDecoration(scaled_geo, attrib, transform, mask, highlighted, pos.scale);
 }
 
 nux::Geometry UnityWindow::GetScaledGeometry()
@@ -3884,10 +3902,10 @@
   auto const& border_rect = window->borderRect();
   auto const& deco_ext = window->border();
 
-  const unsigned width = std::floor(border_rect.width() * pos.scale);
-  const unsigned height = std::floor(border_rect.height() * pos.scale);
-  const int x = pos.x() + window->x() - std::floor(deco_ext.left * pos.scale);
-  const int y = pos.y() + window->y() - std::floor(deco_ext.top * pos.scale);
+  const unsigned width = std::round(border_rect.width() * pos.scale);
+  const unsigned height = std::round(border_rect.height() * pos.scale);
+  const int x = pos.x() + window->x() - std::round(deco_ext.left * pos.scale);
+  const int y = pos.y() + window->y() - std::round(deco_ext.top * pos.scale);
 
   return nux::Geometry(x, y, width, height);
 }
@@ -3896,12 +3914,11 @@
 {
   close_icon_state_ = panel::WindowState::NORMAL;
   middle_clicked_ = false;
-  SetupSharedTextures();
 
   WindowManager& wm = WindowManager::Default();
   Window xid = window->id();
 
-  if (wm.IsWindowDecorated(xid))
+  if (wm.HasWindowDecorations(xid))
     wm.Decorate(xid);
 }
 
@@ -3910,17 +3927,65 @@
   WindowManager& wm = WindowManager::Default();
   Window xid = window->id();
 
-  if (wm.IsWindowDecorated(xid) && wm.IsWindowMaximized(xid))
+  if (wm.IsWindowMaximized(xid))
     wm.Undecorate(xid);
 
   CleanupCachedTextures();
 }
 
+void UnityWindow::paintInnerGlow(nux::Geometry glow_geo, GLMatrix const& matrix, GLWindowPaintAttrib const& attrib, unsigned mask)
+{
+  unsigned glow_size = win::decoration::GLOW;
+
+  if (!glow_size)
+    return;
+
+  if (win::decoration::RADIUS > 0)
+  {
+    // We paint the glow below the window edges to correctly
+    // render the rounded corners
+    glow_size += win::decoration::RADIUS;
+    int inside_glow = win::decoration::RADIUS / 4;
+    glow_geo.Expand(-inside_glow, -inside_glow);
+  }
+
+  glow::Quads const& quads = computeGlowQuads(glow_geo, glow_texture_, glow_size);
+  paintGlow(matrix, attrib, quads, glow_texture_, win::decoration::GLOW_COLOR, mask);
+}
+
+void UnityWindow::paintThumbnail(nux::Geometry const& geo, float alpha, float scale_ratio, unsigned deco_height, bool selected)
+{
+  GLMatrix matrix;
+  matrix.toScreenSpace(UnityScreen::get(screen)->_last_output, -DEFAULT_Z_CAMERA);
+  last_bound = geo;
+
+  GLWindowPaintAttrib attrib = gWindow->lastPaintAttrib();
+  attrib.opacity = (alpha * G_MAXUSHORT);
+  unsigned mask = gWindow->lastMask();
+  nux::Geometry thumb_geo = geo;
+
+  if (selected)
+    paintInnerGlow(thumb_geo, matrix, attrib, mask);
+
+  thumb_geo.y += std::round(deco_height * 0.5f * scale_ratio);
+  nux::Geometry const& g = thumb_geo;
+
+  paintThumb(attrib, matrix, mask, g.x, g.y, g.width, g.height, g.width, g.height);
+
+  mask |= PAINT_WINDOW_BLEND_MASK;
+  attrib.opacity = OPAQUE;
+
+  // The thumbnail is still animating, don't draw the decoration as selected
+  if (selected && alpha < 1.0f)
+    selected = false;
+
+  paintFakeDecoration(geo, attrib, matrix, mask, selected, scale_ratio);
+}
+
 UnityWindow::~UnityWindow()
 {
-  UnityScreen* us = UnityScreen::get(screen);
-  if (us->newFocusedWindow && (UnityWindow::get(us->newFocusedWindow) == this))
-    us->newFocusedWindow = NULL;
+  if (uScreen->newFocusedWindow && UnityWindow::get(uScreen->newFocusedWindow) == this)
+    uScreen->newFocusedWindow = NULL;
 
   if (!window->destroyed ())
   {
@@ -3937,8 +4002,9 @@
   ShowdesktopHandler::animating_windows.remove (static_cast <ShowdesktopHandlerWindowInterface *> (this));
 
   if (window->state () & CompWindowStateFullscreenMask)
-    UnityScreen::get (screen)->fullscreen_windows_.remove(window);
+    uScreen->fullscreen_windows_.remove(window);
 
+  uScreen->fake_decorated_windows_.erase(this);
   PluginAdapter::Default().OnWindowClosed(window);
 }
 
@@ -4045,7 +4111,7 @@
   gfloat version = 0.0f;
   gint32 i;
 
-  for (i = 0; isdigit(version_string[i]); i++)
+  for (i = 0; isdigit(version_string[i]); ++i)
     version = version * 10.0f + (version_string[i] - 48);
 
   if ((version_string[i] == '.' || version_string[i] == ',') &&

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-11-06 18:19:09 +0000
+++ plugins/unityshell/src/unityshell.h	2012-11-15 18:52:31 +0000
@@ -68,6 +68,7 @@
 
 namespace unity
 {
+class UnityWindow;
 
 /* base screen class */
 class UnityScreen :
@@ -233,6 +234,9 @@
   void OnSwitcherStart(GVariant* data);
   void OnSwitcherEnd(GVariant* data);
 
+  void OnInitiateSpread();
+  void OnTerminateSpread();
+
   void RestoreWindow(GVariant* data);
   bool SaveInputThenFocus(const guint xid);
 
@@ -328,6 +332,7 @@
   bool panel_texture_has_changed_;
   bool paint_panel_;
   nux::ObjectPtr<nux::IOpenGLBaseTexture> panel_texture_;
+  std::set<UnityWindow*> fake_decorated_windows_;
 
   bool scale_just_activated_;
   WindowMinimizeSpeedController minimize_speed_controller_;
@@ -387,7 +392,7 @@
   CompPoint tryNotIntersectUI(CompPoint& pos);
   nux::Geometry GetScaledGeometry();
 
-  void paintThumbnail(nux::Geometry const& bounding, float alpha);
+  void paintThumbnail(nux::Geometry const& bounding, float alpha, float scale_ratio, unsigned deco_height, bool selected);
 
   void enterShowDesktop();
   void leaveShowDesktop();
@@ -449,9 +454,11 @@
   void DrawTexture(GLTexture::List const& textures, GLWindowPaintAttrib const&,
                    GLMatrix const&, unsigned mask, int x, int y, double aspect = 1.0f);
 
+  void paintFakeDecoration(nux::Geometry const& geo, GLWindowPaintAttrib const& attrib, GLMatrix const& transform, unsigned int mask, bool highlighted, double scale);
+  void paintInnerGlow(nux::Geometry glow_geo, GLMatrix const&, GLWindowPaintAttrib const&, unsigned mask);
   glow::Quads computeGlowQuads(nux::Geometry const& geo, GLTexture::List const& texture, int glow_size);
-  void paintGlow(GLMatrix const&, GLWindowPaintAttrib const&, CompRegion const&,
-                 glow::Quads const&, GLTexture::List const&, nux::Color const&, unsigned mask);
+  void paintGlow(GLMatrix const&, GLWindowPaintAttrib const&, glow::Quads const&,
+                 GLTexture::List const&, nux::Color const&, unsigned mask);
 
   void BuildDecorationTexture();
   void CleanupCachedTextures();

=== modified file 'plugins/unityshell/src/unityshell_glow.cpp'
--- plugins/unityshell/src/unityshell_glow.cpp	2012-10-05 14:32:39 +0000
+++ plugins/unityshell/src/unityshell_glow.cpp	2012-11-15 18:52:31 +0000
@@ -39,9 +39,8 @@
 
 void
 UnityWindow::paintGlow(GLMatrix const& transform, GLWindowPaintAttrib const& attrib,
-                       CompRegion const& paintRegion, glow::Quads const& glow_quads,
-                       GLTexture::List const& outline_texture, nux::Color const& color,
-                       unsigned mask)
+                       glow::Quads const& glow_quads, GLTexture::List const& outline_texture,
+                       nux::Color const& color, unsigned mask)
 {
   GLushort colorData[4];
   colorData[0] = color.red * 0xffff;
@@ -144,6 +143,7 @@
   CompRect *box;
   GLTexture::Matrix *quadMatrix;
 
+  glow_size = glow_size * texture::GLOW_SIZE / (texture::GLOW_SIZE - texture::GLOW_OFFSET);
   glow_offset = (glow_size * texture::GLOW_OFFSET / texture::GLOW_SIZE) + 1;
 
   /* Top left corner */

=== removed file 'resources/switcher_round_rect.png'
Binary files resources/switcher_round_rect.png	2011-09-22 15:00:17 +0000 and resources/switcher_round_rect.png	1970-01-01 00:00:00 +0000 differ
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-11-13 23:03:47 +0000
+++ tests/CMakeLists.txt	2012-11-15 18:52:31 +0000
@@ -136,6 +136,7 @@
        test_favorite_store_private.cpp
        test_home_lens.cpp
        test_launcher_entry_remote.cpp
+       test_layout_system.cpp
        test_model_iterator.cpp
        test_previews.cpp
        test_ubus.cpp
@@ -152,6 +153,7 @@
   set (GTEST_XLESS_LIBS
       gtest
       unity-shared
+      unity-shared-standalone
       launcher-lib
       ${GMOCK_LIB}
       ${GMOCK_MAIN_LIB}

=== modified file 'tests/autopilot/unity/emulators/screen.py'
--- tests/autopilot/unity/emulators/screen.py	2012-11-06 18:19:09 +0000
+++ tests/autopilot/unity/emulators/screen.py	2012-11-15 18:52:31 +0000
@@ -27,6 +27,14 @@
         """Return the available scaled windows, or None."""
         return self.get_children_by_type(Window, scaled=True)
 
+    def window(self, xid):
+        """Return the window with given xid."""
+        windows = self.get_children_by_type(Window, xid=xid)
+        if len(windows):
+            return windows[0]
+
+        return None
+
 
 class Window(UnityIntrospectionObject):
     """An individual window."""

=== modified file 'tests/autopilot/unity/emulators/switcher.py'
--- tests/autopilot/unity/emulators/switcher.py	2012-07-10 20:41:57 +0000
+++ tests/autopilot/unity/emulators/switcher.py	2012-11-15 18:52:31 +0000
@@ -72,6 +72,16 @@
         return self.controller.model.selection_index
 
     @property
+    def label(self):
+        """The current switcher label"""
+        return self.controller.view.label
+
+    @property
+    def label_visible(self):
+        """The switcher label visibility"""
+        return self.controller.view.label_visible
+
+    @property
     def mode(self):
         """Returns the SwitcherMode that the switcher is currently in."""
         if not self.visible:
@@ -126,7 +136,7 @@
         If no icon matches, a ValueError will be raised.
 
         """
-        if self.mode != SwitcherMode.NORMAL:
+        if self.mode == SwitcherMode.DETAIL:
             raise RuntimeError("Switcher must be initiated in normal mode before calling this method.")
 
         if direction not in (self.DIRECTION_BACKWARDS, self.DIRECTION_FORWARDS):

=== modified file 'tests/autopilot/unity/tests/test_switcher.py'
--- tests/autopilot/unity/tests/test_switcher.py	2012-11-06 18:19:09 +0000
+++ tests/autopilot/unity/tests/test_switcher.py	2012-11-15 18:52:31 +0000
@@ -14,7 +14,7 @@
 from testtools.matchers import Equals, Contains, Not
 from time import sleep
 
-from unity.emulators.switcher import SwitcherMode
+from unity.emulators.switcher import Switcher, SwitcherMode
 from unity.tests import UnityTestCase
 
 logger = logging.getLogger(__name__)
@@ -75,7 +75,7 @@
     def tearDown(self):
         super(SwitcherTests, self).tearDown()
 
-    def test_witcher_starts_in_normal_mode(self):
+    def test_switcher_starts_in_normal_mode(self):
         """Switcher must start in normal (i.e.- not details) mode."""
         self.start_app("Character Map")
 
@@ -83,15 +83,38 @@
         self.addCleanup(self.switcher.terminate)
         self.assertProperty(self.switcher, mode=SwitcherMode.NORMAL)
 
-    def test_first_detail_mode_has_correct_label(self):
-        """Starting switcher in details mode must show the focused window title."""
-        window = self.start_app_window("Text Editor")
-        title = window.title
-
+    def test_label_matches_application_name(self):
+        """The switcher label must match the selected application name in normal mode."""
+        windows = self.start_applications()
+        self.switcher.initiate()
+        self.addCleanup(self.switcher.terminate)
+
+        for win in windows:
+            app_name = win.application.name
+            self.switcher.select_icon(Switcher.DIRECTION_FORWARDS, tooltip_text=app_name)
+            self.assertThat(self.switcher.label_visible, Eventually(Equals(True)))
+            self.assertThat(self.switcher.label, Eventually(Equals(app_name)))
+
+    def test_application_window_is_fake_decorated(self):
+        """When the switcher is in details mode must not show the focused window title."""
+        window = self.start_app_window("Text Editor")
+        self.switcher.initiate()
+        self.addCleanup(self.switcher.terminate)
+
+        self.switcher.select_icon(Switcher.DIRECTION_BACKWARDS, tooltip_text=window.application.name)
+
+        self.switcher.show_details()
+        self.assertThat(self.switcher.label_visible, Eventually(Equals(False)))
+        self.assertThat(self.screen.window(window.x_id).fake_decorated, Eventually(Equals(True)))
+
+    def test_application_window_is_fake_decorated_in_detail_mode(self):
+        """Starting switcher in details mode must not show the focused window title."""
+        window = self.start_app_window("Text Editor")
         self.switcher.initiate(SwitcherMode.DETAIL)
         self.addCleanup(self.switcher.terminate)
 
-        self.assertThat(self.switcher.controller.view.label, Eventually(Equals(title)))
+        self.assertThat(self.switcher.label_visible, Eventually(Equals(False)))
+        self.assertThat(self.screen.window(window.x_id).fake_decorated, Eventually(Equals(True)))
 
     def test_switcher_move_next(self):
         """Test that pressing the next icon binding moves to the next icon"""

=== added file 'tests/test_layout_system.cpp'
--- tests/test_layout_system.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_layout_system.cpp	2012-11-15 18:52:31 +0000
@@ -0,0 +1,158 @@
+/*
+ * Copyright 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 published
+ * by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#include <gmock/gmock.h>
+#include "LayoutSystem.h"
+#include "StandaloneWindowManager.h"
+
+namespace unity
+{
+namespace ui
+{
+namespace
+{
+StandaloneWindowManager* wm = nullptr;
+
+StandaloneWindow::Ptr AddFakeWindowToWM(Window xid, nux::Geometry const& geo = nux::Geometry(1, 2, 30, 40))
+{
+  const unsigned top_deco = 5;
+  auto fake_window = std::make_shared<StandaloneWindow>(xid);
+  fake_window->geo = geo;
+  fake_window->deco_sizes[unsigned(WindowManager::Edge::TOP)] = nux::Size(geo.width, top_deco);
+
+  if (!wm)
+    wm = dynamic_cast<StandaloneWindowManager*>(&WindowManager::Default());
+
+  wm->AddStandaloneWindow(fake_window);
+
+  return fake_window;
+}
+
+TEST(TestLayoutWindow, InitializationNormalWindow)
+{
+  const Window xid = g_random_int();
+  auto fake_window = AddFakeWindowToWM(xid);
+
+  LayoutWindow lwin(xid);
+  EXPECT_EQ(lwin.xid, xid);
+  EXPECT_EQ(lwin.geo, fake_window->geo);
+  EXPECT_EQ(lwin.decoration_height, 0);
+  EXPECT_EQ(lwin.selected, false);
+  EXPECT_EQ(lwin.aspect_ratio, fake_window->geo.width / static_cast<float>(fake_window->geo.height));
+}
+
+TEST(TestLayoutWindow, InitializationMinimizedNormalWindow)
+{
+  const Window xid = g_random_int();
+  auto fake_window = AddFakeWindowToWM(xid);
+  wm->Minimize(xid);
+
+  LayoutWindow lwin(xid);
+  EXPECT_EQ(lwin.xid, xid);
+  EXPECT_EQ(lwin.geo, fake_window->geo);
+  EXPECT_EQ(lwin.decoration_height, 0);
+  EXPECT_EQ(lwin.selected, false);
+  EXPECT_EQ(lwin.aspect_ratio, fake_window->geo.width / static_cast<float>(fake_window->geo.height));
+}
+
+TEST(TestLayoutWindow, InitializationMaximizedWindow)
+{
+  const Window xid = g_random_int();
+  auto fake_window = AddFakeWindowToWM(xid);
+  wm->Maximize(xid);
+
+  nux::Geometry expected_geo(fake_window->geo);
+  unsigned top_deco = wm->GetWindowDecorationSize(xid, WindowManager::Edge::TOP).height;
+  expected_geo.height += top_deco;
+
+  LayoutWindow lwin(xid);
+  EXPECT_EQ(lwin.xid, xid);
+  EXPECT_EQ(lwin.geo, expected_geo);
+  EXPECT_EQ(lwin.decoration_height, top_deco);
+  EXPECT_EQ(lwin.selected, false);
+  EXPECT_EQ(lwin.aspect_ratio, expected_geo.width / static_cast<float>(expected_geo.height));
+}
+
+TEST(TestLayoutWindow, InitializationMinimizedMaximizedWindow)
+{
+  const Window xid = g_random_int();
+  auto fake_window = AddFakeWindowToWM(xid);
+  wm->Maximize(xid);
+  wm->Minimize(xid);
+
+  LayoutWindow lwin(xid);
+  EXPECT_EQ(lwin.xid, xid);
+  EXPECT_EQ(lwin.geo, fake_window->geo);
+  EXPECT_EQ(lwin.decoration_height, 0);
+  EXPECT_EQ(lwin.selected, false);
+  EXPECT_EQ(lwin.aspect_ratio, fake_window->geo.width / static_cast<float>(fake_window->geo.height));
+}
+
+struct TestLayoutSystem : testing::Test
+{
+  TestLayoutSystem()
+  {
+    Window xid = 1;
+    AddFakeWindowToWM(xid, nux::Geometry(4, 5, 500, 600));
+    lwindows.push_back(std::make_shared<LayoutWindow>(xid));
+
+    xid = 2;
+    AddFakeWindowToWM(xid, nux::Geometry(10, 20, 800, 300));
+    lwindows.push_back(std::make_shared<LayoutWindow>(xid));
+  }
+
+  LayoutSystem ls;
+  LayoutWindow::Vector lwindows;
+};
+
+TEST_F(TestLayoutSystem, Initialization)
+{
+  EXPECT_EQ(ls.spacing, 8);
+  EXPECT_EQ(ls.max_row_height, 400);
+}
+
+TEST_F(TestLayoutSystem, LayoutWindows)
+{
+  nux::Geometry max_bounds(0, 0, 200, 100);
+  nux::Geometry final_bounds;
+  ls.LayoutWindows(lwindows, max_bounds, final_bounds);
+
+  nux::Geometry const& win_new_geo1 = lwindows.at(0)->result;
+  nux::Geometry const& win_new_geo2 = lwindows.at(1)->result;
+
+  EXPECT_EQ(max_bounds.Intersect(final_bounds), final_bounds);
+  EXPECT_NE(lwindows.at(0)->geo, win_new_geo1);
+  EXPECT_NE(lwindows.at(1)->geo, win_new_geo1);
+
+  // Computing the area occupied by the grouped windows
+  unsigned min_start_x = std::min(win_new_geo1.x, win_new_geo2.x);
+  unsigned min_start_y = std::min(win_new_geo1.y, win_new_geo2.y);
+  unsigned max_last_x = std::max(win_new_geo1.x + win_new_geo1.width,
+                                 win_new_geo2.x + win_new_geo2.width);
+  unsigned max_last_y = std::max(win_new_geo1.y + win_new_geo1.height,
+                                 win_new_geo2.y + win_new_geo2.height);
+
+  nux::Geometry windows_area(min_start_x, min_start_y, max_last_x - min_start_x, max_last_y - min_start_y);
+
+  EXPECT_EQ(final_bounds.Intersect(windows_area), windows_area);
+}
+
+}
+}
+}

=== modified file 'tests/test_main.cpp'
--- tests/test_main.cpp	2012-11-06 18:19:09 +0000
+++ tests/test_main.cpp	2012-11-15 18:52:31 +0000
@@ -4,8 +4,6 @@
 #include <NuxCore/Logger.h>
 #include <Nux/Nux.h>
 
-#include "unity-shared/WindowManager.h"
-
 int main(int argc, char** argv)
 {
   ::testing::InitGoogleTest(&argc, argv);

=== modified file 'unity-shared/AbstractIconRenderer.h'
--- unity-shared/AbstractIconRenderer.h	2012-05-07 00:49:31 +0000
+++ unity-shared/AbstractIconRenderer.h	2012-11-15 18:52:31 +0000
@@ -21,7 +21,6 @@
 #define ABSTRACTICONRENDERER_H
 
 #include <Nux/Nux.h>
-#include <boost/shared_ptr.hpp>
 
 #include "IconTextureSource.h"
 
@@ -102,7 +101,7 @@
 class AbstractIconRenderer
 {
 public:
-  typedef boost::shared_ptr<AbstractIconRenderer> Ptr;
+  typedef std::shared_ptr<AbstractIconRenderer> Ptr;
 
   virtual ~AbstractIconRenderer() {}
 

=== modified file 'unity-shared/CMakeLists.txt'
--- unity-shared/CMakeLists.txt	2012-11-13 22:39:49 +0000
+++ unity-shared/CMakeLists.txt	2012-11-15 18:52:31 +0000
@@ -44,6 +44,7 @@
      Introspectable.cpp
      IntrospectableWrappers.cpp
      JSONParser.cpp
+     LayoutSystem.cpp
      LineSeparator.cpp
      OverlayRenderer.cpp
      PanelStyle.cpp

=== renamed file 'launcher/LayoutSystem.cpp' => 'unity-shared/LayoutSystem.cpp'
--- launcher/LayoutSystem.cpp	2012-10-11 01:44:15 +0000
+++ unity-shared/LayoutSystem.cpp	2012-11-15 18:52:31 +0000
@@ -23,40 +23,24 @@
 namespace ui {
 
 LayoutSystem::LayoutSystem()
-{
-  spacing = 8;
-  max_row_height = 400;
-}
-
-LayoutSystem::~LayoutSystem()
-{
-}
-
-void LayoutSystem::LayoutWindows(LayoutWindowList windows,
-                                 nux::Geometry const& max_bounds,
-                                 nux::Geometry& final_bounds)
-{
-  unsigned int size = windows.size();
-
-  if (size == 0)
+  : spacing(8)
+  , max_row_height(400)
+{}
+
+void LayoutSystem::LayoutWindows(LayoutWindow::Vector const& windows, nux::Geometry const& max_bounds, nux::Geometry& final_bounds)
+{
+  if (windows.empty())
     return;
 
-  WindowManager& wm = WindowManager::Default();
-  for (auto window : windows)
-  {
-  	window->geo = wm.GetWindowGeometry(window->xid);
-    window->aspect_ratio = (float)window->geo.width / (float)window->geo.height;
-  }
-
   LayoutGridWindows(windows, max_bounds, final_bounds);
 }
 
-nux::Size LayoutSystem::GridSizeForWindows(LayoutWindowList windows, nux::Geometry const& max_bounds)
+nux::Size LayoutSystem::GridSizeForWindows(LayoutWindow::Vector const& windows, nux::Geometry const& max_bounds)
 {
-  int count = (int)windows.size();
+  unsigned count = windows.size();
 
-  int width = 1;
-  int height = 1;
+  unsigned width = 1;
+  unsigned height = 1;
 
   if (count == 2)
   {
@@ -83,14 +67,14 @@
     }
   }
 
-  return nux::Size (width, height);
+  return nux::Size(width, height);
 }
 
-nux::Geometry LayoutSystem::CompressAndPadRow (LayoutWindowList const& windows, nux::Geometry const& max_bounds)
+nux::Geometry LayoutSystem::CompressAndPadRow(LayoutWindow::Vector const& windows, nux::Geometry const& max_bounds)
 {
   int total_width = 0;
   int max_height = 0;
-  for (LayoutWindow::Ptr window : windows)
+  for (LayoutWindow::Ptr const& window : windows)
   {
     window->result.x = total_width;
     total_width += spacing + window->result.width;
@@ -99,17 +83,17 @@
 
   total_width -= spacing;
 
-  int x1 = G_MAXINT;
-  int y1 = G_MAXINT;
-  int x2 = G_MININT;
-  int y2 = G_MININT;
+  int x1 = std::numeric_limits<int>::max();
+  int y1 = std::numeric_limits<int>::max();
+  int x2 = std::numeric_limits<int>::min();
+  int y2 = std::numeric_limits<int>::min();
 
   int offset = std::max (0, (max_bounds.width - total_width) / 2);
-  for (LayoutWindow::Ptr window : windows)
+  for (LayoutWindow::Ptr const& window : windows)
   {
     window->result.x += max_bounds.x + offset;
     window->result.y = max_bounds.y + (max_height - window->result.height) / 2;
-    
+
     x1 = std::min (window->result.x, x1);
     y1 = std::min (window->result.y, y1);
     x2 = std::max (window->result.x + window->result.width, x2);
@@ -119,13 +103,13 @@
   return nux::Geometry (x1, y1, x2 - x1, y2 - y1);
 }
 
-nux::Geometry LayoutSystem::LayoutRow (LayoutWindowList const& row, nux::Geometry const& row_bounds)
+nux::Geometry LayoutSystem::LayoutRow(LayoutWindow::Vector const& row, nux::Geometry const& row_bounds)
 {
   nux::Geometry unpadded_bounds = row_bounds;
   unpadded_bounds.width -= spacing * (row.size () - 1);
 
   int combined_width = 0;
-  for (LayoutWindow::Ptr window : row)
+  for (LayoutWindow::Ptr const& window : row)
   {
     float scalar = unpadded_bounds.height / (float)window->geo.height;
     combined_width += window->geo.width * scalar;
@@ -138,11 +122,11 @@
 
   // precision of X,Y is relatively unimportant as the Compression stage will fix any issues, sizing
   // is however set at this point.
-  for (LayoutWindow::Ptr window : row)
+  for (LayoutWindow::Ptr const& window : row)
   {
     // we dont allow scaling up
-    float final_scalar = std::min (1.0f, (unpadded_bounds.height / (float)window->geo.height) * global_scalar);
-    
+    float final_scalar = std::min(1.0f, (unpadded_bounds.height / (float)window->geo.height) * global_scalar);
+
     window->result.x = x;
     window->result.y = y;
     window->result.width = window->geo.width * final_scalar;
@@ -154,14 +138,14 @@
   return CompressAndPadRow (row, row_bounds);
 }
 
-std::vector<LayoutWindowList> LayoutSystem::GetRows (LayoutWindowList const& windows, nux::Geometry const& max_bounds)
+std::vector<LayoutWindow::Vector> LayoutSystem::GetRows(LayoutWindow::Vector const& windows, nux::Geometry const& max_bounds)
 {
-  std::vector<LayoutWindowList> rows;
+  std::vector<LayoutWindow::Vector> rows;
 
   int size = (int)windows.size();
 
   float total_aspect = 0;
-  for (LayoutWindow::Ptr window : windows)
+  for (LayoutWindow::Ptr const& window : windows)
   {
     total_aspect += window->aspect_ratio;
   }
@@ -173,7 +157,7 @@
   }
   else
   {
-    nux::Size grid_size = GridSizeForWindows (windows, max_bounds);
+    nux::Size const& grid_size = GridSizeForWindows(windows, max_bounds);
 
     int width = grid_size.width;
     int height = grid_size.height;
@@ -188,7 +172,7 @@
 
     float row_aspect = 0.0f;
 
-    LayoutWindowList row_accum;
+    LayoutWindow::Vector row_accum;
     
     int i;
     for (i = 0; i < size; ++i)
@@ -234,33 +218,34 @@
   return rows;
 }
 
-void LayoutSystem::LayoutGridWindows (LayoutWindowList const& windows, nux::Geometry const& max_bounds, nux::Geometry& final_bounds)
+void LayoutSystem::LayoutGridWindows(LayoutWindow::Vector const& windows, nux::Geometry const& max_bounds, nux::Geometry& final_bounds)
 {
-  std::vector<LayoutWindowList> rows = GetRows(windows, max_bounds);
-  
+  std::vector<LayoutWindow::Vector> const& rows = GetRows(windows, max_bounds);
+
   int height = rows.size();
   int non_spacing_height = max_bounds.height - ((height - 1) * spacing);
   int row_height = std::min (max_row_height(), non_spacing_height / height);
   int start_y = max_bounds.y;
   int low_y = 0;
 
-  for (LayoutWindowList row : rows)
+  for (LayoutWindow::Vector const& row : rows)
   {
-    nux::Geometry row_max_bounds (max_bounds.x, start_y, max_bounds.width, row_height);
-    nux::Geometry row_final_bounds = LayoutRow (row, row_max_bounds);
+    nux::Geometry row_max_bounds(max_bounds.x, start_y, max_bounds.width, row_height);
+    nux::Geometry const& row_final_bounds = LayoutRow(row, row_max_bounds);
 
     low_y = row_final_bounds.y + row_final_bounds.height;
 
     start_y += row_final_bounds.height + spacing;
   }
 
-  int x1 = G_MAXINT;
-  int y1 = G_MAXINT;
-  int x2 = G_MININT;
-  int y2 = G_MININT;
+  int x1 = std::numeric_limits<int>::max();
+  int y1 = std::numeric_limits<int>::max();
+  int x2 = std::numeric_limits<int>::min();
+  int y2 = std::numeric_limits<int>::min();
 
   int offset = (max_bounds.height - (low_y - max_bounds.y)) / 2;
-  for (auto window : windows)
+
+  for (auto const& window : windows)
   {
     window->result.y += offset;
 
@@ -274,9 +259,23 @@
 }
 
 LayoutWindow::LayoutWindow(Window xid)
- : xid (xid)
+ : xid(xid)
+ , geo(WindowManager::Default().GetWindowGeometry(xid))
+ , decoration_height(0)
+ , selected(false)
+ , aspect_ratio(geo.width / static_cast<float>(geo.height))
 {
+  auto& wm = WindowManager::Default();
 
+  if (wm.IsWindowMaximized(xid) && !wm.IsWindowMinimized(xid))
+  {
+    // Maximized windows are not decorated, so we define an extra decoration
+    // height to be used to correctly render the window with a fake decoration
+    auto const& deco_size = wm.GetWindowDecorationSize(xid, WindowManager::Edge::TOP);
+    decoration_height = deco_size.height;
+    geo.height += decoration_height;
+    aspect_ratio = geo.width / static_cast<float>(geo.height);
+  }
 }
 
 }

=== renamed file 'launcher/LayoutSystem.h' => 'unity-shared/LayoutSystem.h'
--- launcher/LayoutSystem.h	2012-10-11 01:44:15 +0000
+++ unity-shared/LayoutSystem.h	2012-11-15 18:52:31 +0000
@@ -20,7 +20,7 @@
 #ifndef UNITYSHELL_LAYOUTSYSTEM_H
 #define UNITYSHELL_LAYOUTSYSTEM_H
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include <sigc++/sigc++.h>
 #include <Nux/Nux.h>
 
@@ -29,48 +29,45 @@
 namespace unity {
 namespace ui {
 
-class LayoutWindow
+struct LayoutWindow
 {
-public:
-  typedef boost::shared_ptr<LayoutWindow> Ptr;
+  typedef std::shared_ptr<LayoutWindow> Ptr;
+  typedef std::vector<LayoutWindow::Ptr> Vector;
 
-  LayoutWindow (Window xid);
+  LayoutWindow(Window xid);
 
   Window xid;
 
   nux::Geometry geo;
   nux::Geometry result;
+  unsigned decoration_height;
 
+  bool selected;
   float aspect_ratio;
   float alpha;
 };
 
-typedef std::vector<LayoutWindow::Ptr> LayoutWindowList;
-
 class LayoutSystem
 {
 public:
-  typedef boost::shared_ptr<LayoutSystem> Ptr;
-
   nux::Property<int> spacing;
   nux::Property<int> max_row_height;
 
-  LayoutSystem ();
-  ~LayoutSystem ();
+  LayoutSystem();
 
-  void LayoutWindows (LayoutWindowList windows, nux::Geometry const& max_bounds, nux::Geometry& final_bounds);
+  void LayoutWindows(LayoutWindow::Vector const& windows, nux::Geometry const& max_bounds, nux::Geometry& final_bounds);
 
 protected:
-  void LayoutGridWindows (LayoutWindowList const& windows, nux::Geometry const& max_bounds, nux::Geometry& final_bounds);
-
-  nux::Geometry LayoutRow (LayoutWindowList const& row, nux::Geometry const& row_bounds);
-  nux::Geometry CompressAndPadRow (LayoutWindowList const& windows, nux::Geometry const& max_bounds);
-
-  std::vector<LayoutWindowList> GetRows (LayoutWindowList const& windows, nux::Geometry const& max_bounds);
-
-  nux::Size GridSizeForWindows (LayoutWindowList windows, nux::Geometry const& max_bounds);
-
-  nux::Geometry ScaleBoxIntoBox (nux::Geometry const& bounds, nux::Geometry const& box);
+  void LayoutGridWindows(LayoutWindow::Vector const& windows, nux::Geometry const& max_bounds, nux::Geometry& final_bounds);
+
+  nux::Geometry LayoutRow(LayoutWindow::Vector const& row, nux::Geometry const& row_bounds);
+  nux::Geometry CompressAndPadRow(LayoutWindow::Vector const& windows, nux::Geometry const& max_bounds);
+
+  std::vector<LayoutWindow::Vector> GetRows(LayoutWindow::Vector const& windows, nux::Geometry const& max_bounds);
+
+  nux::Size GridSizeForWindows(LayoutWindow::Vector const& windows, nux::Geometry const& max_bounds);
+
+  nux::Geometry ScaleBoxIntoBox(nux::Geometry const& bounds, nux::Geometry const& box);
 };
 
 }

=== modified file 'unity-shared/PluginAdapter.cpp'
--- unity-shared/PluginAdapter.cpp	2012-11-06 18:19:09 +0000
+++ unity-shared/PluginAdapter.cpp	2012-11-15 18:52:31 +0000
@@ -32,6 +32,7 @@
 {
 const int THRESHOLD_HEIGHT = 600;
 const int THRESHOLD_WIDTH = 1024;
+const char* _UNITY_FRAME_EXTENTS = "_UNITY_FRAME_EXTENTS";
 
 std::shared_ptr<PluginAdapter> global_instance;
 }
@@ -41,7 +42,6 @@
 #define MWM_HINTS_FUNCTIONS     (1L << 0)
 #define MWM_HINTS_DECORATIONS   (1L << 1)
 #define MWM_HINTS_UNDECORATED_UNITY 0x80
-#define _XA_MOTIF_WM_HINTS    "_MOTIF_WM_HINTS"
 
 
 WindowManagerPtr create_window_manager()
@@ -145,21 +145,29 @@
 
 void PluginAdapter::NotifyNewDecorationState(Window xid)
 {
-  bool wasTracked = (_window_decoration_state.find(xid) != _window_decoration_state.end());
+  auto deco_state_it = _window_decoration_state.find(xid);
+  bool wasTracked = (deco_state_it != _window_decoration_state.end());
   bool wasDecorated = false;
 
   if (wasTracked)
-    wasDecorated = _window_decoration_state[xid];
+  {
+    wasDecorated = deco_state_it->second;
+    _window_decoration_state.erase(deco_state_it);
+  }
 
-  bool decorated = IsWindowDecorated(xid);
+  bool decorated = HasWindowDecorations(xid);
 
   if (decorated == wasDecorated)
     return;
 
   if (decorated && (!wasDecorated || !wasTracked))
+  {
     window_decorated.emit(xid);
+  }
   else if (wasDecorated || !wasTracked)
+  {
     window_undecorated.emit(xid);
+  }
 }
 
 void PluginAdapter::Notify(CompWindow* window, CompWindowNotify notify)
@@ -212,6 +220,16 @@
     _vp_switch_started = false;
     screen_viewport_switch_ended.emit();
   }
+  else if (IsScaleActive() && g_strcmp0(plugin, "scale") == 0 &&
+           g_strcmp0(event, "activate") == 0)
+  {
+    // If the scale plugin is activated again while is already grabbing the screen
+    // it means that is switching the view (i.e. switching from a spread application
+    // to another), so we need to notify our clients that it has really terminated
+    // and initiated again.
+    terminate_spread.emit();
+    initiate_spread.emit();
+  }
 }
 
 void MultiActionList::AddNewAction(std::string const& name, CompAction* a, bool primary)
@@ -424,7 +442,7 @@
   return false;
 }
 
-bool PluginAdapter::IsWindowDecorated(Window window_id) const
+unsigned long PluginAdapter::GetMwnDecorations(Window window_id) const
 {
   Display* display = m_Screen->dpy();
   MotifWmHints* hints = NULL;
@@ -432,35 +450,61 @@
   gint format;
   gulong nitems;
   gulong bytes_after;
-  bool ret = true;
-
-  Atom hints_atom = XInternAtom(display, _XA_MOTIF_WM_HINTS, false);
-
-  if (XGetWindowProperty(display, window_id, hints_atom, 0,
+  unsigned long decorations = 0;
+
+  if (XGetWindowProperty(display, window_id, Atoms::mwmHints, 0,
                          sizeof(MotifWmHints) / sizeof(long), False,
-                         hints_atom, &type, &format, &nitems, &bytes_after,
+                         Atoms::mwmHints, &type, &format, &nitems, &bytes_after,
                          (guchar**)&hints) != Success)
-    return false;
+  {
+    return decorations;
+  }
+
+  decorations |= (MwmDecorAll | MwmDecorTitle);
 
   if (!hints)
-    return ret;
+    return decorations;
 
   /* Check for the presence of the high bit
    * if present, it means that we undecorated
    * this window, so don't mark it as undecorated */
-  if (type == hints_atom && format != 0 &&
-      hints->flags & MWM_HINTS_DECORATIONS)
+  if (type == Atoms::mwmHints && format != 0 && hints->flags & MWM_HINTS_DECORATIONS)
   {
-    /* Must have both bits set */
-    ret = (hints->decorations & (MwmDecorAll | MwmDecorTitle))  ||
-          (hints->decorations & MWM_HINTS_UNDECORATED_UNITY);
-    // This is mildly evil and we should look for another solution.
-    PluginAdapter* non_const_this = const_cast<PluginAdapter*>(this);
-    non_const_this->_window_decoration_state[window_id] = ret;
+    decorations = hints->decorations;
   }
 
   XFree(hints);
-  return ret;
+  return decorations;
+}
+
+bool PluginAdapter::HasWindowDecorations(Window window_id) const
+{
+  auto deco_state_it = _window_decoration_state.find(window_id);
+
+  if (deco_state_it != _window_decoration_state.end())
+    return deco_state_it->second;
+
+  unsigned long decorations = GetMwnDecorations(window_id);
+
+  /* Must have both bits set */
+  bool decorated = (decorations & (MwmDecorAll | MwmDecorTitle)) ||
+                   (decorations & MWM_HINTS_UNDECORATED_UNITY);
+
+  _window_decoration_state[window_id] = decorated;
+
+  return decorated;
+}
+
+bool PluginAdapter::IsWindowDecorated(Window window_id) const
+{
+  bool decorated = GetMwnDecorations(window_id) & (MwmDecorAll | MwmDecorTitle);
+
+  if (decorated && GetCardinalProperty(window_id, Atoms::frameExtents).empty())
+  {
+    decorated = false;
+  }
+
+  return decorated;
 }
 
 bool PluginAdapter::IsWindowOnCurrentDesktop(Window window_id) const
@@ -588,6 +632,14 @@
   return false;
 }
 
+bool PluginAdapter::IsWindowMinimized(Window window_id) const
+{
+  if (CompWindow* window = m_Screen->findWindow(window_id))
+    return window->minimized();
+
+  return false;
+}
+
 bool PluginAdapter::IsWindowMinimizable(Window window_id) const
 {
   CompWindow* window = m_Screen->findWindow(window_id);
@@ -606,6 +658,12 @@
   return false;
 }
 
+void PluginAdapter::Maximize(Window window_id)
+{
+  if (CompWindow* window = m_Screen->findWindow(window_id))
+    window->maximize(MAXIMIZE_STATE);
+}
+
 void PluginAdapter::Restore(Window window_id)
 {
   CompWindow* window = m_Screen->findWindow(window_id);
@@ -633,6 +691,13 @@
     window->minimize();
 }
 
+void PluginAdapter::UnMinimize(Window window_id)
+{
+  CompWindow* window = m_Screen->findWindow(window_id);
+  if (window && (window->actions() & CompWindowActionMinimizeMask))
+    window->unminimize();
+}
+
 void PluginAdapter::Close(Window window_id)
 {
   CompWindow* window = m_Screen->findWindow(window_id);
@@ -799,12 +864,7 @@
 
 void PluginAdapter::SetWindowIconGeometry(Window window, nux::Geometry const& geo)
 {
-  long data[4];
-
-  data[0] = geo.x;
-  data[1] = geo.y;
-  data[2] = geo.width;
-  data[3] = geo.height;
+  long data[4] = {geo.x, geo.y, geo.width, geo.height};
 
   XChangeProperty(m_Screen->dpy(), window, Atoms::wmIconGeometry,
                   XA_CARDINAL, 32, PropModeReplace,
@@ -860,38 +920,79 @@
 
 nux::Geometry PluginAdapter::GetWindowGeometry(Window window_id) const
 {
-  nux::Geometry geo;
-  CompWindow* window = m_Screen->findWindow(window_id);
-  if (window)
+  if (CompWindow* window = m_Screen->findWindow(window_id))
   {
-    geo.x = window->borderRect().x();
-    geo.y = window->borderRect().y();
-    geo.width = window->borderRect().width();
-    geo.height = window->borderRect().height();
+    auto const& b = window->borderRect();
+    return nux::Geometry(b.x(), b.y(), b.width(), b.height());
   }
-  return geo;
+
+  return nux::Geometry();
 }
 
 nux::Geometry PluginAdapter::GetWindowSavedGeometry(Window window_id) const
 {
-  nux::Geometry geo(0, 0, 1, 1);
-  CompWindow* window = m_Screen->findWindow(window_id);
-  if (window)
+  if (CompWindow* window = m_Screen->findWindow(window_id))
   {
     XWindowChanges &wc = window->saveWc();
-    geo.x = wc.x;
-    geo.y = wc.y;
-    geo.width = wc.width;
-    geo.height = wc.height;
+    return nux::Geometry(wc.x, wc.y, wc.width, wc.height);
   }
 
-  return geo;
+  return nux::Geometry(0, 0, 1, 1);
 }
 
 nux::Geometry PluginAdapter::GetScreenGeometry() const
 {
-  nux::Geometry geo(0, 0, m_Screen->width(), m_Screen->height());
-  return geo;
+  return nux::Geometry(0, 0, m_Screen->width(), m_Screen->height());
+}
+
+nux::Size PluginAdapter::GetWindowDecorationSize(Window window_id, WindowManager::Edge edge) const
+{
+  if (CompWindow* window = m_Screen->findWindow(window_id))
+  {
+    if (HasWindowDecorations(window_id))
+    {
+      auto const& win_rect = window->borderRect();
+
+      if (IsWindowDecorated(window_id))
+      {
+        auto const& extents = window->border();
+
+        switch (edge)
+        {
+          case Edge::LEFT:
+            return nux::Size(extents.left, win_rect.height());
+          case Edge::TOP:
+            return nux::Size(win_rect.width(), extents.top);
+          case Edge::RIGHT:
+            return nux::Size(extents.right, win_rect.height());
+          case Edge::BOTTOM:
+            return nux::Size(win_rect.width(), extents.bottom);
+        }
+      }
+      else
+      {
+        Atom unity_extents = gdk_x11_get_xatom_by_name(_UNITY_FRAME_EXTENTS);
+        auto const& extents = GetCardinalProperty(window_id, unity_extents);
+
+        if (extents.size() == 4)
+        {
+          switch (edge)
+          {
+            case Edge::LEFT:
+              return nux::Size(extents[unsigned(Edge::LEFT)], win_rect.height());
+            case Edge::TOP:
+              return nux::Size(win_rect.width(), extents[unsigned(Edge::TOP)]);
+            case Edge::RIGHT:
+              return nux::Size(extents[unsigned(Edge::RIGHT)], win_rect.height());
+            case Edge::BOTTOM:
+              return nux::Size(win_rect.width(), extents[unsigned(Edge::BOTTOM)]);
+          }
+        }
+      }
+    }
+  }
+
+  return nux::Size();
 }
 
 nux::Geometry PluginAdapter::GetWorkAreaGeometry(Window window_id) const
@@ -981,7 +1082,6 @@
 void PluginAdapter::SetMwmWindowHints(Window xid, MotifWmHints* new_hints) const
 {
   Display* display = m_Screen->dpy();
-  Atom hints_atom = None;
   MotifWmHints* data = NULL;
   MotifWmHints* hints = NULL;
   Atom type = None;
@@ -989,18 +1089,16 @@
   gulong nitems;
   gulong bytes_after;
 
-  hints_atom = XInternAtom(display, _XA_MOTIF_WM_HINTS, false);
-
   if (XGetWindowProperty(display,
                          xid,
-                         hints_atom, 0, sizeof(MotifWmHints) / sizeof(long),
+                         Atoms::mwmHints, 0, sizeof(MotifWmHints) / sizeof(long),
                          False, AnyPropertyType, &type, &format, &nitems,
                          &bytes_after, (guchar**)&data) != Success)
   {
     return;
   }
 
-  if (type != hints_atom || !data)
+  if (type != Atoms::mwmHints || !data)
   {
     hints = new_hints;
   }
@@ -1020,9 +1118,7 @@
     }
   }
 
-  XChangeProperty(display,
-                  xid,
-                  hints_atom, hints_atom, 32, PropModeReplace,
+  XChangeProperty(display, xid, Atoms::mwmHints, Atoms::mwmHints, 32, PropModeReplace,
                   (guchar*)hints, sizeof(MotifWmHints) / sizeof(long));
 
   if (data)
@@ -1031,16 +1127,41 @@
 
 void PluginAdapter::Decorate(Window window_id) const
 {
+  if (!HasWindowDecorations(window_id))
+    return;
+
   MotifWmHints hints = { 0 };
 
   hints.flags = MWM_HINTS_DECORATIONS;
   hints.decorations = GDK_DECOR_ALL & ~(MWM_HINTS_UNDECORATED_UNITY);
 
   SetMwmWindowHints(window_id, &hints);
+
+  // Removing the saved windows extents
+  Atom atom = gdk_x11_get_xatom_by_name(_UNITY_FRAME_EXTENTS);
+  XDeleteProperty(m_Screen->dpy(), window_id, atom);
 }
 
 void PluginAdapter::Undecorate(Window window_id) const
 {
+  if (!IsWindowDecorated(window_id))
+    return;
+
+  if (CompWindow* window = m_Screen->findWindow(window_id))
+  {
+    // Saving the previous window extents values
+    long extents[4];
+    auto const& border = window->border();
+    extents[unsigned(Edge::LEFT)] = border.left;
+    extents[unsigned(Edge::RIGHT)] = border.right;
+    extents[unsigned(Edge::TOP)] = border.top;
+    extents[unsigned(Edge::BOTTOM)] = border.bottom;
+
+    Atom atom = gdk_x11_get_xatom_by_name(_UNITY_FRAME_EXTENTS);
+    XChangeProperty(m_Screen->dpy(), window_id, atom, XA_CARDINAL, 32,
+                    PropModeReplace, (unsigned char*) extents, 4);
+  }
+
   MotifWmHints hints = { 0 };
 
   /* Set the high bit to indicate that we undecorated this
@@ -1265,13 +1386,11 @@
   std::string name;
   Atom visibleNameAtom;
 
-  visibleNameAtom = XInternAtom(m_Screen->dpy(), "_NET_WM_VISIBLE_NAME", 0);
+  visibleNameAtom = gdk_x11_get_xatom_by_name("_NET_WM_VISIBLE_NAME");
   name = GetUtf8Property(window_id, visibleNameAtom);
+
   if (name.empty())
-  {
-    Atom wmNameAtom = XInternAtom(m_Screen->dpy(), "_NET_WM_NAME", 0);
-    name = GetUtf8Property(window_id, wmNameAtom);
-  }
+    name = GetUtf8Property(window_id, Atoms::wmName);
 
   if (name.empty())
     name = GetTextProperty(window_id, XA_WM_NAME);
@@ -1281,27 +1400,25 @@
 
 std::string PluginAdapter::GetUtf8Property(Window window_id, Atom atom) const
 {
-  Atom          type;
-  int           result, format;
-  unsigned long nItems, bytesAfter;
-  char          *val;
-  std::string   retval;
-  Atom          utf8StringAtom;
+  Atom type;
+  int result, format;
+  unsigned long n_items, bytes_after;
+  char *val = nullptr;
+  std::string retval;
 
-  utf8StringAtom = XInternAtom(m_Screen->dpy(), "UTF8_STRING", 0);
   result = XGetWindowProperty(m_Screen->dpy(), window_id, atom, 0L, 65536, False,
-                              utf8StringAtom, &type, &format, &nItems,
-                              &bytesAfter, reinterpret_cast<unsigned char **>(&val));
+                              Atoms::utf8String, &type, &format, &n_items,
+                              &bytes_after, reinterpret_cast<unsigned char **>(&val));
 
   if (result != Success)
     return retval;
 
-  if (type == utf8StringAtom && format == 8 && val && nItems > 0)
+  if (type == Atoms::utf8String && format == 8 && val && n_items > 0)
   {
-    retval = std::string(val, nItems);
+    retval = std::string(val, n_items);
   }
-  if (val)
-    XFree(val);
+
+  XFree(val);
 
   return retval;
 }
@@ -1310,8 +1427,8 @@
 {
   XTextProperty text;
   std::string retval;
-
   text.nitems = 0;
+
   if (XGetTextProperty(m_Screen->dpy(), window_id, &text, atom))
   {
     if (text.value)
@@ -1324,4 +1441,30 @@
   return retval;
 }
 
+std::vector<long> PluginAdapter::GetCardinalProperty(Window window_id, Atom atom) const
+{
+  Atom type;
+  int result, format;
+  unsigned long n_items, bytes_after;
+  long *buf = nullptr;
+
+  result = XGetWindowProperty(m_Screen->dpy(), window_id, atom, 0L, 65536, False,
+                              XA_CARDINAL, &type, &format, &n_items, &bytes_after,
+                              reinterpret_cast<unsigned char **>(&buf));
+
+  std::unique_ptr<long[], int(*)(void*)> buffer(buf, XFree);
+
+  if (result == Success && type == XA_CARDINAL && format == 32 && buffer && n_items > 0)
+  {
+    std::vector<long> values(n_items);
+
+    for (unsigned i = 0; i < n_items; ++i)
+      values[i] = buffer[i];
+
+    return values;
+  }
+
+  return std::vector<long>();
+}
+
 } // namespace unity

=== modified file 'unity-shared/PluginAdapter.h'
--- unity-shared/PluginAdapter.h	2012-11-06 18:19:09 +0000
+++ unity-shared/PluginAdapter.h	2012-11-15 18:52:31 +0000
@@ -133,12 +133,16 @@
   bool IsWindowVisible(Window window_id) const;
   bool IsWindowOnTop(Window window_id) const;
   bool IsWindowClosable(Window window_id) const;
+  bool IsWindowMinimized(Window window_id) const;
   bool IsWindowMinimizable(Window window_id) const;
   bool IsWindowMaximizable(Window window_id) const;
+  bool HasWindowDecorations(Window window_id) const;
 
+  void Maximize(Window window_id);
   void Restore(Window window_id);
   void RestoreAt(Window window_id, int x, int y);
   void Minimize(Window window_id);
+  void UnMinimize(Window window_id);
   void Close(Window window_id);
   void Activate(Window window_id);
   void Raise(Window window_id);
@@ -166,6 +170,7 @@
   nux::Geometry GetWindowSavedGeometry(Window window_id) const;
   nux::Geometry GetScreenGeometry() const;
   nux::Geometry GetWorkAreaGeometry(Window window_id = 0) const;
+  nux::Size GetWindowDecorationSize(Window window_id, Edge) const;
   std::string GetWindowName(Window window_id) const;
 
   void CheckWindowIntersections(nux::Geometry const& region, bool &active, bool &any);
@@ -191,11 +196,13 @@
 
   bool CheckWindowIntersection(nux::Geometry const& region, CompWindow* window) const;
   void SetMwmWindowHints(Window xid, MotifWmHints* new_hints) const;
+  unsigned long GetMwnDecorations(Window xid) const;
 
   Window GetTopMostValidWindowInViewport() const;
 
   std::string GetTextProperty(Window xid, Atom atom) const;
   std::string GetUtf8Property(Window xid, Atom atom) const;
+  std::vector<long> GetCardinalProperty(Window xid, Atom atom) const;
 
   CompScreen* m_Screen;
   MultiActionList m_ExpoActionList;
@@ -215,7 +222,7 @@
   bool _in_show_desktop;
   CompWindow* _last_focused_window;
 
-  std::map<Window, unsigned int> _window_decoration_state;
+  mutable std::map<Window, unsigned int> _window_decoration_state;
 };
 
 }

=== modified file 'unity-shared/StandaloneWindowManager.cpp'
--- unity-shared/StandaloneWindowManager.cpp	2012-11-06 18:19:09 +0000
+++ unity-shared/StandaloneWindowManager.cpp	2012-11-15 18:52:31 +0000
@@ -16,6 +16,7 @@
  *
  * Authored by: Jason Smith <[e-mail]>
  *              Tim Penhey <[e-mail]>
+ *              Marco Trevisan (Treviño) <[e-mail]>
  */
 
 #include <glib.h>
@@ -32,6 +33,25 @@
 {
 DECLARE_LOGGER(logger, "unity.wm");
 
+StandaloneWindow::StandaloneWindow(Window xid)
+  : xid(xid)
+  , name("StandaloneWindow " + std::to_string(xid))
+  , geo(0, 0, 10, 10)
+  , current_desktop(0)
+  , monitor(0)
+  , active(true)
+  , mapped(true)
+  , visible(true)
+  , maximized(false)
+  , minimized(false)
+  , decorated(true)
+  , has_decorations(true)
+  , on_top(false)
+  , closable(true)
+  , minimizable(false)
+  , maximizable(false)
+{}
+
 WindowManagerPtr create_window_manager()
 {
   return WindowManagerPtr(new StandaloneWindowManager);
@@ -42,26 +62,42 @@
   , in_show_desktop_(false)
   , scale_active_(false)
   , scale_active_for_group_(false)
-{
-}
+  , current_desktop_(0)
+{}
 
 Window StandaloneWindowManager::GetActiveWindow() const
 {
+  for (auto const& it : standalone_windows_)
+    if (it.second->active)
+      return it.second->Xid();
+
   return 0;
 }
 
 bool StandaloneWindowManager::IsWindowMaximized(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->maximized;
+
   return false;
 }
 
 bool StandaloneWindowManager::IsWindowDecorated(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end() && it->second->has_decorations)
+    return it->second->decorated;
+
   return false;
 }
 
 bool StandaloneWindowManager::IsWindowOnCurrentDesktop(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return (it->second->current_desktop == current_desktop_);
+
   return false;
 }
 
@@ -72,31 +108,73 @@
 
 bool StandaloneWindowManager::IsWindowMapped(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->mapped;
+
   return false;
 }
 
 bool StandaloneWindowManager::IsWindowVisible(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->visible;
+
   return false;
 }
 
 bool StandaloneWindowManager::IsWindowOnTop(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->on_top;
+
   return false;
 }
 
 bool StandaloneWindowManager::IsWindowClosable(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->closable;
+
+  return false;
+}
+
+bool StandaloneWindowManager::IsWindowMinimized(Window window_id) const
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->minimized;
+
   return false;
 }
 
 bool StandaloneWindowManager::IsWindowMinimizable(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->minimizable;
+
   return false;
 }
 
 bool StandaloneWindowManager::IsWindowMaximizable(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->maximizable;
+
+  return false;
+}
+
+bool StandaloneWindowManager::HasWindowDecorations(Window window_id) const
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->has_decorations;
+
   return false;
 }
 
@@ -110,20 +188,101 @@
   return in_show_desktop_;
 }
 
+void StandaloneWindowManager::Decorate(Window window_id) const
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+  {
+    it->second->decorated = it->second->has_decorations;
+  }
+}
+
+void StandaloneWindowManager::Undecorate(Window window_id) const
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+  {
+    it->second->decorated = false;
+  }
+}
+
+void StandaloneWindowManager::Maximize(Window window_id)
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+  {
+    it->second->maximized = true;
+    Undecorate(window_id);
+  }
+}
+
 void StandaloneWindowManager::Restore(Window window_id)
-{}
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+  {
+    it->second->maximized = false;
+    Decorate(window_id);
+  }
+}
 
 void StandaloneWindowManager::RestoreAt(Window window_id, int x, int y)
-{}
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+  {
+    Restore(window_id);
+    it->second->geo.x = x;
+    it->second->geo.y = y;
+  }
+}
+
+void StandaloneWindowManager::UnMinimize(Window window_id)
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+  {
+    it->second->minimized = false;
+
+    if (it->second->maximized)
+    {
+      Undecorate(window_id);
+    }
+  }
+}
 
 void StandaloneWindowManager::Minimize(Window window_id)
-{}
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+  {
+    it->second->minimized = true;
+
+    if (it->second->maximized)
+    {
+      Decorate(window_id);
+    }
+  }
+}
 
 void StandaloneWindowManager::Close(Window window_id)
-{}
+{
+  standalone_windows_.erase(window_id);
+}
 
 void StandaloneWindowManager::Activate(Window window_id)
-{}
+{
+  auto old = std::find_if(standalone_windows_.begin(), standalone_windows_.end(),
+                          [this] (std::pair<Window, StandaloneWindow::Ptr> const& it)
+                            { return it.second->active; });
+
+  if (old != standalone_windows_.end())
+    old->second->active = false;
+
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    it->second->active = true;
+}
 
 void StandaloneWindowManager::Raise(Window window_id)
 {}
@@ -197,32 +356,52 @@
 }
 
 void StandaloneWindowManager::MoveResizeWindow(Window window_id, nux::Geometry geometry)
-{}
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    it->second->geo = geometry;
+}
 
 void StandaloneWindowManager::StartMove(Window window_id, int x, int y)
-{}
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+  {
+    it->second->geo.x = x;
+    it->second->geo.y = y;
+  }
+}
 
 int StandaloneWindowManager::GetWindowMonitor(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->monitor;
+
   return -1;
 }
 
 nux::Geometry StandaloneWindowManager::GetWindowGeometry(Window window_id) const
 {
-  nux::Geometry geo(0, 0, 1, 1);
-  return geo;
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->geo;
+
+  return nux::Geometry(0, 0, 1, 1);
 }
 
 nux::Geometry StandaloneWindowManager::GetWindowSavedGeometry(Window window_id) const
 {
-  nux::Geometry geo(0, 0, 1, 1);
-  return geo;
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->geo;
+
+  return nux::Geometry();
 }
 
 nux::Geometry StandaloneWindowManager::GetScreenGeometry() const
 {
-  nux::Geometry geo(0, 0, 1, 1);
-  return geo;
+  return nux::Geometry(0, 0, 1024, 768);
 }
 
 nux::Geometry StandaloneWindowManager::GetWorkAreaGeometry(Window window_id) const
@@ -231,6 +410,15 @@
   return geo;
 }
 
+nux::Size StandaloneWindowManager::GetWindowDecorationSize(Window window_id, WindowManager::Edge edge) const
+{
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->deco_sizes[unsigned(edge)];
+
+  return nux::Size();
+}
+
 unsigned long long StandaloneWindowManager::GetWindowActiveNumber(Window window_id) const
 {
   return 0;
@@ -262,9 +450,37 @@
 
 std::string StandaloneWindowManager::GetWindowName(Window window_id) const
 {
+  auto it = standalone_windows_.find(window_id);
+  if (it != standalone_windows_.end())
+    return it->second->name;
+
   return "";
 }
 
+// Mock functions
+
+void StandaloneWindowManager::SetCurrentDesktop(unsigned desktop_id)
+{
+  current_desktop_ = desktop_id;
+}
+
+void StandaloneWindowManager::AddStandaloneWindow(StandaloneWindow::Ptr const& window)
+{
+  if (!window)
+    return;
+
+  if (standalone_windows_.empty())
+    window->active = true;
+
+  standalone_windows_[window->Xid()] = window;
+}
+
+std::map<Window, StandaloneWindow::Ptr> StandaloneWindowManager::GetStandaloneWindows() const
+{
+  return standalone_windows_;
+}
+
+
 void StandaloneWindowManager::AddProperties(GVariantBuilder* builder)
 {
   unity::variant::BuilderWrapper wrapper(builder);

=== modified file 'unity-shared/StandaloneWindowManager.h'
--- unity-shared/StandaloneWindowManager.h	2012-10-19 09:51:55 +0000
+++ unity-shared/StandaloneWindowManager.h	2012-11-15 18:52:31 +0000
@@ -15,16 +15,47 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Tim Penhey <[e-mail]>
+ *              Marco Trevisan (Treviño) <[e-mail]>
  */
 
 #ifndef UNITYSHARED_STANDALONE_WINDOW_MANAGER_H
 #define UNITYSHARED_STANDALONE_WINDOW_MANAGER_H
 
 #include "unity-shared/WindowManager.h"
+#include <map>
 
 namespace unity
 {
 
+struct StandaloneWindow
+{
+  typedef std::shared_ptr<StandaloneWindow> Ptr;
+  StandaloneWindow(Window xid);
+
+private:
+  Window xid;
+
+public:
+  Window Xid() const { return xid; }
+
+  std::string name;
+  nux::Geometry geo;
+  nux::Size deco_sizes[4];
+  unsigned current_desktop;
+  unsigned monitor;
+  bool active;
+  bool mapped;
+  bool visible;
+  bool maximized;
+  bool minimized;
+  bool decorated;
+  bool has_decorations;
+  bool on_top;
+  bool closable;
+  bool minimizable;
+  bool maximizable;
+};
+
 class StandaloneWindowManager : public WindowManager
 {
 public:
@@ -40,21 +71,28 @@
   virtual bool IsWindowVisible(Window window_id) const;
   virtual bool IsWindowOnTop(Window window_id) const;
   virtual bool IsWindowClosable(Window window_id) const;
+  virtual bool IsWindowMinimized(Window window_id) const;
   virtual bool IsWindowMinimizable(Window window_id) const;
   virtual bool IsWindowMaximizable(Window window_id) const;
+  virtual bool HasWindowDecorations(Window) const;
 
   virtual void ShowDesktop();
   virtual bool InShowDesktop() const;
 
+  virtual void Maximize(Window window_id);
   virtual void Restore(Window window_id);
   virtual void RestoreAt(Window window_id, int x, int y);
   virtual void Minimize(Window window_id);
+  virtual void UnMinimize(Window window_id);
   virtual void Close(Window window_id);
 
   virtual void Activate(Window window_id);
   virtual void Raise(Window window_id);
   virtual void Lower(Window window_id);
 
+  virtual void Decorate(Window window_id) const;
+  virtual void Undecorate(Window window_id) const;
+
   virtual void TerminateScale();
   virtual bool IsScaleActive() const;
   virtual bool IsScaleActiveForGroup() const;
@@ -79,6 +117,7 @@
   virtual int GetWindowMonitor(Window window_id) const;
   virtual nux::Geometry GetWindowGeometry(Window window_id) const;
   virtual nux::Geometry GetWindowSavedGeometry(Window window_id) const;
+  virtual nux::Size GetWindowDecorationSize(Window window_id, Edge) const;
   virtual nux::Geometry GetScreenGeometry() const;
   virtual nux::Geometry GetWorkAreaGeometry(Window window_id) const;
 
@@ -98,6 +137,10 @@
   // Mock functions
   void SetScaleActive(bool scale_active);
   void SetScaleActiveForGroup(bool scale_active_for_group);
+  void SetCurrentDesktop(unsigned desktop_id);
+
+  void AddStandaloneWindow(StandaloneWindow::Ptr const& window);
+  std::map<Window, StandaloneWindow::Ptr> GetStandaloneWindows() const;
 
 protected:
   virtual void AddProperties(GVariantBuilder* builder);
@@ -107,6 +150,8 @@
   bool in_show_desktop_;
   bool scale_active_;
   bool scale_active_for_group_;
+  unsigned current_desktop_;
+  std::map<Window, StandaloneWindow::Ptr> standalone_windows_;
 };
 
 }

=== modified file 'unity-shared/WindowManager.h'
--- unity-shared/WindowManager.h	2012-10-24 08:21:17 +0000
+++ unity-shared/WindowManager.h	2012-11-15 18:52:31 +0000
@@ -62,6 +62,14 @@
     ForceUnminimizeOnCurrentDesktop
   };
 
+  enum class Edge : unsigned
+  {
+    LEFT,
+    RIGHT,
+    TOP,
+    BOTTOM
+  };
+
   static WindowManager& Default();
 
   virtual Window GetActiveWindow() const = 0;
@@ -74,15 +82,19 @@
   virtual bool IsWindowVisible(Window window_id) const = 0;
   virtual bool IsWindowOnTop(Window window_id) const = 0;
   virtual bool IsWindowClosable(Window window_id) const = 0;
+  virtual bool IsWindowMinimized(Window window_id) const = 0;
   virtual bool IsWindowMinimizable(Window window_id) const = 0;
   virtual bool IsWindowMaximizable(Window window_id) const = 0;
+  virtual bool HasWindowDecorations(Window window_id) const = 0;
 
   virtual void ShowDesktop() = 0;
   virtual bool InShowDesktop() const = 0;
 
+  virtual void Maximize(Window window_id) = 0;
   virtual void Restore(Window window_id) = 0;
   virtual void RestoreAt(Window window_id, int x, int y) = 0;
   virtual void Minimize(Window window_id) = 0;
+  virtual void UnMinimize(Window window_id) = 0;
   virtual void Close(Window window_id) = 0;
 
   virtual void Activate(Window window_id) = 0;
@@ -117,6 +129,7 @@
   virtual int GetWindowMonitor(Window window_id) const = 0;
   virtual nux::Geometry GetWindowGeometry(Window window_id) const = 0;
   virtual nux::Geometry GetWindowSavedGeometry(Window window_id) const = 0;
+  virtual nux::Size GetWindowDecorationSize(Window window_id, Edge) const = 0;
   virtual nux::Geometry GetScreenGeometry() const = 0;
   virtual nux::Geometry GetWorkAreaGeometry(Window window_id = 0) const = 0;