Merge lp:~jamespharaoh/ubuntu/oneiric/compiz/fix-881329 into lp:ubuntu/oneiric/compiz

[James Pharaoh]

[Sebastien Bacher (seb128)]

Thank you for your work, it seems the diff list quite some other patches that already got uploaded, do you think you could target the merge request against lp:ubuntu/compiz rather than the oneiric serie?

[Sebastien Bacher (seb128)]

seems like you did a request for precise on https://code.launchpad.net/~jamespharaoh/ubuntu/precise/compiz/fix-881329/+merge/80314 which got approved, did you do an upstream merge request as commented by Sam on the other review?
If you want to do a sru for the fix it should first land in trunk and then you should do a merge request against the oneiric-proposed serie rather than the oneiric one

thank you for working on this!

[Sebastien Bacher (seb128)]

let we know if you need help to get that done btw

[Martin Pitt (pitti)]

Setting to "work in progress" to get it off the sponsoring queue, as this is currently blocked on the precise MP (https://code.launchpad.net/~jamespharaoh/ubuntu/precise/compiz/fix-881329/+merge/80314). Thanks!

[James Pharaoh (jamespharaoh)]

Sorry for taking ages but I'm trying to do this now. I think I do need
help. I have checked out lp:compiz and can see just a debian
directory. I assume I need to get the upstream package from somewhere
and create a patch for it using quilt or something. But I'm not sure
which upstream version I should get or how any of that is managed.

Is there some documentation for this kind of thing somewhere? I've had
a look but all I can find is the documentation I used before which
looks at packages which already have the upstream code expanded into
them. Are these generated automatically or something?

2011/11/24 Sebastien Bacher <email address hidden>:
> let we know if you need help to get that done btw
> --
> https://code.launchpad.net/~jamespharaoh/ubuntu/oneiric/compiz/fix-881329/+merge/82044
> You are the owner of lp:~jamespharaoh/ubuntu/oneiric/compiz/fix-881329.

--
James Pharaoh
Pharaoh Systems Limited
http://phsys.co.uk/contact

Unmerged revisions

253. By James Pharaoh on 2011-10-25

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

252. By Didier Roche-Tolomelli on 2011-10-12

* debian/patches/fix-864330.patch:
  - fix windows which can have towed moving (LP: #864330)
* debian/patches/fix-864478.patch:
  - Window shading is broken (LP: #864478)

251. By Didier Roche-Tolomelli on 2011-10-06

* debian/control:
  - don't suggest nvidia-glx, it's part of the old initial packaging
    and probably a bad hint on non nvidia system (LP: #844218)
* Cherry-pick upstream patches:
  - Windows should not automatically be focused when opened if the focus
    is on another application (LP: #748840)
  - Launcher - If a spread contains minimised windows, when the spread
    exits, the minimised windows momentarily appear on the desktop
    before disappearing (LP: #863328)
  - reproducible stacking bug in compiz (LP: #869316)
  - Click-dragging a window that's stacked above a fullscreen window will
    cause it to go underneath the fullscreen window (LP: #869919)
  - sometimes the keyboard input doesn't go to the apparently focussed
    dialog (LP: #869967)
  - Opening mumble can cause it to be stacked above the dash if you
    open the dash at the same time (LP: #865863)
  - Sometimes configure events are missed and windows move slow as a result
    (LP: #866752)
  - Workaround ubuntu desktop unity. Mouse at the left side doesn't reveal
    launcher (LP: #832150)

=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2011-11-12 05:42:36 +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-11-12 05:42:36 +0000
@@ -0,0 +1,1 @@
+series

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2011-10-04 13:49:01 +0000
+++ .pc/applied-patches	2011-11-12 05:42:36 +0000
@@ -3,3 +3,13 @@
 03_fix_configureframe.patch
 04_fix_insertServerWindow_crash.patch
 05_fix_reconfigureXWindow_crash.patch
+fix-748840.patch
+fix-863328.patch
+fix-865863.patch
+fix-866752.patch
+fix-869316_869919.patch
+fix-869967.patch
+fix-832150.patch
+fix-864478.patch
+fix-864330.patch
+fix-881329.patch

=== added directory '.pc/fix-748840.patch'
=== added directory '.pc/fix-748840.patch/src'
=== added file '.pc/fix-748840.patch/src/window.cpp'
--- .pc/fix-748840.patch/src/window.cpp	1970-01-01 00:00:00 +0000
+++ .pc/fix-748840.patch/src/window.cpp	2011-11-12 05:42:36 +0000
@@ -0,0 +1,6916 @@
+/*
+ * 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 <compiz.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <X11/Xproto.h>
+#include <X11/extensions/shape.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <assert.h>
+#include <math.h>
+
+#include <boost/bind.hpp>
+
+#include <core/core.h>
+#include <core/icon.h>
+#include <core/atoms.h>
+#include "privatewindow.h"
+#include "privatescreen.h"
+#include "privatestackdebugger.h"
+
+PluginClassStorage::Indices windowPluginClassIndices (0);
+
+unsigned int
+CompWindow::allocPluginClassIndex ()
+{
+    unsigned int i = PluginClassStorage::allocatePluginClassIndex (windowPluginClassIndices);
+
+    foreach (CompWindow *w, screen->windows ())
+	if (windowPluginClassIndices.size () != w->pluginClasses.size ())
+	    w->pluginClasses.resize (windowPluginClassIndices.size ());
+
+    return i;
+}
+
+void
+CompWindow::freePluginClassIndex (unsigned int index)
+{
+    PluginClassStorage::freePluginClassIndex (windowPluginClassIndices, index);
+
+    foreach (CompWindow *w, ::screen->windows ())
+	if (windowPluginClassIndices.size () != w->pluginClasses.size ())
+	    w->pluginClasses.resize (windowPluginClassIndices.size ());
+}
+
+bool
+PrivateWindow::isAncestorTo (CompWindow *transient,
+			     CompWindow *ancestor)
+{
+    if (transient->priv->transientFor)
+    {
+	if (transient->priv->transientFor == ancestor->priv->id)
+	    return true;
+
+	transient = screen->findWindow (transient->priv->transientFor);
+	if (transient)
+	    return isAncestorTo (transient, ancestor);
+    }
+
+    return false;
+}
+
+void
+PrivateWindow::recalcNormalHints ()
+{
+    int maxSize;
+
+#warning fixme to max Texture size
+    maxSize  = MAXSHORT;
+    maxSize -= serverGeometry.border () * 2;
+
+    sizeHints.x      = serverGeometry.x ();
+    sizeHints.y      = serverGeometry.y ();
+    sizeHints.width  = serverGeometry.width ();
+    sizeHints.height = serverGeometry.height ();
+
+    if (!(sizeHints.flags & PBaseSize))
+    {
+	if (sizeHints.flags & PMinSize)
+	{
+	    sizeHints.base_width  = sizeHints.min_width;
+	    sizeHints.base_height = sizeHints.min_height;
+	}
+	else
+	{
+	    sizeHints.base_width  = 0;
+	    sizeHints.base_height = 0;
+	}
+
+	sizeHints.flags |= PBaseSize;
+    }
+
+    if (!(sizeHints.flags & PMinSize))
+    {
+	sizeHints.min_width  = sizeHints.base_width;
+	sizeHints.min_height = sizeHints.base_height;
+	sizeHints.flags |= PMinSize;
+    }
+
+    if (!(sizeHints.flags & PMaxSize))
+    {
+	sizeHints.max_width  = 65535;
+	sizeHints.max_height = 65535;
+	sizeHints.flags |= PMaxSize;
+    }
+
+    if (sizeHints.max_width < sizeHints.min_width)
+	sizeHints.max_width = sizeHints.min_width;
+
+    if (sizeHints.max_height < sizeHints.min_height)
+	sizeHints.max_height = sizeHints.min_height;
+
+    if (sizeHints.min_width < 1)
+	sizeHints.min_width = 1;
+
+    if (sizeHints.max_width < 1)
+	sizeHints.max_width = 1;
+
+    if (sizeHints.min_height < 1)
+	sizeHints.min_height = 1;
+
+    if (sizeHints.max_height < 1)
+	sizeHints.max_height = 1;
+
+    if (sizeHints.max_width > maxSize)
+	sizeHints.max_width = maxSize;
+
+    if (sizeHints.max_height > maxSize)
+	sizeHints.max_height = maxSize;
+
+    if (sizeHints.min_width > maxSize)
+	sizeHints.min_width = maxSize;
+
+    if (sizeHints.min_height > maxSize)
+	sizeHints.min_height = maxSize;
+
+    if (sizeHints.base_width > maxSize)
+	sizeHints.base_width = maxSize;
+
+    if (sizeHints.base_height > maxSize)
+	sizeHints.base_height = maxSize;
+
+    if (sizeHints.flags & PResizeInc)
+    {
+	if (sizeHints.width_inc == 0)
+	    sizeHints.width_inc = 1;
+
+	if (sizeHints.height_inc == 0)
+	    sizeHints.height_inc = 1;
+    }
+    else
+    {
+	sizeHints.width_inc  = 1;
+	sizeHints.height_inc = 1;
+	sizeHints.flags |= PResizeInc;
+    }
+
+    if (sizeHints.flags & PAspect)
+    {
+	/* don't divide by 0 */
+	if (sizeHints.min_aspect.y < 1)
+	    sizeHints.min_aspect.y = 1;
+
+	if (sizeHints.max_aspect.y < 1)
+	    sizeHints.max_aspect.y = 1;
+    }
+    else
+    {
+	sizeHints.min_aspect.x = 1;
+	sizeHints.min_aspect.y = 65535;
+	sizeHints.max_aspect.x = 65535;
+	sizeHints.max_aspect.y = 1;
+	sizeHints.flags |= PAspect;
+    }
+
+    if (!(sizeHints.flags & PWinGravity))
+    {
+	sizeHints.win_gravity = NorthWestGravity;
+	sizeHints.flags |= PWinGravity;
+    }
+}
+
+void
+PrivateWindow::updateNormalHints ()
+{
+    Status status;
+    long   supplied;
+
+    status = XGetWMNormalHints (screen->dpy (), priv->id,
+				&priv->sizeHints, &supplied);
+
+    if (!status)
+	priv->sizeHints.flags = 0;
+
+    priv->recalcNormalHints ();
+}
+
+void
+PrivateWindow::updateWmHints ()
+{
+    XWMHints *newHints;
+    long     dFlags = 0;
+    bool     iconChanged = false;
+
+    if (hints)
+	dFlags = hints->flags;
+
+    inputHint = true;
+
+    newHints = XGetWMHints (screen->dpy (), id);
+    if (newHints)
+    {
+	dFlags ^= newHints->flags;
+
+	if (newHints->flags & InputHint)
+	    inputHint = newHints->input;
+
+	if (hints)
+	{
+	    if ((newHints->flags & IconPixmapHint) &&
+		(hints->icon_pixmap != newHints->icon_pixmap))
+	    {
+		iconChanged = true;
+	    }
+	    else if ((newHints->flags & IconMaskHint) &&
+		     (hints->icon_mask != newHints->icon_mask))
+	    {
+		iconChanged = true;
+	    }
+	}
+    }
+
+    iconChanged |= (dFlags & (IconPixmapHint | IconMaskHint));
+
+    if (iconChanged)
+	freeIcons ();
+
+    if (hints)
+	XFree (hints);
+
+    hints = newHints;
+}
+
+void
+PrivateWindow::updateClassHints ()
+{
+    XClassHint classHint;
+    int	       status;
+
+    if (priv->resName)
+    {
+	free (priv->resName);
+	priv->resName = NULL;
+    }
+
+    if (priv->resClass)
+    {
+	free (priv->resClass);
+	priv->resClass = NULL;
+    }
+
+    status = XGetClassHint (screen->dpy (),
+			    priv->id, &classHint);
+    if (status)
+    {
+	if (classHint.res_name)
+	{
+	    priv->resName = strdup (classHint.res_name);
+	    XFree (classHint.res_name);
+	}
+
+	if (classHint.res_class)
+	{
+	    priv->resClass = strdup (classHint.res_class);
+	    XFree (classHint.res_class);
+	}
+    }
+}
+
+void
+PrivateWindow::updateTransientHint ()
+{
+    Window transientFor;
+    Status status;
+
+    priv->transientFor = None;
+
+    status = XGetTransientForHint (screen->dpy (),
+				   priv->id, &transientFor);
+
+    if (status)
+    {
+	CompWindow *ancestor;
+
+	ancestor = screen->findWindow (transientFor);
+	if (!ancestor)
+	    return;
+
+	/* protect against circular transient dependencies */
+	if (transientFor == priv->id ||
+	    PrivateWindow::isAncestorTo (ancestor, window))
+	    return;
+
+	priv->transientFor = transientFor;
+    }
+}
+
+void
+PrivateWindow::updateIconGeometry ()
+{
+    Atom	  actual;
+    int		  result, format;
+    unsigned long n, left;
+    unsigned char *data;
+
+    priv->iconGeometry.setGeometry (0, 0, 0, 0);
+
+    result = XGetWindowProperty (screen->dpy (), priv->id,
+				 Atoms::wmIconGeometry,
+				 0L, 1024L, False, XA_CARDINAL,
+				 &actual, &format, &n, &left, &data);
+
+    if (result == Success && data)
+    {
+	if (n == 4)
+	{
+	    unsigned long *geometry = (unsigned long *) data;
+
+	    priv->iconGeometry.setX (geometry[0]);
+	    priv->iconGeometry.setY (geometry[1]);
+	    priv->iconGeometry.setWidth (geometry[2]);
+	    priv->iconGeometry.setHeight (geometry[3]);
+	}
+
+	XFree (data);
+    }
+}
+
+Window
+PrivateWindow::getClientLeaderOfAncestor ()
+{
+    if (transientFor)
+    {
+	CompWindow *w = screen->findWindow (transientFor);
+	if (w)
+	{
+	    if (w->priv->clientLeader)
+		return w->priv->clientLeader;
+
+	    return w->priv->getClientLeaderOfAncestor ();
+	}
+    }
+
+    return None;
+}
+
+Window
+PrivateWindow::getClientLeader ()
+{
+    Atom	  actual;
+    int		  result, format;
+    unsigned long n, left;
+    unsigned char *data;
+
+    result = XGetWindowProperty (screen->dpy (), priv->id,
+				 Atoms::wmClientLeader,
+				 0L, 1L, False, XA_WINDOW, &actual, &format,
+				 &n, &left, &data);
+
+    if (result == Success && data)
+    {
+	Window win = None;
+
+	if (n)
+	    memcpy (&win, data, sizeof (Window));
+
+	XFree ((void *) data);
+
+	if (win)
+	    return win;
+    }
+
+    return priv->getClientLeaderOfAncestor ();
+}
+
+char *
+PrivateWindow::getStartupId ()
+{
+    Atom	  actual;
+    int		  result, format;
+    unsigned long n, left;
+    unsigned char *data;
+
+    result = XGetWindowProperty (screen->dpy (), priv->id,
+				 Atoms::startupId,
+				 0L, 1024L, False,
+				 Atoms::utf8String,
+				 &actual, &format,
+				 &n, &left, &data);
+
+    if (result == Success && data)
+    {
+	char *id = NULL;
+
+	if (n)
+	    id = strdup ((char *) data);
+	XFree ((void *) data);
+
+	return id;
+    }
+
+    return NULL;
+}
+
+void
+PrivateWindow::setFullscreenMonitors (CompFullscreenMonitorSet *monitors)
+{
+    bool         hadFsMonitors = fullscreenMonitorsSet;
+    unsigned int outputs = screen->outputDevs ().size ();
+
+    fullscreenMonitorsSet = false;
+
+    if (monitors                   &&
+	(unsigned int) monitors->left   < outputs &&
+	(unsigned int) monitors->right  < outputs &&
+	(unsigned int) monitors->top    < outputs &&
+	(unsigned int) monitors->bottom < outputs)
+    {
+	CompRect fsRect (screen->outputDevs ()[monitors->left].x1 (),
+			 screen->outputDevs ()[monitors->top].y1 (),
+			 screen->outputDevs ()[monitors->right].x2 (),
+			 screen->outputDevs ()[monitors->bottom].y2 ());
+
+	if (fsRect.x1 () < fsRect.x2 () && fsRect.y1 () < fsRect.y2 ())
+	{
+	    fullscreenMonitorsSet = true;
+	    fullscreenMonitorRect = fsRect;
+	}
+    }
+
+    if (fullscreenMonitorsSet)
+    {
+	long data[4];
+
+	data[0] = monitors->top;
+	data[1] = monitors->bottom;
+	data[2] = monitors->left;
+	data[3] = monitors->right;
+
+	XChangeProperty (screen->dpy (), id, Atoms::wmFullscreenMonitors,
+			 XA_CARDINAL, 32, PropModeReplace,
+			 (unsigned char *) data, 4);
+    }
+    else if (hadFsMonitors)
+    {
+	XDeleteProperty (screen->dpy (), id, Atoms::wmFullscreenMonitors);
+    }
+
+    if (state & CompWindowStateFullscreenMask)
+	if (fullscreenMonitorsSet || hadFsMonitors)
+	    window->updateAttributes (CompStackingUpdateModeNone);
+}
+
+void
+CompWindow::changeState (unsigned int newState)
+{
+    unsigned int oldState;
+
+    if (priv->state == newState)
+	return;
+
+    oldState = priv->state;
+    priv->state = newState;
+
+    recalcType ();
+    recalcActions ();
+
+    if (priv->managed)
+	screen->priv->setWindowState (priv->state, priv->id);
+
+    stateChangeNotify (oldState);
+    screen->matchPropertyChanged (this);
+}
+
+static void
+setWindowActions (CompScreen   *s,
+		  unsigned int actions,
+		  Window       id)
+{
+    Atom data[32];
+    int	 i = 0;
+
+    if (actions & CompWindowActionMoveMask)
+	data[i++] = Atoms::winActionMove;
+    if (actions & CompWindowActionResizeMask)
+	data[i++] = Atoms::winActionResize;
+    if (actions & CompWindowActionStickMask)
+	data[i++] = Atoms::winActionStick;
+    if (actions & CompWindowActionMinimizeMask)
+	data[i++] = Atoms::winActionMinimize;
+    if (actions & CompWindowActionMaximizeHorzMask)
+	data[i++] = Atoms::winActionMaximizeHorz;
+    if (actions & CompWindowActionMaximizeVertMask)
+	data[i++] = Atoms::winActionMaximizeVert;
+    if (actions & CompWindowActionFullscreenMask)
+	data[i++] = Atoms::winActionFullscreen;
+    if (actions & CompWindowActionCloseMask)
+	data[i++] = Atoms::winActionClose;
+    if (actions & CompWindowActionShadeMask)
+	data[i++] = Atoms::winActionShade;
+    if (actions & CompWindowActionChangeDesktopMask)
+	data[i++] = Atoms::winActionChangeDesktop;
+    if (actions & CompWindowActionAboveMask)
+	data[i++] = Atoms::winActionAbove;
+    if (actions & CompWindowActionBelowMask)
+	data[i++] = Atoms::winActionBelow;
+
+    XChangeProperty (s->dpy (), id, Atoms::wmAllowedActions,
+		     XA_ATOM, 32, PropModeReplace,
+		     (unsigned char *) data, i);
+}
+
+void
+CompWindow::recalcActions ()
+{
+    unsigned int actions = 0;
+    unsigned int setActions, clearActions;
+
+    switch (priv->type) {
+    case CompWindowTypeFullscreenMask:
+    case CompWindowTypeNormalMask:
+	actions =
+	    CompWindowActionMaximizeHorzMask |
+	    CompWindowActionMaximizeVertMask |
+	    CompWindowActionFullscreenMask   |
+	    CompWindowActionMoveMask         |
+	    CompWindowActionResizeMask       |
+	    CompWindowActionStickMask        |
+	    CompWindowActionMinimizeMask     |
+	    CompWindowActionCloseMask	     |
+	    CompWindowActionChangeDesktopMask;
+	break;
+    case CompWindowTypeUtilMask:
+    case CompWindowTypeMenuMask:
+    case CompWindowTypeToolbarMask:
+	actions =
+	    CompWindowActionMoveMask   |
+	    CompWindowActionResizeMask |
+	    CompWindowActionStickMask  |
+	    CompWindowActionCloseMask  |
+	    CompWindowActionChangeDesktopMask;
+	break;
+    case CompWindowTypeDialogMask:
+    case CompWindowTypeModalDialogMask:
+	actions =
+	    CompWindowActionMaximizeHorzMask |
+	    CompWindowActionMaximizeVertMask |
+	    CompWindowActionMoveMask         |
+	    CompWindowActionResizeMask       |
+	    CompWindowActionStickMask        |
+	    CompWindowActionCloseMask        |
+	    CompWindowActionChangeDesktopMask;
+
+	/* allow minimization for dialog windows if they
+	   a) are not a transient (transients can be minimized
+	      with their parent)
+	   b) don't have the skip taskbar hint set (as those
+	      have no target to be minimized to)
+	*/
+	if (!priv->transientFor &&
+	    !(priv->state & CompWindowStateSkipTaskbarMask))
+	{
+	    actions |= CompWindowActionMinimizeMask;
+	}
+    default:
+	break;
+    }
+
+    if (priv->input.top)
+	actions |= CompWindowActionShadeMask;
+
+    actions |= (CompWindowActionAboveMask | CompWindowActionBelowMask);
+
+    switch (priv->wmType) {
+    case CompWindowTypeNormalMask:
+	actions |= CompWindowActionFullscreenMask |
+	           CompWindowActionMinimizeMask;
+    default:
+	break;
+    }
+
+    if (priv->sizeHints.min_width  == priv->sizeHints.max_width &&
+	priv->sizeHints.min_height == priv->sizeHints.max_height)
+	actions &= ~(CompWindowActionResizeMask	      |
+		     CompWindowActionMaximizeHorzMask |
+		     CompWindowActionMaximizeVertMask |
+		     CompWindowActionFullscreenMask);
+
+    if (!(priv->mwmFunc & MwmFuncAll))
+    {
+	if (!(priv->mwmFunc & MwmFuncResize))
+	    actions &= ~(CompWindowActionResizeMask	  |
+			 CompWindowActionMaximizeHorzMask |
+			 CompWindowActionMaximizeVertMask |
+			 CompWindowActionFullscreenMask);
+
+	if (!(priv->mwmFunc & MwmFuncMove))
+	    actions &= ~(CompWindowActionMoveMask	  |
+			 CompWindowActionMaximizeHorzMask |
+			 CompWindowActionMaximizeVertMask |
+			 CompWindowActionFullscreenMask);
+
+	if (!(priv->mwmFunc & MwmFuncIconify))
+	    actions &= ~CompWindowActionMinimizeMask;
+
+	if (!(priv->mwmFunc & MwmFuncClose))
+	    actions &= ~CompWindowActionCloseMask;
+    }
+
+    getAllowedActions (setActions, clearActions);
+    actions &= ~clearActions;
+    actions |= setActions;
+
+    if (actions != priv->actions)
+    {
+	priv->actions = actions;
+	setWindowActions (screen, actions, priv->id);
+    }
+}
+
+void
+CompWindow::getAllowedActions (unsigned int &setActions,
+			       unsigned int &clearActions)
+{
+    WRAPABLE_HND_FUNC (1, getAllowedActions, setActions, clearActions)
+
+    setActions   = 0;
+    clearActions = 0;
+}
+
+unsigned int
+CompWindow::constrainWindowState (unsigned int state,
+				  unsigned int actions)
+{
+    if (!(actions & CompWindowActionMaximizeHorzMask))
+	state &= ~CompWindowStateMaximizedHorzMask;
+
+    if (!(actions & CompWindowActionMaximizeVertMask))
+	state &= ~CompWindowStateMaximizedVertMask;
+
+    if (!(actions & CompWindowActionShadeMask))
+	state &= ~CompWindowStateShadedMask;
+
+    if (!(actions & CompWindowActionFullscreenMask))
+	state &= ~CompWindowStateFullscreenMask;
+
+    return state;
+}
+
+unsigned int
+PrivateWindow::windowTypeFromString (const char *str)
+{
+    if (strcasecmp (str, "desktop") == 0)
+	return CompWindowTypeDesktopMask;
+    else if (strcasecmp (str, "dock") == 0)
+	return CompWindowTypeDockMask;
+    else if (strcasecmp (str, "toolbar") == 0)
+	return CompWindowTypeToolbarMask;
+    else if (strcasecmp (str, "menu") == 0)
+	return CompWindowTypeMenuMask;
+    else if (strcasecmp (str, "utility") == 0)
+	return CompWindowTypeUtilMask;
+    else if (strcasecmp (str, "splash") == 0)
+	return CompWindowTypeSplashMask;
+    else if (strcasecmp (str, "dialog") == 0)
+	return CompWindowTypeDialogMask;
+    else if (strcasecmp (str, "normal") == 0)
+	return CompWindowTypeNormalMask;
+    else if (strcasecmp (str, "dropdownmenu") == 0)
+	return CompWindowTypeDropdownMenuMask;
+    else if (strcasecmp (str, "popupmenu") == 0)
+	return CompWindowTypePopupMenuMask;
+    else if (strcasecmp (str, "tooltip") == 0)
+	return CompWindowTypeTooltipMask;
+    else if (strcasecmp (str, "notification") == 0)
+	return CompWindowTypeNotificationMask;
+    else if (strcasecmp (str, "combo") == 0)
+	return CompWindowTypeComboMask;
+    else if (strcasecmp (str, "dnd") == 0)
+	return CompWindowTypeDndMask;
+    else if (strcasecmp (str, "modaldialog") == 0)
+	return CompWindowTypeModalDialogMask;
+    else if (strcasecmp (str, "fullscreen") == 0)
+	return CompWindowTypeFullscreenMask;
+    else if (strcasecmp (str, "unknown") == 0)
+	return CompWindowTypeUnknownMask;
+    else if (strcasecmp (str, "any") == 0)
+	return ~0;
+
+    return 0;
+}
+
+void
+CompWindow::recalcType ()
+{
+    unsigned int type;
+
+    type = priv->wmType;
+
+    if (!overrideRedirect () && priv->wmType == CompWindowTypeUnknownMask)
+	type = CompWindowTypeNormalMask;
+
+    if (priv->state & CompWindowStateFullscreenMask)
+	type = CompWindowTypeFullscreenMask;
+
+    if (type == CompWindowTypeNormalMask)
+    {
+	if (priv->transientFor)
+	    type = CompWindowTypeDialogMask;
+    }
+
+    if (type == CompWindowTypeDockMask &&
+	(priv->state & CompWindowStateBelowMask))
+    {
+	type = CompWindowTypeNormalMask;
+    }
+
+    if ((type & (CompWindowTypeNormalMask | CompWindowTypeDialogMask)) &&
+	(priv->state & CompWindowStateModalMask))
+    {
+	type = CompWindowTypeModalDialogMask;
+    }
+
+    priv->type = type;
+}
+
+
+void
+PrivateWindow::updateFrameWindow ()
+{
+    XWindowChanges xwc;
+    unsigned int   valueMask = CWX | CWY | CWWidth | CWHeight;
+
+    if (!serverFrame)
+	return;
+
+    /* Flush any changes made to serverFrameGeometry or serverGeometry to the server
+     * since there is a race condition where geometries will go out-of-sync with
+     * window movement */
+
+    window->syncPosition ();
+    if (serverInput.left || serverInput.right || serverInput.top || serverInput.bottom)
+    {
+	int	   bw = serverGeometry.border () * 2;
+
+	xwc.x      = serverGeometry.x () - serverInput.left;
+	xwc.y      = serverGeometry.y () - serverInput.top;
+	xwc.width  = serverGeometry.width () + serverInput.left + serverInput.right + bw;
+	xwc.height = serverGeometry.height () + serverInput.top  + serverInput.bottom + bw;
+
+	if (shaded)
+	    height = serverInput.top + serverInput.bottom;
+
+	if (serverFrameGeometry.x () == xwc.x)
+	    valueMask &= ~(CWX);
+	else
+	    serverFrameGeometry.setX (xwc.x);
+
+	if (serverFrameGeometry.y ()  == xwc.y)
+	    valueMask &= ~(CWY);
+	else
+	    serverFrameGeometry.setY (xwc.y);
+
+	if (serverFrameGeometry.width () == xwc.width)
+	    valueMask &= ~(CWWidth);
+	else
+	    serverFrameGeometry.setWidth (xwc.width);
+
+	if (serverFrameGeometry.height () == xwc.height)
+	    valueMask &= ~(CWHeight);
+	else
+	    serverFrameGeometry.setHeight (xwc.height);
+
+	addPendingConfigure (xwc, valueMask);
+
+
+	/* Geometry is the same, so we're not going to get a ConfigureNotify
+	 * event when the window is configured, which means that other plugins
+	 * won't know that the client, frame and wrapper windows got shifted
+	 * around (and might result in display corruption, eg in OpenGL */
+	if (valueMask == 0)
+	{
+	    XConfigureEvent xev;
+	    XWindowAttributes attrib;
+	    unsigned int      nchildren = 0;
+	    Window            rootRet = 0, parentRet = 0;
+	    Window            *children = NULL;
+
+	    xev.type   = ConfigureNotify;
+	    xev.event  = screen->root ();
+	    xev.window = priv->serverFrame;
+
+	    XGrabServer (screen->dpy ());
+
+	    if (XGetWindowAttributes (screen->dpy (), priv->serverFrame, &attrib))
+	    {
+		xev.x	     = attrib.x;
+		xev.y	     = attrib.y;
+		xev.width	     = attrib.width;
+		xev.height	     = attrib.height;
+		xev.border_width = attrib.border_width;
+		xev.above = None;
+
+		/* We need to ensure that the stacking order is
+		 * based on the current server stacking order so
+		 * find the sibling to this window's frame in the
+		 * server side stack and stack above that */
+		XQueryTree (screen->dpy (), screen->root (), &rootRet, &parentRet, &children, &nchildren);
+
+		if (nchildren)
+		{
+		    for (unsigned int i = 0; i < nchildren; i++)
+		    {
+			if (i + 1 == nchildren ||
+				children[i + 1] == ROOTPARENT (window))
+			{
+			    xev.above = children[i];
+			    break;
+			}
+		    }
+		}
+
+		if (children)
+		    XFree (children);
+
+		if (!xev.above)
+		    xev.above = (window->serverPrev) ? ROOTPARENT (window->serverPrev) : None;
+
+		xev.override_redirect = priv->attrib.override_redirect;
+
+	    }
+
+	    XSendEvent (screen->dpy (), screen->root (), false,
+			SubstructureNotifyMask, (XEvent *) &xev);
+
+	    XUngrabServer (screen->dpy ());
+	    XSync (screen->dpy (), false);
+	}
+	else
+	    XConfigureWindow (screen->dpy (), serverFrame, valueMask, &xwc);
+	if (shaded)
+	{
+	    XUnmapWindow (screen->dpy (), wrapper);
+	}
+	else
+	{
+	    XMapWindow (screen->dpy (), wrapper);
+	    XMoveResizeWindow (screen->dpy (), wrapper, serverInput.left, serverInput.top,
+			       serverGeometry.width (), serverGeometry.height ());
+	}
+	XMoveResizeWindow (screen->dpy (), id, 0, 0,
+			   serverGeometry.width (), serverGeometry.height ());
+	window->sendConfigureNotify ();
+	window->windowNotify (CompWindowNotifyFrameUpdate);
+    }
+    else
+    {
+	int	   bw = serverGeometry.border () * 2;
+
+	xwc.x      = serverGeometry.x ();
+	xwc.y      = serverGeometry.y ();
+	xwc.width  = serverGeometry.width () + bw;
+	xwc.height = serverGeometry.height () + bw;
+
+	if (shaded)
+	    height = 0;
+
+	if (serverFrameGeometry.x () == xwc.x)
+	    valueMask &= ~(CWX);
+	else
+	    serverFrameGeometry.setX (xwc.x);
+
+	if (serverFrameGeometry.y ()  == xwc.y)
+	    valueMask &= ~(CWY);
+	else
+	    serverFrameGeometry.setY (xwc.y);
+
+	if (serverFrameGeometry.width () == xwc.width)
+	    valueMask &= ~(CWWidth);
+	else
+	    serverFrameGeometry.setWidth (xwc.width);
+
+	if (serverFrameGeometry.height () == xwc.height)
+	    valueMask &= ~(CWHeight);
+	else
+	    serverFrameGeometry.setHeight (xwc.height);
+
+	addPendingConfigure (xwc, valueMask);
+
+
+	/* Geometry is the same, so we're not going to get a ConfigureNotify
+	 * event when the window is configured, which means that other plugins
+	 * won't know that the client, frame and wrapper windows got shifted
+	 * around (and might result in display corruption, eg in OpenGL */
+	if (valueMask == 0)
+	{
+	    XConfigureEvent xev;
+	    XWindowAttributes attrib;
+	    unsigned int      nchildren = 0;
+	    Window            rootRet = 0, parentRet = 0;
+	    Window            *children = NULL;
+
+	    xev.type   = ConfigureNotify;
+	    xev.event  = screen->root ();
+	    xev.window = priv->serverFrame;
+
+	    XGrabServer (screen->dpy ());
+
+	    if (XGetWindowAttributes (screen->dpy (), priv->serverFrame, &attrib))
+	    {
+		xev.x	     = attrib.x;
+		xev.y	     = attrib.y;
+		xev.width	     = attrib.width;
+		xev.height	     = attrib.height;
+		xev.border_width = attrib.border_width;
+		xev.above = None;
+
+		/* We need to ensure that the stacking order is
+		 * based on the current server stacking order so
+		 * find the sibling to this window's frame in the
+		 * server side stack and stack above that */
+		XQueryTree (screen->dpy (), screen->root (), &rootRet, &parentRet, &children, &nchildren);
+
+		if (nchildren)
+		{
+		    for (unsigned int i = 0; i < nchildren; i++)
+		    {
+			if (i + 1 == nchildren ||
+				children[i + 1] == ROOTPARENT (window))
+			{
+			    xev.above = children[i];
+			    break;
+			}
+		    }
+		}
+
+		if (children)
+		    XFree (children);
+
+		if (!xev.above)
+		    xev.above = (window->serverPrev) ? ROOTPARENT (window->serverPrev) : None;
+
+		xev.override_redirect = priv->attrib.override_redirect;
+
+	    }
+
+	    XSendEvent (screen->dpy (), screen->root (), false,
+			SubstructureNotifyMask, (XEvent *) &xev);
+
+	    XUngrabServer (screen->dpy ());
+	    XSync (screen->dpy (), false);
+	}
+	else
+	    XConfigureWindow (screen->dpy (), serverFrame, valueMask, &xwc);
+
+	if (shaded)
+	{
+	    XUnmapWindow (screen->dpy (), wrapper);
+	}
+	else
+	{
+	    XMapWindow (screen->dpy (), wrapper);
+	    XMoveResizeWindow (screen->dpy (), wrapper, 0, 0,
+			       serverGeometry.width (), serverGeometry.height ());
+	}
+
+	XMoveResizeWindow (screen->dpy (), id, 0, 0,
+			   serverGeometry.width (), serverGeometry.height ());
+	window->sendConfigureNotify ();
+	window->windowNotify (CompWindowNotifyFrameUpdate);
+    }
+    window->recalcActions ();
+}
+
+
+
+void
+CompWindow::updateWindowOutputExtents ()
+{
+    CompWindowExtents output (priv->output);
+
+    getOutputExtents (output);
+
+    if (output.left   != priv->output.left  ||
+	output.right  != priv->output.right ||
+	output.top    != priv->output.top   ||
+	output.bottom != priv->output.bottom)
+    {
+	priv->output = output;
+
+	resizeNotify (0, 0, 0, 0);
+    }
+}
+
+void
+CompWindow::getOutputExtents (CompWindowExtents& output)
+{
+    WRAPABLE_HND_FUNC (0, getOutputExtents, output)
+
+    output.left   = 0;
+    output.right  = 0;
+    output.top    = 0;
+    output.bottom = 0;
+}
+
+CompRegion
+PrivateWindow::rectsToRegion (unsigned int n, XRectangle *rects)
+{
+    CompRegion ret;
+    int        x1, x2, y1, y2;
+
+    for (unsigned int i = 0; i < n; i++)
+    {
+	x1 = rects[i].x + priv->geometry.border ();
+	y1 = rects[i].y + priv->geometry.border ();
+	x2 = x1 + rects[i].width;
+	y2 = y1 + rects[i].height;
+
+	if (x1 < 0)
+	    x1 = 0;
+	if (y1 < 0)
+	    y1 = 0;
+	if (x2 > priv->width)
+	    x2 = priv->width;
+	if (y2 > priv->height)
+	    y2 = priv->height;
+
+	if (y1 < y2 && x1 < x2)
+	{
+	    x1 += priv->geometry.x ();
+	    y1 += priv->geometry.y ();
+	    x2 += priv->geometry.x ();
+	    y2 += priv->geometry.y ();
+
+	    ret += CompRect (x1, y1, x2 - x1, y2 - y1);
+	}
+    }
+
+    return ret;
+}
+
+/* TODO: This function should be able to check the XShape event
+ * kind and only get/set shape rectangles for either ShapeInput
+ * or ShapeBounding, but not both at the same time
+ */
+
+void
+PrivateWindow::updateRegion ()
+{
+    XRectangle r, *boundingShapeRects = NULL;
+    XRectangle *inputShapeRects = NULL;
+    int	       nBounding = 0, nInput = 0;
+
+    priv->region = CompRegion ();
+    priv->inputRegion = CompRegion ();
+
+    if (screen->XShape ())
+    {
+	int order;
+
+	boundingShapeRects = XShapeGetRectangles (screen->dpy (), priv->id,
+					 	  ShapeBounding, &nBounding, &order);
+	inputShapeRects = XShapeGetRectangles (screen->dpy (), priv->id,
+					       ShapeInput, &nInput, &order);
+
+    }
+
+    r.x      = -priv->attrib.border_width;
+    r.y      = -priv->attrib.border_width;
+    r.width  = priv->width + priv->attrib.border_width;
+    r.height = priv->height + priv->attrib.border_width;
+
+    if (nBounding < 1)
+    {
+	boundingShapeRects = &r;
+	nBounding = 1;
+    }
+
+    if (nInput < 1)
+    {
+	inputShapeRects = &r;
+	nBounding = 1;
+    }
+
+    priv->region += rectsToRegion (nBounding, boundingShapeRects);
+    priv->inputRegion += rectsToRegion (nInput, inputShapeRects);
+
+    if (boundingShapeRects && boundingShapeRects != &r)
+	XFree (boundingShapeRects);
+    if (inputShapeRects && inputShapeRects != &r)
+	XFree (inputShapeRects);
+
+    window->updateFrameRegion ();
+}
+
+bool
+CompWindow::updateStruts ()
+{
+    Atom	  actual;
+    int		  result, format;
+    unsigned long n, left;
+    unsigned char *data;
+    bool	  hasOld, hasNew;
+    CompStruts    oldStrut, newStrut;
+
+    if (priv->struts)
+    {
+	hasOld = true;
+
+	oldStrut.left   = priv->struts->left;
+	oldStrut.right  = priv->struts->right;
+	oldStrut.top    = priv->struts->top;
+	oldStrut.bottom = priv->struts->bottom;
+    }
+    else
+    {
+	hasOld = false;
+    }
+
+    hasNew = false;
+
+    newStrut.left.x	    = 0;
+    newStrut.left.y	    = 0;
+    newStrut.left.width  = 0;
+    newStrut.left.height = screen->height ();
+
+    newStrut.right.x      = screen->width ();
+    newStrut.right.y      = 0;
+    newStrut.right.width  = 0;
+    newStrut.right.height = screen->height ();
+
+    newStrut.top.x	   = 0;
+    newStrut.top.y	   = 0;
+    newStrut.top.width  = screen->width ();
+    newStrut.top.height = 0;
+
+    newStrut.bottom.x      = 0;
+    newStrut.bottom.y      = screen->height ();
+    newStrut.bottom.width  = screen->width ();
+    newStrut.bottom.height = 0;
+
+    result = XGetWindowProperty (screen->dpy (), priv->id,
+				 Atoms::wmStrutPartial,
+				 0L, 12L, false, XA_CARDINAL, &actual, &format,
+				 &n, &left, &data);
+
+    if (result == Success && data)
+    {
+	unsigned long *struts = (unsigned long *) data;
+
+	if (n == 12)
+	{
+	    hasNew = true;
+
+	    newStrut.left.y        = struts[4];
+	    newStrut.left.width    = struts[0];
+	    newStrut.left.height   = struts[5] - newStrut.left.y + 1;
+
+	    newStrut.right.width   = struts[1];
+	    newStrut.right.x       = screen->width () - newStrut.right.width;
+	    newStrut.right.y       = struts[6];
+	    newStrut.right.height  = struts[7] - newStrut.right.y + 1;
+
+	    newStrut.top.x         = struts[8];
+	    newStrut.top.width     = struts[9] - newStrut.top.x + 1;
+	    newStrut.top.height    = struts[2];
+
+	    newStrut.bottom.x      = struts[10];
+	    newStrut.bottom.width  = struts[11] - newStrut.bottom.x + 1;
+	    newStrut.bottom.height = struts[3];
+	    newStrut.bottom.y      = screen->height () - newStrut.bottom.height;
+	}
+
+	XFree (data);
+    }
+
+    if (!hasNew)
+    {
+	result = XGetWindowProperty (screen->dpy (), priv->id,
+				     Atoms::wmStrut,
+				     0L, 4L, false, XA_CARDINAL,
+				     &actual, &format, &n, &left, &data);
+
+	if (result == Success && data)
+	{
+	    unsigned long *struts = (unsigned long *) data;
+
+	    if (n == 4)
+	    {
+		hasNew = true;
+
+		newStrut.left.x        = 0;
+		newStrut.left.width    = struts[0];
+
+		newStrut.right.width   = struts[1];
+		newStrut.right.x       = screen->width () - newStrut.right.width;
+
+		newStrut.top.y         = 0;
+		newStrut.top.height    = struts[2];
+
+		newStrut.bottom.height = struts[3];
+		newStrut.bottom.y      = screen->height () - newStrut.bottom.height;
+	    }
+
+	    XFree (data);
+	}
+    }
+
+    if (hasNew)
+    {
+	int strutX1, strutY1, strutX2, strutY2;
+	int x1, y1, x2, y2;
+
+	/* applications expect us to clip struts to xinerama edges */
+	for (unsigned int i = 0;
+	     i < screen->screenInfo ().size (); i++)
+	{
+	    x1 = screen->screenInfo ()[i].x_org;
+	    y1 = screen->screenInfo ()[i].y_org;
+	    x2 = x1 + screen->screenInfo ()[i].width;
+	    y2 = y1 + screen->screenInfo ()[i].height;
+
+	    strutX1 = newStrut.left.x;
+	    strutX2 = strutX1 + newStrut.left.width;
+	    strutY1 = newStrut.left.y;
+	    strutY2 = strutY1 + newStrut.left.height;
+
+	    if (strutX2 > x1 && strutX2 <= x2 &&
+		strutY1 < y2 && strutY2 > y1)
+	    {
+		newStrut.left.x     = x1;
+		newStrut.left.width = strutX2 - x1;
+	    }
+
+	    strutX1 = newStrut.right.x;
+	    strutX2 = strutX1 + newStrut.right.width;
+	    strutY1 = newStrut.right.y;
+	    strutY2 = strutY1 + newStrut.right.height;
+
+	    if (strutX1 > x1 && strutX1 <= x2 &&
+		strutY1 < y2 && strutY2 > y1)
+	    {
+		newStrut.right.x     = strutX1;
+		newStrut.right.width = x2 - strutX1;
+	    }
+
+	    strutX1 = newStrut.top.x;
+	    strutX2 = strutX1 + newStrut.top.width;
+	    strutY1 = newStrut.top.y;
+	    strutY2 = strutY1 + newStrut.top.height;
+
+	    if (strutX1 < x2 && strutX2 > x1 &&
+		strutY2 > y1 && strutY2 <= y2)
+	    {
+		newStrut.top.y      = y1;
+		newStrut.top.height = strutY2 - y1;
+	    }
+
+	    strutX1 = newStrut.bottom.x;
+	    strutX2 = strutX1 + newStrut.bottom.width;
+	    strutY1 = newStrut.bottom.y;
+	    strutY2 = strutY1 + newStrut.bottom.height;
+
+	    if (strutX1 < x2 && strutX2 > x1 &&
+		strutY1 > y1 && strutY1 <= y2)
+	    {
+		newStrut.bottom.y      = strutY1;
+		newStrut.bottom.height = y2 - strutY1;
+	    }
+	}
+    }
+
+    if (hasOld != hasNew ||
+	(hasNew && hasOld &&
+	 memcmp (&newStrut, &oldStrut, sizeof (CompStruts))))
+    {
+	if (hasNew)
+	{
+	    if (!priv->struts)
+	    {
+		priv->struts = (CompStruts *) malloc (sizeof (CompStruts));
+		if (!priv->struts)
+		    return false;
+	    }
+
+	    *priv->struts = newStrut;
+	}
+	else
+	{
+	    free (priv->struts);
+	    priv->struts = NULL;
+	}
+
+	return true;
+    }
+
+    return false;
+}
+
+void
+CompWindow::incrementDestroyReference ()
+{
+    priv->destroyRefCnt++;
+}
+
+void
+CompWindow::destroy ()
+{
+    if (priv->id)
+    {
+	CompWindow *oldServerNext, *oldServerPrev, *oldNext, *oldPrev;
+	StackDebugger *dbg = StackDebugger::Default ();
+
+	windowNotify (CompWindowNotifyBeforeDestroy);
+
+	/* Don't allow frame windows to block input */
+	XUnmapWindow (screen->dpy (), priv->serverFrame);
+	XUnmapWindow (screen->dpy (), priv->wrapper);
+
+	oldServerNext = serverNext;
+	oldServerPrev = serverPrev;
+	oldNext = next;
+	oldPrev = prev;
+
+	/* This is where things get tricky ... it is possible
+	 * to receive a ConfigureNotify relative to a frame window
+	 * for a destroyed window in case we process a ConfigureRequest
+	 * for the destroyed window and then a DestroyNotify for it directly
+	 * afterwards. In that case, we will receive the ConfigureNotify
+	 * for the XConfigureWindow request we made relative to that frame
+	 * window. Because of this, we must keep the frame window in the stack
+	 * as a new toplevel window so that the ConfigureNotify will be processed
+	 * properly until it too receives a DestroyNotify */
+
+	if (priv->serverFrame)
+	{
+	    XWindowAttributes attrib;
+
+	    /* It's possible that the frame window was already destroyed because
+	     * the client was unreparented before it was destroyed (eg
+	     * UnmapNotify before DestroyNotify). In that case the frame window
+	     * is going to be an invalid window but since we haven't received
+	     * a DestroyNotify for it yet, it is possible that restacking
+	     * operations could occurr relative to it so we need to hold it
+	     * in the stack for now. Ensure that it is marked override redirect */
+	    XGetWindowAttributes (screen->dpy (), priv->serverFrame, &attrib);
+
+	    /* Put the frame window "above" the client window
+	     * in the stack */
+	    CoreWindow *cw = new CoreWindow (priv->serverFrame);
+	    cw->manage (priv->id, attrib);
+	    screen->priv->createdWindows.remove (cw);
+	    delete cw;
+	}
+
+	/* Immediately unhook the window once destroyed
+	 * as the stacking order will be invalid if we don't
+	 * and will continue to be invalid for the period
+	 * that we keep it around in the stack. Instead, push
+	 * it to another stack and keep the next and prev members
+	 * in tact, letting plugins sort out where those windows
+	 * might be in case they need to use them relative to
+	 * other windows */
+
+	screen->unhookWindow (this);
+	screen->unhookServerWindow (this);
+
+	/* We must immediately insert the window into the debugging
+	 * stack */
+	if (dbg)
+	    dbg->removeServerWindow (id ());
+
+	/* Unhooking the window will also NULL the next/prev
+	 * linked list links but we don't want that so don't
+	 * do that */
+
+	next = oldNext;
+	prev = oldPrev;
+	serverNext = oldServerNext;
+	serverPrev = oldServerPrev;
+
+	screen->priv->destroyedWindows.push_back (this);
+
+	/* We must set the xid of this window
+	 * to zero as it no longer references
+	 * a valid window */
+	priv->mapNum = 0;
+	priv->id = 0;
+	priv->frame = 0;
+	priv->serverFrame = 0;
+	priv->managed    = false;
+    }
+
+    priv->destroyRefCnt--;
+    if (priv->destroyRefCnt)
+	return;
+
+    if (!priv->destroyed)
+    {
+	if (!priv->serverFrame)
+	{
+	    StackDebugger *dbg = StackDebugger::Default ();
+
+	    if (dbg)
+		dbg->addDestroyedFrame (priv->serverId);
+	}
+
+	priv->destroyed = true;
+	screen->priv->pendingDestroys++;
+    }
+
+}
+
+void
+CompWindow::sendConfigureNotify ()
+{
+    XConfigureEvent xev;
+    XWindowAttributes attrib;
+    unsigned int      nchildren;
+    Window            rootRet, parentRet;
+    Window            *children;
+
+    xev.type   = ConfigureNotify;
+    xev.event  = priv->id;
+    xev.window = priv->id;
+
+    /* in order to avoid race conditions we must use the current
+     * server configuration */
+
+    XGrabServer (screen->dpy ());
+    XSync (screen->dpy (), false);
+
+    if (XGetWindowAttributes (screen->dpy (), priv->id, &attrib))
+    {
+	xev.x	     = attrib.x;
+	xev.y	     = attrib.y;
+	xev.width	     = attrib.width;
+	xev.height	     = attrib.height;
+	xev.border_width = attrib.border_width;
+	xev.above = None;
+
+	if (priv->frame)
+	{
+	    XWindowAttributes fAttrib;
+	    XWindowAttributes wAttrib;
+
+	    /* Add offset between wrapper and client */
+	    if (XGetWindowAttributes (screen->dpy (), priv->wrapper, &wAttrib))
+	    {
+		xev.x += wAttrib.x;
+		xev.y += wAttrib.y;
+	    }
+
+	    /* Add offset between frame and client */
+	    if (XGetWindowAttributes (screen->dpy (), priv->frame, &fAttrib))
+	    {
+		xev.x += fAttrib.x;
+		xev.y += fAttrib.y;
+	    }
+	}
+
+	/* We need to ensure that the stacking order is
+	 * based on the current server stacking order so
+	 * find the sibling to this window's frame in the
+	 * server side stack and stack above that */
+	XQueryTree (screen->dpy (), screen->root (), &rootRet, &parentRet, &children, &nchildren);
+
+	if (nchildren)
+	{
+	    for (unsigned int i = 0; i < nchildren; i++)
+	    {
+		if (i + 1 == nchildren ||
+		    children[i + 1] == ROOTPARENT (this))
+		{
+		    xev.above = children[i];
+		    break;
+		}
+	    }
+	}
+
+	if (children)
+	    XFree (children);
+
+	if (!xev.above)
+	    xev.above		  = (serverPrev) ? ROOTPARENT (serverPrev) : None;
+	xev.override_redirect = priv->attrib.override_redirect;
+
+	XSendEvent (screen->dpy (), priv->id, false,
+		    StructureNotifyMask, (XEvent *) &xev);
+    }
+
+    XUngrabServer (screen->dpy ());
+    XSync (screen->dpy (), false);
+}
+
+void
+CompWindow::map ()
+{
+    windowNotify (CompWindowNotifyBeforeMap);
+
+    if (!isViewable ())
+    {
+	if (priv->pendingMaps > 0)
+	    priv->pendingMaps = 0;
+
+	priv->mapNum = screen->priv->mapNum++;
+
+	if (priv->struts)
+	    screen->updateWorkarea ();
+
+	if (windowClass () == InputOnly)
+	    return;
+
+	priv->unmapRefCnt = 1;
+
+	priv->attrib.map_state = IsViewable;
+
+	if (!overrideRedirect ())
+	    screen->priv->setWmState (NormalState, priv->id);
+
+	priv->invisible  = true;
+	priv->alive      = true;
+
+	priv->lastPong = screen->priv->lastPing;
+
+	priv->updateRegion ();
+	priv->updateSize ();
+
+	screen->priv->updateClientList ();
+
+	if (priv->type & CompWindowTypeDesktopMask)
+	    screen->priv->desktopWindowCount++;
+
+	if (priv->protocols & CompWindowProtocolSyncRequestMask)
+	{
+	    sendSyncRequest ();
+	    sendConfigureNotify ();
+	}
+
+	if (!overrideRedirect ())
+	{
+	    /* been shaded */
+	    if (!priv->height)
+	    {
+		priv->geometry.setHeight (priv->geometry.height () + 1);
+		resize (priv->geometry.x (), priv->geometry.y (), priv->geometry.width (),
+			priv->geometry.height () - 1, priv->geometry.border ());
+	    }
+	}
+    }
+
+    windowNotify (CompWindowNotifyMap);
+}
+
+void
+CompWindow::incrementUnmapReference ()
+{
+    priv->unmapRefCnt++;
+}
+
+void
+CompWindow::unmap ()
+{
+    windowNotify (CompWindowNotifyBeforeUnmap);
+
+    if (priv->mapNum)
+	priv->mapNum = 0;
+
+    /* Even though we're still keeping the backing
+     * pixmap of the window around, it's safe to
+     * unmap the frame window since there's no use
+     * for it at this point anyways and it just blocks
+     * input */
+
+    XUnmapWindow (screen->dpy (), priv->wrapper);
+    XUnmapWindow (screen->dpy (), priv->serverFrame);
+
+    priv->unmapRefCnt--;
+    if (priv->unmapRefCnt > 0)
+	return;
+
+    if (priv->unmanaging)
+    {
+	XWindowChanges xwc;
+	unsigned int   xwcm;
+	int	       gravity = priv->sizeHints.win_gravity;
+
+	/* revert gravity adjustment made at MapNotify time */
+	xwc.x	= priv->serverGeometry.x ();
+	xwc.y	= priv->serverGeometry.y ();
+	xwc.width   = 0;
+	xwc.height  = 0;
+
+	xwcm = priv->adjustConfigureRequestForGravity (&xwc,
+						       CWX | CWY,
+						       gravity,
+						       -1);
+	if (xwcm)
+	    configureXWindow (xwcm, &xwc);
+
+	priv->unmanaging = false;
+    }
+
+    if (priv->serverFrame)
+	priv->unreparent ();
+
+    if (priv->struts)
+	screen->updateWorkarea ();
+
+    if (priv->attrib.map_state != IsViewable)
+	return;
+
+    if (priv->type == CompWindowTypeDesktopMask)
+	screen->priv->desktopWindowCount--;
+
+    priv->attrib.map_state = IsUnmapped;
+
+    priv->invisible = true;
+
+    if (priv->shaded && priv->height)
+	resize (priv->attrib.x, priv->attrib.y,
+		priv->attrib.width, ++priv->attrib.height - 1,
+		priv->attrib.border_width);
+
+    screen->priv->updateClientList ();
+
+    windowNotify (CompWindowNotifyUnmap);
+}
+
+void
+PrivateWindow::withdraw ()
+{
+    if (!attrib.override_redirect)
+	screen->priv->setWmState (WithdrawnState, id);
+
+    placed     = false;
+    unmanaging = managed;
+    managed    = false;
+}
+
+bool
+PrivateWindow::restack (Window aboveId)
+{
+    if (aboveId && (aboveId == id || aboveId == serverFrame))
+	// Don't try to raise a window above itself
+	return false;
+    else if (window->prev)
+    {
+	if (aboveId && (aboveId == window->prev->id () ||
+			aboveId == window->prev->priv->frame))
+	    return false;
+    }
+    else if (aboveId == None && !window->next)
+	return false;
+
+    if (aboveId && !screen->findTopLevelWindow (aboveId, true))
+    {
+        return false;
+    }
+
+    screen->unhookWindow (window);
+    screen->insertWindow (window, aboveId);
+
+    /* Update the server side window list for
+     * override redirect windows immediately
+     * since there is no opportunity to update
+     * the server side list when we configure them
+     * since we never get a ConfigureRequest for those */
+    if (attrib.override_redirect != 0)
+    {
+	StackDebugger *dbg = StackDebugger::Default ();
+
+	screen->unhookServerWindow (window);
+	screen->insertServerWindow (window, aboveId);
+
+	if (dbg)
+	    dbg->overrideRedirectRestack (window->id (), aboveId);
+    }
+
+    screen->priv->updateClientList ();
+
+    window->windowNotify (CompWindowNotifyRestack);
+
+    return true;
+}
+
+bool
+CompWindow::resize (XWindowAttributes attr)
+{
+    return resize (Geometry (attr.x, attr.y, attr.width, attr.height,
+			     attr.border_width));
+}
+
+bool
+CompWindow::resize (int          x,
+		    int          y,
+		    int          width,
+		    int          height,
+		    int          border)
+{
+    return resize (Geometry (x, y, width, height, border));
+}
+
+bool
+CompWindow::resize (CompWindow::Geometry gm)
+{
+    /* Input extents are now the last thing sent
+     * from the server. This might not work in some
+     * cases though because setWindowFrameExtents may
+     * be called more than once in an event processing
+     * cycle so every set of input extents up until the
+     * last one will be invalid. The real solution
+     * here is to handle ConfigureNotify events on
+     * frame windows and client windows separately */
+
+    priv->input = priv->serverInput;
+
+    if (priv->geometry.width ()   != gm.width ()  ||
+	priv->geometry.height ()  != gm.height () ||
+	priv->geometry.border ()  != gm.border ())
+    {
+	int pw, ph;
+	int dx, dy, dwidth, dheight;
+
+	pw = gm.width () + gm.border () * 2;
+	ph = gm.height () + gm.border () * 2;
+
+	if (priv->shaded)
+	    ph = 0;
+
+	dx      = gm.x () - priv->geometry.x ();
+	dy      = gm.y () - priv->geometry.y ();
+	dwidth  = gm.width () - priv->geometry.width ();
+	dheight = gm.height () - priv->geometry.height ();
+
+	priv->geometry.set (gm.x (), gm.y (),
+			    gm.width (), gm.height (),
+			    gm.border ());
+
+	priv->width = pw;
+	priv->height = ph;
+
+	if (priv->mapNum)
+	    priv->updateRegion ();
+
+	resizeNotify (dx, dy, dwidth, dheight);
+
+	priv->invisible = WINDOW_INVISIBLE (priv);
+    }
+    else if (priv->geometry.x () != gm.x () || priv->geometry.y () != gm.y ())
+    {
+	int dx, dy;
+
+	dx = gm.x () - priv->geometry.x ();
+	dy = gm.y () - priv->geometry.y ();
+
+	priv->geometry.setX (gm.x ());
+	priv->geometry.setY (gm.y ());
+
+	priv->region.translate (dx, dy);
+	priv->inputRegion.translate (dx, dy);
+	if (!priv->frameRegion.isEmpty ())
+	    priv->frameRegion.translate (dx, dy);
+
+	priv->invisible = WINDOW_INVISIBLE (priv);
+
+	moveNotify (dx, dy, true);
+    }
+
+    updateFrameRegion ();
+
+    return true;
+}
+
+static void
+syncValueIncrement (XSyncValue *value)
+{
+    XSyncValue one;
+    int	       overflow;
+
+    XSyncIntToValue (&one, 1);
+    XSyncValueAdd (value, *value, one, &overflow);
+}
+
+bool
+PrivateWindow::initializeSyncCounter ()
+{
+    XSyncAlarmAttributes values;
+    Atom		 actual;
+    int			 result, format;
+    unsigned long	 n, left;
+    unsigned char	 *data;
+
+    if (syncCounter)
+	return syncAlarm != None;
+
+    if (!(protocols & CompWindowProtocolSyncRequestMask))
+	return false;
+
+    result = XGetWindowProperty (screen->dpy (), id,
+				 Atoms::wmSyncRequestCounter,
+				 0L, 1L, false, XA_CARDINAL, &actual, &format,
+				 &n, &left, &data);
+
+    if (result == Success && n && data)
+    {
+	unsigned long *counter = (unsigned long *) data;
+
+	syncCounter = *counter;
+
+	XFree (data);
+
+	XSyncIntsToValue (&syncValue, (unsigned int) rand (), 0);
+	XSyncSetCounter (screen->dpy (),
+			 syncCounter,
+			 syncValue);
+
+	syncValueIncrement (&syncValue);
+
+	values.events = true;
+
+	values.trigger.counter    = syncCounter;
+	values.trigger.wait_value = syncValue;
+
+	values.trigger.value_type = XSyncAbsolute;
+	values.trigger.test_type  = XSyncPositiveComparison;
+
+	XSyncIntToValue (&values.delta, 1);
+
+	values.events = true;
+
+	CompScreen::checkForError (screen->dpy ());
+
+	/* Note that by default, the alarm increments the trigger value
+	 * when it fires until the condition (counter.value < trigger.value)
+	 * is false again.
+	 */
+	syncAlarm = XSyncCreateAlarm (screen->dpy (),
+				      XSyncCACounter   |
+				      XSyncCAValue     |
+				      XSyncCAValueType |
+				      XSyncCATestType  |
+				      XSyncCADelta     |
+				      XSyncCAEvents,
+				      &values);
+
+	if (CompScreen::checkForError (screen->dpy ()))
+	    return true;
+
+	XSyncDestroyAlarm (screen->dpy (), syncAlarm);
+	syncAlarm = None;
+    }
+    else if (result == Success && data)
+    {
+	XFree (data);
+    }
+
+    return false;
+}
+
+void
+CompWindow::sendSyncRequest ()
+{
+    XClientMessageEvent xev;
+
+    if (priv->syncWait)
+	return;
+
+    if (!priv->initializeSyncCounter ())
+	return;
+
+    xev.type	     = ClientMessage;
+    xev.window	     = priv->id;
+    xev.message_type = Atoms::wmProtocols;
+    xev.format	     = 32;
+    xev.data.l[0]    = Atoms::wmSyncRequest;
+    xev.data.l[1]    = CurrentTime;
+    xev.data.l[2]    = XSyncValueLow32 (priv->syncValue);
+    xev.data.l[3]    = XSyncValueHigh32 (priv->syncValue);
+    xev.data.l[4]    = 0;
+
+    syncValueIncrement (&priv->syncValue);
+
+    XSendEvent (screen->dpy (), priv->id, false, 0, (XEvent *) &xev);
+
+    priv->syncWait     = true;
+    priv->syncGeometry = priv->serverGeometry;
+
+    if (!priv->syncWaitTimer.active ())
+	priv->syncWaitTimer.start ();
+}
+
+void
+PrivateWindow::configure (XConfigureEvent *ce)
+{
+    unsigned int valueMask = 0;
+
+    if (priv->frame)
+	return;
+
+    /* remove configure event from pending configures */
+    if (priv->geometry.x () != ce->x)
+	valueMask |= CWX;
+
+    if (priv->geometry.y () != ce->y)
+	valueMask |= CWY;
+
+    if (priv->geometry.width () != ce->width)
+	valueMask |= CWWidth;
+
+    if (priv->geometry.height () != ce->height)
+	valueMask |= CWHeight;
+
+    if (priv->geometry.border () != ce->border_width)
+	valueMask |= CWBorderWidth;
+
+    if (ROOTPARENT (window->prev) != ce->above)
+	valueMask |= CWSibling | CWStackMode;
+
+    priv->attrib.override_redirect = ce->override_redirect;
+
+    priv->frameGeometry.set (ce->x, ce->y, ce->width,
+			     ce->height, ce->border_width);
+
+    if (priv->syncWait)
+	priv->syncGeometry.set (ce->x, ce->y, ce->width, ce->height,
+				ce->border_width);
+    else
+    {
+	if (ce->override_redirect)
+	{
+	    priv->serverGeometry.set (ce->x, ce->y, ce->width, ce->height,
+				      ce->border_width);
+	}
+
+	window->resize (ce->x, ce->y, ce->width, ce->height, ce->border_width);
+    }
+
+    if (ce->event == screen->root ())
+	priv->restack (ce->above);
+}
+
+void
+PrivateWindow::configureFrame (XConfigureEvent *ce)
+{
+    int x, y, width, height;
+    CompWindow	     *above;
+    unsigned int     valueMask = 0;
+    bool             handled = false;
+
+    if (!priv->frame)
+	return;
+
+    /* remove configure event from pending configures */
+    if (priv->frameGeometry.x () != ce->x)
+	valueMask |= CWX;
+
+    if (priv->frameGeometry.y () != ce->y)
+	valueMask |= CWY;
+
+    if (priv->frameGeometry.width () != ce->width)
+	valueMask |= CWWidth;
+
+    if (priv->frameGeometry.height () != ce->height)
+	valueMask |= CWHeight;
+
+    if (priv->frameGeometry.border () != ce->border_width)
+	valueMask |= CWBorderWidth;
+
+    if (window->prev)
+    {
+	if (ROOTPARENT (window->prev) != ce->above)
+	    valueMask |= CWSibling | CWStackMode;
+    }
+    else
+    {
+	if (ce->above != 0)
+	    valueMask |= CWSibling | CWStackMode;
+    }
+
+    for (std::list <XWCValueMask>::iterator it = pendingConfigures.begin ();
+	 it != pendingConfigures.end (); it++)
+    {
+	XWCValueMask &xwcvm = (*it);
+
+
+	if (xwcvm.second != valueMask)
+	{
+	    /* For stacking cases, if a client wants to raise or lower a window
+	     * then they don't need to specify CWSibling, so allow that to be
+	     * excluded in those cases */
+
+	    if (ce->above == ROOTPARENT (screen->windows ().back ()) ||
+		ce->above == 0)
+	    {
+		if ((xwcvm.second & ~(CWSibling)) != valueMask)
+		    continue;
+	    }
+	    else
+		continue;
+	}
+
+	if (xwcvm.second & CWX && xwcvm.first.x != ce->x)
+	    continue;
+
+	if (xwcvm.second & CWY && xwcvm.first.y != ce->y)
+	    continue;
+
+	if (xwcvm.second & CWWidth && xwcvm.first.width != ce->width)
+	    continue;
+
+	if (xwcvm.second & CWHeight && xwcvm.first.height != ce->height)
+	    continue;
+
+	if (xwcvm.second & (CWStackMode | CWSibling) && xwcvm.first.sibling != ce->above)
+	    continue;
+
+	/* Matched ConfigureWindow request to ConfigureNotify event
+	 * remove it from the list */
+
+	handled = true;
+
+	pendingConfigures.erase (it);
+	break;
+    }
+
+    if (!handled)
+    {
+	compLogMessage ("core", CompLogLevelWarn, "unhandled ConfigureNotify on 0x%x!", serverFrame);
+	compLogMessage ("core", CompLogLevelWarn, "this should never happen. you should"\
+						  "probably file a bug about this.");
+#ifdef DEBUG
+	abort ();
+#else
+	pendingConfigures.clear ();
+#endif
+    }
+
+    /* subtract the input extents last sent to the
+     * server to calculate the client size and then
+     * re-sync the input extents and extents last
+     * sent to server on resize () */
+
+    x      = ce->x + priv->serverInput.left;
+    y      = ce->y + priv->serverInput.top;
+    width  = ce->width - priv->serverGeometry.border () * 2 - priv->serverInput.left - priv->serverInput.right;
+    height = ce->height - priv->serverGeometry.border () * 2 - priv->serverInput.top - priv->serverInput.bottom;
+
+    /* set the frame geometry */
+    priv->frameGeometry.set (ce->x, ce->y, ce->width, ce->height, ce->border_width);
+
+
+    if (priv->syncWait)
+	priv->syncGeometry.set (x, y, width, height, ce->border_width);
+    else
+	window->resize (x, y, width, height, ce->border_width);
+
+    if (priv->restack (ce->above))
+	priv->updatePassiveButtonGrabs ();
+
+    above = screen->findWindow (ce->above);
+
+    if (above)
+	above->priv->updatePassiveButtonGrabs ();
+
+    if (pendingConfigures.empty ())
+    {
+	/* Tell plugins its ok to start doing stupid things again but
+	 * obviously FIXME */
+	CompOption::Vector options;
+	CompOption::Value  v;
+
+	options.push_back (CompOption ("window", CompOption::TypeInt));
+	v.set ((int) id);
+	options.back ().set (v);
+	options.push_back (CompOption ("active", CompOption::TypeInt));
+	v.set ((int) 0);
+	options.back ().set (v);
+
+	/* Notify other plugins that it is unsafe to change geometry or serverGeometry
+	 * FIXME: That API should not be accessible to plugins, this is a hack to avoid
+	 * breaking ABI */
+
+	screen->handleCompizEvent ("core", "lock_position", options);
+    }
+}
+
+void
+PrivateWindow::circulate (XCirculateEvent *ce)
+{
+    Window newAboveId;
+
+    if (ce->place == PlaceOnTop)
+	newAboveId = screen->priv->getTopWindow ();
+    else
+	newAboveId = 0;
+
+    priv->restack (newAboveId);
+}
+
+void
+CompWindow::move (int  dx,
+		  int  dy,
+		  bool immediate)
+{
+    if (dx || dy)
+    {
+	/* Don't allow window movement to overwrite working geometries
+	 * last received from the server if we know there are pending
+	 * ConfigureNotify events on this window. That's a clunky workaround
+	 * and a FIXME in any case, however, until we can break the API
+	 * and remove CompWindow::move, this will need to be the case */
+
+	if (!priv->pendingConfigures.size ())
+	{
+	    priv->geometry.setX (priv->geometry.x () + dx);
+	    priv->geometry.setY (priv->geometry.y () + dy);
+	    priv->frameGeometry.setX (priv->frameGeometry.x () + dx);
+	    priv->frameGeometry.setY (priv->frameGeometry.y () + dy);
+
+	    priv->pendingPositionUpdates = true;
+
+	    priv->region.translate (dx, dy);
+	    priv->inputRegion.translate (dx, dy);
+	    if (!priv->frameRegion.isEmpty ())
+		priv->frameRegion.translate (dx, dy);
+
+	    priv->invisible = WINDOW_INVISIBLE (priv);
+
+	    moveNotify (dx, dy, immediate);
+	}
+	else
+	{
+	    XWindowChanges xwc;
+	    unsigned int   valueMask = CWX | CWY;
+	    struct timeval tv, old;
+	    compLogMessage ("core", CompLogLevelDebug, "pending configure notifies on 0x%x,"\
+			    "moving window asyncrhonously!", (unsigned int) priv->serverId);
+
+	    old = priv->lastConfigureRequest;
+	    gettimeofday (&tv, NULL);
+
+	    xwc.x = priv->serverGeometry.x () + dx;
+	    xwc.y = priv->serverGeometry.y () + dy;
+
+	    configureXWindow (valueMask, &xwc);
+
+	    priv->lastConfigureRequest = old;
+
+	    /* FIXME: This is a hack to avoid performance regressions
+	     * and must be removed in 0.9.6 */
+	    if (tv.tv_usec - priv->lastConfigureRequest.tv_usec > 300000)
+	    {
+		compLogMessage ("core", CompLogLevelWarn, "failed to receive ConfigureNotify event from request at %i (now: %i)\n",
+				priv->lastConfigureRequest.tv_usec, tv.tv_usec);
+		priv->pendingConfigures.clear ();
+	    }
+	}
+    }
+}
+
+void
+PrivateWindow::addPendingConfigure (XWindowChanges &xwc, unsigned int valueMask)
+{
+    CompOption::Vector options;
+    CompOption::Value  v;
+
+    options.push_back (CompOption ("window", CompOption::TypeInt));
+    v.set ((int) id);
+    options.back ().set (v);
+    options.push_back (CompOption ("active", CompOption::TypeInt));
+    v.set ((int) 1);
+    options.back ().set (v);
+
+    gettimeofday (&lastConfigureRequest, NULL);
+
+    /* Notify other plugins that it is unsafe to change geometry or serverGeometry
+     * FIXME: That API should not be accessible to plugins, this is a hack to avoid
+     * breaking ABI */
+
+    screen->handleCompizEvent ("core", "lock_position", options);
+
+    priv->pendingConfigures.push_back (XWCValueMask (xwc, valueMask));
+}
+
+void
+CompWindow::syncPosition ()
+{
+    unsigned int   valueMask = CWX | CWY;
+    XWindowChanges xwc;
+
+    if (priv->pendingPositionUpdates && priv->pendingConfigures.empty ())
+    {
+	if (priv->serverFrameGeometry.x () == priv->frameGeometry.x ())
+	    valueMask &= ~(CWX);
+	if (priv->serverFrameGeometry.y () == priv->frameGeometry.y ())
+	    valueMask &= ~(CWY);
+
+	/* Because CompWindow::move can update the geometry last
+	 * received from the server, we must indicate that no values
+	 * changed, because when the ConfigureNotify comes around
+	 * the values are going to be the same. That's obviously
+	 * broken behaviour and worthy of a FIXME, but requires
+	 * larger changes to the window movement system. */
+	if (valueMask)
+	{
+	    priv->addPendingConfigure (xwc, 0);
+
+	    priv->serverGeometry.setX (priv->geometry.x ());
+	    priv->serverGeometry.setY (priv->geometry.y ());
+	    priv->serverFrameGeometry.setX (priv->frameGeometry.x ());
+	    priv->serverFrameGeometry.setY (priv->frameGeometry.y ());
+
+	    xwc.x = priv->serverFrameGeometry.x ();
+	    xwc.y = priv->serverFrameGeometry.y ();
+
+	    XConfigureWindow (screen->dpy (), ROOTPARENT (this), valueMask, &xwc);
+
+	    if (priv->serverFrame)
+	    {
+		XMoveWindow (screen->dpy (), priv->wrapper,
+			     priv->serverInput.left, priv->serverInput.top);
+		sendConfigureNotify ();
+	    }
+	}
+	priv->pendingPositionUpdates = false;
+    }
+}
+
+bool
+CompWindow::focus ()
+{
+    WRAPABLE_HND_FUNC_RETURN (2, bool, focus)
+
+    if (overrideRedirect ())
+	return false;
+
+    if (!priv->managed || priv->unmanaging)
+	return false;
+
+    if (!onCurrentDesktop ())
+	return false;
+
+    if (priv->destroyed)
+	return false;
+
+    if (!priv->shaded && (priv->state & CompWindowStateHiddenMask))
+	return false;
+
+    if (priv->geometry.x () + priv->width  <= 0	||
+	priv->geometry.y () + priv->height <= 0	||
+	priv->geometry.x () >= (int) screen->width ()||
+	priv->geometry.y () >= (int) screen->height ())
+	return false;
+
+    return true;
+}
+
+bool
+CompWindow::place (CompPoint &pos)
+{
+    WRAPABLE_HND_FUNC_RETURN (4, bool, place, pos)
+    return false;
+}
+
+void
+CompWindow::validateResizeRequest (unsigned int   &mask,
+				   XWindowChanges *xwc,
+				   unsigned int   source)
+{
+    WRAPABLE_HND_FUNC (5, validateResizeRequest, mask, xwc, source)
+
+    if (!(priv->type & (CompWindowTypeDockMask    |
+		     CompWindowTypeFullscreenMask |
+		     CompWindowTypeUnknownMask)))
+    {
+	if (mask & CWY)
+	{
+	    int min, max;
+
+	    min = screen->workArea ().y () + priv->input.top;
+	    max = screen->workArea ().bottom ();
+
+	    if (priv->state & CompWindowStateStickyMask &&
+	    	 (xwc->y < min || xwc->y > max))
+	    {
+		xwc->y = priv->serverGeometry.y ();
+	    }
+	    else
+	    {
+		min -= screen->vp ().y () * screen->height ();
+		max += (screen->vpSize ().height () - screen->vp ().y () - 1) *
+			screen->height ();
+
+		if (xwc->y < min)
+		    xwc->y = min;
+		else if (xwc->y > max)
+		    xwc->y = max;
+	    }
+	}
+
+	if (mask & CWX)
+	{
+	    int min, max;
+
+	    min = screen->workArea ().x () + priv->input.left;
+	    max = screen->workArea ().right ();
+
+	    if (priv->state & CompWindowStateStickyMask &&
+		(xwc->x < min || xwc->x > max))
+	    {
+		xwc->x = priv->serverGeometry.x ();
+	    }
+	    else
+	    {
+		min -= screen->vp ().x () * screen->width ();
+		max += (screen->vpSize ().width () - screen->vp ().x () - 1) *
+			screen->width ();
+
+		if (xwc->x < min)
+		    xwc->x = min;
+		else if (xwc->x > max)
+		    xwc->x = max;
+	    }
+	}
+    }
+}
+
+void
+CompWindow::resizeNotify (int dx,
+			  int dy,
+			  int dwidth,
+			  int dheight)
+    WRAPABLE_HND_FUNC (6, resizeNotify, dx, dy, dwidth, dheight)
+
+void
+CompWindow::moveNotify (int  dx,
+			int  dy,
+			bool immediate)
+    WRAPABLE_HND_FUNC (7, moveNotify, dx, dy, immediate)
+
+void
+CompWindow::windowNotify (CompWindowNotify n)
+    WRAPABLE_HND_FUNC (8, windowNotify, n)
+
+void
+CompWindow::grabNotify (int	     x,
+			int	     y,
+			unsigned int state,
+			unsigned int mask)
+{
+    WRAPABLE_HND_FUNC (9, grabNotify, x, y, state, mask)
+    priv->grabbed = true;
+}
+
+void
+CompWindow::ungrabNotify ()
+{
+    WRAPABLE_HND_FUNC (10, ungrabNotify)
+    priv->grabbed = false;
+}
+
+void
+CompWindow::stateChangeNotify (unsigned int lastState)
+{
+    WRAPABLE_HND_FUNC (11, stateChangeNotify, lastState);
+
+    /* if being made sticky */
+    if (!(lastState & CompWindowStateStickyMask) &&
+	(priv->state & CompWindowStateStickyMask))
+    {
+	CompPoint vp;   /* index of the window's vp */
+
+	/* Find which viewport the window falls in,
+	   and check if it's the current viewport */
+	vp = defaultViewport ();
+	if (screen->vp () != vp)
+	{
+	    unsigned int valueMask = CWX | CWY;
+	    XWindowChanges xwc;
+
+	    xwc.x = serverGeometry ().x () +  (screen->vp ().x () - vp.x ()) * screen->width ();
+	    xwc.y = serverGeometry ().y () +  (screen->vp ().y () - vp.y ()) * screen->height ();
+
+	    configureXWindow (valueMask, &xwc);
+	}
+    }
+}
+
+
+bool
+PrivateWindow::isGroupTransient (Window clientLeader)
+{
+    if (!clientLeader)
+	return false;
+
+    if (transientFor == None || transientFor == screen->root ())
+    {
+	if (type & (CompWindowTypeUtilMask    |
+		    CompWindowTypeToolbarMask |
+		    CompWindowTypeMenuMask    |
+		    CompWindowTypeDialogMask  |
+		    CompWindowTypeModalDialogMask))
+	{
+	    if (this->clientLeader == clientLeader)
+		return true;
+	}
+    }
+
+    return false;
+}
+
+CompWindow *
+PrivateWindow::getModalTransient ()
+{
+    CompWindow *w, *modalTransient;
+
+    modalTransient = window;
+
+    for (w = screen->windows ().back (); w; w = w->prev)
+    {
+	if (w == modalTransient || w->priv->mapNum == 0)
+	    continue;
+
+	if (w->priv->transientFor == modalTransient->priv->id)
+	{
+	    if (w->priv->state & CompWindowStateModalMask)
+	    {
+		modalTransient = w;
+		w = screen->windows ().back ();
+	    }
+	}
+    }
+
+    if (modalTransient == window)
+    {
+	/* don't look for group transients with modal state if current window
+	   has modal state */
+	if (state & CompWindowStateModalMask)
+	    return NULL;
+
+	for (w = screen->windows ().back (); w; w = w->prev)
+	{
+	    if (w == modalTransient || w->priv->mapNum == 0)
+		continue;
+
+	    if (isAncestorTo (modalTransient, w))
+		continue;
+
+	    if (w->priv->isGroupTransient (modalTransient->priv->clientLeader))
+	    {
+		if (w->priv->state & CompWindowStateModalMask)
+		{
+		    modalTransient = w;
+		    w = w->priv->getModalTransient ();
+		    if (w)
+			modalTransient = w;
+
+		    break;
+		}
+	    }
+	}
+    }
+
+    if (modalTransient == window)
+	modalTransient = NULL;
+
+    return modalTransient;
+}
+
+void
+CompWindow::moveInputFocusTo ()
+{
+    CompScreen  *s = screen;
+    CompWindow  *modalTransient;
+
+    modalTransient = priv->getModalTransient ();
+    if (modalTransient)
+	return modalTransient->moveInputFocusTo ();
+
+    /* If the window is still hidden but not shaded
+     * it probably meant that a plugin overloaded
+     * CompWindow::focus to allow the focus to go
+     * to this window, so only move the input focus
+     * to the frame if the window is shaded */
+    if (shaded ())
+    {
+	XSetInputFocus (s->dpy (), priv->serverFrame,
+			RevertToPointerRoot, CurrentTime);
+	XChangeProperty (s->dpy (), s->root (), Atoms::winActive,
+			 XA_WINDOW, 32, PropModeReplace,
+			 (unsigned char *) &priv->id, 1);
+    }
+    else
+    {
+	bool setFocus = false;
+
+	if (priv->inputHint)
+	{
+	    XSetInputFocus (s->dpy (), priv->id, RevertToPointerRoot,
+			    CurrentTime);
+	    setFocus = true;
+	}
+
+	if (priv->protocols & CompWindowProtocolTakeFocusMask)
+	{
+	    XEvent ev;
+
+	    ev.type		    = ClientMessage;
+	    ev.xclient.window	    = priv->id;
+	    ev.xclient.message_type = Atoms::wmProtocols;
+	    ev.xclient.format	    = 32;
+	    ev.xclient.data.l[0]    = Atoms::wmTakeFocus;
+	    ev.xclient.data.l[1]    = s->getCurrentTime ();
+	    ev.xclient.data.l[2]    = 0;
+	    ev.xclient.data.l[3]    = 0;
+	    ev.xclient.data.l[4]    = 0;
+
+	    XSendEvent (s->dpy (), priv->id, false, NoEventMask, &ev);
+
+	    setFocus = true;
+	}
+
+	if (setFocus)
+	{
+	    CompWindowList dockWindows;
+	    XWindowChanges xwc;
+	    unsigned int   mask;
+
+	    screen->priv->nextActiveWindow = priv->id;
+
+	    /* Ensure that docks are stacked in the right place
+	     *
+	     * When a normal window gets the focus and is above a
+	     * fullscreen window, restack the docks to be above
+	     * the highest level mapped and visible normal window,
+	     * otherwise put them above the highest fullscreen window
+	     */
+	    if (PrivateWindow::stackDocks (this, dockWindows, &xwc, &mask))
+	    {
+		Window sibling = xwc.sibling;
+		xwc.stack_mode = Above;
+
+                /* Then update the dock windows */
+                foreach (CompWindow *dw, dockWindows)
+                {
+                    xwc.sibling = sibling;
+                    dw->configureXWindow (mask, &xwc);
+                }
+            }
+        }
+
+	if (!setFocus && !modalTransient)
+	{
+	    CompWindow *ancestor;
+
+	    /* move input to closest ancestor */
+	    for (ancestor = s->windows ().front (); ancestor;
+		 ancestor = ancestor->next)
+	    {
+		if (PrivateWindow::isAncestorTo (this, ancestor))
+		{
+		    ancestor->moveInputFocusTo ();
+		    break;
+		}
+	    }
+	}
+    }
+}
+
+void
+CompWindow::moveInputFocusToOtherWindow ()
+{
+    if (priv->id == screen->activeWindow () ||
+	priv->id == screen->priv->nextActiveWindow)
+    {
+	CompWindow *ancestor;
+
+	if (priv->transientFor && priv->transientFor != screen->root ())
+	{
+	    ancestor = screen->findWindow (priv->transientFor);
+	    if (ancestor &&
+		ancestor->focus () &&
+		!(ancestor->priv->type & (CompWindowTypeDesktopMask |
+					  CompWindowTypeDockMask)))
+	    {
+		ancestor->moveInputFocusTo ();
+	    }
+	    else
+		screen->focusDefaultWindow ();
+	}
+	else if (priv->type & (CompWindowTypeDialogMask |
+			       CompWindowTypeModalDialogMask))
+	{
+	    CompWindow *a, *focus = NULL;
+
+	    for (a = screen->windows ().back (); a; a = a->prev)
+	    {
+		if (a->priv->clientLeader == priv->clientLeader)
+		{
+		    if (a->focus ())
+		    {
+			if (focus)
+			{
+			    if (a->priv->type & (CompWindowTypeNormalMask |
+						 CompWindowTypeDialogMask |
+						 CompWindowTypeModalDialogMask))
+			    {
+				if (priv->compareWindowActiveness (focus, a) < 0)
+				    focus = a;
+			    }
+			}
+			else
+			    focus = a;
+		    }
+		}
+	    }
+
+	    if (focus && !(focus->priv->type & (CompWindowTypeDesktopMask |
+						CompWindowTypeDockMask)))
+	    {
+		focus->moveInputFocusTo ();
+	    }
+	    else
+		screen->focusDefaultWindow ();
+	}
+	else
+	    screen->focusDefaultWindow ();
+    }
+}
+
+
+bool
+PrivateWindow::stackLayerCheck (CompWindow *w,
+				Window	    clientLeader,
+				CompWindow *below)
+{
+    if (isAncestorTo (w, below))
+	return true;
+
+    if (isAncestorTo (below, w))
+	return false;
+
+    if (clientLeader && below->priv->clientLeader == clientLeader)
+	if (below->priv->isGroupTransient (clientLeader))
+	    return false;
+
+    if (w->priv->state & CompWindowStateAboveMask)
+    {
+	return true;
+    }
+    else if (w->priv->state & CompWindowStateBelowMask)
+    {
+	if (below->priv->state & CompWindowStateBelowMask)
+	    return true;
+    }
+    else if (!(below->priv->state & CompWindowStateAboveMask))
+    {
+	return true;
+    }
+
+    return false;
+}
+
+bool
+PrivateWindow::avoidStackingRelativeTo (CompWindow *w)
+{
+    if (w->overrideRedirect ())
+	return true;
+
+    if (w->destroyed ())
+	return true;
+
+    if (!w->priv->shaded && !w->priv->pendingMaps)
+    {
+	if (!w->isViewable () || !w->isMapped ())
+	    return true;
+    }
+
+    return false;
+}
+
+/* goes through the stack, top-down until we find a window we should
+   stack above, normal windows can be stacked above fullscreen windows
+   (and fullscreen windows over others in their layer) if aboveFs is true. */
+CompWindow *
+PrivateWindow::findSiblingBelow (CompWindow *w,
+				 bool       aboveFs)
+{
+    CompWindow   *below;
+    CompWindow   *t = screen->findWindow (w->transientFor ());
+    Window	 clientLeader = w->priv->clientLeader;
+    unsigned int type = w->priv->type;
+    unsigned int belowMask;
+
+    if (aboveFs)
+	belowMask = CompWindowTypeDockMask;
+    else
+	belowMask = CompWindowTypeDockMask | CompWindowTypeFullscreenMask;
+
+    /* normal stacking of fullscreen windows with below state */
+    if ((type & CompWindowTypeFullscreenMask) &&
+	(w->priv->state & CompWindowStateBelowMask))
+	type = CompWindowTypeNormalMask;
+
+    while (t && type != CompWindowTypeDockMask)
+    {
+	/* dock stacking of transients for docks */
+	if (t->type () & CompWindowTypeDockMask)
+	    type = CompWindowTypeDockMask;
+
+	t = screen->findWindow (t->transientFor ());
+    }
+
+    if (w->priv->transientFor || w->priv->isGroupTransient (clientLeader))
+	clientLeader = None;
+
+    for (below = screen->serverWindows ().back (); below;
+	 below = below->serverPrev)
+    {
+	if (below == w || avoidStackingRelativeTo (below))
+	    continue;
+
+	/* always above desktop windows */
+	if (below->priv->type & CompWindowTypeDesktopMask)
+	    return below;
+
+	switch (type) {
+	case CompWindowTypeDesktopMask:
+	    /* desktop window layer */
+	    break;
+	case CompWindowTypeFullscreenMask:
+	    if (aboveFs)
+		return below;
+	    /* otherwise fall-through */
+	case CompWindowTypeDockMask:
+	    /* fullscreen and dock layer */
+	    if (below->priv->type & (CompWindowTypeFullscreenMask |
+			       CompWindowTypeDockMask))
+	    {
+		if (stackLayerCheck (w, clientLeader, below))
+		    return below;
+	    }
+	    else
+	    {
+		return below;
+	    }
+	    break;
+	default:
+	{
+	    bool allowedRelativeToLayer = !(below->priv->type & belowMask);
+
+	    t = screen->findWindow (below->transientFor ());
+
+	    while (t && allowedRelativeToLayer)
+	    {
+		/* dock stacking of transients for docks */
+		allowedRelativeToLayer = !(t->priv->type & belowMask);
+
+		t = screen->findWindow (t->transientFor ());
+	    }
+
+	    /* fullscreen and normal layer */
+	    if (allowedRelativeToLayer)
+	    {
+		if (stackLayerCheck (w, clientLeader, below))
+		    return below;
+	    }
+	    break;
+	}
+	}
+    }
+
+    return NULL;
+}
+
+/* goes through the stack, top-down and returns the lowest window we
+   can stack above. */
+CompWindow *
+PrivateWindow::findLowestSiblingBelow (CompWindow *w)
+{
+    CompWindow   *below, *lowest = screen->serverWindows ().back ();
+    CompWindow   *t = screen->findWindow (w->transientFor ());
+    Window	 clientLeader = w->priv->clientLeader;
+    unsigned int type = w->priv->type;
+
+    /* normal stacking fullscreen windows with below state */
+    if ((type & CompWindowTypeFullscreenMask) &&
+	(w->priv->state & CompWindowStateBelowMask))
+	type = CompWindowTypeNormalMask;
+
+    while (t && type != CompWindowTypeDockMask)
+    {
+	/* dock stacking of transients for docks */
+	if (t->type () & CompWindowTypeDockMask)
+	    type = CompWindowTypeDockMask;
+
+	t = screen->findWindow (t->transientFor ());
+    }
+
+
+    if (w->priv->transientFor || w->priv->isGroupTransient (clientLeader))
+	clientLeader = None;
+
+    for (below = screen->serverWindows ().back (); below;
+	 below = below->serverPrev)
+    {
+	if (below == w || avoidStackingRelativeTo (below))
+	    continue;
+
+	/* always above desktop windows */
+	if (below->priv->type & CompWindowTypeDesktopMask)
+	    return below;
+
+	switch (type) {
+	case CompWindowTypeDesktopMask:
+	    /* desktop window layer - desktop windows always should be
+	       stacked at the bottom; no other window should be below them */
+	    return NULL;
+	    break;
+	case CompWindowTypeFullscreenMask:
+	case CompWindowTypeDockMask:
+	    /* fullscreen and dock layer */
+	    if (below->priv->type & (CompWindowTypeFullscreenMask |
+			       CompWindowTypeDockMask))
+	    {
+		if (!stackLayerCheck (below, clientLeader, w))
+		    return lowest;
+	    }
+	    else
+	    {
+		return lowest;
+	    }
+	    break;
+	default:
+	{
+	    bool allowedRelativeToLayer = !(below->priv->type & CompWindowTypeDockMask);
+
+	    t = screen->findWindow (below->transientFor ());
+
+	    while (t && allowedRelativeToLayer)
+	    {
+		/* dock stacking of transients for docks */
+		allowedRelativeToLayer = !(t->priv->type & CompWindowTypeDockMask);
+
+		t = screen->findWindow (t->transientFor ());
+	    }
+
+	    /* fullscreen and normal layer */
+	    if (allowedRelativeToLayer)
+	    {
+		if (!stackLayerCheck (below, clientLeader, w))
+		    return lowest;
+	    }
+	    break;
+	}
+	}
+
+	lowest = below;
+    }
+
+    return lowest;
+}
+
+bool
+PrivateWindow::validSiblingBelow (CompWindow *w,
+				  CompWindow *sibling)
+{
+    CompWindow   *t = screen->findWindow (w->transientFor ());
+    Window	 clientLeader = w->priv->clientLeader;
+    unsigned int type = w->priv->type;
+
+    /* normal stacking fullscreen windows with below state */
+    if ((type & CompWindowTypeFullscreenMask) &&
+	(w->priv->state & CompWindowStateBelowMask))
+	type = CompWindowTypeNormalMask;
+
+    while (t && type != CompWindowTypeDockMask)
+    {
+	/* dock stacking of transients for docks */
+	if (t->type () & CompWindowTypeDockMask)
+	    type = CompWindowTypeDockMask;
+
+	t = screen->findWindow (t->transientFor ());
+    }
+
+
+    if (w->priv->transientFor || w->priv->isGroupTransient (clientLeader))
+	clientLeader = None;
+
+    if (sibling == w || avoidStackingRelativeTo (sibling))
+	return false;
+
+    /* always above desktop windows */
+    if (sibling->priv->type & CompWindowTypeDesktopMask)
+	return true;
+
+    switch (type) {
+    case CompWindowTypeDesktopMask:
+	/* desktop window layer */
+	break;
+    case CompWindowTypeFullscreenMask:
+    case CompWindowTypeDockMask:
+	/* fullscreen and dock layer */
+	if (sibling->priv->type & (CompWindowTypeFullscreenMask |
+			     CompWindowTypeDockMask))
+	{
+	    if (stackLayerCheck (w, clientLeader, sibling))
+		return true;
+	}
+	else
+	{
+	    return true;
+	}
+	break;
+    default:
+    {
+	bool allowedRelativeToLayer = !(sibling->priv->type & CompWindowTypeDockMask);
+
+	t = screen->findWindow (sibling->transientFor ());
+
+	while (t && allowedRelativeToLayer)
+	{
+	    /* dock stacking of transients for docks */
+	    allowedRelativeToLayer = !(t->priv->type & CompWindowTypeDockMask);
+
+	    t = screen->findWindow (t->transientFor ());
+	}
+
+	/* fullscreen and normal layer */
+	if (allowedRelativeToLayer)
+	{
+	    if (stackLayerCheck (w, clientLeader, sibling))
+		return true;
+	}
+	break;
+    }
+    }
+
+    return false;
+}
+
+void
+PrivateWindow::saveGeometry (int mask)
+{
+    int m = mask & ~saveMask;
+
+    /* only save geometry if window has been placed */
+    if (!placed)
+	return;
+
+    if (m & CWX)
+	saveWc.x = serverGeometry.x ();
+
+    if (m & CWY)
+	saveWc.y = serverGeometry.y ();
+
+    if (m & CWWidth)
+	saveWc.width = serverGeometry.width ();
+
+    if (m & CWHeight)
+	saveWc.height = serverGeometry.height ();
+
+    if (m & CWBorderWidth)
+	saveWc.border_width = serverGeometry.border ();
+
+    saveMask |= m;
+}
+
+int
+PrivateWindow::restoreGeometry (XWindowChanges *xwc,
+				int            mask)
+{
+    int m = mask & saveMask;
+
+    if (m & CWX)
+	xwc->x = saveWc.x;
+
+    if (m & CWY)
+	xwc->y = saveWc.y;
+
+    if (m & CWWidth)
+    {
+	xwc->width = saveWc.width;
+
+	/* This is not perfect but it works OK for now. If the saved width is
+	   the same as the current width then make it a little be smaller so
+	   the user can see that it changed and it also makes sure that
+	   windowResizeNotify is called and plugins are notified. */
+	if (xwc->width == (int) serverGeometry.width ())
+	{
+	    xwc->width -= 10;
+	    if (m & CWX)
+		xwc->x += 5;
+	}
+    }
+
+    if (m & CWHeight)
+    {
+	xwc->height = saveWc.height;
+
+	/* As above, if the saved height is the same as the current height
+	   then make it a little be smaller. */
+	if (xwc->height == (int) serverGeometry.height ())
+	{
+	    xwc->height -= 10;
+	    if (m & CWY)
+		xwc->y += 5;
+	}
+    }
+
+    if (m & CWBorderWidth)
+	xwc->border_width = saveWc.border_width;
+
+    saveMask &= ~mask;
+
+    return m;
+}
+
+void
+PrivateWindow::reconfigureXWindow (unsigned int   valueMask,
+				   XWindowChanges *xwc)
+{
+    unsigned int frameValueMask = valueMask;
+
+    /* Immediately sync window position
+     * if plugins were updating w->geometry () directly
+     * in order to avoid a race condition */
+
+    window->syncPosition ();
+
+    /* Remove redundant bits */
+
+    if (serverGeometry.x () == xwc->x)
+	valueMask &= ~(CWX);
+
+    if (serverGeometry.y () == xwc->y)
+	valueMask &= ~(CWY);
+
+    if (serverGeometry.width () == xwc->width)
+	valueMask &= ~(CWWidth);
+
+    if (serverGeometry.height () == xwc->height)
+	valueMask &= ~(CWHeight);
+
+    if (serverGeometry.border () == xwc->border_width)
+	valueMask &= ~(CWBorderWidth);
+
+    if (window->serverPrev && ROOTPARENT (window->serverPrev) == xwc->sibling)
+    {
+	/* check if the sibling is also pending a restack,
+	 * if not, then setting this bit is useless */
+
+	bool pendingRestack = false;
+
+	foreach (XWCValueMask &xwcvm, window->serverPrev->priv->pendingConfigures)
+	{
+	    if (xwcvm.second & (CWSibling | CWStackMode))
+	    {
+		pendingRestack = true;
+		break;
+	    }
+	}
+
+	if (!pendingRestack)
+	    valueMask &= ~(CWSibling | CWStackMode);
+    }
+
+    if (valueMask & CWBorderWidth)
+	serverGeometry.setBorder (xwc->border_width);
+
+    if (valueMask & CWX)
+	serverGeometry.setX (xwc->x);
+
+    if (valueMask & CWY)
+	serverGeometry.setY (xwc->y);
+
+    if (valueMask & CWWidth)
+	serverGeometry.setWidth (xwc->width);
+
+    if (valueMask & CWHeight)
+	serverGeometry.setHeight (xwc->height);
+
+    /* Update the server side window list on raise, lower and restack functions.
+     * This function should only recieve stack_mode == Above
+     * but warn incase something else does get through, to make the cause
+     * of any potential misbehaviour obvious. */
+    if (valueMask & (CWSibling | CWStackMode))
+    {
+	if (xwc->stack_mode == Above)
+	{
+	    if (xwc->sibling)
+	    {
+		screen->unhookServerWindow (window);
+		screen->insertServerWindow (window, xwc->sibling);
+	    }
+	}
+	else
+	    compLogMessage ("core", CompLogLevelWarn, "restack_mode not Above");
+    }
+
+    if (serverFrameGeometry.x () == xwc->x - serverGeometry.border () - serverInput.left)
+	frameValueMask &= ~(CWX);
+
+    if (serverFrameGeometry.y () == xwc->y - serverGeometry.border () - serverInput.top)
+	frameValueMask &= ~(CWY);
+
+   if (serverFrameGeometry.width () == xwc->width + serverGeometry.border () * 2
+				      + serverInput.left + serverInput.right)
+	frameValueMask &= ~(CWWidth);
+
+    if (serverFrameGeometry.height () == xwc->height + serverGeometry.border () * 2
+				      + serverInput.top + serverInput.bottom)
+	frameValueMask &= ~(CWHeight);
+
+    /* Can't set the border width of frame windows */
+    frameValueMask &= ~(CWBorderWidth);
+
+    if (frameValueMask & CWX)
+	serverFrameGeometry.setX (xwc->x - serverGeometry.border () - serverInput.left);
+
+    if (frameValueMask & CWY)
+	serverFrameGeometry.setY (xwc->y -serverGeometry.border () - serverInput.top);
+
+    if (frameValueMask & CWWidth)
+	serverFrameGeometry.setWidth (xwc->width + serverGeometry.border () * 2
+				      + serverInput.left + serverInput.right);
+
+    if (frameValueMask & CWHeight)
+	serverFrameGeometry.setHeight (xwc->height + serverGeometry.border () * 2
+				      + serverInput.top + serverInput.bottom);
+
+
+    if (serverFrame)
+    {
+	if (frameValueMask)
+	{
+	    XWindowChanges wc = *xwc;
+
+	    wc.x      = serverFrameGeometry.x ();
+	    wc.y      = serverFrameGeometry.y ();
+	    wc.width  = serverFrameGeometry.width ();
+	    wc.height = serverFrameGeometry.height ();
+
+	    addPendingConfigure (wc, frameValueMask);
+
+	    XConfigureWindow (screen->dpy (), serverFrame, frameValueMask, &wc);
+	}
+	valueMask &= ~(CWSibling | CWStackMode);
+
+	if (valueMask)
+	{
+	    xwc->x = serverInput.left;
+	    xwc->y = serverInput.top;
+	    XConfigureWindow (screen->dpy (), wrapper, valueMask, xwc);
+
+	    xwc->x = 0;
+	    xwc->y = 0;
+	}
+
+	window->sendConfigureNotify ();
+    }
+
+    if (valueMask)
+	XConfigureWindow (screen->dpy (), id, valueMask, xwc);
+}
+
+bool
+PrivateWindow::stackDocks (CompWindow     *w,
+                           CompWindowList &updateList,
+                           XWindowChanges *xwc,
+                           unsigned int   *mask)
+{
+    CompWindow *firstFullscreenWindow = NULL;
+    CompWindow *belowDocks = NULL;
+
+    foreach (CompWindow *dw, screen->serverWindows ())
+    {
+        /* fullscreen window found */
+        if (firstFullscreenWindow)
+        {
+	    /* If there is another toplevel window above the fullscreen one
+	     * then we need to stack above that */
+            if (dw->focus () &&
+                !PrivateWindow::isAncestorTo (w, dw) &&
+                !(dw->type () & (CompWindowTypeFullscreenMask |
+                                 CompWindowTypeDockMask)) &&
+                !dw->overrideRedirect () &&
+                dw->defaultViewport () == screen->vp () &&
+		dw->isViewable ())
+            {
+                belowDocks = dw;
+            }
+        }
+        else if (dw->type () & CompWindowTypeFullscreenMask)
+        {
+	    /* First fullscreen window found when checking up the stack
+	     * now go back down to find a suitable candidate client
+	     * window to put the docks above */
+            firstFullscreenWindow = dw;
+	    for (CompWindow *dww = dw->serverPrev; dww; dww = dww->serverPrev)
+            {
+                if (!(dww->type () & (CompWindowTypeFullscreenMask |
+                                      CompWindowTypeDockMask)) &&
+                    !dww->overrideRedirect () &&
+                    dww->defaultViewport () == screen->vp () &&
+		    dww->isViewable ())
+                {
+                    belowDocks = dww;
+                    break;
+                }
+            }
+        }
+    }
+
+    if (belowDocks)
+    {
+        *mask = CWSibling | CWStackMode;
+        xwc->sibling = ROOTPARENT (belowDocks);
+
+        /* Collect all dock windows first */
+	foreach (CompWindow *dw, screen->serverWindows ())
+            if (dw->priv->type & CompWindowTypeDockMask)
+                updateList.push_front (dw);
+
+        return true;
+    }
+
+    return false;
+}
+
+bool
+PrivateWindow::stackTransients (CompWindow	*w,
+				CompWindow	*avoid,
+				XWindowChanges *xwc,
+				CompWindowList &updateList)
+{
+    CompWindow *t;
+    Window     clientLeader = w->priv->clientLeader;
+
+    if (w->priv->transientFor || w->priv->isGroupTransient (clientLeader))
+	clientLeader = None;
+
+    for (t = screen->serverWindows ().back (); t; t = t->serverPrev)
+    {
+	if (t == w || t == avoid)
+	    continue;
+
+	if (t->priv->transientFor == w->priv->id ||
+	    t->priv->isGroupTransient (clientLeader))
+	{
+	    if (!stackTransients (t, avoid, xwc, updateList))
+		return false;
+
+	    if (xwc->sibling == t->priv->id ||
+		(t->priv->serverFrame && xwc->sibling == t->priv->serverFrame))
+		return false;
+
+	    if (t->priv->mapNum || t->priv->pendingMaps)
+		updateList.push_back (t);
+	}
+    }
+
+    return true;
+}
+
+void
+PrivateWindow::stackAncestors (CompWindow     *w,
+			       XWindowChanges *xwc,
+			       CompWindowList &updateList)
+{
+    CompWindow *transient = NULL;
+
+    if (w->priv->transientFor)
+	transient = screen->findWindow (w->priv->transientFor);
+
+    if (transient                           &&
+	xwc->sibling != transient->priv->id &&
+	(!transient->priv->serverFrame || xwc->sibling != transient->priv->serverFrame))
+    {
+	CompWindow *ancestor;
+
+	ancestor = screen->findWindow (w->priv->transientFor);
+	if (ancestor)
+	{
+	    if (!stackTransients (ancestor, w, xwc, updateList))
+		return;
+
+	    if (ancestor->priv->type & CompWindowTypeDesktopMask)
+		return;
+
+	    if (ancestor->priv->type & CompWindowTypeDockMask)
+		if (!(w->priv->type & CompWindowTypeDockMask))
+		    return;
+
+	    if (ancestor->priv->mapNum || ancestor->priv->pendingMaps)
+		updateList.push_back (ancestor);
+
+	    stackAncestors (ancestor, xwc, updateList);
+	}
+    }
+    else if (w->priv->isGroupTransient (w->priv->clientLeader))
+    {
+	CompWindow *a;
+
+	for (a = screen->serverWindows ().back (); a; a = a->serverPrev)
+	{
+	    if (a->priv->clientLeader == w->priv->clientLeader &&
+		a->priv->transientFor == None		       &&
+		!a->priv->isGroupTransient (w->priv->clientLeader))
+	    {
+		if (xwc->sibling == a->priv->id ||
+		    (a->priv->serverFrame && xwc->sibling == a->priv->serverFrame))
+		    break;
+
+		if (!stackTransients (a, w, xwc, updateList))
+		    break;
+
+		if (a->priv->type & CompWindowTypeDesktopMask)
+		    continue;
+
+		if (a->priv->type & CompWindowTypeDockMask)
+		    if (!(w->priv->type & CompWindowTypeDockMask))
+			break;
+
+		if (a->priv->mapNum || a->priv->pendingMaps)
+		    updateList.push_back (a);
+	    }
+	}
+    }
+}
+
+void
+CompWindow::configureXWindow (unsigned int valueMask,
+			      XWindowChanges *xwc)
+{
+    if (priv->managed && (valueMask & (CWSibling | CWStackMode)))
+    {
+	CompWindowList transients;
+	CompWindowList ancestors;
+	CompWindowList docks;
+
+	/* Since the window list is being reordered in reconfigureXWindow
+	   the list of windows which need to be restacked must be stored
+	   first. The windows are stacked in the opposite order than they
+	   were previously stacked, in order that they are above xwc->sibling
+	   so that when compiz gets the ConfigureNotify event it doesn't
+	   have to restack all the windows again. */
+
+	/* transient children above */
+	if (PrivateWindow::stackTransients (this, NULL, xwc, transients))
+	{
+	    /* ancestors, siblings and sibling transients below */
+	    PrivateWindow::stackAncestors (this, xwc, ancestors);
+
+	    for (CompWindowList::reverse_iterator w = ancestors.rbegin ();
+		 w != ancestors.rend (); w++)
+	    {
+		(*w)->priv->reconfigureXWindow (CWSibling | CWStackMode, xwc);
+		xwc->sibling = ROOTPARENT (*w);
+	    }
+
+	    this->priv->reconfigureXWindow (valueMask, xwc);
+	    xwc->sibling = ROOTPARENT (this);
+
+	    for (CompWindowList::reverse_iterator w = transients.rbegin ();
+		 w != transients.rend (); w++)
+	    {
+		(*w)->priv->reconfigureXWindow (CWSibling | CWStackMode, xwc);
+		xwc->sibling = ROOTPARENT (*w);
+	    }
+
+	    if (PrivateWindow::stackDocks (this, docks, xwc, &valueMask))
+	    {
+		Window sibling = xwc->sibling;
+		xwc->stack_mode = Above;
+
+                /* Then update the dock windows */
+                foreach (CompWindow *dw, docks)
+                {
+                    xwc->sibling = sibling;
+                    dw->priv->reconfigureXWindow (valueMask, xwc);
+                }
+            }
+	}
+    }
+    else if (priv->id)
+    {
+	priv->reconfigureXWindow (valueMask, xwc);
+    }
+}
+
+int
+PrivateWindow::addWindowSizeChanges (XWindowChanges       *xwc,
+				     CompWindow::Geometry old)
+{
+    CompRect  workArea;
+    int	      mask = 0;
+    int	      x, y;
+    int	      output;
+    CompPoint viewport;
+
+    screen->viewportForGeometry (old, viewport);
+
+    x = (viewport.x () - screen->vp ().x ()) * screen->width ();
+    y = (viewport.y () - screen->vp ().y ()) * screen->height ();
+
+    output   = screen->outputDeviceForGeometry (old);
+    workArea = screen->getWorkareaForOutput (output);
+
+    if (type & CompWindowTypeFullscreenMask)
+    {
+	saveGeometry (CWX | CWY | CWWidth | CWHeight | CWBorderWidth);
+
+	if (fullscreenMonitorsSet)
+	{
+	    xwc->x      = x + fullscreenMonitorRect.x ();
+	    xwc->y      = y + fullscreenMonitorRect.y ();
+	    xwc->width  = fullscreenMonitorRect.width ();
+	    xwc->height = fullscreenMonitorRect.height ();
+	}
+	else
+	{
+	    xwc->x      = x + screen->outputDevs ()[output].x ();
+	    xwc->y      = y + screen->outputDevs ()[output].y ();
+	    xwc->width  = screen->outputDevs ()[output].width ();
+	    xwc->height = screen->outputDevs ()[output].height ();
+	}
+
+	xwc->border_width = 0;
+
+	mask |= CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
+    }
+    else
+    {
+	mask |= restoreGeometry (xwc, CWBorderWidth);
+
+	if (state & CompWindowStateMaximizedVertMask)
+	{
+	    saveGeometry (CWY | CWHeight);
+
+	    xwc->height = workArea.height () - serverInput.top -
+			  serverInput.bottom - old.border () * 2;
+
+	    mask |= CWHeight;
+	}
+	else
+	{
+	    mask |= restoreGeometry (xwc, CWY | CWHeight);
+	}
+
+	if (state & CompWindowStateMaximizedHorzMask)
+	{
+	    saveGeometry (CWX | CWWidth);
+
+	    xwc->width = workArea.width () - serverInput.left -
+			 serverInput.right - old.border () * 2;
+
+	    mask |= CWWidth;
+	}
+	else
+	{
+	    mask |= restoreGeometry (xwc, CWX | CWWidth);
+	}
+
+	/* constrain window width if smaller than minimum width */
+	if (!(mask & CWWidth) && (int) old.width () < sizeHints.min_width)
+	{
+	    xwc->width = sizeHints.min_width;
+	    mask |= CWWidth;
+	}
+
+	/* constrain window width if greater than maximum width */
+	if (!(mask & CWWidth) && (int) old.width () > sizeHints.max_width)
+	{
+	    xwc->width = sizeHints.max_width;
+	    mask |= CWWidth;
+	}
+
+	/* constrain window height if smaller than minimum height */
+	if (!(mask & CWHeight) && (int) old.height () < sizeHints.min_height)
+	{
+	    xwc->height = sizeHints.min_height;
+	    mask |= CWHeight;
+	}
+
+	/* constrain window height if greater than maximum height */
+	if (!(mask & CWHeight) && (int) old.height () > sizeHints.max_height)
+	{
+	    xwc->height = sizeHints.max_height;
+	    mask |= CWHeight;
+	}
+
+	if (mask & (CWWidth | CWHeight))
+	{
+	    int width, height, max;
+
+	    width  = (mask & CWWidth)  ? xwc->width  : old.width ();
+	    height = (mask & CWHeight) ? xwc->height : old.height ();
+
+	    xwc->width  = old.width ();
+	    xwc->height = old.height ();
+
+	    window->constrainNewWindowSize (width, height, &width, &height);
+
+	    if (width != (int) old.width ())
+	    {
+		mask |= CWWidth;
+		xwc->width = width;
+	    }
+	    else
+		mask &= ~CWWidth;
+
+	    if (height != (int) old.height ())
+	    {
+		mask |= CWHeight;
+		xwc->height = height;
+	    }
+	    else
+		mask &= ~CWHeight;
+
+	    if (state & CompWindowStateMaximizedVertMask)
+	    {
+		if (old.y () < y + workArea.y () + serverInput.top)
+		{
+		    xwc->y = y + workArea.y () + serverInput.top;
+		    mask |= CWY;
+		}
+		else
+		{
+		    height = xwc->height + old.border () * 2;
+
+		    max = y + workArea.bottom ();
+		    if (old.y () + (int) old.height () + serverInput.bottom > max)
+		    {
+			xwc->y = max - height - serverInput.bottom;
+			mask |= CWY;
+		    }
+		    else if (old.y () + height + serverInput.bottom > max)
+		    {
+			xwc->y = y + workArea.y () +
+			         (workArea.height () - serverInput.top - height -
+				  serverInput.bottom) / 2 + serverInput.top;
+			mask |= CWY;
+		    }
+		}
+	    }
+
+	    if (state & CompWindowStateMaximizedHorzMask)
+	    {
+		if (old.x () < x + workArea.x () + serverInput.left)
+		{
+		    xwc->x = x + workArea.x () + serverInput.left;
+		    mask |= CWX;
+		}
+		else
+		{
+		    width = xwc->width + old.border () * 2;
+
+		    max = x + workArea.right ();
+		    if (old.x () + (int) old.width () + serverInput.right > max)
+		    {
+			xwc->x = max - width - serverInput.right;
+			mask |= CWX;
+		    }
+		    else if (old.x () + width + serverInput.right > max)
+		    {
+			xwc->x = x + workArea.x () +
+			         (workArea.width () - serverInput.left - width -
+				  serverInput.right) / 2 + serverInput.left;
+			mask |= CWX;
+		    }
+		}
+	    }
+	}
+    }
+
+    if ((mask & CWX) && (xwc->x == old.x ()))
+	mask &= ~CWX;
+
+    if ((mask & CWY) && (xwc->y == old.y ()))
+	mask &= ~CWY;
+
+    if ((mask & CWWidth) && (xwc->width == (int) old.width ()))
+	mask &= ~CWWidth;
+
+    if ((mask & CWHeight) && (xwc->height == (int) old.height ()))
+	mask &= ~CWHeight;
+
+    return mask;
+}
+
+unsigned int
+PrivateWindow::adjustConfigureRequestForGravity (XWindowChanges *xwc,
+						 unsigned int   xwcm,
+						 int            gravity,
+						 int		direction)
+{
+    int          newX, newY;
+    unsigned int mask = 0;
+
+    newX = xwc->x;
+    newY = xwc->y;
+
+    if (xwcm & (CWX | CWWidth))
+    {
+	switch (gravity) {
+	case NorthWestGravity:
+	case WestGravity:
+	case SouthWestGravity:
+	    if (xwcm & CWX)
+		newX += priv->border.left * direction;
+	    break;
+
+	case NorthGravity:
+	case CenterGravity:
+	case SouthGravity:
+	    if (xwcm & CWX)
+		newX -= (xwc->width / 2 - priv->border.left +
+			(priv->border.left + priv->border.right) / 2) * direction;
+	    else
+	        newX -= (xwc->width - priv->serverGeometry.width ()) * direction;
+	    break;
+
+	case NorthEastGravity:
+	case EastGravity:
+	case SouthEastGravity:
+	    if (xwcm & CWX)
+		newX -= xwc->width + priv->border.right * direction;
+	    else
+		newX -= (xwc->width - priv->serverGeometry.width ()) * direction;
+	    break;
+
+	case StaticGravity:
+	default:
+	    break;
+	}
+    }
+
+    if (xwcm & (CWY | CWHeight))
+    {
+	switch (gravity) {
+	case NorthWestGravity:
+	case NorthGravity:
+	case NorthEastGravity:
+	    if (xwcm & CWY)
+		newY = xwc->y + priv->serverInput.top * direction;
+	    break;
+
+	case WestGravity:
+	case CenterGravity:
+	case EastGravity:
+	    if (xwcm & CWY)
+		newY -= (xwc->height / 2 - priv->serverInput.top +
+			(priv->serverInput.top + priv->serverInput.bottom) / 2) * direction;
+	    else
+		newY -= ((xwc->height - priv->serverGeometry.height ()) / 2) * direction;
+	    break;
+
+	case SouthWestGravity:
+	case SouthGravity:
+	case SouthEastGravity:
+	    if (xwcm & CWY)
+		newY -= xwc->height + priv->serverInput.bottom * direction;
+	    else
+		newY -= (xwc->height - priv->serverGeometry.height ()) * direction;
+	    break;
+
+	case StaticGravity:
+	default:
+	    break;
+	}
+    }
+
+    if (newX != xwc->x)
+    {
+	xwc->x += (newX - xwc->x);
+	mask |= CWX;
+    }
+
+    if (newY != xwc->y)
+    {
+	xwc->y += (newY - xwc->y);
+	mask |= CWY;
+    }
+
+    return mask;
+}
+
+void
+CompWindow::moveResize (XWindowChanges *xwc,
+			unsigned int   xwcm,
+			int            gravity,
+			unsigned int   source)
+{
+    bool placed = false;
+
+    xwcm &= (CWX | CWY | CWWidth | CWHeight | CWBorderWidth);
+
+    if (xwcm & (CWX | CWY))
+	if (priv->sizeHints.flags & (USPosition | PPosition))
+	    placed = true;
+
+    if (gravity == 0)
+	gravity = priv->sizeHints.win_gravity;
+
+    if (!(xwcm & CWX))
+	xwc->x = priv->serverGeometry.x ();
+    if (!(xwcm & CWY))
+	xwc->y = priv->serverGeometry.y ();
+    if (!(xwcm & CWWidth))
+	xwc->width = priv->serverGeometry.width ();
+    if (!(xwcm & CWHeight))
+	xwc->height = priv->serverGeometry.height ();
+
+    if (xwcm & (CWWidth | CWHeight))
+    {
+	int width, height;
+
+	if (constrainNewWindowSize (xwc->width, xwc->height, &width, &height))
+	{
+	    if (width != xwc->width)
+		xwcm |= CWWidth;
+
+	    if (height != xwc->height)
+		xwcm |= CWHeight;
+
+	    xwc->width = width;
+	    xwc->height = height;
+	}
+    }
+
+    xwcm |= priv->adjustConfigureRequestForGravity (xwc, xwcm, gravity, 1);
+
+    validateResizeRequest (xwcm, xwc, source);
+
+    /* when horizontally maximized only allow width changes added by
+       addWindowSizeChanges */
+    if (priv->state & CompWindowStateMaximizedHorzMask)
+	xwcm &= ~CWWidth;
+
+    /* when vertically maximized only allow height changes added by
+       addWindowSizeChanges */
+    if (priv->state & CompWindowStateMaximizedVertMask)
+	xwcm &= ~CWHeight;
+
+    xwcm |= priv->addWindowSizeChanges (xwc, Geometry (xwc->x, xwc->y,
+					xwc->width, xwc->height,
+					xwc->border_width));
+
+    /* check if the new coordinates are useful and valid (different
+       to current size); if not, we have to clear them to make sure
+       we send a synthetic ConfigureNotify event if all coordinates
+       match the server coordinates */
+    if (xwc->x == priv->serverGeometry.x ())
+	xwcm &= ~CWX;
+
+    if (xwc->y == priv->serverGeometry.y ())
+	xwcm &= ~CWY;
+
+    if (xwc->width == (int) priv->serverGeometry.width ())
+	xwcm &= ~CWWidth;
+
+    if (xwc->height == (int) priv->serverGeometry.height ())
+	xwcm &= ~CWHeight;
+
+    if (xwc->border_width == (int) priv->serverGeometry.border ())
+	xwcm &= ~CWBorderWidth;
+
+    /* update saved window coordinates - if CWX or CWY is set for fullscreen
+       or maximized windows after addWindowSizeChanges, it should be pretty
+       safe to assume that the saved coordinates should be updated too, e.g.
+       because the window was moved to another viewport by some client */
+    if ((xwcm & CWX) && (priv->saveMask & CWX))
+	priv->saveWc.x += (xwc->x - priv->serverGeometry.x ());
+
+    if ((xwcm & CWY) && (priv->saveMask & CWY))
+	priv->saveWc.y += (xwc->y - priv->serverGeometry.y ());
+
+    if (priv->mapNum && (xwcm & (CWWidth | CWHeight)))
+	sendSyncRequest ();
+
+    if (xwcm)
+	configureXWindow (xwcm, xwc);
+    else
+    {
+	/* we have to send a configure notify on ConfigureRequest events if
+	   we decide not to do anything according to ICCCM 4.1.5 */
+	sendConfigureNotify ();
+    }
+
+    if (placed)
+	priv->placed = true;
+}
+
+void
+PrivateWindow::updateSize ()
+{
+    XWindowChanges xwc;
+    int		   mask;
+
+    if (window->overrideRedirect () || !managed)
+	return;
+
+    mask = priv->addWindowSizeChanges (&xwc, priv->serverGeometry);
+    if (mask)
+    {
+	if (priv->mapNum && (mask & (CWWidth | CWHeight)))
+	    window->sendSyncRequest ();
+
+	window->configureXWindow (mask, &xwc);
+    }
+}
+
+int
+PrivateWindow::addWindowStackChanges (XWindowChanges *xwc,
+				      CompWindow     *sibling)
+{
+    int	mask = 0;
+
+    if (!sibling || sibling->priv->id != id)
+    {
+	/* Alow requests to go on top of serverPrev
+	 * if serverPrev was recently restacked */
+	if (window->serverPrev)
+	{
+	    if (!sibling && id)
+	    {
+		XWindowChanges lxwc;
+		unsigned int   valueMask = CWStackMode;
+
+		lxwc.stack_mode = Below;
+
+		/* Below with no sibling puts the window at the bottom
+		 * of the stack */
+		XConfigureWindow (screen->dpy (), ROOTPARENT (window), valueMask, &lxwc);
+
+		if (serverFrame)
+		    priv->addPendingConfigure (lxwc, CWStackMode);
+
+		/* Update the list of windows last sent to the server */
+		screen->unhookServerWindow (window);
+		screen->insertServerWindow (window, 0);
+	    }
+	    else if (sibling)
+	    {
+		bool pendingRestacks = false;
+
+		foreach (XWCValueMask &xwcvm, sibling->priv->pendingConfigures)
+		{
+		    if (xwcvm.second & (CWSibling | CWStackMode))
+		    {
+			pendingRestacks = true;
+			break;
+		    }
+		}
+
+		if (sibling->priv->id != window->serverPrev->priv->id || pendingRestacks)
+		{
+		    mask |= CWSibling | CWStackMode;
+
+		    xwc->stack_mode = Above;
+		    xwc->sibling    = ROOTPARENT (sibling);
+		}
+	    }
+	}
+	else if (sibling)
+	{
+	    mask |= CWSibling | CWStackMode;
+
+	    xwc->stack_mode = Above;
+	    xwc->sibling    = ROOTPARENT (sibling);
+	}
+    }
+
+    return mask;
+}
+
+void
+CompWindow::raise ()
+{
+    XWindowChanges xwc;
+    int		   mask;
+    bool	   aboveFs = false;
+
+    /* an active fullscreen window should be raised over all other
+       windows in its layer */
+    if (priv->type & CompWindowTypeFullscreenMask)
+	if (priv->id == screen->activeWindow ())
+	    aboveFs = true;
+
+    mask = priv->addWindowStackChanges (&xwc,
+	PrivateWindow::findSiblingBelow (this, aboveFs));
+
+    if (mask)
+	configureXWindow (mask, &xwc);
+}
+
+CompWindow *
+PrivateScreen::focusTopMostWindow ()
+{
+    CompWindow  *focus = NULL;
+    CompWindowList::reverse_iterator it = serverWindows.rbegin ();
+
+    for (; it != serverWindows.rend (); it++)
+    {
+	CompWindow *w = *it;
+
+	if (w->type () & CompWindowTypeDockMask)
+	    continue;
+
+	if (w->focus ())
+	{
+	    focus = w;
+	    break;
+	}
+    }
+
+    if (focus)
+    {
+	if (focus->id () != activeWindow)
+	    focus->moveInputFocusTo ();
+    }
+    else
+	XSetInputFocus (dpy, root, RevertToPointerRoot,
+			CurrentTime);
+    return focus;
+}
+
+
+void
+CompWindow::lower ()
+{
+    XWindowChanges xwc;
+    int		   mask;
+
+    mask = priv->addWindowStackChanges (&xwc,
+	PrivateWindow::findLowestSiblingBelow (this));
+    if (mask)
+	configureXWindow (mask, &xwc);
+
+    /* when lowering a window, focus the topmost window if
+       the click-to-focus option is on */
+    if ((screen->priv->optionGetClickToFocus ()))
+    {
+	CompWindow *focusedWindow = screen->priv->focusTopMostWindow ();
+
+	/* if the newly focused window is a desktop window,
+	   give the focus back to w */
+	if (focusedWindow &&
+	    focusedWindow->type () & CompWindowTypeDesktopMask)
+	{
+	    moveInputFocusTo ();
+	}
+    }
+}
+
+void
+CompWindow::restackAbove (CompWindow *sibling)
+{
+    for (; sibling; sibling = sibling->serverNext)
+	if (PrivateWindow::validSiblingBelow (this, sibling))
+	    break;
+
+    if (sibling)
+    {
+	XWindowChanges xwc;
+	int	       mask;
+
+	mask = priv->addWindowStackChanges (&xwc, sibling);
+	if (mask)
+	    configureXWindow (mask, &xwc);
+    }
+}
+
+/* finds the highest window under sibling we can stack above */
+CompWindow *
+PrivateWindow::findValidStackSiblingBelow (CompWindow *w,
+					   CompWindow *sibling)
+{
+    CompWindow *lowest, *last, *p;
+
+    /* check whether we're allowed to stack under a sibling by finding
+     * the above 'sibling' and checking whether or not we're allowed
+     * to stack under that - if not, then there is no valid sibling
+     * underneath it */
+
+    for (p = sibling; p; p = p->serverNext)
+    {
+	if (!avoidStackingRelativeTo (p))
+	{
+	    if (!validSiblingBelow (p, w))
+		return NULL;
+	    break;
+	}
+    }
+
+    /* get lowest sibling we're allowed to stack above */
+    lowest = last = findLowestSiblingBelow (w);
+
+    /* walk from bottom up */
+    for (p = screen->serverWindows ().front (); p; p = p->serverNext)
+    {
+	/* stop walking when we reach the sibling we should try to stack
+	   below */
+	if (p == sibling)
+	    return lowest;
+
+	/* skip windows that we should avoid */
+	if (w == p || avoidStackingRelativeTo (p))
+	    continue;
+
+	if (validSiblingBelow (w, p))
+	{
+	    /* update lowest as we find windows below sibling that we're
+	       allowed to stack above. last window must be equal to the
+	       lowest as we shouldn't update lowest if we passed an
+	       invalid window */
+	    if (last == lowest)
+		lowest = p;
+	}
+
+	/* update last pointer */
+	last = p;
+    }
+
+    return lowest;
+}
+
+void
+CompWindow::restackBelow (CompWindow *sibling)
+{
+    XWindowChanges xwc;
+    unsigned int   mask;
+
+    mask = priv->addWindowStackChanges (&xwc,
+	PrivateWindow::findValidStackSiblingBelow (this, sibling));
+
+    if (mask)
+	configureXWindow (mask, &xwc);
+}
+
+void
+CompWindow::updateAttributes (CompStackingUpdateMode stackingMode)
+{
+    XWindowChanges xwc;
+    int		   mask = 0;
+
+    if (overrideRedirect () || !priv->managed)
+	return;
+
+    if (priv->state & CompWindowStateShadedMask)
+    {
+	windowNotify (CompWindowNotifyShade);
+
+	priv->hide ();
+    }
+    else if (priv->shaded)
+    {
+	windowNotify (CompWindowNotifyUnshade);
+
+	priv->show ();
+    }
+
+    if (stackingMode != CompStackingUpdateModeNone)
+    {
+	bool       aboveFs;
+	CompWindow *sibling;
+
+	aboveFs = (stackingMode == CompStackingUpdateModeAboveFullscreen);
+	if (priv->type & CompWindowTypeFullscreenMask)
+	{
+	    /* put active or soon-to-be-active fullscreen windows over
+	       all others in their layer */
+	    if (priv->id == screen->activeWindow () ||
+		priv->id == screen->priv->nextActiveWindow)
+	    {
+		aboveFs = true;
+	    }
+	}
+
+	/* put windows that are just mapped, over fullscreen windows */
+	if (stackingMode == CompStackingUpdateModeInitialMap)
+	    aboveFs = true;
+
+	sibling = PrivateWindow::findSiblingBelow (this, aboveFs);
+
+	if (sibling &&
+	    (stackingMode == CompStackingUpdateModeInitialMapDeniedFocus))
+	{
+	    CompWindow *p;
+
+	    for (p = sibling; p; p = p->serverPrev)
+		if (p->priv->id == screen->activeWindow ())
+		    break;
+
+	    /* window is above active window so we should lower it,
+	     * assuing that is allowed (if, for example, our window has
+	     * the "above" state, then lowering beneath the active
+	     * window may not be allowed). */
+	    if (p && PrivateWindow::validSiblingBelow (p, this))
+	    {
+		p = PrivateWindow::findValidStackSiblingBelow (sibling, p);
+
+		/* if we found a valid sibling under the active window, it's
+		   our new sibling we want to stack above */
+		if (p)
+		    sibling = p;
+	    }
+	}
+
+	if (sibling)
+	    mask |= priv->addWindowStackChanges (&xwc, sibling);
+    }
+
+    mask |= priv->addWindowSizeChanges (&xwc, priv->serverGeometry);
+
+    if (priv->mapNum && (mask & (CWWidth | CWHeight)))
+	sendSyncRequest ();
+
+    if (mask)
+	configureXWindow (mask, &xwc);
+}
+
+void
+PrivateWindow::ensureWindowVisibility ()
+{
+    int x1, y1, x2, y2;
+    int	width = serverGeometry.width () + serverGeometry.border () * 2;
+    int	height = serverGeometry.height () + serverGeometry.border () * 2;
+    int dx = 0;
+    int dy = 0;
+
+    if (struts || attrib.override_redirect)
+	return;
+
+    if (type & (CompWindowTypeDockMask	     |
+		CompWindowTypeFullscreenMask |
+		CompWindowTypeUnknownMask))
+	return;
+
+    x1 = screen->workArea ().x () - screen->width () * screen->vp ().x ();
+    y1 = screen->workArea ().y () - screen->height () * screen->vp ().y ();
+    x2 = x1 + screen->workArea ().width () + screen->vpSize ().width () *
+	 screen->width ();
+    y2 = y1 + screen->workArea ().height () + screen->vpSize ().height () *
+	 screen->height ();
+
+    if (serverGeometry.x () - serverInput.left >= x2)
+	dx = (x2 - 25) - serverGeometry.x ();
+    else if (serverGeometry.x () + width + serverInput.right <= x1)
+	dx = (x1 + 25) - (serverGeometry.x () + width);
+
+    if (serverGeometry.y () - serverInput.top >= y2)
+	dy = (y2 - 25) - serverGeometry.y ();
+    else if (serverGeometry.y () + height + serverInput.bottom <= y1)
+	dy = (y1 + 25) - (serverGeometry.y () + height);
+
+    if (dx || dy)
+    {
+	XWindowChanges xwc;
+
+	xwc.x = serverGeometry.x () + dx;
+	xwc.y = serverGeometry.y () + dy;
+
+	window->configureXWindow (CWX | CWY, &xwc);
+    }
+}
+
+void
+PrivateWindow::reveal ()
+{
+    if (window->minimized ())
+	window->unminimize ();
+
+    screen->leaveShowDesktopMode (window);
+}
+
+void
+PrivateWindow::revealAncestors (CompWindow *w,
+				CompWindow *transient)
+{
+    if (isAncestorTo (transient, w))
+    {
+	screen->forEachWindow (boost::bind (revealAncestors, _1, w));
+	w->priv->reveal ();
+    }
+}
+
+void
+CompWindow::activate ()
+{
+    WRAPABLE_HND_FUNC (3, activate)
+
+    screen->priv->setCurrentDesktop (priv->desktop);
+
+    screen->forEachWindow (
+	boost::bind (PrivateWindow::revealAncestors, _1, this));
+    priv->reveal ();
+
+    if (priv->state & CompWindowStateHiddenMask)
+    {
+	priv->state &= ~CompWindowStateShadedMask;
+	if (priv->shaded)
+	    priv->show ();
+    }
+
+    if (priv->state & CompWindowStateHiddenMask)
+	return;
+
+    if (!onCurrentDesktop ())
+	return;
+
+    priv->ensureWindowVisibility ();
+    updateAttributes (CompStackingUpdateModeAboveFullscreen);
+    moveInputFocusTo ();
+}
+
+
+#define PVertResizeInc (1 << 0)
+#define PHorzResizeInc (1 << 1)
+
+bool
+CompWindow::constrainNewWindowSize (int        width,
+				    int        height,
+				    int        *newWidth,
+				    int        *newHeight)
+{
+    const XSizeHints *hints = &priv->sizeHints;
+    int              oldWidth = width;
+    int              oldHeight = height;
+    int		     min_width = 0;
+    int		     min_height = 0;
+    int		     base_width = 0;
+    int		     base_height = 0;
+    int		     xinc = 1;
+    int		     yinc = 1;
+    int		     max_width = MAXSHORT;
+    int		     max_height = MAXSHORT;
+    long	     flags = hints->flags;
+    long	     resizeIncFlags = (flags & PResizeInc) ? ~0 : 0;
+
+    if (screen->priv->optionGetIgnoreHintsWhenMaximized ())
+    {
+	if (priv->state & MAXIMIZE_STATE)
+	{
+	    flags &= ~PAspect;
+
+	    if (priv->state & CompWindowStateMaximizedHorzMask)
+		resizeIncFlags &= ~PHorzResizeInc;
+
+	    if (priv->state & CompWindowStateMaximizedVertMask)
+		resizeIncFlags &= ~PVertResizeInc;
+	}
+    }
+
+    /* Ater gdk_window_constrain_size(), which is partially borrowed from fvwm.
+     *
+     * Copyright 1993, Robert Nation
+     *     You may use this code for any purpose, as long as the original
+     *     copyright remains in the source code and all documentation
+     *
+     * which in turn borrows parts of the algorithm from uwm
+     */
+
+#define FLOOR(value, base) (((int) ((value) / (base))) * (base))
+#define FLOOR64(value, base) (((uint64_t) ((value) / (base))) * (base))
+
+    if ((flags & PBaseSize) && (flags & PMinSize))
+    {
+	base_width = hints->base_width;
+	base_height = hints->base_height;
+	min_width = hints->min_width;
+	min_height = hints->min_height;
+    }
+    else if (flags & PBaseSize)
+    {
+	base_width = hints->base_width;
+	base_height = hints->base_height;
+	min_width = hints->base_width;
+	min_height = hints->base_height;
+    }
+    else if (flags & PMinSize)
+    {
+	base_width = hints->min_width;
+	base_height = hints->min_height;
+	min_width = hints->min_width;
+	min_height = hints->min_height;
+    }
+
+    if (flags & PMaxSize)
+    {
+	max_width = hints->max_width;
+	max_height = hints->max_height;
+    }
+
+    if (resizeIncFlags & PHorzResizeInc)
+	xinc = MAX (xinc, hints->width_inc);
+
+    if (resizeIncFlags & PVertResizeInc)
+	yinc = MAX (yinc, hints->height_inc);
+
+    /* clamp width and height to min and max values */
+    width  = CLAMP (width, min_width, max_width);
+    height = CLAMP (height, min_height, max_height);
+
+    /* shrink to base + N * inc */
+    width  = base_width + FLOOR (width - base_width, xinc);
+    height = base_height + FLOOR (height - base_height, yinc);
+
+    /* constrain aspect ratio, according to:
+     *
+     * min_aspect.x       width      max_aspect.x
+     * ------------  <= -------- <=  -----------
+     * min_aspect.y       height     max_aspect.y
+     */
+    if ((flags & PAspect) && hints->min_aspect.y > 0 && hints->max_aspect.x > 0)
+    {
+	/* Use 64 bit arithmetic to prevent overflow */
+
+	uint64_t min_aspect_x = hints->min_aspect.x;
+	uint64_t min_aspect_y = hints->min_aspect.y;
+	uint64_t max_aspect_x = hints->max_aspect.x;
+	uint64_t max_aspect_y = hints->max_aspect.y;
+	uint64_t delta;
+
+	if (min_aspect_x * height > width * min_aspect_y)
+	{
+	    delta = FLOOR64 (height - width * min_aspect_y / min_aspect_x,
+			     yinc);
+	    if (height - (int) delta >= min_height)
+		height -= delta;
+	    else
+	    {
+		delta = FLOOR64 (height * min_aspect_x / min_aspect_y - width,
+				 xinc);
+		if (width + (int) delta <= max_width)
+		    width += delta;
+	    }
+	}
+
+	if (width * max_aspect_y > max_aspect_x * height)
+	{
+	    delta = FLOOR64 (width - height * max_aspect_x / max_aspect_y,
+			     xinc);
+	    if (width - (int) delta >= min_width)
+		width -= delta;
+	    else
+	    {
+		delta = FLOOR64 (width * min_aspect_y / min_aspect_x - height,
+				 yinc);
+		if (height + (int) delta <= max_height)
+		    height += delta;
+	    }
+	}
+    }
+
+#undef CLAMP
+#undef FLOOR64
+#undef FLOOR
+
+    if (width != oldWidth || height != oldHeight)
+    {
+	*newWidth  = width;
+	*newHeight = height;
+
+	return true;
+    }
+
+    return false;
+}
+
+void
+CompWindow::hide ()
+{
+    priv->hidden = true;
+    priv->hide ();
+}
+
+void
+CompWindow::show ()
+{
+    priv->hidden = false;
+    priv->show ();
+}
+
+void
+PrivateWindow::hide ()
+{
+    bool onDesktop = window->onCurrentDesktop ();
+
+    if (!managed)
+	return;
+
+    if (!window->minimized () && !inShowDesktopMode &&
+	!hidden && onDesktop)
+    {
+	if (state & CompWindowStateShadedMask)
+	{
+	    shaded = true;
+	}
+	else
+	{
+	    return;
+	}
+    }
+    else
+    {
+	shaded = false;
+
+	if ((state & CompWindowStateShadedMask) && serverFrame)
+	    XUnmapWindow (screen->dpy (), serverFrame);
+    }
+
+    if (!pendingMaps && !window->isViewable ())
+	return;
+
+    window->windowNotify (CompWindowNotifyHide);
+
+    pendingUnmaps++;
+
+    if (serverFrame && !shaded)
+	XUnmapWindow (screen->dpy (), serverFrame);
+
+    XUnmapWindow (screen->dpy (), id);
+
+    if (window->minimized () || inShowDesktopMode || hidden || shaded)
+	window->changeState (state | CompWindowStateHiddenMask);
+
+    if (shaded && id == screen->activeWindow ())
+	window->moveInputFocusTo ();
+}
+
+void
+PrivateWindow::show ()
+{
+    bool onDesktop = window->onCurrentDesktop ();
+
+    if (!managed)
+	return;
+
+    if (minimized || inShowDesktopMode ||
+	hidden    || !onDesktop)
+    {
+	/* no longer hidden but not on current desktop */
+	if (!minimized && !inShowDesktopMode && !hidden)
+	    window->changeState (state & ~CompWindowStateHiddenMask);
+
+	return;
+    }
+
+    /* transition from minimized to shaded */
+    if (state & CompWindowStateShadedMask)
+    {
+	shaded = true;
+
+	if (serverFrame)
+	    XMapWindow (screen->dpy (), serverFrame);
+
+	if (height)
+	{
+	    priv->geometry.setHeight (priv->geometry.height () + 1);
+	    window->resize (geometry.x (), geometry.y (),
+			    geometry.width (), geometry.height () - 1,
+			    geometry.border ());
+	}
+
+	return;
+    }
+    else
+    {
+	shaded = false;
+    }
+
+    window->windowNotify (CompWindowNotifyShow);
+
+    pendingMaps++;
+
+    if (serverFrame)
+    {
+	XMapWindow (screen->dpy (), serverFrame);
+	XMapWindow (screen->dpy (), wrapper);
+    }
+
+    XMapWindow (screen->dpy (), id);
+
+    window->changeState (state & ~CompWindowStateHiddenMask);
+    screen->priv->setWindowState (state, id);
+}
+
+void
+PrivateWindow::minimizeTransients (CompWindow *w,
+				   CompWindow *ancestor)
+{
+    if (w->priv->transientFor == ancestor->priv->id ||
+	w->priv->isGroupTransient (ancestor->priv->clientLeader))
+    {
+	w->minimize ();
+    }
+}
+
+void
+CompWindow::minimize ()
+{
+    WRAPABLE_HND_FUNC (13, minimize);
+
+    if (!priv->managed)
+	return;
+
+    if (!priv->minimized)
+    {
+	windowNotify (CompWindowNotifyMinimize);
+
+	priv->minimized = true;
+
+	screen->forEachWindow (
+	    boost::bind (PrivateWindow::minimizeTransients, _1, this));
+
+	priv->hide ();
+    }
+}
+
+void
+PrivateWindow::unminimizeTransients (CompWindow *w,
+				     CompWindow *ancestor)
+{
+    if (w->priv->transientFor == ancestor->priv->id ||
+	w->priv->isGroupTransient (ancestor->priv->clientLeader))
+	w->unminimize ();
+}
+
+void
+CompWindow::unminimize ()
+{
+    WRAPABLE_HND_FUNC (14, unminimize);
+    if (priv->minimized)
+    {
+	windowNotify (CompWindowNotifyUnminimize);
+
+	priv->minimized = false;
+
+	priv->show ();
+
+	screen->forEachWindow (
+	    boost::bind (PrivateWindow::unminimizeTransients, _1, this));
+    }
+}
+
+void
+CompWindow::maximize (unsigned int state)
+{
+    if (overrideRedirect ())
+	return;
+
+    state = constrainWindowState (state, priv->actions);
+
+    state &= MAXIMIZE_STATE;
+
+    if (state == (priv->state & MAXIMIZE_STATE))
+	return;
+
+    state |= (priv->state & ~MAXIMIZE_STATE);
+
+    changeState (state);
+    updateAttributes (CompStackingUpdateModeNone);
+}
+
+bool
+PrivateWindow::getUserTime (Time& time)
+{
+    Atom	  actual;
+    int		  result, format;
+    unsigned long n, left;
+    unsigned char *data;
+    bool          retval = false;
+
+    result = XGetWindowProperty (screen->dpy (), priv->id,
+				 Atoms::wmUserTime,
+				 0L, 1L, False, XA_CARDINAL, &actual, &format,
+				 &n, &left, &data);
+
+    if (result == Success && data)
+    {
+	if (n)
+	{
+	    CARD32 value;
+
+	    memcpy (&value, data, sizeof (CARD32));
+	    retval = true;
+	    time   = (Time) value;
+	}
+
+	XFree ((void *) data);
+    }
+
+    return retval;
+}
+
+void
+PrivateWindow::setUserTime (Time time)
+{
+    CARD32 value = (CARD32) time;
+
+    XChangeProperty (screen->dpy (), priv->id,
+		     Atoms::wmUserTime,
+		     XA_CARDINAL, 32, PropModeReplace,
+		     (unsigned char *) &value, 1);
+}
+
+/*
+ * Macros from metacity
+ *
+ * Xserver time can wraparound, thus comparing two timestamps needs to
+ * take this into account.  Here's a little macro to help out.  If no
+ * wraparound has occurred, this is equivalent to
+ *   time1 < time2
+ * Of course, the rest of the ugliness of this macro comes from
+ * accounting for the fact that wraparound can occur and the fact that
+ * a timestamp of 0 must be special-cased since it means older than
+ * anything else.
+ *
+ * Note that this is NOT an equivalent for time1 <= time2; if that's
+ * what you need then you'll need to swap the order of the arguments
+ * and negate the result.
+ */
+#define XSERVER_TIME_IS_BEFORE_ASSUMING_REAL_TIMESTAMPS(time1, time2) \
+    ( (( (time1) < (time2) ) &&					      \
+       ( (time2) - (time1) < ((unsigned long) -1) / 2 )) ||	      \
+      (( (time1) > (time2) ) &&					      \
+       ( (time1) - (time2) > ((unsigned long) -1) / 2 ))	      \
+	)
+#define XSERVER_TIME_IS_BEFORE(time1, time2)				 \
+    ( (time1) == 0 ||							 \
+      (XSERVER_TIME_IS_BEFORE_ASSUMING_REAL_TIMESTAMPS (time1, time2) && \
+       (time2) != 0)							 \
+	)
+
+bool
+PrivateWindow::getUsageTimestamp (Time& timestamp)
+{
+    if (getUserTime (timestamp))
+	return true;
+
+    if (initialTimestampSet)
+    {
+	timestamp = initialTimestamp;
+	return true;
+    }
+
+    return false;
+}
+
+bool
+PrivateWindow::isWindowFocusAllowed (Time timestamp)
+{
+    CompScreen   *s = screen;
+    CompWindow   *active;
+    Time	 wUserTime, aUserTime;
+    bool         gotTimestamp = false;
+    int          level;
+    CompPoint    dvp;
+
+    level = s->priv->optionGetFocusPreventionLevel ();
+
+    if (level == CoreOptions::FocusPreventionLevelOff)
+	return true;
+
+    if (timestamp)
+    {
+	/* the caller passed a timestamp, so use that
+	   instead of the window's user time */
+	wUserTime = timestamp;
+	gotTimestamp = true;
+    }
+    else
+    {
+	gotTimestamp = getUsageTimestamp (wUserTime);
+    }
+
+    /* if we got no timestamp for the window, try to get at least a timestamp
+       for its transient parent, if any */
+    if (!gotTimestamp && transientFor)
+    {
+	CompWindow *parent;
+
+	parent = screen->findWindow (transientFor);
+	if (parent)
+	    gotTimestamp = parent->priv->getUsageTimestamp (wUserTime);
+    }
+
+    if (gotTimestamp && !wUserTime)
+    {
+	/* window explicitly requested no focus */
+	return false;
+    }
+
+    /* allow focus for excluded windows */
+    CompMatch &match = s->priv->optionGetFocusPreventionMatch ();
+    if (!match.evaluate (window))
+	return true;
+
+    if (level == CoreOptions::FocusPreventionLevelVeryHigh)
+	return false;
+
+    active = s->findWindow (s->activeWindow ());
+
+    /* no active window */
+    if (!active || (active->type () & CompWindowTypeDesktopMask))
+	return true;
+
+    /* active window belongs to same application */
+    if (window->clientLeader () == active->clientLeader ())
+       return true;
+
+    if (level == CoreOptions::FocusPreventionLevelHigh)
+       return false;
+
+    /* not in current viewport or desktop */
+    if (!window->onCurrentDesktop ())
+	return false;
+
+    dvp = window->defaultViewport ();
+    if (dvp.x () != s->vp ().x () || dvp.y () != s->vp ().y ())
+	return false;
+
+    if (!gotTimestamp)
+    {
+	/* unsure as we have nothing to compare - allow focus in low level,
+	   don't allow in normal level */
+	if (level == CoreOptions::FocusPreventionLevelNormal)
+	    return false;
+
+	return true;
+    }
+
+    /* can't get user time for active window */
+    if (!active->priv->getUserTime (aUserTime))
+	return true;
+
+    if (XSERVER_TIME_IS_BEFORE (wUserTime, aUserTime))
+	return false;
+
+    return true;
+}
+
+bool
+PrivateWindow::allowWindowFocus (unsigned int noFocusMask,
+				 Time         timestamp)
+{
+    bool retval;
+
+    if (priv->id == screen->activeWindow ())
+	return true;
+
+    /* do not focus windows of these types */
+    if (priv->type & noFocusMask)
+	return false;
+
+    /* window doesn't take focus */
+    if (!priv->inputHint &&
+	!(priv->protocols & CompWindowProtocolTakeFocusMask))
+    {
+	return false;
+    }
+
+    retval = priv->isWindowFocusAllowed (timestamp);
+    if (!retval)
+    {
+	/* add demands attention state if focus was prevented */
+	window->changeState (priv->state | CompWindowStateDemandsAttentionMask);
+    }
+
+    return retval;
+}
+
+CompPoint
+CompWindow::defaultViewport ()
+{
+    CompPoint viewport;
+
+    if (priv->serverGeometry.x () < (int) screen->width ()            &&
+	priv->serverGeometry.x () + priv->serverGeometry.width () > 0 &&
+	priv->serverGeometry.y () < (int) screen->height ()           &&
+	priv->serverGeometry.y ()+ priv->serverGeometry.height () > 0)
+    {
+	return screen->vp ();
+    }
+
+    screen->viewportForGeometry (priv->serverGeometry, viewport);
+
+    return viewport;
+}
+
+CompPoint &
+CompWindow::initialViewport () const
+{
+    return priv->initialViewport;
+}
+
+void
+PrivateWindow::readIconHint ()
+{
+    XImage       *image, *maskImage = NULL;
+    Display      *dpy = screen->dpy ();
+    unsigned int width, height, dummy;
+    unsigned int i, j, k;
+    int		 iDummy;
+    Window       wDummy;
+    CompIcon     *icon;
+    XColor       *colors;
+    CARD32       *p;
+
+    if (!XGetGeometry (dpy, hints->icon_pixmap, &wDummy, &iDummy,
+		       &iDummy, &width, &height, &dummy, &dummy))
+	return;
+
+    image = XGetImage (dpy, hints->icon_pixmap, 0, 0, width, height,
+		       AllPlanes, ZPixmap);
+    if (!image)
+	return;
+
+    colors = new XColor[width * height];
+    if (!colors)
+    {
+	XDestroyImage (image);
+	return;
+    }
+
+    k = 0;
+    for (j = 0; j < height; j++)
+	for (i = 0; i < width; i++)
+	    colors[k++].pixel = XGetPixel (image, i, j);
+
+    for (i = 0; i < k; i += 256)
+	XQueryColors (dpy, screen->priv->colormap,
+		      &colors[i], MIN (k - i, 256));
+
+    XDestroyImage (image);
+
+    icon = new CompIcon (screen, width, height);
+    if (!icon)
+    {
+	delete [] colors;
+	return;
+    }
+
+    if (hints->flags & IconMaskHint)
+	maskImage = XGetImage (dpy, hints->icon_mask, 0, 0,
+			       width, height, AllPlanes, ZPixmap);
+
+    k = 0;
+    p = (CARD32 *) icon->data ();
+
+    for (j = 0; j < height; j++)
+    {
+	for (i = 0; i < width; i++)
+	{
+	    if (maskImage && !XGetPixel (maskImage, i, j))
+		*p++ = 0;
+	    else if (image->depth == 1)  /* white   : black */
+		*p++ = colors[k].pixel ? 0xffffffff : 0xff000000;
+	    else
+		*p++ = 0xff000000                             | /* alpha */
+		       (((colors[k].red >> 8) & 0xff) << 16)  | /* red */
+		       (((colors[k].green >> 8) & 0xff) << 8) | /* green */
+		       ((colors[k].blue >> 8) & 0xff);          /* blue */
+
+	    k++;
+	}
+    }
+
+    delete [] colors;
+    if (maskImage)
+	XDestroyImage (maskImage);
+
+    icons.push_back (icon);
+}
+
+/* returns icon with dimensions as close as possible to width and height
+   but never greater. */
+CompIcon *
+CompWindow::getIcon (int width,
+		     int height)
+{
+    CompIcon     *icon;
+    int          wh, diff, oldDiff;
+    unsigned int i;
+
+    /* need to fetch icon property */
+    if (priv->icons.size () == 0 && !priv->noIcons)
+    {
+	Atom	      actual;
+	int	      result, format;
+	unsigned long n, left;
+	unsigned char *data;
+
+	result = XGetWindowProperty (screen->dpy (), priv->id, Atoms::wmIcon,
+				     0L, 65536L, false, XA_CARDINAL,
+				     &actual, &format, &n, &left, &data);
+
+	if (result == Success && data)
+	{
+	    CARD32        *p;
+	    CARD32        alpha, red, green, blue;
+	    unsigned long iw, ih;
+
+	    for (i = 0; i + 2 < n; i += iw * ih + 2)
+	    {
+		unsigned long *idata = (unsigned long *) data;
+
+		iw = idata[i];
+		ih = idata[i + 1];
+
+		/* iw * ih may be larger than the value range of unsigned
+		* long, so better do some checking for extremely weird
+		* icon sizes first */
+		if (iw > 2048 || ih > 2048 || iw * ih + 2 > n - i)
+		    break;
+
+		if (iw && ih)
+		{
+		    unsigned long j;
+		    icon = new CompIcon (screen, iw, ih);
+		    if (!icon)
+			continue;
+