Unity

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

unity-lp876017
Merge into trunk

Proposed by Renato Araujo Oliveira Filho on 2012-08-20

Status:

Merged

Approved by:

Renato Araujo Oliveira Filho on 2012-08-31

Approved revision:

no longer in the source branch.

Merged at revision:

2650

Proposed branch:

lp:~renatofilho/unity/unity-lp876017

Merge into:

lp:unity

Diff against target:

729 lines (+507/-31)

6 files modified

CMakeLists.txt (+1/-2)
plugins/unityshell/CMakeLists.txt (+1/-1)
plugins/unityshell/src/unityshell.cpp (+428/-0)
plugins/unityshell/src/unityshell.h (+39/-1)
unity-shared/PanelStyle.cpp (+37/-27)
unity-shared/PanelStyle.h (+1/-0)

To merge this branch:

bzr merge lp:~renatofilho/unity/unity-lp876017

Medium

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Sam Spilsbury (community)		2012-08-20	Approve on 2012-08-30
Review via email: mp+120450@code.launchpad.net

Commit message

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

Description of the change

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

Revision history for this message

Sam Spilsbury (smspillaz) wrote on 2012-08-21:

Download full text (3.7 KiB)

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 + ...

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?

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	+ attrib.opacity != 65535) // no focus
192	+ return;
193	+
194	+ ScalePosition pos = sWindow->getCurrentPosition ();
195	+ int maxHeight, maxWidth;
196	+ int width = window->width () * pos.scale;
197	+ float x = pos.x () + window->x ();
198	+ float y = pos.y () + window->y ();
199	+ float iconY = y + ((SCALE_WINDOW_TITLE_SIZE - CLOSE_ICON_SIZE) / 2.0);
200	+
201	+ maxHeight = maxWidth = 0;

That needs to be under test.

Also avoid the 65535, use OPAQUE

121	+ CompString name (PKGDATADIR"/close_dash.png");

Is that the correct asset?

review: Needs Fixing

Revision history for this message

Renato Araujo Oliveira Filho (renatofilho) wrote on 2012-08-21:

> 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?

Revision history for this message

Renato Araujo Oliveira Filho (renatofilho) wrote on 2012-08-22:

> > 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?

Revision history for this message

Sam Spilsbury (smspillaz) wrote on 2012-08-24:

> > 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.

>
> >
> > 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 :)

> > 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

Thanks.

> 
> >
> > 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?

What do you think?

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

Revision history for this message

Renato Araujo Oliveira Filho (renatofilho) wrote on 2012-08-24:

> 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 ();

Revision history for this message

Renato Araujo Oliveira Filho (renatofilho) wrote on 2012-08-27:

> > >
> > > 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.

Revision history for this message

Sam Spilsbury (smspillaz) wrote on 2012-08-29:

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

Revision history for this message

Sam Spilsbury (smspillaz) on 2012-08-30:

review: Approve

Revision history for this message

Unity Merger (unity-merger) wrote on 2012-08-31:

No commit message specified.

Revision history for this message

Unity Merger (unity-merger) wrote on 2012-08-31:

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.

Revision history for this message

Sam Spilsbury (smspillaz) wrote on 2012-08-31:

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.

Revision history for this message

Unity Merger (unity-merger) wrote on 2012-08-31:

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

Revision history for this message

Marco Trevisan (Treviño) (3v1n0) wrote on 2012-08-31:

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.

Revision history for this message

Renato Araujo Oliveira Filho (renatofilho) wrote on 2012-08-31:

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

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Alin Andrei

Alvaro Leal (Effenberg0x0)

Andrea Azzarone

Brandon Schaefer

Christopher Townsend

DX Unity Bugs

Jason Armstrong

Joey-Elijah Sneddon

Kai-Heng Feng

Loïc Molinari

MC Return

Marco Trevisan (Treviño)

Olli Ries

Rahul

Renato Araujo Oliveira Filho

Sathishkumar D

Stephen Matthews

Unity Team

deaunapaul

to status/vote changes:

Jim Romines

 === 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);