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

[Marco Trevisan (Treviño)]

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

Backporting branch lp:~3v1n0/unity/scale-close-middle-click/+merge/126044

[Brandon Schaefer (brandontschaefer)]

Confirmed still working :)

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 19:39:25 +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-19 13:58:01 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-09-24 19:39:25 +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 19:39:25 +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 19:39:25 +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 19:39:25 +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 19:39:25 +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)