Merge lp:~focus-follows-mouse/ubuntu/precise/compiz/fix-883383 into lp:ubuntu/precise/compiz

[James Pharaoh]

[Sam Spilsbury (smspillaz)]

Hi.

I'm assuming that his is the same thing as https://code.launchpad.net/~jamespharaoh/ubuntu/precise/compiz/fix-881329/+merge/80314

Could you propose this against lp:compiz-core? This is the packaging branch.

[Stéphane Graber (stgraber)]

Based on comment above, marking work in progress.

Unmerged revisions

254. By James Pharaoh on 2011-10-29

* debian/patches/fix-883383.patch:
  - Drag title bar should not raise if raise-on-click is disabled (LP: #883383)

253. By James Pharaoh on 2011-10-25

* debian/patches/fix-881329.patch:
  - Alt+click should raise with raise-on-click disabled (LP: #881329)

=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2011-10-29 09:07:25 +0000
@@ -0,0 +1,1 @@
+debian/patches

=== added file '.pc/.quilt_series'
--- .pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_series	2011-10-29 09:07:25 +0000
@@ -0,0 +1,1 @@
+series

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2011-10-12 10:44:49 +0000
+++ .pc/applied-patches	2011-10-29 09:07:25 +0000
@@ -12,3 +12,5 @@
 fix-832150.patch
 fix-864478.patch
 fix-864330.patch
+fix-881329.patch
+fix-883383.patch

=== added directory '.pc/fix-881329.patch'
=== added file '.pc/fix-881329.patch/.timestamp'
=== added directory '.pc/fix-881329.patch/plugins'
=== added directory '.pc/fix-881329.patch/plugins/move'
=== added directory '.pc/fix-881329.patch/plugins/move/src'
=== added file '.pc/fix-881329.patch/plugins/move/src/move.cpp'
--- .pc/fix-881329.patch/plugins/move/src/move.cpp	1970-01-01 00:00:00 +0000
+++ .pc/fix-881329.patch/plugins/move/src/move.cpp	2011-10-29 09:07:25 +0000
@@ -0,0 +1,756 @@
+/*
+ * Copyright © 2005 Novell, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Novell, Inc. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Novell, Inc. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: David Reveman <[e-mail]>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <X11/cursorfont.h>
+
+#include <core/atoms.h>
+#include "move.h"
+
+COMPIZ_PLUGIN_20090315 (move, MovePluginVTable)
+
+static bool
+moveInitiate (CompAction      *action,
+	      CompAction::State state,
+	      CompOption::Vector &options)
+{
+    CompWindow *w;
+    Window     xid;
+
+    MOVE_SCREEN (screen);
+
+    xid = CompOption::getIntOptionNamed (options, "window");
+
+    w = screen->findWindow (xid);
+    if (w && (w->actions () & CompWindowActionMoveMask))
+    {
+	CompRect     workArea;
+	unsigned int mods;
+	int          x, y, button;
+	bool         sourceExternalApp;
+
+	CompScreen *s = screen;
+
+	mods = CompOption::getIntOptionNamed (options, "modifiers", 0);
+
+	x = CompOption::getIntOptionNamed (options, "x", w->geometry ().x () +
+					   (w->size ().width () / 2));
+	y = CompOption::getIntOptionNamed (options, "y", w->geometry ().y () +
+					   (w->size ().height () / 2));
+
+	button = CompOption::getIntOptionNamed (options, "button", -1);
+
+	if (s->otherGrabExist ("move", NULL))
+	    return false;
+
+	if (ms->w)
+	    return false;
+
+	if (w->type () & (CompWindowTypeDesktopMask |
+		       CompWindowTypeDockMask    |
+		       CompWindowTypeFullscreenMask))
+	    return false;
+
+	if (w->overrideRedirect ())
+	    return false;
+
+	if (state & CompAction::StateInitButton)
+	    action->setState (action->state () | CompAction::StateTermButton);
+
+	if (ms->region)
+	{
+	    XDestroyRegion (ms->region);
+	    ms->region = NULL;
+	}
+
+	ms->status = RectangleOut;
+
+	ms->savedX = w->serverGeometry ().x ();
+	ms->savedY = w->serverGeometry ().y ();
+
+	ms->x = 0;
+	ms->y = 0;
+
+	lastPointerX = x;
+	lastPointerY = y;
+
+	sourceExternalApp =
+	    CompOption::getBoolOptionNamed (options, "external", false);
+	ms->yConstrained = sourceExternalApp && ms->optionGetConstrainY ();
+
+	ms->origState = w->state ();
+
+	workArea = s->getWorkareaForOutput (w->outputDevice ());
+
+	ms->snapBackY = w->serverGeometry ().y () - workArea.y ();
+	ms->snapOffY  = y - workArea.y ();
+
+	if (!ms->grab)
+	    ms->grab = s->pushGrab (ms->moveCursor, "move");
+
+	if (ms->grab)
+	{
+	    unsigned int grabMask = CompWindowGrabMoveMask |
+				    CompWindowGrabButtonMask;
+
+	    if (sourceExternalApp)
+		grabMask |= CompWindowGrabExternalAppMask;
+
+	    ms->w = w;
+
+	    ms->releaseButton = button;
+
+	    w->grabNotify (x, y, mods, grabMask);
+
+	    /* Click raise happens implicitly on buttons 1, 2 and 3 so don't
+	     * restack this window again if the action buttonbinding was from
+	     * one of those buttons */
+	    if (screen->getOption ("raise_on_click")->value ().b () &&
+		button != Button1 && button != Button2 && button != Button3)
+		w->updateAttributes (CompStackingUpdateModeAboveFullscreen);
+
+	    if (state & CompAction::StateInitKey)
+	    {
+		int xRoot, yRoot;
+
+		xRoot = w->geometry ().x () + (w->size ().width () / 2);
+		yRoot = w->geometry ().y () + (w->size ().height () / 2);
+
+		s->warpPointer (xRoot - pointerX, yRoot - pointerY);
+	    }
+
+	    if (ms->moveOpacity != OPAQUE)
+	    {
+		MOVE_WINDOW (w);
+
+		if (mw->cWindow)
+		    mw->cWindow->addDamage ();
+		if (mw->gWindow)
+		mw->gWindow->glPaintSetEnabled (mw, true);
+	    }
+	}
+    }
+
+    return false;
+}
+
+static bool
+moveTerminate (CompAction      *action,
+	       CompAction::State state,
+	       CompOption::Vector &options)
+{
+    MOVE_SCREEN (screen);
+
+    if (ms->w)
+    {
+	if (state & CompAction::StateCancel)
+	    ms->w->move (ms->savedX - ms->w->geometry ().x (),
+			 ms->savedY - ms->w->geometry ().y (), false);
+
+	ms->w->syncPosition ();
+
+	/* update window attributes as window constraints may have
+	   changed - needed e.g. if a maximized window was moved
+	   to another output device */
+	ms->w->updateAttributes (CompStackingUpdateModeNone);
+
+	ms->w->ungrabNotify ();
+
+	if (ms->grab)
+	{
+	    screen->removeGrab (ms->grab, NULL);
+	    ms->grab = NULL;
+	}
+
+	if (ms->moveOpacity != OPAQUE)
+	{
+	    MOVE_WINDOW (ms->w);
+
+	    if (mw->cWindow)
+		mw->cWindow->addDamage ();
+	    if (mw->gWindow)
+		mw->gWindow->glPaintSetEnabled (mw, false);
+	}
+
+	ms->w             = 0;
+	ms->releaseButton = 0;
+    }
+
+    action->setState (action->state () & ~(CompAction::StateTermKey |
+					   CompAction::StateTermButton));
+
+    return false;
+}
+
+/* creates a region containing top and bottom struts. only struts that are
+   outside the screen workarea are considered. */
+static Region
+moveGetYConstrainRegion (CompScreen *s)
+{
+    CompWindow   *w;
+    Region       region;
+    REGION       r;
+    CompRect     workArea;
+    BoxRec       extents;
+    unsigned int i;
+
+    region = XCreateRegion ();
+    if (!region)
+	return NULL;
+
+    r.rects    = &r.extents;
+    r.numRects = r.size = 1;
+
+    r.extents.x1 = MINSHORT;
+    r.extents.y1 = 0;
+    r.extents.x2 = 0;
+    r.extents.y2 = s->height ();
+
+    XUnionRegion (&r, region, region);
+
+    r.extents.x1 = s->width ();
+    r.extents.x2 = MAXSHORT;
+
+    XUnionRegion (&r, region, region);
+
+    for (i = 0; i < s->outputDevs ().size (); i++)
+    {
+	XUnionRegion (s->outputDevs ()[i].region (), region, region);
+
+	workArea = s->getWorkareaForOutput (i);
+	extents = s->outputDevs ()[i].region ()->extents;
+
+	foreach (w, s->windows ())
+	{
+	    if (!w->mapNum ())
+		continue;
+
+	    if (w->struts ())
+	    {
+		r.extents.x1 = w->struts ()->top.x;
+		r.extents.y1 = w->struts ()->top.y;
+		r.extents.x2 = r.extents.x1 + w->struts ()->top.width;
+		r.extents.y2 = r.extents.y1 + w->struts ()->top.height;
+
+		if (r.extents.x1 < extents.x1)
+		    r.extents.x1 = extents.x1;
+		if (r.extents.x2 > extents.x2)
+		    r.extents.x2 = extents.x2;
+		if (r.extents.y1 < extents.y1)
+		    r.extents.y1 = extents.y1;
+		if (r.extents.y2 > extents.y2)
+		    r.extents.y2 = extents.y2;
+
+		if (r.extents.x1 < r.extents.x2 && r.extents.y1 < r.extents.y2)
+		{
+		    if (r.extents.y2 <= workArea.y ())
+			XSubtractRegion (region, &r, region);
+		}
+
+		r.extents.x1 = w->struts ()->bottom.x;
+		r.extents.y1 = w->struts ()->bottom.y;
+		r.extents.x2 = r.extents.x1 + w->struts ()->bottom.width;
+		r.extents.y2 = r.extents.y1 + w->struts ()->bottom.height;
+
+		if (r.extents.x1 < extents.x1)
+		    r.extents.x1 = extents.x1;
+		if (r.extents.x2 > extents.x2)
+		    r.extents.x2 = extents.x2;
+		if (r.extents.y1 < extents.y1)
+		    r.extents.y1 = extents.y1;
+		if (r.extents.y2 > extents.y2)
+		    r.extents.y2 = extents.y2;
+
+		if (r.extents.x1 < r.extents.x2 && r.extents.y1 < r.extents.y2)
+		{
+		    if (r.extents.y1 >= workArea.bottom ())
+			XSubtractRegion (region, &r, region);
+		}
+	    }
+	}
+    }
+
+    return region;
+}
+
+static void
+moveHandleMotionEvent (CompScreen *s,
+		       int	  xRoot,
+		       int	  yRoot)
+{
+    MOVE_SCREEN (s);
+
+    if (ms->grab)
+    {
+	int	     dx, dy;
+	int	     wX, wY;
+	int          wWidth, wHeight;
+	CompWindow   *w;
+
+	w = ms->w;
+
+	wX      = w->geometry ().x ();
+	wY      = w->geometry ().y ();
+	wWidth  = w->geometry ().width () +
+		  w->geometry ().border () * 2;
+	wHeight = w->geometry ().height () +
+		  w->geometry ().border () * 2;
+
+	ms->x += xRoot - lastPointerX;
+	ms->y += yRoot - lastPointerY;
+
+	if (w->type () & CompWindowTypeFullscreenMask)
+	{
+	    dx = dy = 0;
+	}
+	else
+	{
+	    CompRect workArea;
+	    int	     min, max;
+
+	    dx = ms->x;
+	    dy = ms->y;
+
+	    workArea = s->getWorkareaForOutput (w->outputDevice ());
+
+	    if (ms->yConstrained)
+	    {
+		if (!ms->region)
+		    ms->region = moveGetYConstrainRegion (s);
+
+		/* make sure that the top border extents or the top row of
+		   pixels are within what is currently our valid screen
+		   region */
+		if (ms->region)
+		{
+		    int x, y, width, height;
+		    int status;
+
+		    x	   = wX + dx - w->border ().left;
+		    y	   = wY + dy - w->border ().top;
+		    width  = wWidth + w->border ().left + w->border ().right;
+		    height = w->border ().top ? w->border ().top : 1;
+
+		    status = XRectInRegion (ms->region, x, y,
+					    (unsigned int) width,
+					    (unsigned int) height);
+
+		    /* only constrain movement if previous position was valid */
+		    if (ms->status == RectangleIn)
+		    {
+			int xStatus = status;
+
+			while (dx && xStatus != RectangleIn)
+			{
+			    xStatus = XRectInRegion (ms->region,
+						     x, y - dy,
+						     (unsigned int) width,
+						     (unsigned int) height);
+
+			    if (xStatus != RectangleIn)
+				dx += (dx < 0) ? 1 : -1;
+
+			    x = wX + dx - w->border ().left;
+			}
+
+			while (dy && status != RectangleIn)
+			{
+			    status = XRectInRegion (ms->region,
+						    x, y,
+						    (unsigned int) width,
+						    (unsigned int) height);
+
+			    if (status != RectangleIn)
+				dy += (dy < 0) ? 1 : -1;
+
+			    y = wY + dy - w->border ().top;
+			}
+		    }
+		    else
+		    {
+			ms->status = status;
+		    }
+		}
+	    }
+
+	    if (ms->optionGetSnapoffMaximized ())
+	    {
+		if (w->state () & CompWindowStateMaximizedVertMask)
+		{
+		    if (abs (yRoot - workArea.y () - ms->snapOffY) >= SNAP_OFF)
+		    {
+			if (!s->otherGrabExist ("move", NULL))
+			{
+			    int width = w->serverGeometry ().width ();
+
+			    w->saveMask () |= CWX | CWY;
+
+			    if (w->saveMask ()& CWWidth)
+				width = w->saveWc ().width;
+
+			    w->saveWc ().x = xRoot - (width >> 1);
+			    w->saveWc ().y = yRoot + (w->border ().top >> 1);
+
+			    ms->x = ms->y = 0;
+
+			    w->maximize (0);
+
+			    ms->snapOffY = ms->snapBackY;
+
+			    return;
+			}
+		    }
+		}
+		else if (ms->origState & CompWindowStateMaximizedVertMask)
+		{
+		    if (abs (yRoot - workArea.y () - ms->snapBackY) < SNAP_BACK)
+		    {
+			if (!s->otherGrabExist ("move", NULL))
+			{
+			    int wy;
+
+			    /* update server position before maximizing
+			       window again so that it is maximized on
+			       correct output */
+			    w->syncPosition ();
+
+			    w->maximize (ms->origState);
+
+			    wy  = workArea.y () + (w->border ().top >> 1);
+			    wy += w->sizeHints ().height_inc >> 1;
+
+			    s->warpPointer (0, wy - pointerY);
+
+			    return;
+			}
+		    }
+		}
+	    }
+
+	    if (w->state () & CompWindowStateMaximizedVertMask)
+	    {
+		min = workArea.y () + w->border ().top;
+		max = workArea.bottom () - w->border ().bottom - wHeight;
+
+		if (wY + dy < min)
+		    dy = min - wY;
+		else if (wY + dy > max)
+		    dy = max - wY;
+	    }
+
+	    if (w->state () & CompWindowStateMaximizedHorzMask)
+	    {
+		if (wX > (int) s->width () ||
+		    wX + w->size ().width () < 0)
+		    return;
+
+		if (wX + wWidth < 0)
+		    return;
+
+		min = workArea.x () + w->border ().left;
+		max = workArea.right () - w->border ().right - wWidth;
+
+		if (wX + dx < min)
+		    dx = min - wX;
+		else if (wX + dx > max)
+		    dx = max - wX;
+	    }
+	}
+
+	if (dx || dy)
+	{
+	    w->move (wX + dx - w->geometry ().x (),
+		     wY + dy - w->geometry ().y (), false);
+
+	    if (ms->optionGetLazyPositioning () &&
+		ms->hasCompositing &&
+		!MoveWindow::get (ms->w)->mLocked)
+	    {
+		/* FIXME: This form of lazy positioning is broken and should
+		   be replaced asap. Current code exists just to avoid a
+		   major performance regression in the 0.5.2 release. */
+		w->serverGeometry ().setX (w->geometry ().x ());
+		w->serverGeometry ().setY (w->geometry ().y ());
+	    }
+	    else
+	    {
+		w->syncPosition ();
+	    }
+
+	    ms->x -= dx;
+	    ms->y -= dy;
+	}
+    }
+}
+
+/* FIXME: This is a hack to prevent a race condition
+ * when core is processing ConfigureNotify events. It
+ * MUST be removed after 0.9.6 when we can break ABI
+ * and do lazy positioning correctly ! */
+
+void
+MoveScreen::handleCompizEvent (const char *plugin, const char *event, CompOption::Vector &options)
+{
+    if (w)
+    {
+	if (std::string ("core") == std::string (plugin))
+	{
+	    if (std::string ("lock_position") == std::string (event))
+	    {
+		Window xid = CompOption::getIntOptionNamed (options, "window", 0);
+		int    lock = CompOption::getIntOptionNamed (options, "active", 0);
+
+		if (xid == ROOTPARENT (w))
+		    MoveWindow::get (w)->mLocked = lock ? true : false;
+	    }
+	}
+    }
+
+    screen->handleCompizEvent (plugin, event, options);
+}
+
+void
+MoveScreen::handleEvent (XEvent *event)
+{
+    switch (event->type) {
+	case ButtonPress:
+	case ButtonRelease:
+	    if (event->xbutton.root == screen->root ())
+	    {
+		if (grab)
+		{
+		    if (releaseButton == -1 ||
+			releaseButton == (int) event->xbutton.button)
+		    {
+			moveTerminate (&optionGetInitiateButton (),
+				       CompAction::StateTermButton,
+				       noOptions);
+		    }
+		}
+	    }
+	    break;
+	case KeyPress:
+	    if (event->xkey.root == screen->root ())
+	    {
+		if (grab)
+		{
+		    unsigned int i;
+
+		    for (i = 0; i < NUM_KEYS; i++)
+		    {
+			if (event->xkey.keycode == key[i])
+			{
+			    XWarpPointer (screen->dpy (), None, None,
+					  0, 0, 0, 0,
+					  mKeys[i].dx * KEY_MOVE_INC,
+					  mKeys[i].dy * KEY_MOVE_INC);
+			    break;
+			}
+		    }
+		}
+	    }
+	    break;
+	case MotionNotify:
+	    if (event->xmotion.root == screen->root ())
+		moveHandleMotionEvent (screen, pointerX, pointerY);
+	    break;
+	case EnterNotify:
+	case LeaveNotify:
+	    if (event->xcrossing.root == screen->root ())
+		moveHandleMotionEvent (screen, pointerX, pointerY);
+	    break;
+	case ClientMessage:
+	    if (event->xclient.message_type == Atoms::wmMoveResize)
+	    {
+		CompWindow *w;
+		unsigned   long type = (unsigned long) event->xclient.data.l[2];
+
+		MOVE_SCREEN (screen);
+
+		if (type == WmMoveResizeMove ||
+		    type == WmMoveResizeMoveKeyboard)
+		{
+		    w = screen->findWindow (event->xclient.window);
+		    if (w)
+		    {
+			CompOption::Vector o;
+
+			o.push_back (CompOption ("window", CompOption::TypeInt));
+			o[0].value ().set ((int) event->xclient.window);
+
+			o.push_back (CompOption ("external",
+				     CompOption::TypeBool));
+			o[1].value ().set (true);
+
+			if (event->xclient.data.l[2] == WmMoveResizeMoveKeyboard)
+			{
+			    moveInitiate (&optionGetInitiateKey (),
+					  CompAction::StateInitKey, o);
+			}
+			else
+			{
+
+			    /* TODO: not only button 1 */
+			    if (pointerMods & Button1Mask)
+			    {
+				o.push_back (CompOption ("modifiers", CompOption::TypeInt));
+				o[2].value ().set ((int) pointerMods);
+
+				o.push_back (CompOption ("x", CompOption::TypeInt));
+				o[3].value ().set ((int) event->xclient.data.l[0]);
+
+				o.push_back (CompOption ("y", CompOption::TypeInt));
+				o[4].value ().set ((int) event->xclient.data.l[1]);
+
+				o.push_back (CompOption ("button", CompOption::TypeInt));
+				o[5].value ().set ((int) (event->xclient.data.l[3] ?
+					       event->xclient.data.l[3] : -1));
+
+				moveInitiate (&optionGetInitiateButton (),
+					      CompAction::StateInitButton, o);
+
+				moveHandleMotionEvent (screen, pointerX, pointerY);
+			    }
+			}
+		    }
+		}
+		else if (ms->w && type == WmMoveResizeCancel)
+		{
+		    if (ms->w->id () == event->xclient.window)
+		    {
+			moveTerminate (&optionGetInitiateButton (),
+				       CompAction::StateCancel, noOptions);
+			moveTerminate (&optionGetInitiateKey (),
+				       CompAction::StateCancel, noOptions);
+
+		    }
+		}
+	    }
+	    break;
+	case DestroyNotify:
+	    if (w && w->id () == event->xdestroywindow.window)
+	    {
+		moveTerminate (&optionGetInitiateButton (), 0, noOptions);
+		moveTerminate (&optionGetInitiateKey (), 0, noOptions);
+	    }
+	    break;
+	case UnmapNotify:
+	    if (w && w->id () == event->xunmap.window)
+	    {
+		moveTerminate (&optionGetInitiateButton (), 0, noOptions);
+		moveTerminate (&optionGetInitiateKey (), 0, noOptions);
+	    }
+	default:
+	    break;
+    }
+
+    screen->handleEvent (event);
+}
+
+bool
+MoveWindow::glPaint (const GLWindowPaintAttrib &attrib,
+		     const GLMatrix            &transform,
+		     const CompRegion          &region,
+		     unsigned int              mask)
+{
+    GLWindowPaintAttrib sAttrib = attrib;
+    bool                status;
+
+    MOVE_SCREEN (screen);
+
+    if (ms->grab)
+    {
+	if (ms->w == window && ms->moveOpacity != OPAQUE)
+	{
+	    /* modify opacity of windows that are not active */
+	    sAttrib.opacity = (sAttrib.opacity * ms->moveOpacity) >> 16;
+	}
+    }
+
+    status = gWindow->glPaint (sAttrib, transform, region, mask);
+
+    return status;
+}
+
+void
+MoveScreen::updateOpacity ()
+{
+    moveOpacity = (optionGetOpacity () * OPAQUE) / 100;
+}
+
+MoveScreen::MoveScreen (CompScreen *screen) :
+    PluginClassHandler<MoveScreen,CompScreen> (screen),
+    w (0),
+    region (NULL),
+    status (RectangleOut),
+    releaseButton (0),
+    grab (NULL),
+    hasCompositing (false),
+    yConstrained (false)
+{
+
+    updateOpacity ();
+
+    for (unsigned int i = 0; i < NUM_KEYS; i++)
+	key[i] = XKeysymToKeycode (screen->dpy (),
+				   XStringToKeysym (mKeys[i].name));
+
+    moveCursor = XCreateFontCursor (screen->dpy (), XC_fleur);
+    if (CompositeScreen::get (screen))
+	hasCompositing =
+	    CompositeScreen::get (screen)->compositingActive ();
+
+    optionSetOpacityNotify (boost::bind (&MoveScreen::updateOpacity, this));
+
+    optionSetInitiateButtonInitiate (moveInitiate);
+    optionSetInitiateButtonTerminate (moveTerminate);
+
+    optionSetInitiateKeyInitiate (moveInitiate);
+    optionSetInitiateKeyTerminate (moveTerminate);
+
+    ScreenInterface::setHandler (screen);
+}
+
+MoveScreen::~MoveScreen ()
+{
+    if (region)
+	XDestroyRegion (region);
+
+    if (moveCursor)
+	XFreeCursor (screen->dpy (), moveCursor);
+}
+
+bool
+MovePluginVTable::init ()
+{
+    if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION))
+	 return false;
+
+    return true;
+}
+

=== added file '.pc/fix-881329.patch/plugins/move/src/move.h'
--- .pc/fix-881329.patch/plugins/move/src/move.h	1970-01-01 00:00:00 +0000
+++ .pc/fix-881329.patch/plugins/move/src/move.h	2011-10-29 09:07:25 +0000
@@ -0,0 +1,135 @@
+/*
+ * Copyright © 2005 Novell, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of
+ * Novell, Inc. not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior permission.
+ * Novell, Inc. makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: David Reveman <[e-mail]>
+ */
+
+#include <core/core.h>
+#include <core/pluginclasshandler.h>
+
+#include <composite/composite.h>
+#include <opengl/opengl.h>
+
+#include "move_options.h"
+
+#define NUM_KEYS (sizeof (mKeys) / sizeof (mKeys[0]))
+
+#define KEY_MOVE_INC 24
+
+#define SNAP_BACK 20
+#define SNAP_OFF  100
+
+struct _MoveKeys {
+    const char *name;
+    int        dx;
+    int        dy;
+} mKeys[] = {
+    { "Left",  -1,  0 },
+    { "Right",  1,  0 },
+    { "Up",     0, -1 },
+    { "Down",   0,  1 }
+};
+
+class MoveScreen :
+    public ScreenInterface,
+    public PluginClassHandler<MoveScreen,CompScreen>,
+    public MoveOptions
+{
+    public:
+	MoveScreen (CompScreen *screen);
+	~MoveScreen ();
+
+	void updateOpacity ();
+
+	void handleEvent (XEvent *);
+	void handleCompizEvent (const char *plugin,
+				const char *event,
+				CompOption::Vector &options);
+
+	CompWindow *w;
+	int        savedX;
+	int        savedY;
+	int        x;
+	int        y;
+	Region     region;
+	int        status;
+	KeyCode    key[NUM_KEYS];
+
+	int releaseButton;
+
+	GLushort moveOpacity;
+
+	CompScreen::GrabHandle grab;
+
+	Cursor moveCursor;
+
+	unsigned int origState;
+
+	int	snapOffY;
+	int	snapBackY;
+
+	bool hasCompositing;
+
+	bool yConstrained;
+};
+
+class MoveWindow :
+    public GLWindowInterface,
+    public PluginClassHandler<MoveWindow,CompWindow>
+{
+    public:
+	MoveWindow (CompWindow *window) :
+	    PluginClassHandler<MoveWindow,CompWindow> (window),
+	    window (window),
+	    gWindow (GLWindow::get (window)),
+	    cWindow (CompositeWindow::get (window)),
+	    mLocked (false)
+	{
+	    if (gWindow)
+		GLWindowInterface::setHandler (gWindow, false);
+	};
+
+	bool glPaint (const GLWindowPaintAttrib &, const GLMatrix &,
+		      const CompRegion &, unsigned int);
+
+	CompWindow      *window;
+	GLWindow        *gWindow;
+	CompositeWindow *cWindow;
+
+	bool            mLocked;
+};
+
+#define MOVE_SCREEN(s) \
+    MoveScreen *ms = MoveScreen::get (s)
+
+#define MOVE_WINDOW(w) \
+    MoveWindow *mw = MoveWindow::get (w)
+
+
+class MovePluginVTable :
+    public CompPlugin::VTableForScreenAndWindow<MoveScreen, MoveWindow>
+{
+    public:
+
+	bool init ();
+};
+

=== added directory '.pc/fix-883383.patch'
=== added file '.pc/fix-883383.patch/.timestamp'
=== added directory '.pc/fix-883383.patch/unity'
=== added directory '.pc/fix-883383.patch/unity/unity_window_decorator'
=== added directory '.pc/fix-883383.patch/unity/unity_window_decorator/src'
=== added file '.pc/fix-883383.patch/unity/unity_window_decorator/src/events.c'
--- .pc/fix-883383.patch/unity/unity_window_decorator/src/events.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-883383.patch/unity/unity_window_decorator/src/events.c	2011-10-29 09:07:25 +0000
@@ -0,0 +1,1146 @@
+#include "gtk-window-decorator.h"
+
+void
+move_resize_window (WnckWindow *win,
+		    int	       direction,
+		    decor_event *gtkwd_event)
+{
+    Display    *xdisplay;
+    GdkDisplay *gdkdisplay;
+    GdkScreen  *screen;
+    Window     xroot;
+    XEvent     ev;
+
+    gdkdisplay = gdk_display_get_default ();
+    xdisplay   = GDK_DISPLAY_XDISPLAY (gdkdisplay);
+    screen     = gdk_display_get_default_screen (gdkdisplay);
+    xroot      = RootWindowOfScreen (gdk_x11_screen_get_xscreen (screen));
+
+    if (action_menu_mapped)
+    {
+	gtk_object_destroy (GTK_OBJECT (action_menu));
+	action_menu_mapped = FALSE;
+	action_menu = NULL;
+	return;
+    }
+
+    ev.xclient.type    = ClientMessage;
+    ev.xclient.display = xdisplay;
+
+    ev.xclient.serial	  = 0;
+    ev.xclient.send_event = TRUE;
+
+    ev.xclient.window	    = wnck_window_get_xid (win);
+    ev.xclient.message_type = wm_move_resize_atom;
+    ev.xclient.format	    = 32;
+
+    ev.xclient.data.l[0] = gtkwd_event->x_root;
+    ev.xclient.data.l[1] = gtkwd_event->y_root;
+    ev.xclient.data.l[2] = direction;
+    ev.xclient.data.l[3] = gtkwd_event->button;
+    ev.xclient.data.l[4] = 1;
+
+    XUngrabPointer (xdisplay, gtkwd_event->time);
+    XUngrabKeyboard (xdisplay, gtkwd_event->time);
+
+    XSendEvent (xdisplay, xroot, FALSE,
+		SubstructureRedirectMask | SubstructureNotifyMask,
+		&ev);
+
+    XSync (xdisplay, FALSE);
+}
+
+void
+common_button_event (WnckWindow *win,
+		     decor_event *gtkwd_event,
+		     decor_event_type gtkwd_type,
+		     int	button,
+		     int	max)
+{
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+    guint   state = d->button_states[button];
+
+    if (d->frame_window && gtkwd_type == GEnterNotify)
+    {
+	GdkCursor* cursor;
+	cursor = gdk_cursor_new (GDK_LEFT_PTR);
+	gdk_window_set_cursor (d->frame_window, cursor);
+	gdk_cursor_unref (cursor);
+    }
+
+    switch (gtkwd_type) {
+    case GButtonPress:
+	if (gtkwd_event->button <= max)
+	    d->button_states[button] |= PRESSED_EVENT_WINDOW;
+	break;
+    case GButtonRelease:
+	if (gtkwd_event->button <= max)
+	    d->button_states[button] &= ~PRESSED_EVENT_WINDOW;
+	break;
+    case GEnterNotify:
+	d->button_states[button] |= IN_EVENT_WINDOW;
+	break;
+    case GLeaveNotify:
+	d->button_states[button] &= ~IN_EVENT_WINDOW;
+	break;
+    default:
+	break;
+    }
+
+    if (state != d->button_states[button])
+	queue_decor_draw (d);
+}
+
+#define BUTTON_EVENT_ACTION_STATE (PRESSED_EVENT_WINDOW | IN_EVENT_WINDOW)
+
+void
+close_button_event (WnckWindow *win,
+		    decor_event *gtkwd_event,
+		    decor_event_type gtkwd_type)
+{
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+    guint   state = d->button_states[BUTTON_CLOSE];
+
+    common_button_event (win, gtkwd_event, gtkwd_type,
+			 BUTTON_CLOSE, 1);
+
+    switch (gtkwd_type) {
+    case GButtonRelease:
+	if (gtkwd_event->button == 1)
+	    if (state == BUTTON_EVENT_ACTION_STATE)
+		wnck_window_close (win, gtkwd_event->time);
+	break;
+    default:
+	break;
+    }
+}
+
+void
+max_button_event (WnckWindow *win,
+		  decor_event *gtkwd_event,
+		  decor_event_type gtkwd_type)
+{
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+    guint   state = d->button_states[BUTTON_MAX];
+
+    if (wnck_window_is_maximized (win))
+	common_button_event (win, gtkwd_event, gtkwd_type, BUTTON_MAX,
+			     3);
+    else
+	common_button_event (win, gtkwd_event, gtkwd_type, BUTTON_MAX,
+			     3);
+
+    switch (gtkwd_type) {
+    case GButtonRelease:
+	if (gtkwd_event->button <= 3)
+	{
+	    if (state == BUTTON_EVENT_ACTION_STATE)
+	    {
+		if (gtkwd_event->button == 2)
+		{
+		    if (wnck_window_is_maximized_vertically (win))
+			wnck_window_unmaximize_vertically (win);
+		    else
+			wnck_window_maximize_vertically (win);
+		}
+		else if (gtkwd_event->button == 3)
+		{
+		    if (wnck_window_is_maximized_horizontally (win))
+			wnck_window_unmaximize_horizontally (win);
+		    else
+			wnck_window_maximize_horizontally (win);
+		}
+		else
+		{
+		    if (wnck_window_is_maximized (win))
+			wnck_window_unmaximize (win);
+		    else
+			wnck_window_maximize (win);
+		}
+	    }
+	}
+	break;
+    default:
+	break;
+    }
+}
+
+void
+min_button_event (WnckWindow *win,
+		  decor_event *gtkwd_event,
+		  decor_event_type gtkwd_type)
+{
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+    guint   state = d->button_states[BUTTON_MIN];
+
+    common_button_event (win, gtkwd_event, gtkwd_type,
+			 BUTTON_MIN, 1);
+
+    switch (gtkwd_type) {
+    case GButtonRelease:
+	if (gtkwd_event->button == 1)
+	    if (state == BUTTON_EVENT_ACTION_STATE)
+		wnck_window_minimize (win);
+	break;
+    default:
+	break;
+    }
+}
+
+void
+menu_button_event (WnckWindow *win,
+		   decor_event *gtkwd_event,
+		   decor_event_type gtkwd_type)
+{
+
+    common_button_event (win, gtkwd_event, gtkwd_type,
+			 BUTTON_MENU, 1);
+
+    switch (gtkwd_type) {
+    case GButtonPress:
+	if (gtkwd_event->button == 1)
+	    action_menu_map (win,
+			     gtkwd_event->button,
+			     gtkwd_event->time);
+	break;
+    default:
+	break;
+    }
+}
+
+void
+shade_button_event (WnckWindow *win,
+		    decor_event *gtkwd_event,
+		    decor_event_type gtkwd_type)
+{
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+    guint   state = d->button_states[BUTTON_SHADE];
+
+    common_button_event (win, gtkwd_event, gtkwd_type,
+			 BUTTON_SHADE, 1);
+
+    switch (gtkwd_type) {
+    case GButtonRelease:
+	if (gtkwd_event->button == 1)
+	{
+	    if (state == BUTTON_EVENT_ACTION_STATE)
+		wnck_window_shade (win);
+	}
+	break;
+    default:
+	break;
+    }
+}
+
+void
+above_button_event (WnckWindow *win,
+		    decor_event *gtkwd_event,
+		    decor_event_type gtkwd_type)
+{
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+    guint   state = d->button_states[BUTTON_ABOVE];
+
+    common_button_event (win, gtkwd_event, gtkwd_type,
+			 BUTTON_ABOVE, 1);
+
+    switch (gtkwd_type) {
+    case GButtonRelease:
+	if (gtkwd_event->button == 1)
+	    if (state == BUTTON_EVENT_ACTION_STATE)
+#ifdef HAVE_LIBWNCK_2_18_1
+		wnck_window_make_above (win);
+#endif
+	break;
+    default:
+	break;
+    }
+}
+
+void
+stick_button_event (WnckWindow *win,
+		    decor_event *gtkwd_event,
+		    decor_event_type gtkwd_type)
+{
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+    guint   state = d->button_states[BUTTON_STICK];
+
+    common_button_event (win, gtkwd_event, gtkwd_type,
+			 BUTTON_STICK, 1);
+
+    switch (gtkwd_type) {
+    case GButtonRelease:
+	if (gtkwd_event->button == 1)
+	    if (state == BUTTON_EVENT_ACTION_STATE)
+		wnck_window_stick (win);
+	break;
+    default:
+	break;
+    }
+}
+
+void
+unshade_button_event (WnckWindow *win,
+		      decor_event *gtkwd_event,
+		      decor_event_type gtkwd_type)
+{
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+    guint   state = d->button_states[BUTTON_UNSHADE];
+
+    common_button_event (win, gtkwd_event, gtkwd_type,
+			 BUTTON_UNSHADE, 1);
+
+    switch (gtkwd_type) {
+    case GButtonRelease:
+	if (gtkwd_event->button == 1)
+	    if (state == BUTTON_EVENT_ACTION_STATE)
+		wnck_window_unshade (win);
+	break;
+    default:
+	break;
+    }
+}
+
+void
+unabove_button_event (WnckWindow *win,
+		      decor_event *gtkwd_event,
+		      decor_event_type gtkwd_type)
+{
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+    guint   state = d->button_states[BUTTON_UNABOVE];
+
+    common_button_event (win, gtkwd_event, gtkwd_type,
+			 BUTTON_UNABOVE, 1);
+
+    switch (gtkwd_type) {
+    case GButtonRelease:
+	if (gtkwd_event->button == 1)
+	    if (state == BUTTON_EVENT_ACTION_STATE)
+#ifdef HAVE_LIBWNCK_2_18_1
+		wnck_window_unmake_above (win);
+#endif
+	break;
+    default:
+	break;
+    }
+}
+
+void
+unstick_button_event (WnckWindow *win,
+		      decor_event *gtkwd_event,
+		      decor_event_type gtkwd_type)
+{
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+    guint   state = d->button_states[BUTTON_UNSTICK];
+
+    common_button_event (win, gtkwd_event, gtkwd_type,
+			 BUTTON_UNSTICK, 1);
+
+    switch (gtkwd_type) {
+    case GButtonRelease:
+	if (gtkwd_event->button == 1)
+	    if (state == BUTTON_EVENT_ACTION_STATE)
+		wnck_window_unstick (win);
+	break;
+    default:
+	break;
+    }
+}
+
+void
+handle_title_button_event (WnckWindow   *win,
+			   int          action,
+			   decor_event *gtkwd_event)
+{
+    switch (action) {
+    case CLICK_ACTION_SHADE:
+	if (wnck_window_is_shaded (win))
+	    wnck_window_unshade (win);
+	else
+	    wnck_window_shade (win);
+	break;
+    case CLICK_ACTION_MAXIMIZE:
+	if (wnck_window_is_maximized (win))
+	    wnck_window_unmaximize (win);
+	else
+	    wnck_window_maximize (win);
+	break;
+    case CLICK_ACTION_MINIMIZE:
+	if (!wnck_window_is_minimized (win))
+	    wnck_window_minimize (win);
+	break;
+    case CLICK_ACTION_RAISE:
+	restack_window (win, Above);
+	break;
+    case CLICK_ACTION_LOWER:
+	restack_window (win, Below);
+	break;
+    case CLICK_ACTION_MENU:
+	action_menu_map (win, gtkwd_event->button, gtkwd_event->time);
+	break;
+    }
+}
+
+void
+handle_mouse_wheel_title_event (WnckWindow   *win,
+				unsigned int button)
+{
+    switch (wheel_action) {
+    case WHEEL_ACTION_SHADE:
+	if (button == 4)
+	{
+	    if (!wnck_window_is_shaded (win))
+		wnck_window_shade (win);
+	}
+	else if (button == 5)
+	{
+	    if (wnck_window_is_shaded (win))
+		wnck_window_unshade (win);
+	}
+	break;
+    default:
+	break;
+    }
+}
+
+void
+title_event (WnckWindow       *win,
+	     decor_event      *gtkwd_event,
+	     decor_event_type gtkwd_type)
+{
+    static int	  last_button_num = 0;
+    static Window last_button_xwindow = None;
+    static Time	  last_button_time = 0;
+    static int	  last_button_x = 0;
+    static int	  last_button_y = 0;
+
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+
+    if (d->frame_window && gtkwd_type == GEnterNotify)
+    {
+	GdkCursor* cursor = gdk_cursor_new (GDK_LEFT_PTR);
+	gdk_window_set_cursor (d->frame_window, cursor);
+	gdk_cursor_unref (cursor);
+    }
+
+    if (gtkwd_type != GButtonPress)
+	return;
+
+    if (gtkwd_event->button == 1)
+    {
+	if (gtkwd_event->button == last_button_num		        &&
+	    gtkwd_event->window == last_button_xwindow		        &&
+	    gtkwd_event->time < last_button_time + double_click_timeout &&
+	    dist (gtkwd_event->x, gtkwd_event->y,
+		  last_button_x, last_button_y) < DOUBLE_CLICK_DISTANCE)
+	{
+	    handle_title_button_event (win, double_click_action,
+				       gtkwd_event);
+
+	    last_button_num	= 0;
+	    last_button_xwindow = None;
+	    last_button_time	= 0;
+	    last_button_x	= 0;
+	    last_button_y	= 0;
+	}
+	else
+	{
+	    last_button_num	= gtkwd_event->button;
+	    last_button_xwindow = gtkwd_event->window;
+	    last_button_time	= gtkwd_event->time;
+	    last_button_x	= gtkwd_event->x;
+	    last_button_y	= gtkwd_event->y;
+
+	    restack_window (win, Above);
+
+	    move_resize_window (win, WM_MOVERESIZE_MOVE, gtkwd_event);
+	}
+    }
+    else if (gtkwd_event->button == 2)
+    {
+	handle_title_button_event (win, middle_click_action,
+				   gtkwd_event);
+    }
+    else if (gtkwd_event->button == 3)
+    {
+	handle_title_button_event (win, right_click_action,
+				   gtkwd_event);
+    }
+    else if (gtkwd_event->button == 4 ||
+	     gtkwd_event->button == 5)
+    {
+	handle_mouse_wheel_title_event (win, gtkwd_event->button);
+    }
+}
+
+void
+frame_common_event (WnckWindow       *win,
+		    int              direction,
+		    decor_event      *gtkwd_event,
+		    decor_event_type gtkwd_type)
+{
+
+    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+
+    if (d->frame_window && gtkwd_type == GEnterNotify)
+    {
+	GdkCursor *cursor = NULL;
+
+	switch (direction)
+	{
+	    case WM_MOVERESIZE_SIZE_TOPLEFT:
+		cursor = gdk_cursor_new (GDK_TOP_LEFT_CORNER);
+		break;
+	    case WM_MOVERESIZE_SIZE_LEFT:
+		cursor = gdk_cursor_new (GDK_LEFT_SIDE);
+		break;
+	    case WM_MOVERESIZE_SIZE_BOTTOMLEFT:
+		cursor = gdk_cursor_new (GDK_BOTTOM_LEFT_CORNER);
+		break;
+	    case WM_MOVERESIZE_SIZE_BOTTOM:
+		cursor = gdk_cursor_new (GDK_BOTTOM_SIDE);
+	        break;
+	    case WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
+		cursor = gdk_cursor_new (GDK_BOTTOM_RIGHT_CORNER);
+		break;
+	    case WM_MOVERESIZE_SIZE_RIGHT:
+		cursor = gdk_cursor_new (GDK_RIGHT_SIDE);
+		break;
+	    case WM_MOVERESIZE_SIZE_TOPRIGHT:
+		cursor = gdk_cursor_new (GDK_TOP_RIGHT_CORNER);
+		break;
+	    case WM_MOVERESIZE_SIZE_TOP:
+		cursor = gdk_cursor_new (GDK_TOP_SIDE);
+		break;
+	    default:
+		break;
+	}
+
+	if (cursor)
+	{
+	    gdk_window_set_cursor (d->frame_window, cursor);
+	    gdk_cursor_unref (cursor);
+	}
+    }
+
+    if (gtkwd_type != GButtonPress)
+	return;
+
+    switch (gtkwd_event->button) {
+    case 1:
+	move_resize_window (win, direction, gtkwd_event);
+	restack_window (win, Above);
+	break;
+    case 2:
+	handle_title_button_event (win, middle_click_action,
+				   gtkwd_event);
+	break;
+    case 3:
+	handle_title_button_event (win, right_click_action,
+				   gtkwd_event);
+	break;
+    }
+}
+
+void
+top_left_event (WnckWindow       *win,
+		decor_event      *gtkwd_event,
+		decor_event_type gtkwd_type)
+{
+    frame_common_event (win, WM_MOVERESIZE_SIZE_TOPLEFT,
+		        gtkwd_event, gtkwd_type);
+}
+
+void
+top_event (WnckWindow       *win,
+	   decor_event      *gtkwd_event,
+	   decor_event_type gtkwd_type)
+{
+    frame_common_event (win, WM_MOVERESIZE_SIZE_TOP,
+			gtkwd_event, gtkwd_type);
+}
+
+void
+top_right_event (WnckWindow       *win,
+		 decor_event      *gtkwd_event,
+		 decor_event_type gtkwd_type)
+{
+    frame_common_event (win, WM_MOVERESIZE_SIZE_TOPRIGHT,
+			gtkwd_event, gtkwd_type);
+}
+
+void
+left_event (WnckWindow       *win,
+	    decor_event      *gtkwd_event,
+	    decor_event_type gtkwd_type)
+{
+    frame_common_event (win, WM_MOVERESIZE_SIZE_LEFT,
+			gtkwd_event, gtkwd_type);
+}
+
+void
+right_event (WnckWindow       *win,
+	     decor_event      *gtkwd_event,
+	     decor_event_type gtkwd_type)
+{
+    frame_common_event (win, WM_MOVERESIZE_SIZE_RIGHT,
+			gtkwd_event, gtkwd_type);
+}
+
+void
+bottom_left_event (WnckWindow *win,
+		   decor_event *gtkwd_event,
+		   decor_event_type gtkwd_type)
+{
+    frame_common_event (win, WM_MOVERESIZE_SIZE_BOTTOMLEFT,
+			gtkwd_event, gtkwd_type);
+}
+
+void
+bottom_event (WnckWindow *win,
+	      decor_event *gtkwd_event,
+	      decor_event_type gtkwd_type)
+{
+    frame_common_event (win, WM_MOVERESIZE_SIZE_BOTTOM,
+			gtkwd_event, gtkwd_type);
+}
+
+void
+bottom_right_event (WnckWindow *win,
+		    decor_event *gtkwd_event,
+		    decor_event_type gtkwd_type)
+{
+    frame_common_event (win, WM_MOVERESIZE_SIZE_BOTTOMRIGHT,
+			gtkwd_event, gtkwd_type);
+}
+
+void
+frame_window_realized (GtkWidget *widget,
+		       gpointer  data)
+{
+    decor_t *d = (decor_t *) data;
+
+    if (d)
+    {
+	GdkWindow *gdk_frame_window = gtk_widget_get_window (d->decor_window);
+	gdk_window_reparent (gdk_frame_window, d->frame_window, 0, 0);
+	gdk_window_lower (gdk_frame_window);
+
+    }
+}
+
+event_callback
+find_event_callback_for_point (decor_t *d,
+			       int     x,
+			       int     y,
+			       Bool    *enter,
+			       Bool    *leave,
+			       BoxPtr  *entered_box)
+{
+    int    i, j;
+    BoxPtr box;
+
+    for (i = 0; i < BUTTON_NUM; i++)
+    {
+	box = &d->button_windows[i].pos;
+	if (x >= box->x1 && x <= box->x2 &&
+	    y >= box->y1 && y <= box->y2)
+	{
+	    if (d->last_pos_entered != box)
+	    {
+		if (enter)
+		    *enter = TRUE;
+		if (leave && d->last_pos_entered)
+		    *leave = TRUE;
+		if (entered_box)
+		    *entered_box = box;
+	    }
+	    return d->button_windows[i].callback;
+	}
+    }
+
+    for (i = 0; i < 3; i++)
+    {
+	for (j = 0; j < 3; j++)
+	{
+	    box = &d->event_windows[i][j].pos;
+	    if (x >= box->x1 && x <= box->x2 &&
+		y >= box->y1 && y <= box->y2)
+	    {
+		if (d->last_pos_entered != box)
+		{
+		    if (enter)
+			*enter = TRUE;
+		    if (leave && d->last_pos_entered)
+			*leave = TRUE;
+		    if (entered_box)
+			*entered_box = box;
+		}
+		return d->event_windows[i][j].callback;
+	    }
+	}
+    }
+
+    return NULL;
+}
+
+event_callback
+find_leave_event_callback (decor_t *d)
+{
+    int i, j;
+
+    for (i = 0; i < BUTTON_NUM; i++)
+    {
+	if (d->last_pos_entered == &d->button_windows[i].pos)
+	    return d->button_windows[i].callback;
+    }
+
+    for (i = 0; i < 3; i++)
+    {
+	for (j = 0; j < 3; j++)
+	{
+	    if (d->last_pos_entered == &d->event_windows[i][j].pos)
+		return d->event_windows[i][j].callback;
+	}
+    }
+
+    return NULL;
+}
+
+void
+frame_handle_button_press (GtkWidget      *widget,
+			   GdkEventButton *event,
+			   gpointer       user_data)
+{
+    decor_t *d = (decor_t *) user_data;
+
+    if (d)
+    {
+	/* Check to see where the event happened and fill out an appropriate
+	 * struct
+	 */
+	event_callback cb;
+
+	cb = find_event_callback_for_point (d, event->x, event->y,
+					    NULL, NULL, NULL);
+
+	if (cb && d->decorated)
+	{
+	    decor_event gtkwd_event;
+
+	    gtkwd_event.window = GDK_WINDOW_XID (d->frame_window);
+	    gtkwd_event.button = event->button;
+	    gtkwd_event.x      = event->x;
+	    gtkwd_event.y      = event->y;
+	    gtkwd_event.x_root = event->x_root;
+	    gtkwd_event.y_root = event->y_root;
+	    gtkwd_event.time   = event->time;
+
+	    (*cb) (d->win, &gtkwd_event, GButtonPress);
+	}
+    }
+}
+
+void
+frame_handle_button_release (GtkWidget      *widget,
+			     GdkEventButton *event,
+			     gpointer       user_data)
+{
+    decor_t *d = (decor_t *) user_data;
+
+    if (d)
+    {
+	event_callback cb;
+
+	cb = find_event_callback_for_point (d, event->x, event->y,
+					    NULL, NULL, NULL);
+
+	if (cb && d->decorated)
+	{
+	    decor_event gtkwd_event;
+
+	    gtkwd_event.window = GDK_WINDOW_XID (d->frame_window);
+	    gtkwd_event.button = event->button;
+	    gtkwd_event.x      = event->x;
+	    gtkwd_event.y      = event->y;
+	    gtkwd_event.x_root = event->x_root;
+	    gtkwd_event.y_root = event->y_root;
+	    gtkwd_event.time   = event->time;
+
+	    (*cb) (d->win, &gtkwd_event, GButtonRelease);
+	}
+    }
+}
+
+void
+frame_handle_motion (GtkWidget      *widget,
+		     GdkEventMotion *event,
+		     gpointer       user_data)
+{
+    decor_t *d = (decor_t *) user_data;
+
+    if (d)
+    {
+	event_callback cb = NULL;
+	Bool           send_enter = FALSE;
+	Bool           send_leave = FALSE;
+	BoxPtr         entered_box;
+
+	cb = find_event_callback_for_point (d, event->x, event->y,
+					    &send_enter, &send_leave,
+					    &entered_box);
+
+	if (cb && d->decorated)
+	{
+	    decor_event gtkwd_event;
+
+	    gtkwd_event.window = GDK_WINDOW_XID (d->frame_window);
+	    gtkwd_event.x      = event->x;
+	    gtkwd_event.y      = event->y;
+	    gtkwd_event.x_root = event->x_root;
+	    gtkwd_event.y_root = event->y_root;
+	    gtkwd_event.time   = event->time;
+
+	    if (send_enter)
+		(*cb) (d->win, &gtkwd_event, GEnterNotify);
+
+	    if (send_leave)
+	    {
+		event_callback leave_cb;
+
+		leave_cb = find_leave_event_callback (d);
+
+		if (leave_cb)
+		    (*leave_cb) (d->win, &gtkwd_event, GLeaveNotify);
+
+	    }
+
+	    if (send_enter)
+		d->last_pos_entered = entered_box;
+	}
+	else if (d->last_pos_entered && d->decorated)
+	{
+	    /* We are not in an event / button window but last_pos_entered
+	     * is still set, so send a GLeaveNotify to last_pos_entered
+	     * and set it to NULL
+	     */
+
+	    event_callback leave_cb;
+
+	    leave_cb = find_leave_event_callback (d);
+
+	    if (leave_cb)
+	    {
+		decor_event    gtkwd_event;
+
+		gtkwd_event.window = GDK_WINDOW_XID (d->frame_window);
+		gtkwd_event.x      = event->x;
+		gtkwd_event.y      = event->y;
+		gtkwd_event.x_root = event->x_root;
+		gtkwd_event.y_root = event->y_root;
+		gtkwd_event.time   = event->time;
+
+		(*leave_cb) (d->win, &gtkwd_event, GLeaveNotify);
+	    }
+
+	    d->last_pos_entered = NULL;
+	}
+    }
+}
+
+GdkFilterReturn
+event_filter_func (GdkXEvent *gdkxevent,
+		   GdkEvent  *event,
+		   gpointer  data)
+{
+    Display    *xdisplay;
+    GdkDisplay *gdkdisplay;
+    XEvent     *xevent = gdkxevent;
+    gulong     xid = 0;
+    Window     select = 0;
+
+    gdkdisplay = gdk_display_get_default ();
+    xdisplay   = GDK_DISPLAY_XDISPLAY (gdkdisplay);
+
+    switch (xevent->type) {
+    case CreateNotify:
+	{
+	    if (!wnck_window_get (xevent->xcreatewindow.window))
+	    {
+		GdkWindow *toplevel = create_foreign_window (xevent->xcreatewindow.window);
+
+		if (toplevel)
+		{
+		    gdk_window_set_events (toplevel,
+					   gdk_window_get_events (toplevel) |
+					   GDK_PROPERTY_CHANGE_MASK);
+
+		    /* check if the window is a switcher and update accordingly */
+
+		    if (get_window_prop (xevent->xcreatewindow.window, select_window_atom, &select))
+			update_switcher_window (xevent->xcreatewindow.window, select);
+		}
+	    }
+	}
+	break;
+    case ButtonPress:
+    case ButtonRelease:
+	xid = (gulong)
+	    g_hash_table_lookup (frame_table,
+				 GINT_TO_POINTER (xevent->xbutton.window));
+	break;
+    case EnterNotify:
+    case LeaveNotify:
+	xid = (gulong)
+	    g_hash_table_lookup (frame_table,
+				 GINT_TO_POINTER (xevent->xcrossing.window));
+	break;
+    case MotionNotify:
+	xid = (gulong)
+	    g_hash_table_lookup (frame_table,
+				 GINT_TO_POINTER (xevent->xmotion.window));
+	break;
+    case PropertyNotify:
+	if (xevent->xproperty.atom == frame_input_window_atom)
+	{
+	    WnckWindow *win;
+
+	    xid = xevent->xproperty.window;
+
+	    win = wnck_window_get (xid);
+	    if (win)
+	    {
+		Window frame;
+
+		if (!get_window_prop (xid, select_window_atom, &select))
+		{
+		    if (get_window_prop (xid, frame_input_window_atom, &frame))
+			add_frame_window (win, frame, FALSE);
+		    else
+			remove_frame_window (win);
+		}
+	    }
+	}
+	if (xevent->xproperty.atom == frame_output_window_atom)
+	{
+	    WnckWindow *win;
+
+	    xid = xevent->xproperty.window;
+
+	    win = wnck_window_get (xid);
+	    if (win)
+	    {
+		Window frame;
+
+		if (!get_window_prop (xid, select_window_atom, &select))
+		{
+		    if (get_window_prop (xid, frame_output_window_atom, &frame))
+			add_frame_window (win, frame, TRUE);
+		    else
+			remove_frame_window (win);
+		}
+	    }
+	}
+	else if (xevent->xproperty.atom == compiz_shadow_info_atom ||
+		 xevent->xproperty.atom == compiz_shadow_color_atom)
+	{
+	    GdkScreen  *g_screen = gdk_display_get_default_screen (gdkdisplay);
+	    Window     root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (g_screen));
+	    WnckScreen *screen;
+
+	    screen = wnck_screen_get_for_root (root);
+
+	    if (screen)
+	    {
+		shadow_property_changed (screen);
+	    }
+	}
+	else if (xevent->xproperty.atom == mwm_hints_atom)
+	{
+	    WnckWindow *win;
+
+	    xid = xevent->xproperty.window;
+
+	    win = wnck_window_get (xid);
+	    if (win)
+	    {
+		decor_t  *d = g_object_get_data (G_OBJECT (win), "decor");
+		gboolean decorated = FALSE;
+
+		if (get_mwm_prop (xid) & (MWM_DECOR_ALL | MWM_DECOR_TITLE))
+		    decorated = TRUE;
+
+		if (decorated != d->decorated)
+		{
+		    d->decorated = decorated;
+		    if (decorated)
+		    {
+			d->context = NULL;
+			d->width = d->height = 0;
+
+			update_window_decoration_size (win);
+			update_event_windows (win);
+		    }
+		    else
+		    {
+			gdk_error_trap_push ();
+			XDeleteProperty (xdisplay, xid, win_decor_atom);
+			gdk_display_sync (gdk_display_get_default ());
+			gdk_error_trap_pop ();
+		    }
+		}
+	    }
+	}
+	else if (xevent->xproperty.atom == select_window_atom)
+	{
+	    Window select;
+
+	    if (get_window_prop (xevent->xproperty.window, select_window_atom, &select))
+		update_switcher_window (xevent->xproperty.window, select);
+	}
+	break;
+    case DestroyNotify:
+    {
+	g_hash_table_remove (frame_table,
+			     GINT_TO_POINTER (xevent->xproperty.window));
+
+	break;
+    }
+    case ClientMessage:
+	if (xevent->xclient.message_type == toolkit_action_atom)
+	{
+	    long action;
+
+	    action = xevent->xclient.data.l[0];
+	    if (action == toolkit_action_window_menu_atom)
+	    {
+		WnckWindow *win;
+
+		win = wnck_window_get (xevent->xclient.window);
+		if (win)
+		{
+		    action_menu_map (win,
+				     xevent->xclient.data.l[2],
+				     xevent->xclient.data.l[1]);
+		}
+	    }
+	    else if (action == toolkit_action_force_quit_dialog_atom)
+	    {
+		WnckWindow *win;
+
+		win = wnck_window_get (xevent->xclient.window);
+		if (win)
+		{
+		    if (xevent->xclient.data.l[2])
+			show_force_quit_dialog (win,
+						xevent->xclient.data.l[1]);
+		    else
+			hide_force_quit_dialog (win);
+		}
+	    }
+	}
+    default:
+	break;
+    }
+
+    if (xid)
+    {
+	WnckWindow *win;
+
+	win = wnck_window_get (xid);
+	if (win)
+	{
+	    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
+
+	    if (d->decorated)
+	    {
+		gint             i, j;
+		event_callback   cb = NULL;
+		Window           w = xevent->xany.window;
+
+		for (i = 0; i < 3; i++)
+		    for (j = 0; j < 3; j++)
+			if (d->event_windows[i][j].window == w)
+			    cb = d->event_windows[i][j].callback;
+
+		if (!cb)
+		{
+		    for (i = 0; i < BUTTON_NUM; i++)
+			if (d->button_windows[i].window == w)
+			    cb = d->button_windows[i].callback;
+		}
+
+		if (cb)
+		{
+		    decor_event      gtkwd_event;
+		    decor_event_type gtkwd_type;
+
+		    gtkwd_event.window = w;
+
+		    switch (xevent->type)
+		    {
+			case ButtonPress:
+			case ButtonRelease:
+			    if (xevent->type == ButtonPress)
+				gtkwd_type = GButtonPress;
+			    else
+				gtkwd_type = GButtonRelease;
+			    gtkwd_event.button = xevent->xbutton.button;
+			    gtkwd_event.x = xevent->xbutton.x;
+			    gtkwd_event.y = xevent->xbutton.y;
+			    gtkwd_event.x_root = xevent->xbutton.x_root;
+			    gtkwd_event.y_root = xevent->xbutton.y_root;
+			    gtkwd_event.time = xevent->xbutton.time;
+			    break;
+			case EnterNotify:
+			case LeaveNotify:
+			    if (xevent->type == EnterNotify)
+				gtkwd_type = GEnterNotify;
+			    else
+				gtkwd_type = GLeaveNotify;
+			    gtkwd_event.x = xevent->xcrossing.x;
+			    gtkwd_event.y = xevent->xcrossing.y;
+			    gtkwd_event.x_root = xevent->xcrossing.x_root;
+			    gtkwd_event.y_root = xevent->xcrossing.y_root;
+			    gtkwd_event.time = xevent->xcrossing.time;
+			    break;
+			default:
+			    cb = NULL;
+			    break;
+		    }
+		    if (cb)
+			(*cb) (win, &gtkwd_event, gtkwd_type);
+		}
+	    }
+	}
+    }
+
+    return GDK_FILTER_CONTINUE;
+}
+
+GdkFilterReturn
+selection_event_filter_func (GdkXEvent *gdkxevent,
+			     GdkEvent  *event,
+			     gpointer  data)
+{
+    Display    *xdisplay;
+    GdkDisplay *gdkdisplay;
+    XEvent     *xevent = gdkxevent;
+    int	       status;
+
+    gdkdisplay = gdk_display_get_default ();
+    xdisplay   = GDK_DISPLAY_XDISPLAY (gdkdisplay);
+
+    switch (xevent->type) {
+    case SelectionRequest:
+	decor_handle_selection_request (xdisplay, xevent, dm_sn_timestamp);
+	break;
+    case SelectionClear:
+	status = decor_handle_selection_clear (xdisplay, xevent, 0);
+	if (status == DECOR_SELECTION_GIVE_UP)
+	    exit (0);
+    default:
+	break;
+    }
+
+    return GDK_FILTER_CONTINUE;
+}

=== added file '.pc/fix-883383.patch/unity/unity_window_decorator/src/gtk-window-decorator.c'
--- .pc/fix-883383.patch/unity/unity_window_decorator/src/gtk-window-decorator.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-883383.patch/unity/unity_window_decorator/src/gtk-window-decorator.c	2011-10-29 09:07:25 +0000
@@ -0,0 +1,443 @@
+/*
+ * Copyright © 2006 Novell, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author: David Reveman <[e-mail]>
+ */
+
+#include "gtk-window-decorator.h"
+
+gboolean minimal = FALSE;
+
+double decoration_alpha = 0.5;
+
+#define SWITCHER_SPACE 40
+
+decor_extents_t _shadow_extents      = { 0, 0, 0, 0 };
+decor_extents_t _win_extents         = { 6, 6, 6, 6 };
+decor_extents_t _max_win_extents     = { 6, 6, 4, 6 };
+decor_extents_t _default_win_extents = { 6, 6, 6, 6 };
+decor_extents_t _switcher_extents    = { 6, 6, 6, 6 + SWITCHER_SPACE };
+
+int titlebar_height = 17;
+int max_titlebar_height = 17;
+
+decor_context_t window_active_context = {
+    { 0, 0, 0, 0 },
+    6, 6, 4, 6,
+    0, 0, 0, 0
+};
+
+decor_context_t max_window_active_context = {
+    { 0, 0, 0, 0 },
+    6, 6, 4, 6,
+    0, 0, 0, 0
+};
+
+decor_context_t window_inactive_context = {
+    { 0, 0, 0, 0 },
+    6, 6, 4, 6,
+    0, 0, 0, 0
+};
+
+decor_context_t max_window_inactive_context = {
+    { 0, 0, 0, 0 },
+    6, 6, 4, 6,
+    0, 0, 0, 0
+};
+
+decor_context_t window_context_no_shadow = {
+    { 0, 0, 0, 0 },
+    6, 6, 4, 6,
+    0, 0, 0, 0
+};
+
+decor_context_t max_window_context_no_shadow = {
+    { 0, 0, 0, 0 },
+    6, 6, 4, 6,
+    0, 0, 0, 0
+};
+
+decor_context_t switcher_context = {
+    { 0, 0, 0, 0 },
+    6, 6, 6, 6 + SWITCHER_SPACE,
+    0, 0, 0, 0
+};
+
+decor_context_t shadow_context = {
+    { 0, 0, 0, 0 },
+    0, 0, 0, 0,
+    0, 0, 0, 0,
+};
+
+gdouble shadow_radius   = SHADOW_RADIUS;
+gdouble shadow_opacity  = SHADOW_OPACITY;
+gushort shadow_color[3] = {
+  SHADOW_COLOR_RED,
+  SHADOW_COLOR_GREEN,
+  SHADOW_COLOR_BLUE
+};
+gint    shadow_offset_x = SHADOW_OFFSET_X;
+gint    shadow_offset_y = SHADOW_OFFSET_Y;
+
+guint cmdline_options = 0;
+
+decor_shadow_t *no_border_shadow = NULL;
+decor_shadow_t *border_active_shadow = NULL;
+decor_shadow_t *border_inactive_shadow = NULL;
+decor_shadow_t *max_border_active_shadow = NULL;
+decor_shadow_t *max_border_inactive_shadow = NULL;
+decor_shadow_t *border_no_shadow = NULL;
+decor_shadow_t *max_border_no_shadow = NULL;
+decor_shadow_t *switcher_shadow = NULL;
+
+GdkPixmap *decor_normal_pixmap = NULL;
+GdkPixmap *decor_active_pixmap = NULL;
+
+Atom frame_input_window_atom;
+Atom frame_output_window_atom;
+Atom win_decor_atom;
+Atom win_blur_decor_atom;
+Atom wm_move_resize_atom;
+Atom restack_window_atom;
+Atom select_window_atom;
+Atom mwm_hints_atom;
+Atom switcher_fg_atom;
+
+Atom compiz_shadow_info_atom;
+Atom compiz_shadow_color_atom;
+
+Atom toolkit_action_atom;
+Atom toolkit_action_window_menu_atom;
+Atom toolkit_action_force_quit_dialog_atom;
+
+Time dm_sn_timestamp;
+
+struct _cursor cursor[3][3] = {
+    { C (top_left_corner),    C (top_side),    C (top_right_corner)    },
+    { C (left_side),	      C (left_ptr),    C (right_side)	       },
+    { C (bottom_left_corner), C (bottom_side), C (bottom_right_corner) }
+};
+
+struct _pos pos[3][3] = {
+    {
+	{  0,  0, 10, 21,   0, 0, 0, 0, 0, 1 },
+	{ 10,  0, -8,  6,   0, 0, 1, 0, 0, 1 },
+	{  2,  0, 10, 21,   1, 0, 0, 0, 0, 1 }
+    }, {
+	{  0, 10,  6, 11,   0, 0, 0, 1, 1, 0 },
+	{  6,  6,  0, 15,   0, 0, 1, 0, 0, 1 },
+	{  6, 10,  6, 11,   1, 0, 0, 1, 1, 0 }
+    }, {
+	{  0, 17, 10, 10,   0, 1, 0, 0, 1, 0 },
+	{ 10, 21, -8,  6,   0, 1, 1, 0, 1, 0 },
+	{  2, 17, 10, 10,   1, 1, 0, 0, 1, 0 }
+    }
+}, bpos[] = {
+    { 0, 6, 16, 16,   1, 0, 0, 0, 0, 0 },
+    { 0, 6, 16, 16,   1, 0, 0, 0, 0, 0 },
+    { 0, 6, 16, 16,   1, 0, 0, 0, 0, 0 },
+    { 6, 2, 16, 16,   0, 0, 0, 0, 0, 0 }
+};
+
+char *program_name;
+
+GtkWidget     *style_window_rgba;
+GtkWidget     *style_window_rgb;
+GtkWidget     *switcher_label;
+
+GHashTable    *frame_table;
+GtkWidget     *action_menu = NULL;
+gboolean      action_menu_mapped = FALSE;
+decor_color_t _title_color[2];
+PangoContext  *pango_context;
+gint	     double_click_timeout = 250;
+
+GSList *draw_list = NULL;
+guint  draw_idle_id = 0;
+
+PangoFontDescription *titlebar_font = NULL;
+gboolean		    use_system_font = FALSE;
+gint		    text_height;
+
+gint blur_type = BLUR_TYPE_NONE;
+
+GdkPixmap *switcher_pixmap = NULL;
+GdkPixmap *switcher_buffer_pixmap = NULL;
+gint      switcher_width;
+gint      switcher_height;
+Window    switcher_selected_window = None;
+decor_t   *switcher_window = NULL;
+
+XRenderPictFormat *xformat_rgba;
+XRenderPictFormat *xformat_rgb;
+
+int
+main (int argc, char *argv[])
+{
+    GdkDisplay *gdkdisplay;
+    Display    *xdisplay;
+    GdkScreen  *gdkscreen;
+    WnckScreen *screen;
+    gint       i, j, status;
+    unsigned int nchildren;
+    Window     root_ret, parent_ret;
+    Window     *children = NULL;
+    gboolean   replace = FALSE;
+
+#ifdef USE_METACITY
+    char       *meta_theme = NULL;
+#endif
+
+    program_name = argv[0];
+
+    gtk_init (&argc, &argv);
+
+    bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+    bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+    textdomain (GETTEXT_PACKAGE);
+
+    for (i = 0; i < argc; i++)
+    {
+	if (strcmp (argv[i], "--minimal") == 0)
+	{
+	    minimal = TRUE;
+	}
+	else if (strcmp (argv[i], "--replace") == 0)
+	{
+	    replace = TRUE;
+	}
+	else if (strcmp (argv[i], "--blur") == 0)
+	{
+	    if (argc > ++i)
+	    {
+		if (strcmp (argv[i], "titlebar") == 0)
+		    blur_type = BLUR_TYPE_TITLEBAR;
+		else if (strcmp (argv[i], "all") == 0)
+		    blur_type = BLUR_TYPE_ALL;
+	    }
+	    cmdline_options |= CMDLINE_BLUR;
+	}
+
+#ifdef USE_METACITY
+	else if (strcmp (argv[i], "--opacity") == 0)
+	{
+	    if (argc > ++i)
+		meta_opacity = atof (argv[i]);
+	    cmdline_options |= CMDLINE_OPACITY;
+	}
+	else if (strcmp (argv[i], "--no-opacity-shade") == 0)
+	{
+	    meta_shade_opacity = FALSE;
+	    cmdline_options |= CMDLINE_OPACITY_SHADE;
+	}
+	else if (strcmp (argv[i], "--active-opacity") == 0)
+	{
+	    if (argc > ++i)
+		meta_active_opacity = atof (argv[i]);
+	    cmdline_options |= CMDLINE_ACTIVE_OPACITY;
+	}
+	else if (strcmp (argv[i], "--no-active-opacity-shade") == 0)
+	{
+	    meta_active_shade_opacity = FALSE;
+	    cmdline_options |= CMDLINE_ACTIVE_OPACITY_SHADE;
+	}
+	else if (strcmp (argv[i], "--metacity-theme") == 0)
+	{
+	    if (argc > ++i)
+		meta_theme = argv[i];
+	    cmdline_options |= CMDLINE_THEME;
+	}
+#endif
+
+	else if (strcmp (argv[i], "--help") == 0)
+	{
+	    fprintf (stderr, "%s "
+		     "[--minimal] "
+		     "[--replace] "
+		     "[--blur none|titlebar|all] "
+
+#ifdef USE_METACITY
+		     "[--opacity OPACITY] "
+		     "[--no-opacity-shade] "
+		     "[--active-opacity OPACITY] "
+		     "[--no-active-opacity-shade] "
+		     "[--metacity-theme THEME] "
+#endif
+
+		     "[--help]"
+
+		     "\n", program_name);
+	    return 0;
+	}
+    }
+
+    theme_draw_window_decoration    = draw_window_decoration;
+    theme_calc_decoration_size	    = calc_decoration_size;
+    theme_update_border_extents	    = update_border_extents;
+    theme_get_event_window_position = get_event_window_position;
+    theme_get_button_position       = get_button_position;
+    theme_update_shadow		    = cairo_update_shadow;
+    theme_get_shadow		    = get_shadow;
+    theme_get_border_extents	    = get_border_extents;
+
+#ifdef USE_METACITY
+    if (meta_theme)
+    {
+	meta_theme_set_current (meta_theme, TRUE);
+	if (meta_theme_get_current ())
+	{
+	    theme_draw_window_decoration    = meta_draw_window_decoration;
+	    theme_calc_decoration_size	    = meta_calc_decoration_size;
+	    theme_update_border_extents	    = meta_update_border_extents;
+	    theme_get_event_window_position = meta_get_event_window_position;
+	    theme_get_button_position	    = meta_get_button_position;
+	    theme_update_shadow		    = meta_update_shadow;
+	    theme_get_shadow		    = meta_get_shadow;
+	    theme_get_border_extents	    = meta_get_border_extents;
+	}
+    }
+#endif
+
+    gdkdisplay = gdk_display_get_default ();
+    xdisplay   = gdk_x11_display_get_xdisplay (gdkdisplay);
+    gdkscreen  = gdk_display_get_default_screen (gdkdisplay);
+
+    frame_input_window_atom  = XInternAtom (xdisplay,
+					    DECOR_INPUT_FRAME_ATOM_NAME, FALSE);
+    frame_output_window_atom = XInternAtom (xdisplay,
+					    DECOR_OUTPUT_FRAME_ATOM_NAME, FALSE);
+
+    win_decor_atom	= XInternAtom (xdisplay, DECOR_WINDOW_ATOM_NAME, FALSE);
+    win_blur_decor_atom	= XInternAtom (xdisplay, DECOR_BLUR_ATOM_NAME, FALSE);
+    wm_move_resize_atom = XInternAtom (xdisplay, "_NET_WM_MOVERESIZE", FALSE);
+    restack_window_atom = XInternAtom (xdisplay, "_NET_RESTACK_WINDOW", FALSE);
+    select_window_atom	= XInternAtom (xdisplay, DECOR_SWITCH_WINDOW_ATOM_NAME,
+				       FALSE);
+    mwm_hints_atom	= XInternAtom (xdisplay, "_MOTIF_WM_HINTS", FALSE);
+    switcher_fg_atom    = XInternAtom (xdisplay,
+				       DECOR_SWITCH_FOREGROUND_COLOR_ATOM_NAME,
+				       FALSE);
+
+    compiz_shadow_info_atom  = XInternAtom (xdisplay, "_COMPIZ_NET_CM_SHADOW_PROPERTIES", FALSE);
+    compiz_shadow_color_atom = XInternAtom (xdisplay, "_COMPIZ_NET_CM_SHADOW_COLOR", FALSE);
+
+    toolkit_action_atom			  =
+	XInternAtom (xdisplay, "_COMPIZ_TOOLKIT_ACTION", FALSE);
+    toolkit_action_window_menu_atom	  =
+	XInternAtom (xdisplay, "_COMPIZ_TOOLKIT_ACTION_WINDOW_MENU", FALSE);
+    toolkit_action_force_quit_dialog_atom =
+	XInternAtom (xdisplay, "_COMPIZ_TOOLKIT_ACTION_FORCE_QUIT_DIALOG",
+		     FALSE);
+
+    status = decor_acquire_dm_session (xdisplay,
+				       gdk_screen_get_number (gdkscreen),
+				       "gwd", replace, &dm_sn_timestamp);
+    if (status != DECOR_ACQUIRE_STATUS_SUCCESS)
+    {
+	if (status == DECOR_ACQUIRE_STATUS_FAILED)
+	{
+	    fprintf (stderr,
+		     "%s: Could not acquire decoration manager "
+		     "selection on screen %d display \"%s\"\n",
+		     program_name, gdk_screen_get_number (gdkscreen),
+		     DisplayString (xdisplay));
+	}
+	else if (status == DECOR_ACQUIRE_STATUS_OTHER_DM_RUNNING)
+	{
+	    fprintf (stderr,
+		     "%s: Screen %d on display \"%s\" already "
+		     "has a decoration manager; try using the "
+		     "--replace option to replace the current "
+		     "decoration manager.\n",
+		     program_name, gdk_screen_get_number (gdkscreen),
+		     DisplayString (xdisplay));
+	}
+
+	return 1;
+    }
+
+    for (i = 0; i < 3; i++)
+    {
+	for (j = 0; j < 3; j++)
+	{
+	    if (cursor[i][j].shape != XC_left_ptr)
+		cursor[i][j].cursor =
+		    XCreateFontCursor (xdisplay, cursor[i][j].shape);
+	}
+    }
+
+    xformat_rgba = XRenderFindStandardFormat (xdisplay, PictStandardARGB32);
+    xformat_rgb  = XRenderFindStandardFormat (xdisplay, PictStandardRGB24);
+
+    frame_table = g_hash_table_new (NULL, NULL);
+
+    screen = wnck_screen_get_default ();
+    wnck_set_client_type (WNCK_CLIENT_TYPE_PAGER);
+
+    gdk_window_add_filter (NULL,
+			   selection_event_filter_func,
+			   NULL);
+
+    if (!minimal)
+    {
+	GdkWindow *root = create_foreign_window (gdk_x11_get_default_root_xwindow ());
+
+	gdk_window_add_filter (NULL,
+			       event_filter_func,
+			       NULL);
+			       
+	XQueryTree (xdisplay, gdk_x11_get_default_root_xwindow (),
+		    &root_ret, &parent_ret, &children, &nchildren);
+
+	for (i = 0; i < nchildren; i++)
+	{
+	    GdkWindow *toplevel = create_foreign_window (children[i]);
+
+	    /* Need property notify on all windows */
+
+	    gdk_window_set_events (toplevel,
+				   gdk_window_get_events (toplevel) |
+				   GDK_PROPERTY_CHANGE_MASK);
+	}
+
+	/* Need MapNotify on new windows */
+	gdk_window_set_events (root, gdk_window_get_events (root) |
+			       GDK_STRUCTURE_MASK |
+			       GDK_PROPERTY_CHANGE_MASK |
+			       GDK_VISIBILITY_NOTIFY_MASK |
+			       GDK_SUBSTRUCTURE_MASK);
+
+	connect_screen (screen);
+    }
+
+    if (!init_settings (screen))
+    {
+	fprintf (stderr, "%s: Failed to get necessary gtk settings\n", argv[0]);
+	return 1;
+    }
+
+    decor_set_dm_check_hint (xdisplay, gdk_screen_get_number (gdkscreen),
+			     WINDOW_DECORATION_TYPE_PIXMAP |
+			     WINDOW_DECORATION_TYPE_WINDOW);
+
+    update_default_decorations (gdkscreen);
+
+    gtk_main ();
+
+    return 0;
+}

=== added file '.pc/fix-883383.patch/unity/unity_window_decorator/src/gtk-window-decorator.h'
--- .pc/fix-883383.patch/unity/unity_window_decorator/src/gtk-window-decorator.h	1970-01-01 00:00:00 +0000
+++ .pc/fix-883383.patch/unity/unity_window_decorator/src/gtk-window-decorator.h	2011-10-29 09:07:25 +0000
@@ -0,0 +1,1009 @@
+#ifndef _GTK_WINDOW_DECORATOR_H
+#define _GTK_WINDOW_DECORATOR_H
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <decoration.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <X11/cursorfont.h>
+#include <X11/extensions/Xrender.h>
+#include <X11/Xregion.h>
+
+#ifdef HAVE_GTK_2_24
+
+#ifndef GDK_DISABLE_DEPRECATED
+#define GDK_DISABLE_DEPRECATED
+#endif
+
+#define create_foreign_window(xid)					      \
+    gdk_x11_foreign_new_for_display (gdk_display_get_default (),	      \
+				     xid);
+#else
+
+#define create_foreign_window(xid)					      \
+    gdk_window_foreign_new (xid)
+
+#ifdef GTK_DISABLE_DEPRECATED
+#undef GTK_DISABLE_DEPRECATED
+#endif
+
+#endif
+
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include <gdk/gdk.h>
+
+#ifdef USE_GCONF_UNITY_WINDOW_DECORATOR
+#include <gconf/gconf-client.h>
+#endif
+
+#ifdef USE_DBUS_GLIB
+#define DBUS_API_SUBJECT_TO_CHANGE
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib-lowlevel.h>
+#endif
+
+#define WNCK_I_KNOW_THIS_IS_UNSTABLE
+#include <libwnck/libwnck.h>
+#include <libwnck/window-action-menu.h>
+
+#ifndef HAVE_LIBWNCK_2_19_4
+#define wnck_window_get_client_window_geometry wnck_window_get_geometry
+#endif
+
+#include <cairo.h>
+#include <cairo-xlib.h>
+
+#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 1, 0)
+#define CAIRO_EXTEND_PAD CAIRO_EXTEND_NONE
+#endif
+
+#include <pango/pango-context.h>
+#include <pango/pangocairo.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include <limits.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <signal.h>
+
+#include <libintl.h>
+#define _(x)  gettext (x)
+#define N_(x) x
+
+#ifdef USE_METACITY
+#include <metacity-private/theme.h>
+#endif
+
+#define METACITY_GCONF_DIR "/apps/metacity/general"
+
+#define COMPIZ_USE_SYSTEM_FONT_KEY		    \
+METACITY_GCONF_DIR "/titlebar_uses_system_font"
+
+#define COMPIZ_TITLEBAR_FONT_KEY	\
+METACITY_GCONF_DIR "/titlebar_font"
+
+#define COMPIZ_DOUBLE_CLICK_TITLEBAR_KEY	       \
+METACITY_GCONF_DIR "/action_double_click_titlebar"
+
+#define COMPIZ_MIDDLE_CLICK_TITLEBAR_KEY	       \
+METACITY_GCONF_DIR "/action_middle_click_titlebar"
+
+#define COMPIZ_RIGHT_CLICK_TITLEBAR_KEY	       \
+METACITY_GCONF_DIR "/action_right_click_titlebar"
+
+#define COMPIZ_GCONF_DIR1 "/apps/compiz/plugins/decoration/allscreens/options"
+
+#define COMPIZ_SHADOW_RADIUS_KEY \
+COMPIZ_GCONF_DIR1 "/shadow_radius"
+
+#define COMPIZ_SHADOW_OPACITY_KEY \
+COMPIZ_GCONF_DIR1 "/shadow_opacity"
+
+#define COMPIZ_SHADOW_COLOR_KEY \
+COMPIZ_GCONF_DIR1 "/shadow_color"
+
+#define COMPIZ_SHADOW_OFFSET_X_KEY \
+COMPIZ_GCONF_DIR1 "/shadow_x_offset"
+
+#define COMPIZ_SHADOW_OFFSET_Y_KEY \
+COMPIZ_GCONF_DIR1 "/shadow_y_offset"
+
+#define META_THEME_KEY		\
+METACITY_GCONF_DIR "/theme"
+
+#define META_BUTTON_LAYOUT_KEY		\
+METACITY_GCONF_DIR "/button_layout"
+
+#define GCONF_DIR "/apps/gwd"
+
+#define USE_META_THEME_KEY	    \
+GCONF_DIR "/use_metacity_theme"
+
+#define META_THEME_OPACITY_KEY	        \
+GCONF_DIR "/metacity_theme_opacity"
+
+#define META_THEME_SHADE_OPACITY_KEY	      \
+GCONF_DIR "/metacity_theme_shade_opacity"
+
+#define META_THEME_ACTIVE_OPACITY_KEY	       \
+GCONF_DIR "/metacity_theme_active_opacity"
+
+#define META_THEME_ACTIVE_SHADE_OPACITY_KEY          \
+GCONF_DIR "/metacity_theme_active_shade_opacity"
+
+#define BLUR_TYPE_KEY	   \
+GCONF_DIR "/blur_type"
+
+#define WHEEL_ACTION_KEY   \
+GCONF_DIR "/mouse_wheel_action"
+
+#define DBUS_DEST       "org.freedesktop.compiz"
+#define DBUS_PATH       "/org/freedesktop/compiz/decor/screen0"
+#define DBUS_INTERFACE  "org.freedesktop.compiz"
+#define DBUS_METHOD_GET "get"
+
+#define STROKE_ALPHA 0.6
+
+#define ICON_SPACE 20
+
+#define DOUBLE_CLICK_DISTANCE 8.0
+
+#define WM_MOVERESIZE_SIZE_TOPLEFT      0
+#define WM_MOVERESIZE_SIZE_TOP          1
+#define WM_MOVERESIZE_SIZE_TOPRIGHT     2
+#define WM_MOVERESIZE_SIZE_RIGHT        3
+#define WM_MOVERESIZE_SIZE_BOTTOMRIGHT  4
+#define WM_MOVERESIZE_SIZE_BOTTOM       5
+#define WM_MOVERESIZE_SIZE_BOTTOMLEFT   6
+#define WM_MOVERESIZE_SIZE_LEFT         7
+#define WM_MOVERESIZE_MOVE              8
+#define WM_MOVERESIZE_SIZE_KEYBOARD     9
+#define WM_MOVERESIZE_MOVE_KEYBOARD    10
+
+#define SHADOW_RADIUS      8.0
+#define SHADOW_OPACITY     0.5
+#define SHADOW_OFFSET_X    1
+#define SHADOW_OFFSET_Y    1
+#define SHADOW_COLOR_RED   0x0000
+#define SHADOW_COLOR_GREEN 0x0000
+#define SHADOW_COLOR_BLUE  0x0000
+
+#define SHADOW_TYPE_ACTIVE_NORMAL 1
+#define SHADOW_TYPE_ACTIVE_MAX    2
+#define SHADOW_TYPE_INACTIVE_NORMAL 3
+#define SHADOW_TYPE_INACTIVE_MAX    4
+
+#define META_OPACITY              0.75
+#define META_SHADE_OPACITY        TRUE
+#define META_ACTIVE_OPACITY       1.0
+#define META_ACTIVE_SHADE_OPACITY TRUE
+
+#define META_MAXIMIZED (WNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY | \
+WNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY)
+
+#define CMDLINE_OPACITY              (1 << 0)
+#define CMDLINE_OPACITY_SHADE        (1 << 1)
+#define CMDLINE_ACTIVE_OPACITY       (1 << 2)
+#define CMDLINE_ACTIVE_OPACITY_SHADE (1 << 3)
+#define CMDLINE_BLUR                 (1 << 4)
+#define CMDLINE_THEME                (1 << 5)
+
+#define MWM_HINTS_DECORATIONS (1L << 1)
+
+#define MWM_DECOR_ALL      (1L << 0)
+#define MWM_DECOR_BORDER   (1L << 1)
+#define MWM_DECOR_HANDLE   (1L << 2)
+#define MWM_DECOR_TITLE    (1L << 3)
+#define MWM_DECOR_MENU     (1L << 4)
+#define MWM_DECOR_MINIMIZE (1L << 5)
+#define MWM_DECOR_MAXIMIZE (1L << 6)
+
+#define PROP_MOTIF_WM_HINT_ELEMENTS 3
+
+/* to save some memory, value is specific to current decorations */
+#define TRANSLUCENT_CORNER_SIZE 3
+
+typedef struct {
+unsigned long flags;
+unsigned long functions;
+unsigned long decorations;
+} MwmHints;
+
+enum {
+    CLICK_ACTION_NONE,
+    CLICK_ACTION_SHADE,
+    CLICK_ACTION_MAXIMIZE,
+    CLICK_ACTION_MINIMIZE,
+    CLICK_ACTION_RAISE,
+    CLICK_ACTION_LOWER,
+    CLICK_ACTION_MENU
+};
+
+enum {
+    WHEEL_ACTION_NONE,
+    WHEEL_ACTION_SHADE
+};
+
+#define DOUBLE_CLICK_ACTION_DEFAULT CLICK_ACTION_MAXIMIZE
+#define MIDDLE_CLICK_ACTION_DEFAULT CLICK_ACTION_LOWER
+#define RIGHT_CLICK_ACTION_DEFAULT  CLICK_ACTION_MENU
+#define WHEEL_ACTION_DEFAULT        WHEEL_ACTION_NONE
+
+int double_click_action;
+int middle_click_action;
+int right_click_action;
+int wheel_action;
+
+extern gboolean minimal;
+extern double decoration_alpha;
+
+#define SWITCHER_SPACE 40
+
+extern decor_extents_t _shadow_extents;
+extern decor_extents_t _win_extents;
+extern decor_extents_t _max_win_extents;
+extern decor_extents_t _default_win_extents;
+extern decor_extents_t _switcher_extents;
+
+extern int titlebar_height;
+extern int max_titlebar_height;
+
+extern decor_context_t window_active_context;
+extern decor_context_t window_inactive_context;
+extern decor_context_t window_context_no_shadow;
+extern decor_context_t max_window_active_context;
+extern decor_context_t max_window_inactive_context;
+extern decor_context_t max_window_context_no_shadow;
+extern decor_context_t switcher_context;
+extern decor_context_t shadow_context;
+
+extern gdouble shadow_radius;
+extern gdouble shadow_opacity;
+extern gushort shadow_color[3];
+extern gint    shadow_offset_x;
+extern gint    shadow_offset_y;
+
+#ifdef USE_METACITY
+extern double   meta_opacity;
+extern gboolean meta_shade_opacity;
+extern double   meta_active_opacity;
+extern gboolean meta_active_shade_opacity;
+
+extern gboolean         meta_button_layout_set;
+extern MetaButtonLayout meta_button_layout;
+#endif
+
+extern guint cmdline_options;
+
+extern decor_shadow_t *no_border_shadow;
+extern decor_shadow_t *border_active_shadow;
+extern decor_shadow_t *border_inactive_shadow;
+extern decor_shadow_t *border_no_shadow;
+extern decor_shadow_t *max_border_active_shadow;
+extern decor_shadow_t *max_border_inactive_shadow;
+extern decor_shadow_t *max_border_no_shadow;
+extern decor_shadow_t *switcher_shadow;
+
+extern GdkPixmap *decor_normal_pixmap;
+extern GdkPixmap *decor_active_pixmap;
+
+extern Atom frame_input_window_atom;
+extern Atom frame_output_window_atom;
+extern Atom win_decor_atom;
+extern Atom win_blur_decor_atom;
+extern Atom wm_move_resize_atom;
+extern Atom restack_window_atom;
+extern Atom select_window_atom;
+extern Atom mwm_hints_atom;
+extern Atom switcher_fg_atom;
+
+extern Atom toolkit_action_atom;
+extern Atom toolkit_action_window_menu_atom;
+extern Atom toolkit_action_force_quit_dialog_atom;
+
+extern Time dm_sn_timestamp;
+
+#define C(name) { 0, XC_ ## name }
+
+struct _cursor {
+    Cursor	 cursor;
+    unsigned int shape;
+};
+
+extern struct _cursor cursor[3][3];
+
+#define BUTTON_CLOSE   0
+#define BUTTON_MAX     1
+#define BUTTON_MIN     2
+#define BUTTON_MENU    3
+#define BUTTON_SHADE   4
+#define BUTTON_ABOVE   5
+#define BUTTON_STICK   6
+#define BUTTON_UNSHADE 7
+#define BUTTON_UNABOVE 8
+#define BUTTON_UNSTICK 9
+#define BUTTON_NUM     10
+
+struct _pos {
+    int x, y, w, h;
+    int xw, yh, ww, hh, yth, hth;
+};
+
+extern struct _pos pos[3][3], bpos[];
+
+typedef struct _decor_color {
+    double r;
+    double g;
+    double b;
+} decor_color_t;
+
+
+#define IN_EVENT_WINDOW      (1 << 0)
+#define PRESSED_EVENT_WINDOW (1 << 1)
+
+typedef struct _decor_event {
+    guint time;
+    guint window;
+    guint x;
+    guint y;
+    guint x_root;
+    guint y_root;
+    guint button;
+} decor_event;
+
+typedef enum _decor_event_type {
+    GButtonPress = 1,
+    GButtonRelease,
+    GEnterNotify,
+    GLeaveNotify,
+    GMotionNotify
+} decor_event_type;
+
+typedef void (*event_callback) (WnckWindow       *win,
+				decor_event      *gtkwd_event,
+				decor_event_type gtkwd_type);
+
+typedef struct {
+    Window         window;
+    Box            pos;
+    event_callback callback;
+} event_window;
+
+typedef struct _decor {
+    WnckWindow	      *win;
+    event_window      event_windows[3][3];
+    event_window      button_windows[BUTTON_NUM];
+    Box		      *last_pos_entered;
+    guint	      button_states[BUTTON_NUM];
+    GdkPixmap	      *pixmap;
+    GdkPixmap	      *buffer_pixmap;
+    GdkWindow	      *frame_window;
+    GtkWidget         *decor_window;
+    GtkWidget	      *decor_event_box;
+    GtkWidget         *decor_image;
+    cairo_t	      *cr;
+    decor_layout_t    border_layout;
+    decor_context_t   *context;
+    decor_shadow_t    *shadow;
+    Picture	      picture;
+    gint	      button_width;
+    gint	      width;
+    gint	      height;
+    gint	      client_width;
+    gint	      client_height;
+    gboolean	      decorated;
+    gboolean	      active;
+    PangoLayout	      *layout;
+    gchar	      *name;
+    cairo_pattern_t   *icon;
+    GdkPixmap	      *icon_pixmap;
+    GdkPixbuf	      *icon_pixbuf;
+    WnckWindowState   state;
+    WnckWindowActions actions;
+    XID		      prop_xid;
+    GtkWidget	      *force_quit_dialog;
+    GSList	      *transient_windows;
+    WnckWindow	      *transient_parent;
+    Bool	      created;
+    void	      (*draw) (struct _decor *d);
+} decor_t;
+
+void     (*theme_draw_window_decoration)    (decor_t *d);
+gboolean (*theme_calc_decoration_size)      (decor_t *d,
+					     int     client_width,
+					     int     client_height,
+					     int     text_width,
+					     int     *width,
+					     int     *height);
+void     (*theme_update_border_extents)     (gint    text_height);
+void     (*theme_get_event_window_position) (decor_t *d,
+					     gint    i,
+					     gint    j,
+					     gint    width,
+					     gint    height,
+					     gint    *x,
+					     gint    *y,
+					     gint    *w,
+					     gint    *h);
+gboolean (*theme_get_button_position)       (decor_t *d,
+					     gint    i,
+					     gint    width,
+					     gint    height,
+					     gint    *x,
+					     gint    *y,
+					     gint    *w,
+					     gint    *h);
+
+decor_shadow_t * (*theme_update_shadow) (gint    shadow_type);
+
+void (*theme_get_shadow) (decor_t *d,
+			  gint    shadow_type);
+
+void (*theme_get_border_extents) (decor_extents_t *extents,
+				  decor_extents_t *frame_extents,
+				  decor_extents_t *extents_max,
+				  decor_extents_t *frame_extents_max);
+
+extern char *program_name;
+
+extern GtkWidget     *style_window_rgba;
+extern GtkWidget     *style_window_rgb;
+extern GtkWidget     *switcher_label;
+
+extern GHashTable    *frame_table;
+extern GtkWidget     *action_menu;
+extern gboolean      action_menu_mapped;
+extern decor_color_t _title_color[2];
+extern PangoContext  *pango_context;
+extern gint	     double_click_timeout;
+
+extern GSList *draw_list;
+extern guint  draw_idle_id;
+
+extern PangoFontDescription *titlebar_font;
+extern gboolean		    use_system_font;
+extern gint		    text_height;
+
+#define BLUR_TYPE_NONE     0
+#define BLUR_TYPE_TITLEBAR 1
+#define BLUR_TYPE_ALL      2
+
+extern gint blur_type;
+
+extern GdkPixmap *switcher_pixmap;
+extern GdkPixmap *switcher_buffer_pixmap;
+extern gint      switcher_width;
+extern gint      switcher_height;
+extern Window    switcher_selected_window;
+extern decor_t   *switcher_window;
+
+extern XRenderPictFormat *xformat_rgba;
+extern XRenderPictFormat *xformat_rgb;
+
+extern Atom compiz_shadow_info_atom;
+extern Atom compiz_shadow_color_atom;
+
+/* gtk-window-decorator.c */
+
+double
+dist (double x1, double y1,
+      double x2, double y2);
+
+/* decorator.c */
+
+gboolean
+update_window_decoration_size (WnckWindow *win);
+
+void
+update_window_decoration_name (WnckWindow *win);
+
+gint
+max_window_name_width (WnckWindow *win);
+
+void
+update_default_decorations (GdkScreen *screen);
+
+void
+update_window_decoration_state (WnckWindow *win);
+
+void
+update_window_decoration_actions (WnckWindow *win);
+
+void
+update_window_decoration_icon (WnckWindow *win);
+
+void
+update_event_windows (WnckWindow *win);
+
+int
+update_shadow (void);
+
+void
+shadow_property_changed (WnckScreen *screen);
+
+void
+update_titlebar_font (void);
+
+void
+update_window_decoration_name (WnckWindow *win);
+
+void
+update_window_decoration (WnckWindow *win);
+
+void
+queue_decor_draw (decor_t *d);
+
+void
+copy_to_front_buffer (decor_t *d);
+
+void
+draw_border_shape (Display	   *xdisplay,
+		   Pixmap	   pixmap,
+		   Picture	   picture,
+		   int		   width,
+		   int		   height,
+		   decor_context_t *c,
+		   void		   *closure);
+
+
+/* wnck.c*/
+
+void
+decorations_changed (WnckScreen *screen);
+
+void
+connect_screen (WnckScreen *screen);
+
+void
+add_frame_window (WnckWindow *win,
+		  Window     frame,
+		  Bool	     mode);
+
+void
+remove_frame_window (WnckWindow *win);
+
+void
+restack_window (WnckWindow *win,
+		int	   stack_mode);
+
+void connect_window (WnckWindow *win);
+
+/* blur.c */
+
+void
+decor_update_blur_property (decor_t *d,
+			    int     width,
+			    int     height,
+			    Region  top_region,
+			    int     top_offset,
+			    Region  bottom_region,
+			    int     bottom_offset,
+			    Region  left_region,
+			    int     left_offset,
+			    Region  right_region,
+			    int     right_offset);
+
+/* decorprops.c */
+
+void
+decor_update_window_property (decor_t *d);
+
+void
+decor_update_switcher_property (decor_t *d);
+
+/* cairo.c */
+
+#define CORNER_TOPLEFT     (1 << 0)
+#define CORNER_TOPRIGHT    (1 << 1)
+#define CORNER_BOTTOMRIGHT (1 << 2)
+#define CORNER_BOTTOMLEFT  (1 << 3)
+
+#define SHADE_LEFT   (1 << 0)
+#define SHADE_RIGHT  (1 << 1)
+#define SHADE_TOP    (1 << 2)
+#define SHADE_BOTTOM (1 << 3)
+
+void
+draw_shadow_background (decor_t		*d,
+			cairo_t		*cr,
+			decor_shadow_t  *s,
+			decor_context_t *c);
+
+void
+draw_window_decoration (decor_t *d);
+
+void
+fill_rounded_rectangle (cairo_t       *cr,
+			double        x,
+			double        y,
+			double        w,
+			double        h,
+			double	      radius,
+			int	      corner,
+			decor_color_t *c0,
+			double        alpha0,
+			decor_color_t *c1,
+			double	      alpha1,
+			int	      gravity);
+
+void
+rounded_rectangle (cairo_t *cr,
+		   double  x,
+		   double  y,
+		   double  w,
+		   double  h,
+		   double  radius,
+		   int	   corner);
+
+gboolean
+calc_decoration_size (decor_t *d,
+		      gint    w,
+		      gint    h,
+		      gint    name_width,
+		      gint    *width,
+		      gint    *height);
+
+void
+update_border_extents (gint text_height);
+
+void
+get_border_extents (decor_extents_t *extents,
+		    decor_extents_t *frame_extents,
+		    decor_extents_t *extents_max,
+		    decor_extents_t *frame_extents_max);
+
+gboolean
+get_button_position (decor_t *d,
+		     gint    i,
+		     gint    width,
+		     gint    height,
+		     gint    *x,
+		     gint    *y,
+		     gint    *w,
+		     gint    *h);
+
+void
+get_event_window_position (decor_t *d,
+			   gint    i,
+			   gint    j,
+			   gint    width,
+			   gint    height,
+			   gint    *x,
+			   gint    *y,
+			   gint    *w,
+			   gint    *h);
+
+decor_shadow_t *
+cairo_update_shadow (gint shadow_type);
+
+void
+get_shadow (decor_t *, gint shadow_type);
+
+/* gdk.c */
+
+void
+gdk_cairo_set_source_color_alpha (cairo_t  *cr,
+				  GdkColor *color,
+				  double   alpha);
+
+inline GdkWindow *
+create_gdk_window (Window xframe);
+
+GdkColormap *
+get_colormap_for_drawable (GdkDrawable *d);
+
+XRenderPictFormat *
+get_format_for_drawable (decor_t *d, GdkDrawable *drawable);
+
+GdkPixmap *
+create_pixmap (int w,
+	       int h,
+	       int depth);
+
+GdkPixmap *
+pixmap_new_from_pixbuf (GdkPixbuf *pixbuf, int depth);
+
+/* metacity.c */
+#ifdef USE_METACITY
+void
+meta_draw_window_decoration (decor_t *d);
+
+void
+meta_get_decoration_geometry (decor_t		*d,
+			      MetaTheme	        *theme,
+			      MetaFrameFlags    *flags,
+			      MetaFrameGeometry *fgeom,
+			      MetaButtonLayout  *button_layout,
+			      GdkRectangle      *clip);
+
+void
+meta_calc_button_size (decor_t *d);
+
+gboolean
+meta_calc_decoration_size (decor_t *d,
+			   gint    w,
+			   gint    h,
+			   gint    name_width,
+			   gint    *width,
+			   gint    *height);
+
+gboolean
+meta_get_button_position (decor_t *d,
+			  gint    i,
+			  gint	  width,
+			  gint	  height,
+			  gint    *x,
+			  gint    *y,
+			  gint    *w,
+			  gint    *h);
+
+gboolean
+meta_button_present (MetaButtonLayout   *button_layout,
+		     MetaButtonFunction function);
+
+void
+meta_get_event_window_position (decor_t *d,
+				gint    i,
+				gint    j,
+				gint	width,
+				gint	height,
+				gint    *x,
+				gint    *y,
+				gint    *w,
+				gint    *h);
+void
+meta_update_border_extents (gint text_height);
+
+void
+meta_get_border_extents (decor_extents_t *extents,
+			 decor_extents_t *frame_extents,
+			 decor_extents_t *extents_max,
+			 decor_extents_t *frame_extents_max);
+
+void
+meta_update_button_layout (const char *value);
+
+decor_shadow_t *
+meta_update_shadow (gint shadow_type);
+
+void
+meta_get_shadow (decor_t *, gint shadow_type);
+
+#endif
+/* switcher.c */
+
+#define SWITCHER_ALPHA 0xa0a0
+
+void
+draw_switcher_decoration (decor_t *d);
+
+gboolean
+update_switcher_window (Window 	   popup,
+			Window     selected);
+
+decor_t *
+switcher_window_opened (Window popup, Window selected);
+
+void
+switcher_window_closed ();
+
+/* events.c */
+
+void
+move_resize_window (WnckWindow *win,
+		    int	       direction,
+		    decor_event *gtkwd_event);
+
+void
+common_button_event (WnckWindow *win,
+		     decor_event *gtkwd_event,
+		     decor_event_type gtkwd_type,
+		     int	button,
+		     int	max);
+
+void
+close_button_event (WnckWindow *win,
+		    decor_event *gtkwd_event,
+		    decor_event_type gtkwd_type);
+
+void
+max_button_event (WnckWindow *win,
+		  decor_event *gtkwd_event,
+		  decor_event_type gtkwd_type);
+
+void
+min_button_event (WnckWindow *win,
+		  decor_event *gtkwd_event,
+		  decor_event_type gtkwd_type);
+
+void
+menu_button_event (WnckWindow *win,
+		   decor_event *gtkwd_event,
+		   decor_event_type gtkwd_type);
+
+void
+shade_button_event (WnckWindow *win,
+		    decor_event *gtkwd_event,
+		    decor_event_type gtkwd_type);
+
+void
+above_button_event (WnckWindow *win,
+		    decor_event *gtkwd_event,
+		    decor_event_type gtkwd_type);
+
+void
+stick_button_event (WnckWindow *win,
+		    decor_event *gtkwd_event,
+		    decor_event_type gtkwd_type);
+void
+unshade_button_event (WnckWindow *win,
+		      decor_event *gtkwd_event,
+		      decor_event_type gtkwd_type);
+
+void
+unabove_button_event (WnckWindow *win,
+		      decor_event *gtkwd_event,
+		      decor_event_type gtkwd_type);
+
+void
+unstick_button_event (WnckWindow *win,
+		      decor_event *gtkwd_event,
+		      decor_event_type gtkwd_type);
+
+void
+handle_title_button_event (WnckWindow   *win,
+			   int          action,
+			   decor_event *gtkwd_event);
+
+void
+handle_mouse_wheel_title_event (WnckWindow   *win,
+				unsigned int button);
+
+void
+title_event (WnckWindow       *win,
+	     decor_event      *gtkwd_event,
+	     decor_event_type gtkwd_type);
+
+void
+frame_common_event (WnckWindow       *win,
+		    int              direction,
+		    decor_event      *gtkwd_event,
+		    decor_event_type gtkwd_type);
+
+void
+top_left_event (WnckWindow       *win,
+		decor_event      *gtkwd_event,
+		decor_event_type gtkwd_type);
+
+void
+top_event (WnckWindow       *win,
+	   decor_event      *gtkwd_event,
+	   decor_event_type gtkwd_type);
+
+void
+top_right_event (WnckWindow       *win,
+		 decor_event      *gtkwd_event,
+		 decor_event_type gtkwd_type);
+
+void
+left_event (WnckWindow       *win,
+	    decor_event      *gtkwd_event,
+	    decor_event_type gtkwd_type);
+void
+right_event (WnckWindow       *win,
+	     decor_event      *gtkwd_event,
+	     decor_event_type gtkwd_type);
+
+void
+bottom_left_event (WnckWindow *win,
+		   decor_event *gtkwd_event,
+		   decor_event_type gtkwd_type);
+
+void
+bottom_event (WnckWindow *win,
+	      decor_event *gtkwd_event,
+	      decor_event_type gtkwd_type);
+void
+bottom_right_event (WnckWindow *win,
+		    decor_event *gtkwd_event,
+		    decor_event_type gtkwd_type);
+
+void
+frame_window_realized (GtkWidget *widget,
+		       gpointer  data);
+
+event_callback
+find_event_callback_for_point (decor_t *d,
+			       int     x,
+			       int     y,
+			       Bool    *enter,
+			       Bool    *leave,
+			       BoxPtr  *entered_box);
+
+event_callback
+find_leave_event_callback (decor_t *d);
+
+void
+frame_handle_button_press (GtkWidget      *widget,
+			   GdkEventButton *event,
+			   gpointer       user_data);
+
+void
+frame_handle_button_release (GtkWidget      *widget,
+			     GdkEventButton *event,
+			     gpointer       user_data);
+
+void
+frame_handle_motion (GtkWidget      *widget,
+		     GdkEventMotion *event,
+		     gpointer       user_data);
+
+GdkFilterReturn
+selection_event_filter_func (GdkXEvent *gdkxevent,
+			     GdkEvent  *event,
+			     gpointer  data);
+
+GdkFilterReturn
+event_filter_func (GdkXEvent *gdkxevent,
+		   GdkEvent  *event,
+		   gpointer  data);
+
+/* forcequit.c */
+
+void
+show_force_quit_dialog (WnckWindow *win,
+			Time        timestamp);
+
+void
+hide_force_quit_dialog (WnckWindow *win);
+
+/* actionmenu.c */
+
+void
+action_menu_map (WnckWindow *win,
+		 long	     button,
+		 Time	     time);
+
+/* util.c */
+
+double
+square (double x);
+
+double
+dist (double x1, double y1,
+      double x2, double y2);
+
+void
+shade (const decor_color_t *a,
+       decor_color_t	   *b,
+       float		   k);
+
+gboolean
+get_window_prop (Window xwindow,
+		 Atom   atom,
+		 Window *val);
+
+unsigned int
+get_mwm_prop (Window xwindow);
+
+
+/* style.c */
+
+void
+update_style (GtkWidget *widget);
+
+void
+style_changed (GtkWidget *widget);
+
+/* settings.c */
+
+gboolean
+init_settings (WnckScreen *screen);
+
+#endif

=== added file '.pc/fix-883383.patch/unity/unity_window_decorator/src/settings.c'
--- .pc/fix-883383.patch/unity/unity_window_decorator/src/settings.c	1970-01-01 00:00:00 +0000
+++ .pc/fix-883383.patch/unity/unity_window_decorator/src/settings.c	2011-10-29 09:07:25 +0000
@@ -0,0 +1,567 @@
+#include "gtk-window-decorator.h"
+
+/* TODO: Trash all of this and use a window property
+ * instead - much much cleaner!
+ */
+
+void
+shadow_property_changed (WnckScreen *s)
+{
+    GdkDisplay *display = gdk_display_get_default ();
+    Display    *xdisplay = GDK_DISPLAY_XDISPLAY (display);
+    GdkScreen  *screen = gdk_display_get_default_screen (display);
+    Window     root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen));
+    Atom actual;
+    int  result, format;
+    unsigned long n, left;
+    unsigned char *prop_data;
+    gboolean	  changed = FALSE;
+    XTextProperty shadow_color_xtp;
+
+    result = XGetWindowProperty (xdisplay, root, compiz_shadow_info_atom,
+				 0, 32768, 0, XA_INTEGER, &actual,
+				 &format, &n, &left, &prop_data);
+
+    if (result != Success)
+	return;
+
+    if (n == 4)
+    {
+	long *data      = (long *) prop_data;
+	gdouble radius  = data[0];
+	gdouble opacity = data[1];
+	gint x_off      = data[2];
+	gint y_off      = data[3];
+
+	/* Radius and Opacity are multiplied by 1000 to keep precision,
+	 * divide by that much to get our real radius and opacity
+	 */
+	radius /= 1000;
+	opacity /= 1000;
+
+	changed = radius != shadow_radius   ||
+		  opacity != shadow_opacity ||
+		  x_off != shadow_offset_x  ||
+		  y_off != shadow_offset_y;
+
+	shadow_radius = (gdouble) MAX (0.0, MIN (radius, 48.0));
+	shadow_opacity = (gdouble) MAX (0.0, MIN (opacity, 6.0));
+	shadow_offset_x = (gint) MAX (-16, MIN (x_off, 16));
+	shadow_offset_y = (gint) MAX (-16, MIN (y_off, 16));
+    }
+
+    XFree (prop_data);
+
+    result = XGetTextProperty (xdisplay, root, &shadow_color_xtp,
+			       compiz_shadow_color_atom);
+
+    if (shadow_color_xtp.value)
+    {
+	int  ret_count = 0;
+	char **t_data = NULL;
+
+	XTextPropertyToStringList (&shadow_color_xtp, &t_data, &ret_count);
+
+	if (ret_count == 1)
+	{
+	    int c[4];
+
+	    if (sscanf (t_data[0], "#%2x%2x%2x%2x",
+			&c[0], &c[1], &c[2], &c[3]) == 4)
+	    {
+		shadow_color[0] = c[0] << 8 | c[0];
+		shadow_color[1] = c[1] << 8 | c[1];
+		shadow_color[2] = c[2] << 8 | c[2];
+		changed = TRUE;
+	    }
+	}
+
+	XFree (shadow_color_xtp.value);
+	if (t_data)
+	    XFreeStringList (t_data);
+    }
+
+    if (changed)
+	decorations_changed (s);
+}
+
+#ifdef USE_GCONF_UNITY_WINDOW_DECORATOR
+static gboolean
+blur_settings_changed (GConfClient *client)
+{
+    gchar *type;
+    int   new_type = blur_type;
+
+    if (cmdline_options & CMDLINE_BLUR)
+	return FALSE;
+
+    type = gconf_client_get_string (client,
+				    BLUR_TYPE_KEY,
+				    NULL);
+
+    if (type)
+    {
+	if (strcmp (type, "titlebar") == 0)
+	    new_type = BLUR_TYPE_TITLEBAR;
+	else if (strcmp (type, "all") == 0)
+	    new_type = BLUR_TYPE_ALL;
+	else if (strcmp (type, "none") == 0)
+	    new_type = BLUR_TYPE_NONE;
+
+	g_free (type);
+    }
+
+    if (new_type != blur_type)
+    {
+	blur_type = new_type;
+	return TRUE;
+    }
+
+    return FALSE;
+}
+
+static gboolean
+theme_changed (GConfClient *client)
+{
+
+#ifdef USE_METACITY
+    gboolean use_meta_theme;
+
+    if (cmdline_options & CMDLINE_THEME)
+	return FALSE;
+
+    use_meta_theme = gconf_client_get_bool (client,
+					    USE_META_THEME_KEY,
+					    NULL);
+
+    if (use_meta_theme)
+    {
+	gchar *theme;
+
+	theme = gconf_client_get_string (client,
+					 META_THEME_KEY,
+					 NULL);
+
+	if (theme)
+	{
+	    meta_theme_set_current (theme, TRUE);
+	    if (!meta_theme_get_current ())
+		use_meta_theme = FALSE;
+
+	    g_free (theme);
+	}
+	else
+	{
+	    use_meta_theme = FALSE;
+	}
+    }
+
+    if (use_meta_theme)
+    {
+	theme_draw_window_decoration	= meta_draw_window_decoration;
+	theme_calc_decoration_size	= meta_calc_decoration_size;
+	theme_update_border_extents	= meta_update_border_extents;
+	theme_get_event_window_position = meta_get_event_window_position;
+	theme_get_button_position	= meta_get_button_position;
+	theme_update_shadow		= meta_update_shadow;
+	theme_get_shadow		= meta_get_shadow;
+	theme_get_border_extents	= meta_get_border_extents;
+    }
+    else
+    {
+	theme_draw_window_decoration	= draw_window_decoration;
+	theme_calc_decoration_size	= calc_decoration_size;
+	theme_update_border_extents	= update_border_extents;
+	theme_get_event_window_position = get_event_window_position;
+	theme_get_button_position	= get_button_position;
+	theme_update_shadow		= cairo_update_shadow;
+	theme_get_shadow		= get_shadow;
+	theme_get_border_extents	= get_border_extents;
+    }
+
+    return TRUE;
+#else
+    theme_draw_window_decoration    = draw_window_decoration;
+    theme_calc_decoration_size	    = calc_decoration_size;
+    theme_update_border_extents	    = update_border_extents;
+    theme_get_event_window_position = get_event_window_position;
+    theme_get_button_position	    = get_button_position;
+    theme_get_border_extents	    = get_border_extents;
+
+    return FALSE;
+#endif
+
+}
+
+static gboolean
+theme_opacity_changed (GConfClient *client)
+{
+
+#ifdef USE_METACITY
+    gboolean shade_opacity, changed = FALSE;
+    gdouble  opacity;
+
+    opacity = gconf_client_get_float (client,
+				      META_THEME_OPACITY_KEY,
+				      NULL);
+
+    if (!(cmdline_options & CMDLINE_OPACITY) &&
+	opacity != meta_opacity)
+    {
+	meta_opacity = opacity;
+	changed = TRUE;
+    }
+
+    if (opacity < 1.0)
+    {
+	shade_opacity = gconf_client_get_bool (client,
+					       META_THEME_SHADE_OPACITY_KEY,
+					       NULL);
+
+	if (!(cmdline_options & CMDLINE_OPACITY_SHADE) &&
+	    shade_opacity != meta_shade_opacity)
+	{
+	    meta_shade_opacity = shade_opacity;
+	    changed = TRUE;
+	}
+    }
+
+    opacity = gconf_client_get_float (client,
+				      META_THEME_ACTIVE_OPACITY_KEY,
+				      NULL);
+
+    if (!(cmdline_options & CMDLINE_ACTIVE_OPACITY) &&
+	opacity != meta_active_opacity)
+    {
+	meta_active_opacity = opacity;
+	changed = TRUE;
+    }
+
+    if (opacity < 1.0)
+    {
+	shade_opacity =
+	    gconf_client_get_bool (client,
+				   META_THEME_ACTIVE_SHADE_OPACITY_KEY,
+				   NULL);
+
+	if (!(cmdline_options & CMDLINE_ACTIVE_OPACITY_SHADE) &&
+	    shade_opacity != meta_active_shade_opacity)
+	{
+	    meta_active_shade_opacity = shade_opacity;
+	    changed = TRUE;
+	}
+    }
+
+    return changed;
+#else
+    return FALSE;
+#endif
+
+}
+
+static gboolean
+button_layout_changed (GConfClient *client)
+{
+
+#ifdef USE_METACITY
+    gchar *button_layout;
+
+    button_layout = gconf_client_get_string (client,
+					     META_BUTTON_LAYOUT_KEY,
+					     NULL);
+
+    if (button_layout)
+    {
+	meta_update_button_layout (button_layout);
+
+	meta_button_layout_set = TRUE;
+
+	g_free (button_layout);
+
+	return TRUE;
+    }
+
+    if (meta_button_layout_set)
+    {
+	meta_button_layout_set = FALSE;
+	return TRUE;
+    }
+#endif
+
+    return FALSE;
+}
+
+static void
+titlebar_font_changed (GConfClient *client)
+{
+    gchar *str;
+
+    str = gconf_client_get_string (client,
+				   COMPIZ_TITLEBAR_FONT_KEY,
+				   NULL);
+    if (!str)
+	str = g_strdup ("Sans Bold 12");
+
+    if (titlebar_font)
+	pango_font_description_free (titlebar_font);
+
+    titlebar_font = pango_font_description_from_string (str);
+
+    g_free (str);
+}
+
+static void
+titlebar_click_action_changed (GConfClient *client,
+			       const gchar *key,
+			       int         *action_value,
+			       int          default_value)
+{
+    gchar *action;
+
+    *action_value = default_value;
+
+    action = gconf_client_get_string (client, key, NULL);
+    if (action)
+    {
+	if (strcmp (action, "toggle_shade") == 0)
+	    *action_value = CLICK_ACTION_SHADE;
+	else if (strcmp (action, "toggle_maximize") == 0)
+	    *action_value = CLICK_ACTION_MAXIMIZE;
+	else if (strcmp (action, "minimize") == 0)
+	    *action_value = CLICK_ACTION_MINIMIZE;
+	else if (strcmp (action, "raise") == 0)
+	    *action_value = CLICK_ACTION_RAISE;
+	else if (strcmp (action, "lower") == 0)
+	    *action_value = CLICK_ACTION_LOWER;
+	else if (strcmp (action, "menu") == 0)
+	    *action_value = CLICK_ACTION_MENU;
+	else if (strcmp (action, "none") == 0)
+	    *action_value = CLICK_ACTION_NONE;
+
+	g_free (action);
+    }
+}
+
+static void
+wheel_action_changed (GConfClient *client)
+{
+    gchar *action;
+
+    wheel_action = WHEEL_ACTION_DEFAULT;
+
+    action = gconf_client_get_string (client, WHEEL_ACTION_KEY, NULL);
+    if (action)
+    {
+	if (strcmp (action, "shade") == 0)
+	    wheel_action = WHEEL_ACTION_SHADE;
+	else if (strcmp (action, "none") == 0)
+	    wheel_action = WHEEL_ACTION_NONE;
+
+	g_free (action);
+    }
+}
+
+static void
+value_changed (GConfClient *client,
+	       const gchar *key,
+	       GConfValue  *value,
+	       void        *data)
+{
+    gboolean changed = FALSE;
+
+    if (strcmp (key, COMPIZ_USE_SYSTEM_FONT_KEY) == 0)
+    {
+	if (gconf_client_get_bool (client,
+				   COMPIZ_USE_SYSTEM_FONT_KEY,
+				   NULL) != use_system_font)
+	{
+	    use_system_font = !use_system_font;
+	    changed = TRUE;
+	}
+    }
+    else if (strcmp (key, COMPIZ_TITLEBAR_FONT_KEY) == 0)
+    {
+	titlebar_font_changed (client);
+	changed = !use_system_font;
+    }
+    else if (strcmp (key, COMPIZ_DOUBLE_CLICK_TITLEBAR_KEY) == 0)
+    {
+	titlebar_click_action_changed (client, key,
+				       &double_click_action,
+				       DOUBLE_CLICK_ACTION_DEFAULT);
+    }
+    else if (strcmp (key, COMPIZ_MIDDLE_CLICK_TITLEBAR_KEY) == 0)
+    {
+	titlebar_click_action_changed (client, key,
+				       &middle_click_action,
+				       MIDDLE_CLICK_ACTION_DEFAULT);
+    }
+    else if (strcmp (key, COMPIZ_RIGHT_CLICK_TITLEBAR_KEY) == 0)
+    {
+	titlebar_click_action_changed (client, key,
+				       &right_click_action,
+				       RIGHT_CLICK_ACTION_DEFAULT);
+    }
+    else if (strcmp (key, WHEEL_ACTION_KEY) == 0)
+    {
+	wheel_action_changed (client);
+    }
+    else if (strcmp (key, BLUR_TYPE_KEY) == 0)
+    {
+	if (blur_settings_changed (client))
+	    changed = TRUE;
+    }
+    else if (strcmp (key, USE_META_THEME_KEY) == 0 ||
+	     strcmp (key, META_THEME_KEY) == 0)
+    {
+	if (theme_changed (client))
+	    changed = TRUE;
+    }
+    else if (strcmp (key, META_BUTTON_LAYOUT_KEY) == 0)
+    {
+	if (button_layout_changed (client))
+	    changed = TRUE;
+    }
+    else if (strcmp (key, META_THEME_OPACITY_KEY)	       == 0 ||
+	     strcmp (key, META_THEME_SHADE_OPACITY_KEY)	       == 0 ||
+	     strcmp (key, META_THEME_ACTIVE_OPACITY_KEY)       == 0 ||
+	     strcmp (key, META_THEME_ACTIVE_SHADE_OPACITY_KEY) == 0)
+    {
+	if (theme_opacity_changed (client))
+	    changed = TRUE;
+    }
+
+    if (changed)
+	decorations_changed (data);
+}
+#endif
+
+gboolean
+init_settings (WnckScreen *screen)
+{
+    GtkSettings	   *settings;
+    GdkScreen	   *gdkscreen;
+    GdkColormap	   *colormap;
+    AtkObject	   *switcher_label_obj;
+
+#ifdef USE_GCONF_UNITY_WINDOW_DECORATOR
+    GConfClient	   *gconf;
+
+    gconf = gconf_client_get_default ();
+
+    gconf_client_add_dir (gconf,
+			  GCONF_DIR,
+			  GCONF_CLIENT_PRELOAD_ONELEVEL,
+			  NULL);
+
+    gconf_client_add_dir (gconf,
+			  METACITY_GCONF_DIR,
+			  GCONF_CLIENT_PRELOAD_ONELEVEL,
+			  NULL);
+
+    g_signal_connect (G_OBJECT (gconf),
+		      "value_changed",
+		      G_CALLBACK (value_changed),
+		      screen);
+#endif
+
+    style_window_rgba = gtk_window_new (GTK_WINDOW_POPUP);
+
+    gdkscreen = gdk_display_get_default_screen (gdk_display_get_default ());
+    colormap = gdk_screen_get_rgba_colormap (gdkscreen);
+    if (colormap)
+	gtk_widget_set_colormap (style_window_rgba, colormap);
+
+    gtk_widget_realize (style_window_rgba);
+
+    switcher_label = gtk_label_new ("");
+    switcher_label_obj = gtk_widget_get_accessible (switcher_label);
+    atk_object_set_role (switcher_label_obj, ATK_ROLE_STATUSBAR);
+    gtk_container_add (GTK_CONTAINER (style_window_rgba), switcher_label);
+
+    gtk_widget_set_size_request (style_window_rgba, 0, 0);
+    gtk_window_move (GTK_WINDOW (style_window_rgba), -100, -100);
+    gtk_widget_show_all (style_window_rgba);
+
+    g_signal_connect_object (style_window_rgba, "style-set",
+			     G_CALLBACK (style_changed),
+			     0, 0);
+
+    settings = gtk_widget_get_settings (style_window_rgba);
+
+    g_object_get (G_OBJECT (settings), "gtk-double-click-time",
+		  &double_click_timeout, NULL);
+
+    pango_context = gtk_widget_create_pango_context (style_window_rgba);
+
+    style_window_rgb = gtk_window_new (GTK_WINDOW_POPUP);
+
+    gdkscreen = gdk_display_get_default_screen (gdk_display_get_default ());
+    colormap = gdk_screen_get_rgb_colormap (gdkscreen);
+    if (colormap)
+	gtk_widget_set_colormap (style_window_rgb, colormap);
+
+    gtk_widget_realize (style_window_rgb);
+
+    switcher_label = gtk_label_new ("");
+    switcher_label_obj = gtk_widget_get_accessible (switcher_label);
+    atk_object_set_role (switcher_label_obj, ATK_ROLE_STATUSBAR);
+    gtk_container_add (GTK_CONTAINER (style_window_rgb), switcher_label);
+
+    gtk_widget_set_size_request (style_window_rgb, 0, 0);
+    gtk_window_move (GTK_WINDOW (style_window_rgb), -100, -100);
+    gtk_widget_show_all (style_window_rgb);
+
+    g_signal_connect_object (style_window_rgb, "style-set",
+			     G_CALLBACK (style_changed),
+			     0, 0);
+
+    settings = gtk_widget_get_settings (style_window_rgb);
+
+    g_object_get (G_OBJECT (settings), "gtk-double-click-time",
+		  &double_click_timeout, NULL);
+
+    pango_context = gtk_widget_create_pango_context (style_window_rgb);
+
+#ifdef USE_GCONF_UNITY_WINDOW_DECORATOR
+    use_system_font = gconf_client_get_bool (gconf,
+					     COMPIZ_USE_SYSTEM_FONT_KEY,
+					     NULL);
+    theme_changed (gconf);
+    theme_opacity_changed (gconf);
+    button_layout_changed (gconf);
+#endif
+
+    update_style (style_window_rgba);
+    update_style (style_window_rgb);
+#ifdef USE_GCONF_UNITY_WINDOW_DECORATOR
+    titlebar_font_changed (gconf);
+#endif
+
+    update_titlebar_font ();
+
+#ifdef USE_GCONF_UNITY_WINDOW_DECORATOR
+    titlebar_click_action_changed (gconf,
+				   COMPIZ_DOUBLE_CLICK_TITLEBAR_KEY,
+				   &double_click_action,
+				   DOUBLE_CLICK_ACTION_DEFAULT);
+    titlebar_click_action_changed (gconf,
+				   COMPIZ_MIDDLE_CLICK_TITLEBAR_KEY,
+				   &middle_click_action,
+				   MIDDLE_CLICK_ACTION_DEFAULT);
+    titlebar_click_action_changed (gconf,
+				   COMPIZ_RIGHT_CLICK_TITLEBAR_KEY,
+				   &right_click_action,
+				   RIGHT_CLICK_ACTION_DEFAULT);
+    wheel_action_changed (gconf);
+    blur_settings_changed (gconf);
+#endif
+
+    (*theme_update_border_extents) (text_height);
+
+    shadow_property_changed (screen);
+
+    update_shadow ();
+
+    return TRUE;
+}

=== modified file 'debian/changelog'
--- debian/changelog	2011-10-12 10:44:49 +0000
+++ debian/changelog	2011-10-29 09:07:25 +0000
@@ -1,3 +1,12 @@
+compiz (1:0.9.6+bzr20110929-0ubuntu6) precise; urgency=low
+
+  * debian/patches/fix-881329.patch:
+    - Alt+click should raise with raise-on-click disabled (LP: #881329)
+  * debian/patches/fix-883383.patch:
+    - Drag title bar should not raise if raise-on-click is disabled (LP: #883383)
+
+ -- James Pharaoh <[e-mail]>  Tue, 25 Oct 2011 12:07:03 +0200
+
 compiz (1:0.9.6+bzr20110929-0ubuntu5) oneiric-proposed; urgency=low
 
   * debian/patches/fix-864330.patch:

=== added file 'debian/patches/fix-881329.patch'
--- debian/patches/fix-881329.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/fix-881329.patch	2011-10-29 09:07:25 +0000
@@ -0,0 +1,49 @@
+Index: fix-881329/plugins/move/src/move.cpp
+===================================================================
+--- fix-881329.orig/plugins/move/src/move.cpp	2011-10-25 11:55:52.191836766 +0200
++++ fix-881329/plugins/move/src/move.cpp	2011-10-25 11:56:01.683903132 +0200
+@@ -153,6 +153,8 @@
+ 		if (mw->gWindow)
+ 		mw->gWindow->glPaintSetEnabled (mw, true);
+ 	    }
++
++	    ms->hasMoved = false;
+ 	}
+     }
+ 
+@@ -177,7 +179,12 @@
+ 	/* update window attributes as window constraints may have
+ 	   changed - needed e.g. if a maximized window was moved
+ 	   to another output device */
+-	ms->w->updateAttributes (CompStackingUpdateModeNone);
++	/* also raise on alt-click when raise on click is disabled */
++	bool raiseOnClick = screen->getOption ("raise_on_click")->value ().b ();
++	if (! raiseOnClick && ! ms->hasMoved)
++	    ms->w->updateAttributes (CompStackingUpdateModeAboveFullscreen);
++	else
++	    ms->w->updateAttributes (CompStackingUpdateModeNone);
+ 
+ 	ms->w->ungrabNotify ();
+ 
+@@ -504,6 +511,8 @@
+ 
+ 	    ms->x -= dx;
+ 	    ms->y -= dy;
++
++	    ms->hasMoved = true;
+ 	}
+     }
+ }
+Index: fix-881329/plugins/move/src/move.h
+===================================================================
+--- fix-881329.orig/plugins/move/src/move.h	2011-10-25 11:55:52.215836933 +0200
++++ fix-881329/plugins/move/src/move.h	2011-10-25 11:56:01.683903132 +0200
+@@ -90,6 +90,8 @@
+ 	bool hasCompositing;
+ 
+ 	bool yConstrained;
++
++	bool hasMoved;
+ };
+ 
+ class MoveWindow :

=== added file 'debian/patches/fix-883383.patch'
--- debian/patches/fix-883383.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/fix-883383.patch	2011-10-29 09:07:25 +0000
@@ -0,0 +1,77 @@
+Index: fix-883383/unity/unity_window_decorator/src/events.c
+===================================================================
+--- fix-883383.orig/unity/unity_window_decorator/src/events.c	2011-10-29 10:22:29.079644323 +0200
++++ fix-883383/unity/unity_window_decorator/src/events.c	2011-10-29 10:22:31.631675000 +0200
+@@ -450,7 +450,8 @@
+ 	    last_button_x	= gtkwd_event->x;
+ 	    last_button_y	= gtkwd_event->y;
+ 
+-	    restack_window (win, Above);
++	    if (raise_on_click)
++		restack_window (win, Above);
+ 
+ 	    move_resize_window (win, WM_MOVERESIZE_MOVE, gtkwd_event);
+ 	}
+Index: fix-883383/unity/unity_window_decorator/src/gtk-window-decorator.c
+===================================================================
+--- fix-883383.orig/unity/unity_window_decorator/src/gtk-window-decorator.c	2011-10-29 10:22:29.099644474 +0200
++++ fix-883383/unity/unity_window_decorator/src/gtk-window-decorator.c	2011-10-29 10:22:31.631675000 +0200
+@@ -25,6 +25,8 @@
+ 
+ double decoration_alpha = 0.5;
+ 
++gboolean raise_on_click = TRUE;
++
+ #define SWITCHER_SPACE 40
+ 
+ decor_extents_t _shadow_extents      = { 0, 0, 0, 0 };
+Index: fix-883383/unity/unity_window_decorator/src/gtk-window-decorator.h
+===================================================================
+--- fix-883383.orig/unity/unity_window_decorator/src/gtk-window-decorator.h	2011-10-29 10:22:29.123644654 +0200
++++ fix-883383/unity/unity_window_decorator/src/gtk-window-decorator.h	2011-10-29 10:22:31.631675000 +0200
+@@ -97,6 +97,9 @@
+ #define COMPIZ_RIGHT_CLICK_TITLEBAR_KEY	       \
+ METACITY_GCONF_DIR "/action_right_click_titlebar"
+ 
++#define COMPIZ_RAISE_ON_CLICK_KEY \
++METACITY_GCONF_DIR "/raise_on_click"
++
+ #define COMPIZ_GCONF_DIR1 "/apps/compiz/plugins/decoration/allscreens/options"
+ 
+ #define COMPIZ_SHADOW_RADIUS_KEY \
+@@ -243,6 +246,8 @@
+ extern gboolean minimal;
+ extern double decoration_alpha;
+ 
++extern gboolean raise_on_click;
++
+ #define SWITCHER_SPACE 40
+ 
+ extern decor_extents_t _shadow_extents;
+Index: fix-883383/unity/unity_window_decorator/src/settings.c
+===================================================================
+--- fix-883383.orig/unity/unity_window_decorator/src/settings.c	2011-10-29 10:22:29.151644865 +0200
++++ fix-883383/unity/unity_window_decorator/src/settings.c	2011-10-29 10:22:31.631675000 +0200
+@@ -402,6 +402,12 @@
+ 				       &right_click_action,
+ 				       RIGHT_CLICK_ACTION_DEFAULT);
+     }
++    else if (strcmp (key, COMPIZ_RAISE_ON_CLICK_KEY) == 0)
++    {
++	raise_on_click = gconf_client_get_bool (client,
++						COMPIZ_RAISE_ON_CLICK_KEY,
++						NULL);
++    }
+     else if (strcmp (key, WHEEL_ACTION_KEY) == 0)
+     {
+ 	wheel_action_changed (client);
+@@ -555,6 +561,9 @@
+ 				   RIGHT_CLICK_ACTION_DEFAULT);
+     wheel_action_changed (gconf);
+     blur_settings_changed (gconf);
++    raise_on_click = gconf_client_get_bool (gconf,
++					    COMPIZ_RAISE_ON_CLICK_KEY,
++					    NULL);
+ #endif
+ 
+     (*theme_update_border_extents) (text_height);

=== modified file 'debian/patches/series'
--- debian/patches/series	2011-10-12 10:44:49 +0000
+++ debian/patches/series	2011-10-29 09:07:25 +0000
@@ -12,3 +12,5 @@
 fix-832150.patch
 fix-864478.patch
 fix-864330.patch
+fix-881329.patch
+fix-883383.patch

=== modified file 'plugins/move/src/move.cpp'
--- plugins/move/src/move.cpp	2011-10-12 10:44:49 +0000
+++ plugins/move/src/move.cpp	2011-10-29 09:07:25 +0000
@@ -153,6 +153,8 @@
 		if (mw->gWindow)
 		mw->gWindow->glPaintSetEnabled (mw, true);
 	    }
+
+	    ms->hasMoved = false;
 	}
     }
 
@@ -177,7 +179,12 @@
 	/* update window attributes as window constraints may have
 	   changed - needed e.g. if a maximized window was moved
 	   to another output device */
-	ms->w->updateAttributes (CompStackingUpdateModeNone);
+	/* also raise on alt-click when raise on click is disabled */
+	bool raiseOnClick = screen->getOption ("raise_on_click")->value ().b ();
+	if (! raiseOnClick && ! ms->hasMoved)
+	    ms->w->updateAttributes (CompStackingUpdateModeAboveFullscreen);
+	else
+	    ms->w->updateAttributes (CompStackingUpdateModeNone);
 
 	ms->w->ungrabNotify ();
 
@@ -504,6 +511,8 @@
 
 	    ms->x -= dx;
 	    ms->y -= dy;
+
+	    ms->hasMoved = true;
 	}
     }
 }

=== modified file 'plugins/move/src/move.h'
--- plugins/move/src/move.h	2011-09-28 14:15:21 +0000
+++ plugins/move/src/move.h	2011-10-29 09:07:25 +0000
@@ -90,6 +90,8 @@
 	bool hasCompositing;
 
 	bool yConstrained;
+
+	bool hasMoved;
 };
 
 class MoveWindow :

=== modified file 'unity/unity_window_decorator/src/events.c'
--- unity/unity_window_decorator/src/events.c	2011-09-28 14:15:21 +0000
+++ unity/unity_window_decorator/src/events.c	2011-10-29 09:07:25 +0000
@@ -450,7 +450,8 @@
 	    last_button_x	= gtkwd_event->x;
 	    last_button_y	= gtkwd_event->y;
 
-	    restack_window (win, Above);
+	    if (raise_on_click)
+		restack_window (win, Above);
 
 	    move_resize_window (win, WM_MOVERESIZE_MOVE, gtkwd_event);
 	}

=== modified file 'unity/unity_window_decorator/src/gtk-window-decorator.c'
--- unity/unity_window_decorator/src/gtk-window-decorator.c	2011-08-23 18:19:11 +0000
+++ unity/unity_window_decorator/src/gtk-window-decorator.c	2011-10-29 09:07:25 +0000
@@ -25,6 +25,8 @@
 
 double decoration_alpha = 0.5;
 
+gboolean raise_on_click = TRUE;
+
 #define SWITCHER_SPACE 40
 
 decor_extents_t _shadow_extents      = { 0, 0, 0, 0 };

=== modified file 'unity/unity_window_decorator/src/gtk-window-decorator.h'
--- unity/unity_window_decorator/src/gtk-window-decorator.h	2011-08-23 18:19:11 +0000
+++ unity/unity_window_decorator/src/gtk-window-decorator.h	2011-10-29 09:07:25 +0000
@@ -97,6 +97,9 @@
 #define COMPIZ_RIGHT_CLICK_TITLEBAR_KEY	       \
 METACITY_GCONF_DIR "/action_right_click_titlebar"
 
+#define COMPIZ_RAISE_ON_CLICK_KEY \
+METACITY_GCONF_DIR "/raise_on_click"
+
 #define COMPIZ_GCONF_DIR1 "/apps/compiz/plugins/decoration/allscreens/options"
 
 #define COMPIZ_SHADOW_RADIUS_KEY \
@@ -243,6 +246,8 @@
 extern gboolean minimal;
 extern double decoration_alpha;
 
+extern gboolean raise_on_click;
+
 #define SWITCHER_SPACE 40
 
 extern decor_extents_t _shadow_extents;

=== modified file 'unity/unity_window_decorator/src/settings.c'
--- unity/unity_window_decorator/src/settings.c	2011-08-23 18:19:11 +0000
+++ unity/unity_window_decorator/src/settings.c	2011-10-29 09:07:25 +0000
@@ -402,6 +402,12 @@
 				       &right_click_action,
 				       RIGHT_CLICK_ACTION_DEFAULT);
     }
+    else if (strcmp (key, COMPIZ_RAISE_ON_CLICK_KEY) == 0)
+    {
+	raise_on_click = gconf_client_get_bool (client,
+						COMPIZ_RAISE_ON_CLICK_KEY,
+						NULL);
+    }
     else if (strcmp (key, WHEEL_ACTION_KEY) == 0)
     {
 	wheel_action_changed (client);
@@ -555,6 +561,9 @@
 				   RIGHT_CLICK_ACTION_DEFAULT);
     wheel_action_changed (gconf);
     blur_settings_changed (gconf);
+    raise_on_click = gconf_client_get_bool (gconf,
+					    COMPIZ_RAISE_ON_CLICK_KEY,
+					    NULL);
 #endif
 
     (*theme_update_border_extents) (text_height);