Merge lp:~3v1n0/unity/scale-close-middle-click into lp:unity

[Marco Trevisan (Treviño)]

UnityShell: enable closing on middle-click, fix scaled decoration sizes, fix theming issues, added scale autopilot tests

Improved the computation of an unity scaled window size, so that there won't be drawing issues, updated the corner radius value to match the system default, fix style issues on theme changed. Plus, lots of code cleanup and optimizations.

Added introspection for the UnityScreen and UnityWindows so that we can now use autopilot for them.
So, new AP tests for new scale features.

[Brandon Schaefer (brandontschaefer)]

Code looks good, tests work, bugs look fixed and also works manually :). +1

review: Approve

=== added file 'plugins/unityshell/src/ScreenIntrospection.h'
--- plugins/unityshell/src/ScreenIntrospection.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/ScreenIntrospection.h	2012-09-24 16:14:49 +0000
@@ -0,0 +1,48 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 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 warranty of
+ * MERCHANTABILITY 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
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#ifndef SCREEN_INTROSPECTION_H
+#define SCREEN_INTROSPECTION_H
+
+#include "Introspectable.h"
+#include <core/core.h>
+
+namespace unity
+{
+namespace debug
+{
+
+class ScreenIntrospection : public Introspectable
+{
+public:
+  ScreenIntrospection(CompScreen* screen);
+
+protected:
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+  IntrospectableList GetIntrospectableChildren();
+
+private:
+  CompScreen* screen_;
+};
+
+}
+}
+
+#endif
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-09-21 21:52:27 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-09-24 16:14:49 +0000
@@ -26,6 +26,8 @@
 #include <Nux/WindowCompositor.h>
 #include <Nux/NuxTimerTickSource.h>
 
+#include <UnityCore/Variant.h>
+
 #include "BaseWindowRaiserImp.h"
 #include "IconRenderer.h"
 #include "Launcher.h"
@@ -125,7 +127,6 @@
   , allowWindowPaint(false)
   , _key_nav_mode_requested(false)
   , _last_output(nullptr)
-  , _bghash(NULL)
   , grab_index_ (0)
   , painting_tray_ (false)
   , last_scroll_event_(0)
@@ -133,7 +134,7 @@
   , panel_texture_has_changed_(true)
   , paint_panel_(false)
   , scale_just_activated_(false)
-  , minimize_speed_controller(new WindowMinimizeSpeedController())
+  , screen_introspection_(screen)
 {
   Timer timer;
 #ifndef USE_GLES
@@ -244,7 +245,7 @@
     // _bghash is a pointer. We don't want it to be created before Nux system has had a chance
     // to start. BGHash relies on animations. Nux animation system starts after the WindowThread
     // has been created.
-    _bghash = new BGHash();
+    _bghash.reset(new BGHash());
 
      unity_a11y_init(wt.get());
 
@@ -375,13 +376,15 @@
     Display* display = gdk_x11_display_get_xdisplay(gdk_display_get_default());;
     XSelectInput(display, GDK_ROOT_WINDOW(), PropertyChangeMask);
     LOG_INFO(logger) << "UnityScreen constructed: " << timer.ElapsedSeconds() << "s";
+
+    panel::Style::Instance().changed.connect(sigc::mem_fun(this, &UnityScreen::OnPanelStyleChanged));
+
+    minimize_speed_controller_.DurationChanged.connect(
+        sigc::mem_fun(this, &UnityScreen::OnMinimizeDurationChanged)
+    );
+
+    AddChild(&screen_introspection_);
   }
-
-  panel::Style::Instance().changed.connect(sigc::mem_fun(this, &UnityScreen::OnPanelStyleChanged));
-
-  minimize_speed_controller->DurationChanged.connect(
-      sigc::mem_fun(this, &UnityScreen::OnMinimizeDurationChanged)
-  );
 }
 
 UnityScreen::~UnityScreen()
@@ -391,7 +394,6 @@
   unity_a11y_finalize();
   ::unity::ui::IconRenderer::DestroyTextures();
   QuicklistManager::Destroy();
-  delete _bghash;
 
   reset_glib_logging();
 }
@@ -659,10 +661,15 @@
   wy = y + (last_bound.height - height) / 2;
 }
 
-void
-UnityScreen::OnPanelStyleChanged()
+void UnityScreen::OnPanelStyleChanged()
 {
   panel_texture_has_changed_ = true;
+
+  // Reload the windows themed textures
+  UnityWindow::CleanupSharedTextures();
+
+  if (WindowManager::Default()->IsScaleActive())
+    UnityWindow::SetupSharedTextures();
 }
 
 void UnityScreen::paintDisplay()
@@ -1136,6 +1143,12 @@
         DoAddDamage();
         handled = true;
       }
+      else if (event->xbutton.button == Button2 &&
+               GetScaledGeometry().IsPointInside(event->xbutton.x_root, event->xbutton.y_root))
+      {
+        middle_clicked_ = true;
+        handled = true;
+      }
       break;
 
     case ButtonRelease:
@@ -1155,6 +1168,18 @@
 
           handled = true;
         }
+
+        if (middle_clicked_)
+        {
+          if (event->xbutton.button == Button2 &&
+              GetScaledGeometry().IsPointInside(event->xbutton.x_root, event->xbutton.y_root))
+          {
+            window->close(0);
+          }
+
+          middle_clicked_ = false;
+          handled = true;
+        }
       }
       break;
 
@@ -2277,8 +2302,7 @@
 }
 
 void UnityScreen::AddProperties(GVariantBuilder* builder)
-{
-}
+{}
 
 std::string UnityScreen::GetName() const
 {
@@ -2469,10 +2493,10 @@
         CompOption::Value& value = o.value();
         CompOption::Value::Vector& list = value.list();
         CompOption::Value::Vector::iterator i = list.begin();
-        if (i != list.end()) {
-          i->set(minimize_speed_controller->getDuration());
-        }
-        value.set(list);                
+        if (i != list.end())
+          i->set(minimize_speed_controller_.getDuration());
+
+        value.set(list);
         screen->setOptionForPlugin(p->vTable->name().c_str(),
                                    o.name().c_str(), value);
         break;
@@ -2603,7 +2627,7 @@
       case CompWindowNotifyMinimize:
         /* Updating the count in dconf will trigger a "changed" signal to which
          * the method setting the new animation speed is attached */
-        UnityScreen::get(screen)->minimize_speed_controller->UpdateCount();
+        UnityScreen::get(screen)->minimize_speed_controller_.UpdateCount();
         break;
       default:
         break;
@@ -3458,107 +3482,117 @@
   WindowManager::Default()->terminate_spread.connect(sigc::mem_fun(this, &UnityWindow::OnTerminateSpreed));
 }
 
-void
-UnityWindow::DrawTexture(GLTexture* icon,
-                         const GLWindowPaintAttrib& attrib,
-                         const GLMatrix& transform,
-                         unsigned int mask,
-                         float x, float y,
-                         int &maxWidth, int &maxHeight)
-{
-  if (icon)
+void UnityWindow::AddProperties(GVariantBuilder* builder)
+{
+  Window xid = window->id();
+  auto const& swins = ScaleScreen::get(screen)->getWindows();
+  bool scaled = std::find(swins.begin(), swins.end(), ScaleWindow::get(window)) != swins.end();
+  auto wm = WindowManager::Default();
+
+  variant::BuilderWrapper(builder)
+    .add(scaled ? GetScaledGeometry() : wm->GetWindowGeometry(xid))
+    .add("xid", xid)
+    .add("title", wm->GetWindowName(xid))
+    .add("scaled", scaled)
+    .add("scaled_close_x", close_button_geo_.x)
+    .add("scaled_close_y", close_button_geo_.y)
+    .add("scaled_close_width", close_button_geo_.width)
+    .add("scaled_close_height", close_button_geo_.height);
+}
+
+std::string UnityWindow::GetName() const
+{
+  return "Window";
+}
+
+void UnityWindow::DrawTexture(GLTexture::List const& textures, GLWindowPaintAttrib const& attrib,
+                              GLMatrix const& transform, unsigned int mask, int x, int y)
+{
+  for (auto const& texture : textures)
   {
-    int width, height;
-    width  = icon->width();
-    height = icon->height();
-
-    if (height > maxHeight)
-      maxHeight = height;
-
-    if (width > maxWidth)
-      maxWidth = width;
-
-    CompRegion  iconReg(0, 0, width, height);
-    GLTexture::MatrixList ml(1);
-
-    ml[0] = icon->matrix();
+    if (!texture)
+      continue;
+
     gWindow->vertexBuffer()->begin();
-    if (width && height)
-      gWindow->glAddGeometry(ml, iconReg, iconReg);
+
+    if (texture->width() && texture->height())
+    {
+      GLTexture::MatrixList ml(1);
+      ml[0] = texture->matrix();
+      CompRegion texture_region(0, 0, texture->width(), texture->height());
+      gWindow->glAddGeometry(ml, texture_region, texture_region);
+    }
 
     if (gWindow->vertexBuffer()->end())
     {
       GLMatrix wTransform(transform);
-
       wTransform.translate(x, y, 0.0f);
 
-      gWindow->glDrawTexture(icon, wTransform, attrib, mask);
+      gWindow->glDrawTexture(texture, wTransform, attrib, mask);
     }
   }
 }
 
-void
-UnityWindow::RenderText(UnityWindow::CairoContext const& context,
-                        float x, float y,
-                        float maxWidth, float maxHeight)
+void UnityWindow::RenderText(CairoContext const& context, int x, int y, int width, int height)
 {
   panel::Style& style = panel::Style::Instance();
-  std::string fontDescription(style.GetFontDescription(panel::PanelItem::TITLE));
+  std::string const& font_desc = style.GetFontDescription(panel::PanelItem::TITLE);
 
   glib::Object<PangoLayout> layout(pango_cairo_create_layout(context.cr_));
-  std::shared_ptr<PangoFontDescription> font(pango_font_description_from_string(fontDescription.c_str()),
+  std::shared_ptr<PangoFontDescription> font(pango_font_description_from_string(font_desc.c_str()),
                                              pango_font_description_free);
 
   pango_layout_set_font_description(layout, font.get());
 
-  GdkScreen* gdkScreen = gdk_screen_get_default();
-  PangoContext* pCxt = pango_layout_get_context(layout);
+  GdkScreen* gdk_screen = gdk_screen_get_default();
+  PangoContext* pango_ctx = pango_layout_get_context(layout);
   int dpi = style.GetTextDPI();
 
-  pango_cairo_context_set_font_options(pCxt, gdk_screen_get_font_options(gdkScreen));
-  pango_cairo_context_set_resolution(pCxt, dpi / static_cast<float>(PANGO_SCALE));
+  pango_cairo_context_set_font_options(pango_ctx, gdk_screen_get_font_options(gdk_screen));
+  pango_cairo_context_set_resolution(pango_ctx, dpi / static_cast<float>(PANGO_SCALE));
   pango_layout_context_changed(layout);
 
-  pango_layout_set_height(layout, maxHeight);
+  std::string const& win_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);
-  pango_layout_set_text(layout,
-                        WindowManager::Default()->GetWindowName(window->id()).c_str(),
-                        -1);
+  pango_layout_set_text(layout, win_title.c_str(), -1);
 
   /* update the size of the pango layout */
   pango_cairo_update_layout(context.cr_, layout);
-  cairo_set_operator(context.cr_, CAIRO_OPERATOR_OVER);
-  cairo_set_source_rgba(context.cr_,
-                        1.0,
-                        1.0,
-                        1.0,
-                        1.0);
+
+  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);
 
   // alignment
   PangoRectangle lRect;
-  int textWidth, textHeight;
-
-  pango_layout_get_extents(layout, NULL, &lRect);
-  textWidth = lRect.width / PANGO_SCALE;
-  textHeight = lRect.height / PANGO_SCALE;
-
-  y = ((maxHeight - textHeight) / 2.0) + y;
-  cairo_translate(context.cr_, x, y);
-
-  if (textWidth > maxWidth)
+  pango_layout_get_extents(layout, nullptr, &lRect);
+  int text_width = lRect.width / PANGO_SCALE;
+  int text_height = lRect.height / PANGO_SCALE;
+  y += (height - text_height) / 2.0f;
+  int text_space = width - x;
+
+  if (text_width > text_space)
   {
-    // apply a fade effect in the right corner
-    const int outPixels = textWidth - maxWidth;
-    const int fadingPixels = 35;
-    const int fadingWidth = outPixels < fadingPixels ? outPixels : fadingPixels;
+    // Cut the text with fade
+    int out_pixels = text_width - text_space;
+    const int fading_pixels = 35;
+    int fading_width = (out_pixels < fading_pixels) ? out_pixels : fading_pixels;
 
     cairo_push_group(context.cr_);
-    pango_cairo_show_layout(context.cr_, layout);
+    gtk_render_layout(style_context, context.cr_, x, y, layout);
     cairo_pop_group_to_source(context.cr_);
 
-    std::shared_ptr<cairo_pattern_t> linpat(cairo_pattern_create_linear(maxWidth - fadingWidth,
-                                                                        y, maxWidth, y),
+    std::shared_ptr<cairo_pattern_t> linpat(cairo_pattern_create_linear(width - fading_width, y, width, y),
                                             cairo_pattern_destroy);
     cairo_pattern_add_color_stop_rgba(linpat.get(), 0, 0, 0, 0, 1);
     cairo_pattern_add_color_stop_rgba(linpat.get(), 1, 0, 0, 0, 0);
@@ -3566,61 +3600,55 @@
   }
   else
   {
-    pango_cairo_show_layout(context.cr_, layout);
+    gtk_render_layout(style_context, context.cr_, x, y, layout);
   }
+
+  gtk_style_context_restore(style_context);
 }
 
-void
-UnityWindow::DrawWindowDecoration(GLWindowPaintAttrib const& attrib,
-                                  GLMatrix const& transform,
-                                  unsigned int mask,
-                                  bool highlighted,
-                                  int x, int y, unsigned width, unsigned height)
+void UnityWindow::DrawWindowDecoration(GLWindowPaintAttrib const& attrib,
+                                       GLMatrix const& transform,
+                                       unsigned int mask,
+                                       bool highlighted,
+                                       int x, int y, unsigned width, unsigned height)
 {
   // Paint a fake window decoration
   CairoContext context(width, height);
 
   cairo_save(context.cr_);
+
+  // Draw window decoration based on gtk style
   cairo_push_group(context.cr_);
+  auto& style = panel::Style::Instance();
+  gtk_render_background(style.GetStyleContext(), context.cr_, 0, 0, width, height);
+  gtk_render_frame(style.GetStyleContext(), context.cr_, 0, 0, width, height);
+  cairo_pop_group_to_source(context.cr_);
 
   // Round window decoration top border
-  const double aspect = 1.0;
-  const double corner_radius = height / 10.0;
-  const double radius = corner_radius / aspect;
-  const double degrees = M_PI / 180.0;
+  const double aspect = ScaleWindow::get(window)->getCurrentPosition().scale;
+  const double radius = 8.0 * aspect;
 
   cairo_new_sub_path(context.cr_);
-
-  cairo_arc(context.cr_, radius, radius, radius, 180 * degrees, 270 * degrees);
-  cairo_arc(context.cr_, width - radius, radius, radius, -90 * degrees, 0 * degrees);
+  cairo_line_to(context.cr_, 0, height);
+  cairo_arc(context.cr_, radius, radius, radius, M_PI, -M_PI * 0.5f);
+  cairo_line_to(context.cr_, width - radius, 0);
+  cairo_arc(context.cr_, width - radius, radius, radius, M_PI * 0.5f, 0);
   cairo_line_to(context.cr_, width, height);
-  cairo_line_to(context.cr_, 0, height);
-
   cairo_close_path(context.cr_);
-  cairo_clip(context.cr_);
-
-  // Draw window decoration based on gtk style
-  auto& style = panel::Style::Instance();
-  gtk_render_background(style.GetStyleContext(), context.cr_, 0, 0, width, height);
-  gtk_render_frame(style.GetStyleContext(), context.cr_, 0, 0, width, height);
-
-  cairo_pop_group_to_source(context.cr_);
-
-  cairo_paint_with_alpha(context.cr_, 1.0);
+
+  cairo_fill(context.cr_);
+
   cairo_restore(context.cr_);
 
   if (highlighted)
   {
     // Draw windows title
     const float xText = SCALE_ITEMS_PADDING * 2 + SCALE_CLOSE_ICON_SIZE;
-    RenderText(context, xText, 0.0, width - xText - SCALE_ITEMS_PADDING, height);
+    RenderText(context, xText, 0.0, width - SCALE_ITEMS_PADDING, height);
   }
 
   mask |= PAINT_WINDOW_BLEND_MASK;
-  int maxWidth, maxHeight;
-
-  for (GLTexture *icon : context.texture_)
-    DrawTexture(icon, attrib, transform, mask, x, y, maxWidth , maxHeight);
+  DrawTexture(context.texture_, attrib, transform, mask, x, y);
 }
 
 void UnityWindow::LoadCloseIcon(panel::WindowState state, GLTexture::List& texture)
@@ -3631,12 +3659,12 @@
   auto& style = panel::Style::Instance();
   auto const& files = style.GetWindowButtonFileNames(panel::WindowButtonType::CLOSE, state);
 
-  CompString pName("unityshell");
+  CompString plugin("unityshell");
   for (std::string const& file : files)
   {
-    CompString fileName(file.c_str());
+    CompString file_name = file;
     CompSize size(SCALE_CLOSE_ICON_SIZE, SCALE_CLOSE_ICON_SIZE);
-    texture = GLTexture::readImageToTexture(fileName, pName, size);
+    texture = GLTexture::readImageToTexture(file_name, plugin, size);
     if (!texture.empty())
       break;
   }
@@ -3649,49 +3677,57 @@
     else if (state == panel::WindowState::PRESSED)
       suffix = "_pressed";
 
-    CompString fileName((PKGDATADIR"/close_dash" + suffix + ".png").c_str());
+    CompString file_name(PKGDATADIR"/close_dash" + suffix + ".png");
     CompSize size(SCALE_CLOSE_ICON_SIZE, SCALE_CLOSE_ICON_SIZE);
-    texture = GLTexture::readImageToTexture(fileName, pName, size);
+    texture = GLTexture::readImageToTexture(file_name, plugin, size);
   }
 }
 
-void UnityWindow::SetupScaleHeaderStyle()
+void UnityWindow::SetupSharedTextures()
 {
   LoadCloseIcon(panel::WindowState::NORMAL, close_normal_tex_);
   LoadCloseIcon(panel::WindowState::PRELIGHT, close_prelight_tex_);
   LoadCloseIcon(panel::WindowState::PRESSED, close_pressed_tex_);
 }
 
+void UnityWindow::CleanupSharedTextures()
+{
+  close_normal_tex_.clear();
+  close_prelight_tex_.clear();
+  close_pressed_tex_.clear();
+}
+
 void UnityWindow::scalePaintDecoration(GLWindowPaintAttrib const& attrib,
                                        GLMatrix const& transform,
                                        CompRegion const& region,
                                        unsigned int mask)
 {
   ScaleWindow *scale_win = ScaleWindow::get(window);
-  if (!scale_win)
-    return;
-
   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& decoration_extents = window->border();
+  auto const& pos = scale_win->getCurrentPosition();
+
   const bool highlighted = (ss->getSelectedWindow() == window->id());
-
-  ScalePosition const& pos = scale_win->getCurrentPosition();
-  auto const& border_rect = window->borderRect();
-  auto const& deco_ext = window->border();
-
-  const unsigned decoration_height = deco_ext.top;
-  unsigned width = (border_rect.width() + deco_ext.left + deco_ext.right)  * pos.scale;
-  unsigned height = decoration_height * pos.scale;
-  int x = pos.x() + border_rect.x();
-  int y = pos.y() + border_rect.y() + decoration_height - height - 1;
-
-  // If window is highlighted, we draw the decoration at full size
-  if (highlighted)
-    height = decoration_height;
+  int width = scaled_geo.width;
+  int height = decoration_extents.top;
+  int x = scaled_geo.x;
+  int y = scaled_geo.y;
+
+
+  // If window is not highlighted, we draw the decoration at scaled size
+  if (!highlighted)
+    height *= pos.scale;
 
   DrawWindowDecoration(attrib, transform, mask, highlighted, x, y, width, height);
 
@@ -3699,30 +3735,25 @@
   {
     x += SCALE_ITEMS_PADDING;
     y += (height - SCALE_CLOSE_ICON_SIZE) / 2.0f;
-    int max_height = 0;
-    int max_width = 0;
     mask |= PAINT_WINDOW_BLEND_MASK;
 
-    switch(close_icon_state_)
+    switch (close_icon_state_)
     {
       case panel::WindowState::NORMAL:
       default:
-        for (GLTexture *icon : close_normal_tex_)
-          DrawTexture(icon, attrib, transform, mask, x, y, max_width , max_height);
+        DrawTexture(close_normal_tex_, attrib, transform, mask, x, y);
         break;
 
       case panel::WindowState::PRELIGHT:
-        for (GLTexture *icon : close_prelight_tex_)
-          DrawTexture(icon, attrib, transform, mask, x, y, max_width , max_height);
+        DrawTexture(close_prelight_tex_, attrib, transform, mask, x, y);
         break;
 
       case panel::WindowState::PRESSED:
-        for (GLTexture *icon : close_pressed_tex_)
-          DrawTexture(icon, attrib, transform, mask, x, y, max_width , max_height);
+        DrawTexture(close_pressed_tex_, attrib, transform, mask, x, y);
         break;
     }
 
-    close_button_geo_.Set(x, y, max_height, max_width);
+    close_button_geo_.Set(x, y, SCALE_CLOSE_ICON_SIZE, SCALE_CLOSE_ICON_SIZE);
   }
   else if (!close_button_geo_.IsNull())
   {
@@ -3730,14 +3761,27 @@
   }
 }
 
+nux::Geometry UnityWindow::GetScaledGeometry()
+{
+  ScaleWindow *scale_win = ScaleWindow::get(window);
+
+  ScalePosition const& pos = scale_win->getCurrentPosition();
+  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);
+
+  return nux::Geometry(x, y, width, height);
+}
+
 void UnityWindow::OnInitiateSpreed()
 {
-  auto const& windows = screen->windows();
-  if (std::find(windows.begin(), windows.end(), window) == windows.end())
-    return;
-
   close_icon_state_ = panel::WindowState::NORMAL;
-  SetupScaleHeaderStyle();
+  middle_clicked_ = false;
+  SetupSharedTextures();
 
   WindowManager *wm = WindowManager::Default();
   Window xid = window->id();
@@ -3748,10 +3792,6 @@
 
 void UnityWindow::OnTerminateSpreed()
 {
-  auto const& windows = screen->windows();
-  if (std::find(windows.begin(), windows.end(), window) == windows.end())
-    return;
-
   WindowManager *wm = WindowManager::Default();
   Window xid = window->id();
 
@@ -3813,6 +3853,33 @@
   return true;
 }
 
+namespace debug
+{
+
+ScreenIntrospection::ScreenIntrospection(CompScreen* screen)
+  : screen_(screen)
+{}
+
+std::string ScreenIntrospection::GetName() const
+{
+  return "Screen";
+}
+
+void ScreenIntrospection::AddProperties(GVariantBuilder* builder)
+{}
+
+Introspectable::IntrospectableList ScreenIntrospection::GetIntrospectableChildren()
+{
+  IntrospectableList children;
+
+  for (auto const& win : screen_->windows())
+    children.push_back(UnityWindow::get(win));
+
+  return children;
+}
+
+} // debug namespace
+
 namespace
 {
 
 
=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-09-19 16:57:39 +0000
+++ plugins/unityshell/src/unityshell.h	2012-09-24 16:14:49 +0000
@@ -27,7 +27,6 @@
 #include <Nux/WindowThread.h>
 #include <NuxCore/Property.h>
 #include <sigc++/sigc++.h>
-#include <boost/shared_ptr.hpp>
 
 #include <scale/scale.h>
 #include <core/core.h>
@@ -50,6 +49,7 @@
 #include "PanelStyle.h"
 #include "UScreen.h"
 #include "DebugDBusInterface.h"
+#include "ScreenIntrospection.h"
 #include "SwitcherController.h"
 #include "UBusWrapper.h"
 #include "UnityshellPrivate.h"
@@ -69,7 +69,7 @@
 
 /* base screen class */
 class UnityScreen :
-  public unity::debug::Introspectable,
+  public debug::Introspectable,
   public sigc::trackable,
   public ScreenInterface,
   public CompositeScreenInterface,
@@ -307,7 +307,7 @@
 
   nux::Property<nux::Geometry> primary_monitor_;
 
-  BGHash* _bghash;
+  std::unique_ptr<BGHash> _bghash;
 
   ::GLFramebufferObject *oldFbo;
 
@@ -329,11 +329,13 @@
   nux::ObjectPtr<nux::IOpenGLBaseTexture> panel_texture_;
 
   bool scale_just_activated_;
+  WindowMinimizeSpeedController minimize_speed_controller_;
+
+  debug::ScreenIntrospection screen_introspection_;
 
   UBusManager ubus_manager_;
   glib::SourceManager sources_;
 
-  WindowMinimizeSpeedController* minimize_speed_controller;
   friend class UnityWindow;
 };
 
@@ -345,6 +347,7 @@
   public WrapableHandler<ScaleWindowInterface, 4>,
   public BaseSwitchWindow,
   public PluginClassHandler <UnityWindow, CompWindow>,
+  public debug::Introspectable,
   public sigc::trackable
 {
 public:
@@ -391,6 +394,7 @@
 
   bool place(CompPoint& pos);
   CompPoint tryNotIntersectUI(CompPoint& pos);
+  nux::Geometry GetScaledGeometry();
 
   void paintThumbnail (nux::Geometry const& bounding, float alpha);
 
@@ -413,6 +417,10 @@
                             const CompRegion &,
                             unsigned int);
 
+protected:
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
 private:
   struct CairoContext;
 
@@ -449,23 +457,16 @@
 
   compiz::WindowInputRemoverLock::Ptr GetInputRemover ();
 
-  void DrawWindowDecoration(GLWindowPaintAttrib const& attrib,
-                            GLMatrix const& transform,
-                            unsigned int mask,
-                            bool highlighted,
+  void DrawWindowDecoration(GLWindowPaintAttrib const& attrib, GLMatrix const& transform,
+                            unsigned int mask, bool highlighted,
                             int x, int y, unsigned width, unsigned height);
-  void DrawTexture(GLTexture *icon,
-                   const GLWindowPaintAttrib& attrib,
-                   const GLMatrix& transform,
-                   unsigned int mask,
-                   float x, float y,
-                   int &maxWidth, int &maxHeight);
-  void RenderText(CairoContext const& context,
-                  float x, float y,
-                  float maxWidth, float maxHeight);
+  void DrawTexture(GLTexture::List const& textures, GLWindowPaintAttrib const& attrib,
+                   GLMatrix const& transform, unsigned int mask, int x, int y);
+  void RenderText(CairoContext const& context, int x, int y, int width, int height);
 
-  void SetupScaleHeaderStyle();
-  void LoadCloseIcon(panel::WindowState state, GLTexture::List& texture);
+  static void SetupSharedTextures();
+  static void CleanupSharedTextures();
+  static void LoadCloseIcon(panel::WindowState state, GLTexture::List& texture);
 
   static GLTexture::List close_normal_tex_;
   static GLTexture::List close_prelight_tex_;
@@ -473,7 +474,10 @@
   compiz::WindowInputRemoverLock::Weak input_remover_;
   panel::WindowState close_icon_state_;
   nux::Geometry close_button_geo_;
+  bool middle_clicked_;
   glib::Source::UniquePtr focus_desktop_timeout_;
+
+  friend class UnityScreen;
 };
 
 
 
=== added file 'tests/autopilot/unity/emulators/screen.py'
--- tests/autopilot/unity/emulators/screen.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/unity/emulators/screen.py	2012-09-24 16:14:49 +0000
@@ -0,0 +1,42 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2012 Canonical
+# Author: Marco Trevisan (Treviño)
+#
+# 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.
+#
+
+from __future__ import absolute_import
+
+import logging
+from unity.emulators import UnityIntrospectionObject
+logger = logging.getLogger(__name__)
+
+
+class Screen(UnityIntrospectionObject):
+    """The Screen class."""
+
+    @property
+    def windows(self):
+        """Return the available windows, or None."""
+        return self.get_children_by_type(Window)
+
+    @property
+    def scaled_windows(self):
+        """Return the available scaled windows, or None."""
+        return self.get_children_by_type(Window, scaled=True)
+
+
+class Window(UnityIntrospectionObject):
+    """An individual window."""
+
+    @property
+    def geometry(self):
+        """Returns a tuple of (x,y,w,h) for the current window."""
+        return (self.x, self.y, self.width, self.height)
+
+    @property
+    def scale_close_geometry(self):
+        """Returns a tuple of (x,y,w,h) for the scale close button."""
+        return (self.scaled_close_x, self.scaled_close_y, self.scaled_close_width, self.scaled_close_height)
 
=== modified file 'tests/autopilot/unity/tests/__init__.py'
--- tests/autopilot/unity/tests/__init__.py	2012-07-12 20:54:59 +0000
+++ tests/autopilot/unity/tests/__init__.py	2012-09-24 16:14:49 +0000
@@ -20,6 +20,7 @@
 from testtools.content import text_content
 from testtools.matchers import Equals
 
+from unity.emulators.screen import Screen
 from unity.emulators.dash import Dash
 from unity.emulators.hud import Hud
 from unity.emulators.launcher import LauncherController
@@ -114,6 +115,12 @@
         return True
 
     @property
+    def screen(self):
+        if not getattr(self, '__screen', None):
+            self.__screen = self._get_screen()
+        return self.__screen
+
+    @property
     def dash(self):
         if not getattr(self, '__dash', None):
             self.__dash = Dash()
@@ -155,6 +162,11 @@
             self.__workspace = WorkspaceManager()
         return self.__workspace
 
+    def _get_screen(self):
+        screens = Screen.get_all_instances()
+        self.assertThat(len(screens), Equals(1))
+        return screens[0]
+
     def _get_launcher_controller(self):
         controllers = LauncherController.get_all_instances()
         self.assertThat(len(controllers), Equals(1))
 
=== added file 'tests/autopilot/unity/tests/test_spread.py'
--- tests/autopilot/unity/tests/test_spread.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/unity/tests/test_spread.py	2012-09-24 16:14:49 +0000
@@ -0,0 +1,124 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2012 Canonical
+# Author: Marco Trevisan (Treviño)
+#
+# 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.
+
+from __future__ import absolute_import
+
+from autopilot.matchers import Eventually
+import logging
+from time import sleep
+from testtools.matchers import Equals, NotEquals
+
+from unity.tests import UnityTestCase
+from unity.emulators.screen import Screen
+
+
+class SpreadTests(UnityTestCase):
+    """Spread tests"""
+
+    def start_test_application_windows(self, app_name, num_windows=2):
+        """Start a given number of windows of the requested application"""
+        self.close_all_app(app_name)
+        windows = []
+
+        for i in range(num_windows):
+            win = self.start_app_window(app_name)
+            if len(windows):
+                self.assertThat(win.application, Equals(windows[-1].application))
+
+            windows.append(win)
+
+        self.assertThat(len(windows), Equals(num_windows))
+
+        return windows
+
+    def initiate_spread_for_screen(self):
+        """Initiate the Spread for all windows"""
+        self.addCleanup(self.keybinding, "spread/cancel")
+        self.keybinding("spread/start")
+        sleep(1)
+        self.assertThat(self.window_manager.scale_active, Eventually(Equals(True)))
+
+
+    def initiate_spread_for_application(self, desktop_id):
+        """Initiate the Spread for windows of the given app"""
+        icon = self.launcher.model.get_icon(desktop_id=desktop_id)
+        self.assertThat(lambda: icon, Eventually(NotEquals(None)))
+        launcher = self.launcher.get_launcher_for_monitor(self.screen_geo.get_primary_monitor())
+
+        self.addCleanup(self.keybinding, "spread/cancel")
+        launcher.click_launcher_icon(icon)
+        self.assertThat(self.window_manager.scale_active_for_group, Eventually(Equals(True)))
+
+    def assertWindowIsNotScaled(self, xid):
+        """Assert that a window is not scaled"""
+        refresh_fn = lambda: xid in [w.xid for w in self.screen.scaled_windows]
+        self.assertThat(refresh_fn, Eventually(Equals(False)))
+
+    def assertWindowIsClosed(self, xid):
+        """Assert that a window is not in the list of the open windows"""
+        refresh_fn = lambda: xid in [w.x_id for w in self.bamf.get_open_windows()]
+        self.assertThat(refresh_fn, Eventually(Equals(False)))
+
+
+    def test_scale_application_windows(self):
+        """Test if all the windows of an application are scaled when application spread is initiated"""
+        [win1, win2] = self.start_test_application_windows("Calculator")
+        self.initiate_spread_for_application(win1.application.desktop_file)
+
+        self.assertThat(lambda: len(self.screen.scaled_windows), Eventually(Equals(2)))
+        self.assertThat(lambda: (win1.x_id and win2.x_id) in [w.xid for w in self.screen.scaled_windows],
+                        Eventually(Equals(True)))
+
+    def test_scaled_window_is_focused_on_click(self):
+        """Test that a window is focused when clicked in spread"""
+        windows = self.start_test_application_windows("Calculator", 3)
+        self.initiate_spread_for_application(windows[0].application.desktop_file)
+
+        not_focused = [w for w in windows if not w.is_focused][0]
+
+        target_xid = not_focused.x_id
+        [target_win] = [w for w in self.screen.scaled_windows if w.xid == target_xid]
+
+        (x, y, w, h) = target_win.geometry
+        self.mouse.move(x + w / 2, y + h / 2)
+        sleep(.5)
+        self.mouse.click()
+
+        self.assertThat(lambda: not_focused.is_focused, Eventually(Equals(True)))
+
+    def test_scaled_window_closes_on_middle_click(self):
+        """Test that a window is closed when middle-clicked in spread"""
+        win = self.start_test_application_windows("Calculator", 2)[0]
+        self.initiate_spread_for_application(win.application.desktop_file)
+
+        target_xid = win.x_id
+        [target_win] = [w for w in self.screen.scaled_windows if w.xid == target_xid]
+
+        (x, y, w, h) = target_win.geometry
+        self.mouse.move(x + w / 2, y + h / 2)
+        sleep(.5)
+        self.mouse.click(button=2)
+
+        self.assertWindowIsNotScaled(target_xid)
+        self.assertWindowIsClosed(target_xid)
+
+    def test_scaled_window_closes_on_close_button_click(self):
+        """Test that a window is closed when its close button is clicked in spread"""
+        win = self.start_test_application_windows("Calculator", 1)[0]
+        self.initiate_spread_for_screen()
+
+        target_xid = win.x_id
+        [target_win] = [w for w in self.screen.scaled_windows if w.xid == target_xid]
+
+        (x, y, w, h) = target_win.scale_close_geometry
+        self.mouse.move(x + w / 2, y + h / 2)
+        sleep(.5)
+        self.mouse.click()
+
+        self.assertWindowIsNotScaled(target_xid)
+        self.assertWindowIsClosed(target_xid)