Merge lp:~renatofilho/unity/unity-lp876017 into lp:unity

[Renato Araujo Oliveira Filho]

UnityWindow now implements ScaleWindowInterface.
Implemented support to close window during the scale plugin.
Fake windows decoration rendering using panel code as base.

UnityWindow now implements ScaleWindowInterface.
Implemented support to close window during the scale plugin.
Fake windows decoration rendering using panel code as base.

[Sam Spilsbury (smspillaz)]

Right approach, some pointers:

76 +// Based on Scale plugin code
77 +CompWindow* UnityScreen::checkForWindowAt (int x, int y)
78 +{
79 + int x1, y1, x2, y2;
80 + CompWindowList::reverse_iterator rit = screen->windows ().rbegin ();
81 +
82 + for (; rit != screen->windows ().rend (); ++rit)
83 + {
84 + CompWindow *w = *rit;
85 + SCALE_WINDOW (w);
86 +
87 + ScalePosition pos = sw->getCurrentPosition ();
88 + if (sw->hasSlot ())
89 + {
90 + x1 = w->x () - w->input ().left * pos.scale;
91 + y1 = w->y () - w->input ().top * pos.scale;
92 + x2 = w->x () + (w->width () + w->input ().right) * pos.scale;
93 + y2 = w->y () + (w->height () + w->input ().bottom) * pos.scale;
94 + x1 += pos.x ();
95 + y1 += pos.y ();
96 + x2 += pos.x ();
97 + y2 += pos.y ();
98 + if (x1 <= x && y1 <= y && x2 > x && y2 > y)
99 + return w;
100 + }
101 + }
102 + return NULL;
103 +}

Is this necessary?

I think you can just overload scaleSelectWindow to determine what the currently hovered window is. From there you will need to damage and re-render both the new and old window. Have a look at the scaleaddon plugin.

151 + gWindow->geometry ().reset ();
152 + if (width && height)
153 + gWindow->glAddGeometry (ml, iconReg, iconReg);
154 +
155 + if (gWindow->geometry ().vCount)
156 + {
157 + GLFragment::Attrib fragment (attrib);
158 + GLMatrix wTransform (transform);
159 +
160 + wTransform.translate (x, y, 0.0f);
161 +
162 + glPushMatrix ();
163 + glLoadMatrixf (wTransform.getMatrix ());
164 + gWindow->glDrawTexture (icon, fragment, mask);
165 + glPopMatrix ();
166 + }

You will need to put this inside of #if USE_MODERN_COMPIZ_GL ifdefs. Sorry :( Here's how to do it:

#ifdef USE_MODERN_COMPIZ_GL
gWindow->vertexBuffer ()->begin ();
#else
151 + gWindow->geometry ().reset ();
#endif
152 + if (width && height)
153 + gWindow->glAddGeometry (ml, iconReg, iconReg);
154 +
#ifdef USE_MODERN_COMPIZ_GL
gWindow->vertexBuffer ().end ();
if (gWindow->vertexBuffer ().countVertices ())
#else
155 + if (gWindow->geometry ().vCount)
#endif
156 + {
#ifdef USE_MODERN_COMPIZ_GL
157 + GLFragment::Attrib fragment (attrib);
#endif
158 + GLMatrix wTransform (transform);
159 +
160 + wTransform.translate (x, y, 0.0f);
161 +
#ifdef USE_MODERN_COMPIZ_GL
gWindow->glDrawTexture (icon, wTransform, attrib, mask);
#else
162 + glPushMatrix ();
163 + glLoadMatrixf (wTransform.getMatrix ());
164 + gWindow->glDrawTexture (icon, fragment, mask);
165 + glPopMatrix ();
#endif
166 + }

172 + // BG
173 + glColor3f (0.0f, 0.0f, 0.0f);
174 + glRectf (x, y2, x2, y);

Preferably use client side buffers for this, eg

#ifndef USE_MODERN_COMPIZ_GL
172 + // BG
173 + glColor3f (0.0f, 0.0f, 0.0f);
174 + glRectf (x, y2, x2, y);
#else
GLVertexBuffer *vertexBuffer = GLVertexBuffer::streamingBuffer ();
vertexBuffer->begin (GL_TRIANGLE_STRIP)
const GLfloat vertices[] =
{
    x, y2, 0.0f,
    x, y, 0.0f,
    x2, y, 0.0f,
    x2, y2, 0.0f
};

vertexBuffer->addVertices (4, vertices);
vertexBuffer->color4f (0.0f, 0.0f, 0.0f, 1.0f);
vertexBuffer->end ();
vertexBuffer->render (transform, attrib);

209 + x + CLOSE_ICON_SPACE, iconY,
210 + maxWidth , maxHeight);

Make this a constant

190 + if (!sWindow->hasSlot() || // animation finished
191 + ...

review: Needs Fixing

[Renato Araujo Oliveira Filho (renatofilho)]

> I think you can just overload scaleSelectWindow to determine what the
> currently hovered window is. From there you will need to damage and re-render
> both the new and old window. Have a look at the scaleaddon plugin.
> #ifdef USE_MODERN_COMPIZ_GL
> gWindow->vertexBuffer ()->begin ();
> #else
> 151 + gWindow->geometry ().reset ();
> #endif
> 152 + if (width && height)
> 153 + gWindow->glAddGeometry (ml, iconReg, iconReg);
> 154 +
> #ifdef USE_MODERN_COMPIZ_GL
> gWindow->vertexBuffer ().end ();
> if (gWindow->vertexBuffer ().countVertices ())
> #else
> 155 + if (gWindow->geometry ().vCount)
> #endif
> 156 + {
> #ifdef USE_MODERN_COMPIZ_GL
> 157 + GLFragment::Attrib fragment (attrib);
> #endif
> 158 + GLMatrix wTransform (transform);
> 159 +
> 160 + wTransform.translate (x, y, 0.0f);
> 161 +
> #ifdef USE_MODERN_COMPIZ_GL
> gWindow->glDrawTexture (icon, wTransform, attrib, mask);
> #else
> 162 + glPushMatrix ();
> 163 + glLoadMatrixf (wTransform.getMatrix ());
> 164 + gWindow->glDrawTexture (icon, fragment, mask);
> 165 + glPopMatrix ();
> #endif
> 166 + }
Fixed on rev: 2577
I have implemented the "scaleSelectWindow" based on scaleaddon plugin, but I did not understand why I need this code. (The implementation is working well without this)

>
> 172 + // BG
> 173 + glColor3f (0.0f, 0.0f, 0.0f);
> 174 + glRectf (x, y2, x2, y);
>
> Preferably use client side buffers for this
Fixed on rev: 2574
Thanks for the example code.

> Make this a constant
Fixed on rev: 2575

>
> Also avoid the 65535, use OPAQUE
Fixed on rev: 2576

>
> 121 + CompString name (PKGDATADIR"/close_dash.png");
>
> Is that the correct asset?
Based on designer docs, yes this is the correct icon.

>
> That needs to be under test.
Any suggestion or example how to test it?

[Renato Araujo Oliveira Filho (renatofilho)]

> > That needs to be under test.
My suggestion to make the code testable is split unityshell.(h/cpp) file into different files (UnityWindow/UnityWindowPrivate, UntiyScree/UnityScreenPrivate and UnityShell), with this we can instantiate only the private class inside of the tests and call/test the "private" functions.

What do you think?

[Sam Spilsbury (smspillaz)]

> > I think you can just overload scaleSelectWindow to determine what the
> > currently hovered window is. From there you will need to damage and re-
> render
> > both the new and old window. Have a look at the scaleaddon plugin.
> > #ifdef USE_MODERN_COMPIZ_GL
> > gWindow->vertexBuffer ()->begin ();
> > #else
> > 151 + gWindow->geometry ().reset ();
> > #endif
> > 152 + if (width && height)
> > 153 + gWindow->glAddGeometry (ml, iconReg, iconReg);
> > 154 +
> > #ifdef USE_MODERN_COMPIZ_GL
> > gWindow->vertexBuffer ().end ();
> > if (gWindow->vertexBuffer ().countVertices ())
> > #else
> > 155 + if (gWindow->geometry ().vCount)
> > #endif
> > 156 + {
> > #ifdef USE_MODERN_COMPIZ_GL
> > 157 + GLFragment::Attrib fragment (attrib);
> > #endif
> > 158 + GLMatrix wTransform (transform);
> > 159 +
> > 160 + wTransform.translate (x, y, 0.0f);
> > 161 +
> > #ifdef USE_MODERN_COMPIZ_GL
> > gWindow->glDrawTexture (icon, wTransform, attrib, mask);
> > #else
> > 162 + glPushMatrix ();
> > 163 + glLoadMatrixf (wTransform.getMatrix ());
> > 164 + gWindow->glDrawTexture (icon, fragment, mask);
> > 165 + glPopMatrix ();
> > #endif
> > 166 + }
> Fixed on rev: 2577
> I have implemented the "scaleSelectWindow" based on scaleaddon plugin, but I
> did not understand why I need this code. (The implementation is working well
> without this)

Hmm, what do you mean by this? If you're saying that you don't need either I guess you can remove them both? Its just that overriding scaleSelectWindow is the preferred way to finding out the currently highlighted window as opposed to reimplementing checkForWindowAt.

>
> >
> > 172 + // BG
> > 173 + glColor3f (0.0f, 0.0f, 0.0f);
> > 174 + glRectf (x, y2, x2, y);
> >
> > Preferably use client side buffers for this
> Fixed on rev: 2574
> Thanks for the example code.
>
> > Make this a constant
> Fixed on rev: 2575
>
> >
> > Also avoid the 65535, use OPAQUE
> Fixed on rev: 2576

Thanks.

>
> >
> > 121 + CompString name (PKGDATADIR"/close_dash.png");
> >
> > Is that the correct asset?
> Based on designer docs, yes this is the correct icon.

+1

>
> >
> > That needs to be under test.
> Any suggestion or example how to test it?

My suggestion to make the code testable is split unityshell.(h/cpp) file into different files (UnityWindow/UnityWindowPrivate, UntiyScree/UnityScreenPrivate and UnityShell), with this we can instantiate only the private class inside of the tests and call/test the "private" functions.

What do you think?

^ This suggestion is the right way to do it :)

[Renato Araujo Oliveira Filho (renatofilho)]

> Hmm, what do you mean by this? If you're saying that you don't need either I
> guess you can remove them both? Its just that overriding scaleSelectWindow is
> the preferred way to finding out the currently highlighted window as opposed
> to reimplementing checkForWindowAt.

I have implemented "scaleSelectWindow" but I did not use all the code you suggested, what I did was:

+void UnityWindow::scaleSelectWindow ()
210 +{
211 + UnityScreen* us = UnityScreen::get(screen);
212 +
213 + if (us->highlighted_window_ != window->id ())
214 + {
215 + CompositeWindow *cWindow = CompositeWindow::get (window);
216 + if (cWindow)
217 + cWindow->addDamage ();
218 +
219 + cWindow = 0;
220 + CompWindow *old_window = screen->findWindow (us->highlighted_window_);
221 + if (old_window)
222 + cWindow = CompositeWindow::get (old_window);
223 +
224 + if (cWindow)
225 + cWindow->addDamage ();
226 +
227 + us->highlighted_window_ = window->id ();
228 + }
229 +
230 + ScaleWindow *sWindow = ScaleWindow::get (window);
231 + if (sWindow)
232 + sWindow->scaleSelectWindow ();

[Renato Araujo Oliveira Filho (renatofilho)]

> > >
> > > That needs to be under test.
> > Any suggestion or example how to test it?
>
> My suggestion to make the code testable is split unityshell.(h/cpp) file into
> different files (UnityWindow/UnityWindowPrivate, UntiyScree/UnityScreenPrivate
> and UnityShell), with this we can instantiate only the private class inside of
> the tests and call/test the "private" functions.
>
> What do you think?
>
> ^ This suggestion is the right way to do it :)

This will be a big change in the code, because of that me and Olivier think this is not the best moment to do it, since this is our last week working on Unity bug fixes, and the code is already in feature freeze.

[Sam Spilsbury (smspillaz)]

This looks good. I don't know how much of this is testable, but I agree at this point its probably better in than out. I'll put my +1 here and hopefully someone can give a second opinion in the next few hours.

review: Approve

[Sam Spilsbury (smspillaz)]

review: Approve

[Unity Merger (unity-merger)]

No commit message specified.

[Unity Merger (unity-merger)]

The Jenkins job https://jenkins.qa.ubuntu.com/job/automerge-unity/1164/console reported an error when processing this lp:~renatofilho/unity/unity-lp876017 branch.
Not merging it.

[Sam Spilsbury (smspillaz)]

Hey renato.

You need to add xrender to the pkgconfig deps in the top level cmakelists file.

Sent from Samsung Mobile

 Unity Merger <email address hidden> wrote:

The Jenkins job https://jenkins.qa.ubuntu.com/job/automerge-unity/1164/console reported an error when processing this lp:~renatofilho/unity/unity-lp876017 branch.
Not merging it.
--
https://code.launchpad.net/~renatofilho/unity/unity-lp876017/+merge/120450
You are reviewing the proposed merge of lp:~renatofilho/unity/unity-lp876017 into lp:unity.

[Unity Merger (unity-merger)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

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

64 + WindowCairoContext ()

When you have some time, could you please update this code to match the unity coding stiles (i.e. no spaces between methods and brackets)

Instead of GetTextProperty and GetTextProperty why not just using gdk_x11_get_xatom_by_name?
Also, these functions should actually be in WindowManager class (implemented by PluginAdapterCompiz).

441 + if (window_header_style_)
442 + g_object_unref (window_header_style_);

You should have used glib::Object for this, and try to get rid of some manual deletion using smart pointers.

[Renato Araujo Oliveira Filho (renatofilho)]

@Trevino
Fixes on: https://code.launchpad.net/~renatofilho/unity/unity-lp876017-fixes/+merge/122357

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2012-08-30 12:52:53 +0000
+++ CMakeLists.txt	2012-08-31 13:28:34 +0000
@@ -130,8 +130,7 @@
 #
 # Compiz Plugins
 #
-
-set (UNITY_PLUGIN_DEPS "compiz;nux-3.0>=3.0.0;libbamf3;dee-1.0;gio-2.0;gio-unix-2.0;gmodule-2.0;dbusmenu-glib-0.4;x11;libstartup-notification-1.0;gthread-2.0;indicator3-0.4>=0.4.90;atk;unity-misc>=0.4.0;dbus-glib-1;gtk+-3.0>=3.1;sigc++-2.0;json-glib-1.0;libnotify;xfixes;unity-protocol-private>=5.95.1;libgeis")
+set (UNITY_PLUGIN_DEPS "compiz;nux-3.0>=3.0.0;libbamf3;dee-1.0;gio-2.0;gio-unix-2.0;gmodule-2.0;dbusmenu-glib-0.4;x11;libstartup-notification-1.0;gthread-2.0;indicator3-0.4>=0.4.90;atk;unity-misc>=0.4.0;dbus-glib-1;gtk+-3.0>=3.1;sigc++-2.0;json-glib-1.0;libnotify;xfixes;unity-protocol-private>=5.95.1;libgeis;xrender>=0.9")
 set (UNITY_PROTOCOL_PRIVATE_DEPS "unity-protocol-private>=5.95.1")
 
 find_package (PkgConfig)
 
=== modified file 'plugins/unityshell/CMakeLists.txt'
--- plugins/unityshell/CMakeLists.txt	2012-08-03 12:51:02 +0000
+++ plugins/unityshell/CMakeLists.txt	2012-08-31 13:28:34 +0000
@@ -6,7 +6,7 @@
 
 compiz_plugin (unityshell
                PKGDEPS ${UNITY_PLUGIN_DEPS}
-               PLUGINDEPS composite opengl compiztoolbox
+               PLUGINDEPS composite opengl compiztoolbox scale
                CFLAGSADD "-DINSTALLPREFIX='\"${CMAKE_INSTALL_PREFIX}\"' -DPKGDATADIR='\"${PKGDATADIR}\"' -I${CMAKE_BINARY_DIR} -I${CMAKE_SOURCE_DIR} ${BOOT_LOGGER_FLAG} -DGETTEXT_PACKAGE='\"unity\"' ${MAINTAINER_CFLAGS} -I${CMAKE_SOURCE_DIR}/dash/ -I${CMAKE_SOURCE_DIR}/launcher/ -I${CMAKE_SOURCE_DIR}/hud/ -I${CMAKE_SOURCE_DIR}/panel/ -I${CMAKE_SOURCE_DIR}/shortcuts/ -I${CMAKE_SOURCE_DIR}/unity-shared/"
                LIBDIRS "${CMAKE_BINARY_DIR}/UnityCore"
                )
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-08-31 09:15:33 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-08-31 13:28:34 +0000
@@ -43,6 +43,9 @@
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <libnotify/notify.h>
+#include <cairo-xlib-xrender.h>
+
+#include <text/text.h>
 
 #include <sstream>
 #include <memory>
@@ -80,6 +83,10 @@
 
 UnityScreen* uScreen = 0;
 
+static unsigned int CLOSE_ICON_SIZE = 19;
+static unsigned int CLOSE_ICON_SPACE = 5;
+static unsigned int SCALE_WINDOW_TITLE_SIZE = 28;
+
 void reset_glib_logging();
 void configure_logging();
 void capture_g_log_calls(const gchar* log_domain,
@@ -100,6 +107,34 @@
 } // namespace local
 } // anon namespace
 
+class WindowCairoContext
+{
+  public:
+    Pixmap pixmap_;
+    cairo_surface_t* surface_;
+    GLTexture::List texture_;
+    cairo_t *cr_;
+
+    WindowCairoContext ()
+      : pixmap_ (0), surface_ (0), cr_ (0)
+    {
+    }
+
+    ~WindowCairoContext ()
+    {
+      if (cr_)
+        cairo_destroy (cr_);
+
+      if (surface_)
+        cairo_surface_destroy (surface_);
+
+      texture_.clear ();
+
+      if (pixmap_)
+        XFreePixmap (screen->dpy (), pixmap_);
+    }
+};
+
 UnityScreen::UnityScreen(CompScreen* screen)
   : BaseSwitchScreen (screen)
   , PluginClassHandler <UnityScreen, CompScreen> (screen)
@@ -128,6 +163,7 @@
   , panel_texture_has_changed_(true)
   , paint_panel_(false)
   , scale_just_activated_(false)
+  , highlighted_window_(0)
   , minimize_speed_controller(new WindowMinimizeSpeedController())
 {
   Timer timer;
@@ -1221,6 +1257,11 @@
   }
 }
 
+CompRect UnityWindow::closeButtonArea ()
+{
+    return close_button_area_;
+}
+
 bool UnityScreen::shellCouldBeHidden(CompOutput const& output)
 {
   std::vector<Window> const& nuxwins(nux::XInputWindow::NativeHandleList());
@@ -1588,6 +1629,24 @@
         launcher_controller_->KeyNavTerminate(false);
         EnableCancelAction(CancelActionTarget::LAUNCHER_SWITCHER, false);
       }
+      if (PluginAdapter::Default()->IsScaleActive() &&
+          event->xbutton.button == Button1 &&
+          highlighted_window_ != 0)
+      {
+        CompWindow *w = screen->findWindow (highlighted_window_);
+        if (w)
+        {
+          UnityWindow *uw = UnityWindow::get (w);
+          CompPoint pointer (pointerX, pointerY);
+          if (uw->closeButtonArea ().contains (pointer))
+          {
+            w->close (0);
+            skip_other_plugins = true;
+          }
+        }
+
+      }
+
       break;
     case ButtonRelease:
       if (switcher_controller_ && switcher_controller_->Visible())
@@ -3409,9 +3468,11 @@
   , gWindow(GLWindow::get(window))
   , mMinimizeHandler()
   , mShowdesktopHandler(nullptr)
+  , window_header_style_(0)
 {
   WindowInterface::setHandler(window);
   GLWindowInterface::setHandler(gWindow);
+  ScaleWindowInterface::setHandler (ScaleWindow::get (window));
 
   if (UnityScreen::get (screen)->optionGetShowMinimizedWindows () &&
       window->mapNum ())
@@ -3456,6 +3517,292 @@
   }
 }
 
+void UnityWindow::DrawTexture (GLTexture* icon,
+                               const GLWindowPaintAttrib& attrib,
+                               const GLMatrix& transform,
+                               unsigned int mask,
+                               float x, float y,
+                               int &maxWidth, int &maxHeight)
+{
+  if (icon)
+  {
+    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 ();
+    gWindow->vertexBuffer ()->begin ();
+    if (width && height)
+      gWindow->glAddGeometry (ml, iconReg, iconReg);
+
+    if (gWindow->vertexBuffer ()->end ())
+    {
+      GLMatrix wTransform (transform);
+
+      wTransform.translate (x, y, 0.0f);
+
+      gWindow->glDrawTexture (icon, wTransform, attrib, mask);
+    }
+  }
+}
+
+WindowCairoContext* UnityWindow::CreateCairoContext (float width, float height)
+{
+    XRenderPictFormat *format;
+    Screen *xScreen;
+    WindowCairoContext *context = new WindowCairoContext();
+
+    xScreen = ScreenOfDisplay (screen->dpy (), screen->screenNum ());
+
+    format = XRenderFindStandardFormat (screen->dpy (), PictStandardARGB32);
+    context->pixmap_ = XCreatePixmap (screen->dpy (),
+                                      screen->root (),
+                                      width, height, 32);
+
+    context->texture_ = GLTexture::bindPixmapToTexture (context->pixmap_,
+                                                        width, height,
+                                                        32);
+    if (context->texture_.empty ())
+    {
+      delete context;
+      return 0;
+    }
+
+    context->surface_ = cairo_xlib_surface_create_with_xrender_format (screen->dpy (),
+                                                                       context->pixmap_,
+                                                                       xScreen,
+                                                                       format,
+                                                                       width,
+                                                                       height);
+    context->cr_ = cairo_create (context->surface_);
+
+    // clear
+    cairo_save (context->cr_);
+    cairo_set_operator (context->cr_, CAIRO_OPERATOR_CLEAR);
+    cairo_paint (context->cr_);
+    cairo_restore (context->cr_);
+
+    return context;
+}
+
+void UnityWindow::RenderText (WindowCairoContext *context,
+                              float x, float y,
+                              float maxWidth, float maxHeight)
+{
+  PangoFontDescription* font = pango_font_description_new ();
+  pango_font_description_set_family (font, "sans");
+  pango_font_description_set_absolute_size (font, 12 * PANGO_SCALE);
+  pango_font_description_set_style (font, PANGO_STYLE_NORMAL);
+  pango_font_description_set_weight (font, PANGO_WEIGHT_BOLD);
+
+  PangoLayout* layout = pango_cairo_create_layout (context->cr_);
+  pango_layout_set_font_description (layout, font);
+  pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
+  pango_layout_set_height (layout, maxHeight);
+
+  pango_layout_set_auto_dir (layout, false);
+  pango_layout_set_text (layout,
+                         GetWindowName (window->id ()).c_str (),
+                         -1);
+
+  /* update the size of the pango layout */
+  pango_layout_set_width (layout, maxWidth * PANGO_SCALE);
+  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);
+
+  // alignment
+  int lWidth, lHeight;
+  pango_layout_get_pixel_size (layout, &lWidth, &lHeight);
+
+  y = ((maxHeight - lHeight) / 2.0) + y;
+  cairo_translate (context->cr_, x, y);
+  pango_cairo_show_layout (context->cr_, layout);
+}
+
+void UnityWindow::DrawWindowTitle (const GLWindowPaintAttrib& attrib,
+                                   const GLMatrix& transform,
+                                   unsigned int mask,
+                                   float x, float y, float x2, float y2)
+{
+  const float width = x2 - x;
+
+  // Paint a fake window decoration
+  WindowCairoContext *context = CreateCairoContext (width, SCALE_WINDOW_TITLE_SIZE);
+
+  cairo_save (context->cr_);
+  cairo_push_group (context->cr_);
+
+  // Round window decoration top border
+  const double height = SCALE_WINDOW_TITLE_SIZE;
+  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;
+
+  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_, width, height);
+  cairo_line_to (context->cr_, 0, height);
+
+  cairo_close_path (context->cr_);
+  cairo_clip (context->cr_);
+
+  // Draw window decoration abased on gtk style
+  gtk_render_background (window_header_style_, context->cr_, 0, 0, width, SCALE_WINDOW_TITLE_SIZE);
+  gtk_render_frame (window_header_style_, context->cr_, 0, 0, width, SCALE_WINDOW_TITLE_SIZE);
+
+  cairo_pop_group_to_source (context->cr_);
+
+  cairo_paint_with_alpha (context->cr_, 1.0);
+  cairo_restore (context->cr_);
+
+  // Draw windows title
+  RenderText (context,
+              CLOSE_ICON_SPACE * 2 + CLOSE_ICON_SIZE,
+              0.0,
+              width, SCALE_WINDOW_TITLE_SIZE);
+
+  mask |= PAINT_WINDOW_BLEND_MASK;
+  int maxWidth, maxHeight;
+  foreach(GLTexture *icon, context->texture_)
+  {
+    DrawTexture (icon, attrib, transform, mask,
+                 x, y,
+                 maxWidth , maxHeight);
+  }
+
+  delete context;
+}
+
+void UnityWindow::scalePaintDecoration (const GLWindowPaintAttrib& attrib,
+                                        const GLMatrix& transform,
+                                        const CompRegion& region,
+                                        unsigned int mask)
+{
+  ScaleWindow *sWindow = ScaleWindow::get (window);
+  if (!sWindow)
+    return;
+
+  sWindow->scalePaintDecoration (attrib, transform, region, mask);
+
+  if (!sWindow->hasSlot()) // animation not finished
+    return;
+
+  if (!window_header_style_)
+  {
+    GtkWidgetPath* widget_path = gtk_widget_path_new ();
+    gint pos = gtk_widget_path_append_type (widget_path, GTK_TYPE_WINDOW);
+    gtk_widget_path_iter_set_name (widget_path, pos, "UnityPanelWidget");
+
+    window_header_style_  = gtk_style_context_new ();
+    gtk_style_context_set_path (window_header_style_, widget_path);
+    gtk_style_context_add_class (window_header_style_, "gnome-panel-menu-bar");
+    gtk_style_context_add_class (window_header_style_, "unity-panel");
+
+    // get close button
+    panel::Style& style = panel::Style::Instance();
+
+    std::vector<std::string> files = style.GetWindowButtonFileNames (panel::WindowButtonType::CLOSE,
+                                                                     panel::WindowState::NORMAL);
+
+    CompString pName ("unityshell");
+    foreach (std::string file, files)
+    {
+      CompString fileName (file.c_str ());
+      CompSize size (CLOSE_ICON_SIZE, CLOSE_ICON_SIZE);
+      close_icon_ = GLTexture::readImageToTexture (fileName,
+                                                   pName,
+                                                   size);
+      if (close_icon_.size () != 0)
+        break;
+    }
+
+    if (close_icon_.size () == 0)
+    {
+      CompString fileName (PKGDATADIR"/close_dash.png");
+      CompSize size (CLOSE_ICON_SIZE, CLOSE_ICON_SIZE);
+      close_icon_ = GLTexture::readImageToTexture (fileName,
+                                                   pName,
+                                                   size);
+    }
+  }
+
+  // Make the windows header opaque to override the original
+  GLWindowPaintAttrib sAttrib (attrib);
+  sAttrib.opacity = OPAQUE;
+
+  ScalePosition pos = sWindow->getCurrentPosition ();
+  int maxHeight, maxWidth;
+  // Use "2" as margin to make sure to cover all originial decoration
+  const float width = (window->width () + 4) * pos.scale;
+  const float x = pos.x () + window->x () - (2 * pos.scale);
+  const float y = pos.y () + window->y () - SCALE_WINDOW_TITLE_SIZE;
+  const float iconX = x + CLOSE_ICON_SPACE;
+  const float iconY = y + ((SCALE_WINDOW_TITLE_SIZE - CLOSE_ICON_SIZE)  / 2.0);
+
+  maxHeight = maxWidth = 0;
+
+  DrawWindowTitle (sAttrib,
+                   transform,
+                   mask,
+                   x, y,
+                   x + width, y + SCALE_WINDOW_TITLE_SIZE);
+
+  mask |= PAINT_WINDOW_BLEND_MASK;
+  foreach(GLTexture *icon, close_icon_)
+  {
+    DrawTexture (icon, sAttrib, transform, mask,
+                 iconX, iconY,
+                 maxWidth , maxHeight);
+  }
+
+  close_button_area_ = CompRect (iconX, iconY, maxWidth, maxHeight);
+}
+
+void UnityWindow::scaleSelectWindow ()
+{
+  UnityScreen* us = UnityScreen::get(screen);
+
+  if (us->highlighted_window_ != window->id ())
+  {
+    CompositeWindow *cWindow = CompositeWindow::get (window);
+    if (cWindow)
+      cWindow->addDamage ();
+
+    cWindow = 0;
+    CompWindow *old_window = screen->findWindow (us->highlighted_window_);
+    if (old_window)
+      cWindow = CompositeWindow::get (old_window);
+
+    if (cWindow)
+      cWindow->addDamage ();
+
+    us->highlighted_window_ = window->id ();
+  }
+
+  ScaleWindow *sWindow = ScaleWindow::get (window);
+  if (sWindow)
+    sWindow->scaleSelectWindow ();
+}
+
 UnityWindow::~UnityWindow()
 {
   UnityScreen* us = UnityScreen::get(screen);
@@ -3474,6 +3821,9 @@
       window->minimize ();
   }
 
+  if (window_header_style_)
+    g_object_unref (window_header_style_);
+
   ShowdesktopHandler::animating_windows.remove (static_cast <ShowdesktopHandlerWindowInterface *> (this));
 
   if (mShowdesktopHandler)
@@ -3513,6 +3863,84 @@
   return true;
 }
 
+CompString UnityWindow::GetUtf8Property (Window id,
+                                         Atom atom)
+{
+    Atom          type;
+    int           result, format;
+    unsigned long nItems, bytesAfter;
+    char          *val;
+    CompString    retval;
+    Atom          utf8StringAtom;
+
+    utf8StringAtom = XInternAtom (screen->dpy (), "UTF8_STRING", 0);
+    result = XGetWindowProperty (screen->dpy (), id, atom, 0L, 65536, False,
+                                 utf8StringAtom, &type, &format, &nItems,
+                                 &bytesAfter, (unsigned char **) &val);
+
+    if (result != Success)
+      return retval;
+
+    if (type == utf8StringAtom && format == 8 && val && nItems > 0)
+    {
+      char valueString[nItems + 1];
+      strncpy (valueString, val, nItems);
+      valueString[nItems] = 0;
+      retval = valueString;
+    }
+    if (val)
+      XFree (val);
+
+    return retval;
+}
+
+CompString UnityWindow::GetTextProperty (Window id,
+                                         Atom   atom)
+{
+  XTextProperty text;
+  CompString    retval;
+
+  text.nitems = 0;
+  if (XGetTextProperty (screen->dpy (), id, &text, atom))
+  {
+    if (text.value)
+    {
+      char valueString[text.nitems + 1];
+
+      strncpy (valueString, (char *) text.value, text.nitems);
+      valueString[text.nitems] = 0;
+
+      retval = valueString;
+
+      XFree (text.value);
+    }
+  }
+
+  return retval;
+}
+
+
+CompString UnityWindow::GetWindowName (Window id)
+{
+  CompString name;
+  Atom       visibleNameAtom;
+
+  visibleNameAtom = XInternAtom (screen->dpy (), "_NET_WM_VISIBLE_NAME", 0);
+  name = GetUtf8Property (id, visibleNameAtom);
+  if (name.empty ())
+  {
+    Atom wmNameAtom = XInternAtom (screen->dpy (), "_NET_WM_NAME", 0);
+    name = GetUtf8Property (id, wmNameAtom);
+  }
+
+
+  if (name.empty ())
+    name = GetTextProperty (id, XA_WM_NAME);
+
+  return name;
+}
+
+
 
 namespace
 {
 
=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2012-08-27 13:51:29 +0000
+++ plugins/unityshell/src/unityshell.h	2012-08-31 13:28:34 +0000
@@ -29,6 +29,7 @@
 #include <sigc++/sigc++.h>
 #include <boost/shared_ptr.hpp>
 
+#include <scale/scale.h>
 #include <core/core.h>
 #include <core/pluginclasshandler.h>
 #include <composite/composite.h>
@@ -70,6 +71,8 @@
 namespace unity
 {
 
+class WindowCairoContext;
+
 /* base screen class */
 class UnityScreen :
   public unity::debug::Introspectable,
@@ -344,8 +347,9 @@
   glib::SourceManager sources_;
   unity::ThumbnailGenerator thumb_generator;
 
+  Window highlighted_window_;
+
   WindowMinimizeSpeedController* minimize_speed_controller;
-  
   friend class UnityWindow;
 };
 
@@ -354,6 +358,7 @@
   public GLWindowInterface,
   public ShowdesktopHandlerWindowInterface,
   public compiz::WindowInputRemoverLockAcquireInterface,
+  public WrapableHandler<ScaleWindowInterface, 4>,
   public BaseSwitchWindow,
   public PluginClassHandler <UnityWindow, CompWindow>
 {
@@ -414,6 +419,8 @@
 
   void handleEvent (XEvent *event);
 
+  CompRect closeButtonArea ();
+
   typedef compiz::CompizMinimizedWindowHandler<UnityScreen, UnityWindow>
           UnityMinimizedHandler;
   std::unique_ptr <UnityMinimizedHandler> mMinimizeHandler;
@@ -422,6 +429,13 @@
 
   //! Emited when CompWindowNotifyBeforeDestroy is received
   sigc::signal<void> being_destroyed;
+
+  void scaleSelectWindow ();
+  void scalePaintDecoration (const GLWindowPaintAttrib &,
+                             const GLMatrix &,
+                             const CompRegion &,
+                             unsigned int);
+
 private:
   void DoEnableFocus ();
   void DoDisableFocus ();
@@ -453,8 +467,32 @@
 
   compiz::WindowInputRemoverLock::Ptr GetInputRemover ();
 
+  void DrawWindowTitle (const GLWindowPaintAttrib& attrib,
+                        const GLMatrix& transform,
+                        unsigned int mask,
+                        float x, float y, float x2, float y2);
+  void DrawTexture (GLTexture *icon,
+                    const GLWindowPaintAttrib& attrib,
+                    const GLMatrix& transform,
+                    unsigned int mask,
+                    float x, float y,
+                    int &maxWidth, int &maxHeight);
+  void RenderText (WindowCairoContext *context,
+                   float x, float y,
+                   float maxWidth, float maxHeight);
+  WindowCairoContext* CreateCairoContext (float width, float height);
+
+  // based on compiz text plugin
+  CompString GetWindowName (Window id);
+  CompString GetUtf8Property (Window id, Atom atom);
+  CompString GetTextProperty (Window id, Atom atom);
+
   compiz::WindowInputRemoverLock::Weak input_remover_;
   glib::Source::UniquePtr focus_desktop_timeout_;
+
+  GLTexture::List close_icon_;
+  CompRect close_button_area_;
+  GtkStyleContext* window_header_style_;
 };
 
 
 
=== modified file 'unity-shared/PanelStyle.cpp'
--- unity-shared/PanelStyle.cpp	2012-08-01 20:46:31 +0000
+++ unity-shared/PanelStyle.cpp	2012-08-31 13:28:34 +0000
@@ -182,9 +182,17 @@
   return context.GetBitmap();
 }
 
-nux::BaseTexture* Style::GetWindowButton(WindowButtonType type, WindowState state)
+/*!
+  Return a vector with the possible file names sorted by priority
+
+  @param type The type of the button.
+  @param state The button state.
+
+  @return A vector of strings with the possible file names sorted by priority.
+*/
+std::vector<std::string> Style::GetWindowButtonFileNames(WindowButtonType type, WindowState state)
 {
-  nux::BaseTexture* texture = NULL;
+  std::vector<std::string> files;
   std::string names[] = { "close", "minimize", "unmaximize", "maximize" };
   std::string states[] = { "", "_focused_prelight", "_focused_pressed", "_unfocused",
                            "_unfocused", "_unfocused_prelight", "_unfocused_pressed"};
@@ -200,38 +208,40 @@
     glib::String filename(g_build_filename(home_dir, ".themes", _theme_name.c_str(), subpath.str().c_str(), NULL));
 
     if (g_file_test(filename.Value(), G_FILE_TEST_EXISTS))
-    {
-      glib::Error error;
-
-      // Found a file, try loading the pixbuf
-      glib::Object<GdkPixbuf> pixbuf(gdk_pixbuf_new_from_file(filename.Value(), &error));
-      if (error)
-        LOG_WARNING(logger) << "Unable to load window button " << filename.Value() << ": " << error.Message();
-      else
-        texture = nux::CreateTexture2DFromPixbuf(pixbuf, true);
-    }
+      files.push_back (filename.Value());
   }
 
-  // texture is NULL if the pixbuf is not loaded
-  if (!texture)
+  const char* var = g_getenv("GTK_DATA_PREFIX");
+  if (!var)
+    var = "/usr";
+
+  glib::String filename(g_build_filename(var, "share", "themes", _theme_name.c_str(), subpath.str().c_str(), NULL));
+  if (g_file_test(filename.Value(), G_FILE_TEST_EXISTS))
+    files.push_back (filename.Value());
+
+  return files;
+}
+
+nux::BaseTexture* Style::GetWindowButton(WindowButtonType type, WindowState state)
+{
+  nux::BaseTexture* texture = NULL;
+
+  std::vector<std::string> files = GetWindowButtonFileNames (type, state);
+  for (unsigned int i=0; i < files.size(); i++)
   {
-    const char* var = g_getenv("GTK_DATA_PREFIX");
-    if (!var)
-      var = "/usr";
-
-    glib::String filename(g_build_filename(var, "share", "themes", _theme_name.c_str(), subpath.str().c_str(), NULL));
-
-    if (g_file_test(filename.Value(), G_FILE_TEST_EXISTS))
-    {
       glib::Error error;
-
-      // Found a file, try loading the pixbuf
-      glib::Object<GdkPixbuf> pixbuf(gdk_pixbuf_new_from_file(filename.Value(), &error));
+      // Try loading the pixbuf
+      glib::Object<GdkPixbuf> pixbuf(gdk_pixbuf_new_from_file(files[i].c_str (), &error));
       if (error)
-        LOG_WARNING(logger) << "Unable to load window button " << filename.Value() << ": " << error.Message();
+      {
+        LOG_WARNING(logger) << "Unable to load window button " << files[i] << ": " << error.Message();
+      }
       else
+      {
         texture = nux::CreateTexture2DFromPixbuf(pixbuf, true);
-    }
+        if (texture)
+          break;
+      }
   }
 
   if (!texture)
 
=== modified file 'unity-shared/PanelStyle.h'
--- unity-shared/PanelStyle.h	2012-08-01 20:46:31 +0000
+++ unity-shared/PanelStyle.h	2012-08-31 13:28:34 +0000
@@ -71,6 +71,7 @@
   GtkStyleContext* GetStyleContext();
   nux::NBitmapData* GetBackground(int width, int height, float opacity);
   nux::BaseTexture* GetWindowButton(WindowButtonType type, WindowState state);
+  std::vector<std::string> GetWindowButtonFileNames(WindowButtonType type, WindowState state);
   nux::BaseTexture* GetFallbackWindowButton(WindowButtonType type, WindowState state);
   glib::Object<GdkPixbuf> GetHomeButton();
   std::string GetFontDescription(PanelItem item);