Merge lp:~noskcaj/ubuntu/trusty/xfwm4/4.11 into lp:ubuntu/trusty/xfwm4

[Jackson Doak]

Merge from debian experimental, needed for xubuntu

[Daniel Holbach (dholbach)]

Thanks. Uploaded.

review: Approve

Unmerged revisions

69. By Jackson Doak on 2014-01-19

* Merge from Debian unstable. Remaining changes:
  - debian/control: demote xfwm4-themes from Recommends to Suggests, per
    the 'other-p-xubuntu-cleanthemes' spec.
  - Add patch from XFCE bugzilla to fix fullscreen behavior with Qt
    based apps

=== removed directory '.pc/0004-Optimize-smart-placement-bug-5785.patch'
=== removed directory '.pc/0004-Optimize-smart-placement-bug-5785.patch/src'
=== removed file '.pc/0004-Optimize-smart-placement-bug-5785.patch/src/placement.c'
--- .pc/0004-Optimize-smart-placement-bug-5785.patch/src/placement.c	2013-05-21 23:37:03 +0000
+++ .pc/0004-Optimize-smart-placement-bug-5785.patch/src/placement.c	1970-01-01 00:00:00 +0000
@@ -1,952 +0,0 @@
-/*      $Id$
-
-        This program is free software; you can redistribute it and/or modify
-        it under the terms of the GNU General Public License as published by
-        the Free Software Foundation; either version 2, or (at your option)
-        any later version.
-
-        This program is distributed in the hope that it will be useful,
-        but WITHOUT ANY WARRANTY; without even the implied warranty of
-        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-        GNU General Public License for more details.
-
-        You should have received a copy of the GNU General Public License
-        along with this program; if not, write to the Free Software
-        Foundation, Inc., Inc., 51 Franklin Street, Fifth Floor, Boston,
-        MA 02110-1301, USA.
-
-
-        xfwm4    - (c) 2002-2011 Olivier Fourdan
-
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <glib.h>
-#include <libxfce4util/libxfce4util.h>
-
-#include "screen.h"
-#include "misc.h"
-#include "client.h"
-#include "placement.h"
-#include "transients.h"
-#include "workspaces.h"
-#include "frame.h"
-#include "netwm.h"
-
-
-/* Compute rectangle overlap area */
-
-static inline unsigned long
-segment_overlap (int x0, int x1, int tx0, int tx1)
-{
-    if (tx0 > x0)
-    {
-        x0 = tx0;
-    }
-    if (tx1 < x1)
-    {
-        x1 = tx1;
-    }
-    if (x1 <= x0)
-    {
-        return 0;
-    }
-    return (x1 - x0);
-}
-
-static inline unsigned long
-overlap (int x0, int y0, int x1, int y1, int tx0, int ty0, int tx1, int ty1)
-{
-    /* Compute overlapping box */
-    return (segment_overlap (x0, x1, tx0, tx1)
-            * segment_overlap (y0, y1, ty0, ty1));
-}
-
-static unsigned long
-clientStrutAreaOverlap (int x, int y, int w, int h, Client * c)
-{
-    unsigned long sigma = 0;
-
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_HAS_STRUT)
-        && FLAG_TEST (c->xfwm_flags, XFWM_FLAG_VISIBLE))
-    {
-        sigma = overlap (x, y, x + w, y + h,
-                         0, c->struts[STRUTS_LEFT_START_Y],
-                         c->struts[STRUTS_LEFT],
-                         c->struts[STRUTS_LEFT_END_Y])
-              + overlap (x, y, x + w, y + h,
-                         c->screen_info->width - c->struts[STRUTS_RIGHT],
-                         c->struts[STRUTS_RIGHT_START_Y],
-                         c->screen_info->width, c->struts[STRUTS_RIGHT_END_Y])
-              + overlap (x, y, x + w, y + h,
-                         c->struts[STRUTS_TOP_START_X], 0,
-                         c->struts[STRUTS_TOP_END_X],
-                         c->struts[STRUTS_TOP])
-              + overlap (x, y, x + w, y + h,
-                         c->struts[STRUTS_BOTTOM_START_X],
-                         c->screen_info->height - c->struts[STRUTS_BOTTOM],
-                         c->struts[STRUTS_BOTTOM_END_X],
-                         c->screen_info->height);
-    }
-    return sigma;
-}
-
-void
-clientMaxSpace (ScreenInfo *screen_info, int *x, int *y, int *w, int *h)
-{
-    Client *c2;
-    guint i;
-    gint delta, screen_width, screen_height;
-
-    g_return_if_fail (x != NULL);
-    g_return_if_fail (y != NULL);
-    g_return_if_fail (w != NULL);
-    g_return_if_fail (h != NULL);
-
-    screen_width = 0;
-    screen_height = 0;
-    delta = 0;
-
-    for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
-    {
-        if (FLAG_TEST (c2->flags, CLIENT_FLAG_HAS_STRUT)
-            && FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE))
-        {
-            screen_width = c2->screen_info->width;
-            screen_height = c2->screen_info->height;
-
-            /* Left */
-            if (overlap (*x, *y, *x + *w, *y + *h,
-                         0, c2->struts[STRUTS_LEFT_START_Y], c2->struts[STRUTS_LEFT], c2->struts[STRUTS_LEFT_END_Y]))
-            {
-                delta = c2->struts[STRUTS_LEFT] - *x;
-                *x = *x + delta;
-                *w = *w - delta;
-            }
-
-            /* Right */
-            if (overlap (*x, *y, *x + *w, *y + *h,
-                         screen_width - c2->struts[STRUTS_RIGHT], c2->struts[STRUTS_RIGHT_START_Y],
-                         screen_width, c2->struts[STRUTS_RIGHT_END_Y]))
-            {
-                delta = (*x + *w) - screen_width + c2->struts[STRUTS_RIGHT];
-                *w = *w - delta;
-            }
-
-            /* Top */
-            if (overlap (*x, *y, *x + *w, *y + *h,
-                         c2->struts[STRUTS_TOP_START_X], 0, c2->struts[STRUTS_TOP_END_X], c2->struts[STRUTS_TOP]))
-            {
-                delta = c2->struts[STRUTS_TOP] - *y;
-                *y = *y + delta;
-                *h = *h - delta;
-            }
-
-            /* Bottom */
-            if (overlap (*x, *y, *x + *w, *y + *h,
-                         c2->struts[STRUTS_BOTTOM_START_X], screen_height - c2->struts[STRUTS_BOTTOM],
-                         c2->struts[STRUTS_BOTTOM_END_X], screen_height))
-            {
-                delta = (*y + *h) - screen_height + c2->struts[STRUTS_BOTTOM];
-                *h = *h - delta;
-            }
-        }
-    }
-}
-
-gboolean
-clientCkeckTitle (Client * c)
-{
-    Client *c2;
-    ScreenInfo *screen_info;
-    guint i;
-    gint frame_x, frame_y, frame_width, frame_top;
-
-    frame_x = frameX (c);
-    frame_y = frameY (c);
-    frame_width = frameWidth (c);
-    frame_top = frameTop (c);
-
-    /* Struts and other partial struts */
-    screen_info = c->screen_info;
-    for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
-    {
-        if ((c2 != c) && clientStrutAreaOverlap (frame_x, frame_y, frame_width, frame_top, c2))
-        {
-            return FALSE;
-        }
-    }
-    return TRUE;
-}
-
-/* clientConstrainPos() is used when moving windows
-   to ensure that the window stays accessible to the user
-
-   Returns the position in which the window was constrained.
-    CLIENT_CONSTRAINED_TOP    = 1<<0
-    CLIENT_CONSTRAINED_BOTTOM = 1<<1
-    CLIENT_CONSTRAINED_LEFT   = 1<<2
-    CLIENT_CONSTRAINED_RIGHT  = 1<<3
-
- */
-unsigned int
-clientConstrainPos (Client * c, gboolean show_full)
-{
-    Client *c2;
-    ScreenInfo *screen_info;
-    guint i;
-    gint cx, cy, disp_x, disp_y, disp_max_x, disp_max_y;
-    gint frame_height, frame_width, frame_top, frame_left;
-    gint frame_x, frame_y, frame_visible;
-    gint screen_width, screen_height;
-    guint ret;
-    GdkRectangle rect;
-    gint min_visible;
-
-    g_return_val_if_fail (c != NULL, 0);
-    TRACE ("entering clientConstrainPos %s",
-        show_full ? "(with show full)" : "(w/out show full)");
-    TRACE ("client \"%s\" (0x%lx)", c->name, c->window);
-
-    /* We use a bunch of local vars to reduce the overhead of calling other functions all the time */
-    frame_x = frameX (c);
-    frame_y = frameY (c);
-    frame_height = frameHeight (c);
-    frame_width = frameWidth (c);
-    frame_top = frameTop (c);
-    frame_left = frameLeft (c);
-    frame_visible = (frame_top ? frame_top : frame_height);
-    min_visible = MAX (frame_top, CLIENT_MIN_VISIBLE);
-    ret = 0;
-
-    cx = frame_x + (frame_width / 2);
-    cy = frame_y + (frame_height / 2);
-
-    screen_info = c->screen_info;
-    myScreenFindMonitorAtPoint (screen_info, cx, cy, &rect);
-
-    screen_width = screen_info->width;
-    screen_height = screen_info->height;
-
-    disp_x = rect.x;
-    disp_y = rect.y;
-    disp_max_x = rect.x + rect.width;
-    disp_max_y = rect.y + rect.height;
-
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
-    {
-        TRACE ("ignoring constrained for client \"%s\" (0x%lx)", c->name,
-            c->window);
-        return 0;
-    }
-    if (show_full)
-    {
-        /* Struts and other partial struts */
-
-        for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
-        {
-            if (FLAG_TEST (c2->flags, CLIENT_FLAG_HAS_STRUT)
-                && FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE)
-                && (c2 != c))
-            {
-                /* Right */
-                if (segment_overlap (frame_y, frame_y + frame_height,
-                              c2->struts[STRUTS_RIGHT_START_Y], c2->struts[STRUTS_RIGHT_END_Y]))
-                {
-                    if (segment_overlap (frame_x, frame_x + frame_width,
-                                  screen_width - c2->struts[STRUTS_RIGHT],
-                                  screen_width))
-                    {
-                        c->x = screen_width - c2->struts[STRUTS_RIGHT] - frame_width + frame_left;
-                        frame_x = frameX (c);
-                        ret |= CLIENT_CONSTRAINED_RIGHT;
-                    }
-                }
-
-                /* Bottom */
-                if (segment_overlap (frame_x, frame_x + frame_width,
-                              c2->struts[STRUTS_BOTTOM_START_X], c2->struts[STRUTS_BOTTOM_END_X]))
-                {
-                    if (segment_overlap (frame_y, frame_y + frame_height,
-                                  screen_height - c2->struts[STRUTS_BOTTOM],
-                                  screen_height))
-                    {
-                        c->y = screen_height - c2->struts[STRUTS_BOTTOM] - frame_height + frame_top;
-                        frame_y = frameY (c);
-                        ret |= CLIENT_CONSTRAINED_BOTTOM;
-
-                    }
-                }
-            }
-        }
-
-        if (frame_x + frame_width >= disp_max_x)
-        {
-            c->x = disp_max_x - frame_width + frame_left;
-            frame_x = frameX (c);
-            ret |= CLIENT_CONSTRAINED_RIGHT;
-        }
-        if (frame_x <= disp_x)
-        {
-            c->x = disp_x + frame_left;
-            frame_x = frameX (c);
-            ret |= CLIENT_CONSTRAINED_LEFT;
-        }
-        if (frame_y + frame_height >= disp_max_y)
-        {
-            c->y = disp_max_y - frame_height + frame_top;
-            frame_y = frameY (c);
-            ret |= CLIENT_CONSTRAINED_BOTTOM;
-        }
-        if (frame_y <= disp_y)
-        {
-            c->y = disp_y + frame_top;
-            frame_y = frameY (c);
-            ret |= CLIENT_CONSTRAINED_TOP;
-        }
-
-        for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
-        {
-            if (FLAG_TEST (c2->flags, CLIENT_FLAG_HAS_STRUT)
-                && FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE)
-                && (c2 != c))
-            {
-                /* Left */
-                if (segment_overlap (frame_y, frame_y + frame_height,
-                              c2->struts[STRUTS_LEFT_START_Y], c2->struts[STRUTS_LEFT_END_Y]))
-                {
-                    if (segment_overlap (frame_x, frame_x + frame_width,
-                                  0, c2->struts[STRUTS_LEFT]))
-                    {
-                        c->x = c2->struts[STRUTS_LEFT] + frame_left;
-                        frame_x = frameX (c);
-                        ret |= CLIENT_CONSTRAINED_LEFT;
-                    }
-                }
-
-                /* Top */
-                if (segment_overlap (frame_x,
-                              frame_x + frame_width,
-                              c2->struts[STRUTS_TOP_START_X],
-                              c2->struts[STRUTS_TOP_END_X]))
-                {
-                    if (segment_overlap (frame_y, frame_y + frame_height,
-                                  0, c2->struts[STRUTS_TOP]))
-                    {
-                        c->y = c2->struts[STRUTS_TOP] + frame_top;
-                        frame_y = frameY (c);
-                        ret |= CLIENT_CONSTRAINED_TOP;
-                    }
-                }
-            }
-        }
-    }
-    else
-    {
-        if (frame_x + frame_width <= disp_x + min_visible)
-        {
-            c->x = disp_x + min_visible - frame_width + frame_left;
-            frame_x = frameX (c);
-            ret |= CLIENT_CONSTRAINED_LEFT;
-        }
-        if (frame_x + min_visible >= disp_max_x)
-        {
-            c->x = disp_max_x - min_visible + frame_left;
-            frame_x = frameX (c);
-            ret |= CLIENT_CONSTRAINED_RIGHT;
-        }
-        if (frame_y + frame_height <= disp_y + min_visible)
-        {
-            c->y = disp_y + min_visible - frame_height + frame_top;
-            frame_y = frameY (c);
-            ret |= CLIENT_CONSTRAINED_TOP;
-        }
-        if (frame_y + min_visible >= disp_max_y)
-        {
-            c->y = disp_max_y - min_visible + frame_top;
-            frame_y = frameY (c);
-            ret |= CLIENT_CONSTRAINED_BOTTOM;
-        }
-        if ((frame_y <= disp_y) && (frame_y >= disp_y - frame_top))
-        {
-            c->y = disp_y + frame_top;
-            frame_y = frameY (c);
-            ret |= CLIENT_CONSTRAINED_TOP;
-        }
-        /* Struts and other partial struts */
-        for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
-        {
-            if (FLAG_TEST (c2->flags, CLIENT_FLAG_HAS_STRUT)
-                && FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE)
-                && (c2 != c))
-            {
-                /* Right */
-                if (segment_overlap (frame_y, frame_y + frame_height,
-                              c2->struts[STRUTS_RIGHT_START_Y], c2->struts[STRUTS_RIGHT_END_Y]))
-                {
-                    if (frame_x >= screen_width - c2->struts[STRUTS_RIGHT] - min_visible)
-                    {
-                        c->x = screen_width - c2->struts[STRUTS_RIGHT] - min_visible + frame_left;
-                        frame_x = frameX (c);
-                        ret |= CLIENT_CONSTRAINED_RIGHT;
-                    }
-                }
-
-                /* Left */
-                if (segment_overlap (frame_y, frame_y + frame_height,
-                              c2->struts[STRUTS_LEFT_START_Y], c2->struts[STRUTS_LEFT_END_Y]))
-                {
-                    if (frame_x + frame_width <= c2->struts[STRUTS_LEFT] + min_visible)
-                    {
-                        c->x = c2->struts[STRUTS_LEFT] + min_visible - frame_width + frame_left;
-                        frame_x = frameX (c);
-                        ret |= CLIENT_CONSTRAINED_LEFT;
-                    }
-                }
-
-                /* Bottom */
-                if (segment_overlap (frame_x, frame_x + frame_width,
-                              c2->struts[STRUTS_BOTTOM_START_X], c2->struts[STRUTS_BOTTOM_END_X]))
-                {
-                    if (frame_y >= screen_height - c2->struts[STRUTS_BOTTOM] - min_visible)
-                    {
-                        c->y = screen_height - c2->struts[STRUTS_BOTTOM] - min_visible + frame_top;
-                        frame_y = frameY (c);
-                        ret |= CLIENT_CONSTRAINED_BOTTOM;
-                    }
-                }
-
-                /* Top */
-                if (segment_overlap (frame_x, frame_x + frame_width,
-                              c2->struts[STRUTS_TOP_START_X], c2->struts[STRUTS_TOP_END_X]))
-                {
-                    if (segment_overlap (frame_y, frame_y + frame_visible, 0, c2->struts[STRUTS_TOP]))
-                    {
-                        c->y = c2->struts[STRUTS_TOP] + frame_top;
-                        frame_y = frameY (c);
-                        ret |= CLIENT_CONSTRAINED_TOP;
-                    }
-                    if (frame_y + frame_height <= c2->struts[STRUTS_TOP] + min_visible)
-                    {
-                        c->y = c2->struts[STRUTS_TOP] + min_visible - frame_height + frame_top;
-                        frame_y = frameY (c);
-                        ret |= CLIENT_CONSTRAINED_TOP;
-                    }
-                }
-            }
-        }
-    }
-    return ret;
-}
-
-/* clientKeepVisible is used at initial mapping, to make sure
-   the window is visible on screen. It also does coordonate
-   translation in Xinerama to center window on physical screen
-   Not to be confused with clientConstrainPos()
- */
-static void
-clientKeepVisible (Client * c, gint n_monitors, GdkRectangle *monitor_rect)
-{
-    ScreenInfo *screen_info;
-    GdkRectangle rect;
-    gboolean centered;
-    int diff_x, diff_y;
-    int monitor_nbr;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientKeepVisible");
-    TRACE ("client \"%s\" (0x%lx)", c->name, c->window);
-
-    screen_info = c->screen_info;
-
-    centered = FALSE;
-    if ((c->size->x == 0) && (c->size->y == 0) && (c->type & (WINDOW_TYPE_DIALOG)))
-    {
-        /* Dialogs that place temselves in (0,0) will be centered */
-        centered = TRUE;
-    }
-    else if (n_monitors > 1)
-    {
-        /* First, check if the window is centered on the whole screen */
-        diff_x = abs (c->size->x - ((c->screen_info->width - c->size->width) / 2));
-        diff_y = abs (c->size->y - ((c->screen_info->height - c->size->height) / 2));
-
-        monitor_nbr = 0;
-        centered = ((diff_x < 25) && (diff_y < 25));
-
-        while ((!centered) && (monitor_nbr < n_monitors))
-        {
-            gdk_screen_get_monitor_geometry (screen_info->gscr, monitor_nbr, &rect);
-            diff_x = abs (c->size->x - ((rect.width - c->size->width) / 2));
-            diff_y = abs (c->size->y - ((rect.height - c->size->height) / 2));
-            centered = ((diff_x < 25) && (diff_y < 25));
-            monitor_nbr++;
-        }
-    }
-    if (centered)
-    {
-        /* We consider that the windows is centered on screen,
-         * Thus, will move it so its center on the current
-         * physical screen
-         */
-        c->x = monitor_rect->x + (monitor_rect->width - c->width) / 2;
-        c->y = monitor_rect->y + (monitor_rect->height - c->height) / 2;
-    }
-    clientConstrainPos (c, TRUE);
-}
-
-static void
-clientAutoMaximize (Client * c, int full_w, int full_h)
-{
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN) ||
-        !FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER))
-    {
-        /*
-         * Fullscreen or undecorated windows should not be
-         * automatically maximized...
-         */
-        return;
-    }
-
-    if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ) &&
-        (frameWidth (c) > full_w))
-    {
-        TRACE ("The application \"%s\" has requested a window width "
-               "(%u) larger than the actual width available in the workspace (%u), "
-               "the window will be maximized horizontally.", c->name, frameWidth (c), full_w);
-        FLAG_SET (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ);
-    }
-
-    if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_VERT) &&
-        (frameHeight (c) > full_h))
-    {
-        TRACE ("The application \"%s\" has requested a window height "
-               "(%u) larger than the actual height available in the workspace (%u), "
-               "the window will be maximized vertically.", c->name, frameHeight (c), full_h);
-        FLAG_SET (c->flags, CLIENT_FLAG_MAXIMIZED_VERT);
-    }
-}
-
-static void
-smartPlacement (Client * c, int full_x, int full_y, int full_w, int full_h)
-{
-    Client *c2;
-    ScreenInfo *screen_info;
-    gfloat best_overlaps;
-    guint i;
-    gint test_x, test_y, xmax, ymax, best_x, best_y;
-    gint frame_height, frame_width, frame_left, frame_top;
-    gboolean first;
-    gint c2_x, c2_y;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering smartPlacement");
-
-    screen_info = c->screen_info;
-    frame_height = frameHeight (c);
-    frame_width = frameWidth (c);
-    frame_left = frameLeft(c);
-    frame_top = frameTop (c);
-    test_x = 0;
-    test_y = 0;
-    best_overlaps = 0.0;
-    first = TRUE;
-
-    xmax = full_x + full_w - c->width - frameRight (c);
-    ymax = full_y + full_h - c->height - frameBottom (c);
-    best_x = full_x + frameLeft (c);
-    best_y = full_y + frameTop (c);
-
-    test_y = full_y + frameTop (c);
-    do
-    {
-        test_x = full_x + frameLeft (c);
-        do
-        {
-            gfloat count_overlaps = 0.0;
-            TRACE ("analyzing %i clients", screen_info->client_count);
-            for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
-            {
-                if ((c2 != c) && (c2->type != WINDOW_DESKTOP)
-                    && (c->win_workspace == c2->win_workspace)
-                    && FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE))
-                {
-                    c2_x = frameX (c2);
-                    c2_y = frameY (c2);
-
-                    count_overlaps += overlap (test_x - frame_left,
-                                               test_y - frame_top,
-                                               test_x - frame_left + frame_width,
-                                               test_y - frame_top + frame_height,
-                                               c2_x,
-                                               c2_y,
-                                               c2_x + frameWidth (c2),
-                                               c2_y + frameHeight (c2));
-                }
-            }
-            if (count_overlaps < 0.1)
-            {
-                TRACE ("overlaps is 0 so it's the best we can get");
-                c->x = test_x;
-                c->y = test_y;
-
-                return;
-            }
-            else if ((count_overlaps < best_overlaps) || (first))
-            {
-                best_x = test_x;
-                best_y = test_y;
-                best_overlaps = count_overlaps;
-            }
-            if (first)
-            {
-                first = FALSE;
-            }
-            test_x += 8;
-        }
-        while (test_x <= xmax);
-        test_y += 8;
-    }
-    while (test_y <= ymax);
-
-    c->x = best_x;
-    c->y = best_y;
-}
-
-static void
-centerPlacement (Client * c, int full_x, int full_y, int full_w, int full_h)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering centerPlacement");
-
-    c->x = MAX (full_x + frameLeft(c) + (full_w - frameWidth(c)) / 2, full_x + frameLeft(c));
-    c->y = MAX (full_y + frameTop(c) + (full_h - frameHeight(c)) / 2, full_y + frameTop(c));
-}
-
-static void
-mousePlacement (Client * c, int full_x, int full_y, int full_w, int full_h, int mx, int my)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering mousePlacement");
-
-    c->x = mx + frameLeft(c) - frameWidth(c) / 2;
-    c->y = my + frameTop(c) - frameHeight(c) / 2;
-
-    c->x = MIN (c->x, full_x + full_w - frameWidth(c) + frameLeft(c));
-    c->y = MIN (c->y, full_y + full_h - frameHeight(c) + frameTop(c));
-
-    c->x = MAX (c->x, full_x + frameLeft(c));
-    c->y = MAX (c->y, full_y + frameTop(c));
-}
-
-void
-clientInitPosition (Client * c)
-{
-    ScreenInfo *screen_info;
-    Client *c2;
-    GdkRectangle rect;
-    int full_x, full_y, full_w, full_h, msx, msy;
-    gint n_monitors;
-    gboolean place;
-    gboolean position;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientInitPosition");
-
-    screen_info = c->screen_info;
-    msx = 0;
-    msy = 0;
-    position = (c->size->flags & (PPosition | USPosition));
-
-    n_monitors = myScreenGetNumMonitors (c->screen_info);
-    if ((n_monitors > 1) || (screen_info->params->placement_mode == PLACE_MOUSE))
-    {
-        getMouseXY (screen_info, screen_info->xroot, &msx, &msy);
-        myScreenFindMonitorAtPoint (screen_info, msx, msy, &rect);
-    }
-    else
-    {
-        gdk_screen_get_monitor_geometry (screen_info->gscr, 0, &rect);
-    }
-    if (position || (c->type & (WINDOW_TYPE_DONT_PLACE | WINDOW_TYPE_DIALOG)) || clientIsTransient (c))
-    {
-        if (!position && clientIsTransient (c) && (c2 = clientGetTransient (c)))
-        {
-            /* Center transient relative to their parent window */
-            c->x = c2->x + (c2->width - c->width) / 2;
-            c->y = c2->y + (c2->height - c->height) / 2;
-
-            if (n_monitors > 1)
-            {
-                msx = frameX (c) + (frameWidth (c) / 2);
-                msy = frameY (c) + (frameHeight (c) / 2);
-                myScreenFindMonitorAtPoint (screen_info, msx, msy, &rect);
-            }
-        }
-        if (CONSTRAINED_WINDOW (c))
-        {
-            clientKeepVisible (c, n_monitors, &rect);
-        }
-        place = FALSE;
-    }
-    else
-    {
-        place = TRUE;
-    }
-
-    full_x = MAX (screen_info->params->xfwm_margins[STRUTS_LEFT], rect.x);
-    full_y = MAX (screen_info->params->xfwm_margins[STRUTS_TOP], rect.y);
-    full_w = MIN (screen_info->width - screen_info->params->xfwm_margins[STRUTS_RIGHT],
-                  rect.x + rect.width) - full_x;
-    full_h = MIN (screen_info->height - screen_info->params->xfwm_margins[STRUTS_BOTTOM],
-                  rect.y + rect.height) - full_y;
-
-    /* Adjust size to the widest size available, not covering struts */
-    clientMaxSpace (screen_info, &full_x, &full_y, &full_w, &full_h);
-
-    /*
-       If the windows is smaller than the given ratio of the available screen area,
-       or if the window is larger than the screen area or if the given ratio is higher
-       than 100% place the window at the center.
-       Otherwise, place the window "smartly", using the good old CPU consuming algorithm...
-     */
-    if (place)
-    {
-        if ((screen_info->params->placement_ratio >= 100) ||
-            (100 * frameWidth(c) * frameHeight(c)) < (screen_info->params->placement_ratio * full_w * full_h))
-        {
-            if (screen_info->params->placement_mode == PLACE_MOUSE)
-            {
-                mousePlacement (c, full_x, full_y, full_w, full_h, msx, msy);
-            }
-            else
-            {
-                centerPlacement (c, full_x, full_y, full_w, full_h);
-            }
-        }
-        else if ((frameWidth(c) >= full_w) && (frameHeight(c) >= full_h))
-        {
-            centerPlacement (c, full_x, full_y, full_w, full_h);
-        }
-        else
-        {
-            smartPlacement (c, full_x, full_y, full_w, full_h);
-        }
-    }
-
-    if (c->type & WINDOW_REGULAR_FOCUSABLE)
-    {
-        clientAutoMaximize (c, full_w, full_h);
-    }
-}
-
-
-void
-clientFill (Client * c, int fill_type)
-{
-    ScreenInfo *screen_info;
-    Client *east_neighbour;
-    Client *west_neighbour;
-    Client *north_neighbour;
-    Client *south_neighbour;
-    Client *c2;
-    GdkRectangle rect;
-    XWindowChanges wc;
-    unsigned short mask;
-    guint i;
-    gint cx, cy, full_x, full_y, full_w, full_h;
-    gint tmp_x, tmp_y, tmp_w, tmp_h;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientFill");
-
-    if (!CLIENT_CAN_FILL_WINDOW (c))
-    {
-        return;
-    }
-
-    screen_info = c->screen_info;
-    mask = 0;
-    east_neighbour = NULL;
-    west_neighbour = NULL;
-    north_neighbour = NULL;
-    south_neighbour = NULL;
-
-    for (c2 = screen_info->clients, i = 0; i < screen_info->client_count; c2 = c2->next, i++)
-    {
-
-        /* Filter out all windows which are not visible, or not on the same layer
-         * as well as the client window itself
-         */
-        if ((c != c2) && FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_VISIBLE) && (c2->win_layer == c->win_layer))
-        {
-            /* Fill horizontally */
-            if (fill_type & CLIENT_FILL_HORIZ)
-            {
-                /*
-                 * check if the neigbour client (c2) is located
-                 * east or west of our client.
-                 */
-                if (segment_overlap (frameY(c), frameY(c) + frameHeight(c), frameY(c2), frameY(c2) + frameHeight(c2)))
-                {
-                    if ((frameX(c2) + frameWidth(c2)) <= frameX(c))
-                    {
-                        if (west_neighbour)
-                        {
-                            /* Check if c2 is closer to the client
-                             * then the west neighbour already found
-                             */
-                            if ((frameX(west_neighbour) + frameWidth(west_neighbour)) < (frameX(c2) + frameWidth(c2)))
-                            {
-                                west_neighbour = c2;
-                            }
-                        }
-                        else
-                        {
-                            west_neighbour = c2;
-                        }
-                    }
-                    if ((frameX(c) + frameWidth(c)) <= frameX(c2))
-                    {
-                        /* Check if c2 is closer to the client
-                         * then the west neighbour already found
-                         */
-                        if (east_neighbour)
-                        {
-                            if (frameX(c2) < frameX(east_neighbour))
-                            {
-                                east_neighbour = c2;
-                            }
-                        }
-                        else
-                        {
-                            east_neighbour = c2;
-                        }
-                    }
-                }
-            }
-
-            /* Fill vertically */
-            if (fill_type & CLIENT_FILL_VERT)
-            {
-                /* check if the neigbour client (c2) is located
-                 * north or south of our client.
-                 */
-                if (segment_overlap (frameX(c), frameX(c) + frameWidth(c), frameX(c2), frameX(c2) + frameWidth(c2)))
-                {
-                    if ((frameY(c2) + frameHeight(c2)) <= frameY(c))
-                    {
-                        if (north_neighbour)
-                        {
-                            /* Check if c2 is closer to the client
-                             * then the north neighbour already found
-                             */
-                            if ((frameY(north_neighbour) + frameHeight(north_neighbour)) < (frameY(c2) + frameHeight(c2)))
-                            {
-                                north_neighbour = c2;
-                            }
-                        }
-                        else
-                        {
-                            north_neighbour = c2;
-                        }
-                    }
-                    if ((frameY(c) + frameHeight(c)) <= frameY(c2))
-                    {
-                        if (south_neighbour)
-                        {
-                            /* Check if c2 is closer to the client
-                             * then the south neighbour already found
-                             */
-                            if (frameY(c2) < frameY(south_neighbour))
-                            {
-                                south_neighbour = c2;
-                            }
-                        }
-                        else
-                        {
-                            south_neighbour = c2;
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /* Compute the largest size available, based on struts, margins and Xinerama layout */
-    tmp_x = frameX (c);
-    tmp_y = frameY (c);
-    tmp_h = frameHeight (c);
-    tmp_w = frameWidth (c);
-
-    cx = tmp_x + (tmp_w / 2);
-    cy = tmp_y + (tmp_h / 2);
-
-    myScreenFindMonitorAtPoint (screen_info, cx, cy, &rect);
-
-    full_x = MAX (screen_info->params->xfwm_margins[STRUTS_LEFT], rect.x);
-    full_y = MAX (screen_info->params->xfwm_margins[STRUTS_TOP], rect.y);
-    full_w = MIN (screen_info->width - screen_info->params->xfwm_margins[STRUTS_RIGHT],
-                  rect.x + rect.width) - full_x;
-    full_h = MIN (screen_info->height - screen_info->params->xfwm_margins[STRUTS_BOTTOM],
-                  rect.y + rect.height) - full_y;
-
-    if ((fill_type & CLIENT_FILL) == CLIENT_FILL)
-    {
-        mask = CWX | CWY | CWHeight | CWWidth;
-        /* Adjust size to the largest size available, not covering struts */
-        clientMaxSpace (screen_info, &full_x, &full_y, &full_w, &full_h);
-    }
-    else if (fill_type & CLIENT_FILL_VERT)
-    {
-        mask = CWY | CWHeight;
-        /* Adjust size to the tallest size available, for the current horizontal position/width */
-        clientMaxSpace (screen_info, &tmp_x, &full_y, &tmp_w, &full_h);
-    }
-    else if (fill_type & CLIENT_FILL_HORIZ)
-    {
-        mask = CWX | CWWidth;
-        /* Adjust size to the widest size available, for the current vertical position/height */
-        clientMaxSpace (screen_info, &full_x, &tmp_y, &full_w, &tmp_h);
-    }
-
-    /* If there are neighbours, resize to their borders.
-     * If not, resize to the largest size available that you just have computed.
-     */
-
-    wc.x = full_x + frameLeft(c);
-    if (west_neighbour)
-    {
-        wc.x += MAX (frameX(west_neighbour) + frameWidth(west_neighbour) - full_x, 0);
-    }
-
-    wc.width = full_w - frameRight(c) - (wc.x - full_x);
-    if (east_neighbour)
-    {
-        wc.width -= MAX (full_w - (frameX(east_neighbour) - full_x), 0);
-    }
-
-    wc.y = full_y + frameTop(c);
-    if (north_neighbour)
-    {
-        wc.y += MAX (frameY(north_neighbour) + frameHeight(north_neighbour) - full_y, 0);
-    }
-
-    wc.height = full_h - frameBottom(c) - (wc.y - full_y);
-    if (south_neighbour)
-    {
-        wc.height -= MAX (full_h - (frameY(south_neighbour) - full_y), 0);
-    }
-
-    TRACE ("Fill size request: (%d,%d) %dx%d", wc.x, wc.y, wc.width, wc.height);
-    if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_MANAGED))
-    {
-        clientConfigure(c, &wc, mask, NO_CFG_FLAG);
-    }
-}
-

=== removed directory '.pc/8563.patch'
=== removed directory '.pc/8563.patch/src'
=== removed file '.pc/8563.patch/src/client.c'
--- .pc/8563.patch/src/client.c	2013-12-03 15:24:16 +0000
+++ .pc/8563.patch/src/client.c	1970-01-01 00:00:00 +0000
@@ -1,3926 +0,0 @@
-/*      $Id$
-
-        This program is free software; you can redistribute it and/or modify
-        it under the terms of the GNU General Public License as published by
-        the Free Software Foundation; either version 2, or (at your option)
-        any later version.
-
-        This program is distributed in the hope that it will be useful,
-        but WITHOUT ANY WARRANTY; without even the implied warranty of
-        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-        GNU General Public License for more details.
-
-        You should have received a copy of the GNU General Public License
-        along with this program; if not, write to the Free Software
-        Foundation, Inc., Inc., 51 Franklin Street, Fifth Floor, Boston,
-        MA 02110-1301, USA.
-
-
-        oroborus - (c) 2001 Ken Lynch
-        xfwm4    - (c) 2002-2011 Olivier Fourdan
-
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <sys/types.h>
-#include <signal.h>
-#include <unistd.h>
-#include <errno.h>
-
-#include <X11/X.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xatom.h>
-#include <X11/extensions/shape.h>
-
-#include <glib.h>
-#include <gdk/gdk.h>
-#include <gdk/gdkx.h>
-#include <gtk/gtk.h>
-#include <libxfce4util/libxfce4util.h>
-
-#include "client.h"
-#include "compositor.h"
-#include "focus.h"
-#include "frame.h"
-#include "hints.h"
-#include "icons.h"
-#include "misc.h"
-#include "moveresize.h"
-#include "mypixmap.h"
-#include "mywindow.h"
-#include "netwm.h"
-#include "placement.h"
-#include "screen.h"
-#include "session.h"
-#include "settings.h"
-#include "stacking.h"
-#include "startup_notification.h"
-#include "transients.h"
-#include "workspaces.h"
-#include "xsync.h"
-#include "event_filter.h"
-
-/* Event mask definition */
-
-#define POINTER_EVENT_MASK \
-    ButtonPressMask|\
-    ButtonReleaseMask
-
-#define FRAME_EVENT_MASK \
-    SubstructureNotifyMask|\
-    SubstructureRedirectMask|\
-    PointerMotionMask|\
-    ButtonMotionMask|\
-    FocusChangeMask|\
-    EnterWindowMask|\
-    PropertyChangeMask
-
-#define CLIENT_EVENT_MASK \
-    StructureNotifyMask|\
-    FocusChangeMask|\
-    PropertyChangeMask
-
-#define BUTTON_EVENT_MASK \
-    EnterWindowMask|\
-    LeaveWindowMask
-
-/* Useful macros */
-#define START_ICONIC(c) \
-    ((c->wmhints) && \
-     (c->wmhints->initial_state == IconicState) && \
-     !clientIsTransientOrModal (c))
-
-#define OPACITY_SET_STEP        (guint) 0x16000000
-#define OPACITY_SET_MIN         (guint) 0x40000000
-
-typedef struct _ButtonPressData ButtonPressData;
-struct _ButtonPressData
-{
-    int b;
-    Client *c;
-};
-
-/* Forward decl */
-static void
-clientUpdateIconPix (Client *c);
-static gboolean
-clientNewMaxSize (Client *c, XWindowChanges *wc, GdkRectangle *, tilePositionType tile);
-
-Display *
-clientGetXDisplay (Client *c)
-{
-    g_return_val_if_fail (c, NULL);
-
-    return myScreenGetXDisplay (c->screen_info);
-}
-
-void
-clientInstallColormaps (Client *c)
-{
-    XWindowAttributes attr;
-    gboolean installed;
-    int i;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientInstallColormaps");
-
-    installed = FALSE;
-    if (c->ncmap)
-    {
-        for (i = c->ncmap - 1; i >= 0; i--)
-        {
-            XGetWindowAttributes (clientGetXDisplay (c), c->cmap_windows[i], &attr);
-            XInstallColormap (clientGetXDisplay (c), attr.colormap);
-            if (c->cmap_windows[i] == c->window)
-            {
-                installed = TRUE;
-            }
-        }
-    }
-    if ((!installed) && (c->cmap))
-    {
-        XInstallColormap (clientGetXDisplay (c), c->cmap);
-    }
-}
-
-void
-clientUpdateColormaps (Client *c)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientUpdateColormaps");
-
-    if (c->ncmap)
-    {
-        XFree (c->cmap_windows);
-        c->ncmap = 0;
-    }
-    if (!XGetWMColormapWindows (clientGetXDisplay (c), c->window, &c->cmap_windows, &c->ncmap))
-    {
-        c->cmap_windows = NULL;
-        c->ncmap = 0;
-    }
-}
-
-static gchar*
-clientCreateTitleName (Client *c, gchar *name, gchar *hostname)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    gchar *title;
-
-    g_return_val_if_fail (c != NULL, NULL);
-    TRACE ("entering clientCreateTitleName");
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if (strlen (hostname) && (display_info->hostname) && (g_ascii_strcasecmp (display_info->hostname, hostname)))
-    {
-        /* TRANSLATORS: "(on %s)" is like "running on" the name of the other host */
-        title = g_strdup_printf (_("%s (on %s)"), name, hostname);
-    }
-    else
-    {
-        title = g_strdup (name);
-    }
-
-    return title;
-}
-
-void
-clientUpdateName (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    gchar *hostname;
-    gchar *wm_name;
-    gchar *name;
-    gboolean refresh;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientUpdateName");
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    getWindowName (display_info, c->window, &wm_name);
-    getWindowHostname (display_info, c->window, &hostname);
-    refresh = FALSE;
-
-    /* Update hostname too, as it's used when terminating a client */
-    if (hostname)
-    {
-        if (c->hostname)
-        {
-            g_free (c->hostname);
-        }
-        c->hostname = hostname;
-    }
-
-    if (wm_name)
-    {
-        name = clientCreateTitleName (c, wm_name, hostname);
-        g_free (wm_name);
-        if (c->name)
-        {
-            if (strcmp (name, c->name))
-            {
-                refresh = TRUE;
-                FLAG_SET (c->flags, CLIENT_FLAG_NAME_CHANGED);
-            }
-            g_free (c->name);
-        }
-        c->name = name;
-    }
-
-    if (refresh)
-    {
-        frameQueueDraw (c, TRUE);
-    }
-}
-
-void
-clientUpdateAllFrames (ScreenInfo *screen_info, int mask)
-{
-    Client *c;
-    XWindowChanges wc;
-    guint i;
-
-    g_return_if_fail (screen_info != NULL);
-
-    TRACE ("entering clientRedrawAllFrames");
-    for (c = screen_info->clients, i = 0; i < screen_info->client_count; c = c->next, i++)
-    {
-        unsigned long configure_flags = 0L;
-
-        if (mask & UPDATE_BUTTON_GRABS)
-        {
-            clientUngrabButtons (c);
-            clientGrabButtons (c);
-            clientGrabMouseButton (c);
-        }
-        if (mask & UPDATE_CACHE)
-        {
-            clientUpdateIconPix (c);
-        }
-        if (mask & UPDATE_GRAVITY)
-        {
-            clientCoordGravitate (c, c->gravity, REMOVE, &c->x, &c->y);
-            clientCoordGravitate (c, c->gravity, APPLY, &c->x, &c->y);
-            setNetFrameExtents (screen_info->display_info,
-                                c->window,
-                                frameTop (c),
-                                frameLeft (c),
-                                frameRight (c),
-                                frameBottom (c));
-            configure_flags |= CFG_FORCE_REDRAW;
-            mask &= ~UPDATE_FRAME;
-        }
-        if (mask & UPDATE_MAXIMIZE)
-        {
-            unsigned long maximization_flags = 0L;
-
-            /* Recompute size and position of maximized windows */
-            if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ | CLIENT_FLAG_MAXIMIZED_VERT))
-            {
-                maximization_flags = c->flags & CLIENT_FLAG_MAXIMIZED;
-
-                /* Force an update by clearing the internal flags */
-                FLAG_UNSET (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ | CLIENT_FLAG_MAXIMIZED_VERT);
-                clientToggleMaximized (c, maximization_flags, FALSE);
-
-                configure_flags |= CFG_FORCE_REDRAW;
-                mask &= ~UPDATE_FRAME;
-            }
-        }
-        if (configure_flags != 0L)
-        {
-            wc.x = c->x;
-            wc.y = c->y;
-            wc.width = c->width;
-            wc.height = c->height;
-            clientConfigure (c, &wc, CWX | CWY | CWWidth | CWHeight, configure_flags);
-        }
-        if (mask & UPDATE_FRAME)
-        {
-            frameQueueDraw (c, TRUE);
-        }
-
-    }
-}
-
-void
-clientGrabButtons (Client *c)
-{
-    ScreenInfo *screen_info;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientGrabButtons");
-    TRACE ("grabbing buttons for client \"%s\" (0x%lx)", c->name, c->window);
-
-    screen_info = c->screen_info;
-    if (screen_info->params->easy_click)
-    {
-        grabButton(clientGetXDisplay (c), AnyButton, screen_info->params->easy_click, c->window);
-    }
-}
-
-void
-clientUngrabButtons (Client *c)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientUngrabButtons");
-    TRACE ("grabbing buttons for client \"%s\" (0x%lx)", c->name, c->window);
-
-    XUngrabButton (clientGetXDisplay (c), AnyButton, AnyModifier, c->window);
-}
-
-static gboolean
-urgent_cb (gpointer data)
-{
-    Client *c;
-    ScreenInfo *screen_info;
-
-    c = (Client *) data;
-    g_return_val_if_fail (c != NULL, FALSE);
-    TRACE ("entering urgent_cb, iteration %i", c->blink_iterations);
-    screen_info = c->screen_info;
-
-    if (c != clientGetFocus ())
-    {
-        /*
-         * If we do not blink on urgency, check if the window was last
-         * drawn focused and redraw it unfocused.
-         * This is for th case when the tuser changes the settings
-         * in between two redraws.
-         */
-        if (!screen_info->params->urgent_blink)
-        {
-            if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_SEEN_ACTIVE))
-            {
-                FLAG_TOGGLE (c->xfwm_flags, XFWM_FLAG_SEEN_ACTIVE);
-                frameQueueDraw (c, FALSE);
-            }
-
-            if (c->blink_iterations)
-            {
-                c->blink_iterations = 0;
-            }
-            return TRUE;
-        }
-        /*
-         * If we blink on urgency, check if we've not reach the number
-         * of iterations and if not, simply change the status and redraw
-         */
-        if (c->blink_iterations < (2 * MAX_BLINK_ITERATIONS))
-        {
-            c->blink_iterations++;
-            FLAG_TOGGLE (c->xfwm_flags, XFWM_FLAG_SEEN_ACTIVE);
-            frameQueueDraw (c, FALSE);
-            return TRUE;
-        }
-        /*
-         * If we reached the max number of iterations, check if we
-         * repeat. If repeat_urgent_blink is set, redraw the frame and
-         * restart counting from 1
-         */
-        if (screen_info->params->repeat_urgent_blink)
-        {
-            FLAG_TOGGLE (c->xfwm_flags, XFWM_FLAG_SEEN_ACTIVE);
-            frameQueueDraw (c, FALSE);
-            c->blink_iterations = 1;
-            return TRUE;
-        }
-    }
-    else if (c->blink_iterations)
-    {
-        c->blink_iterations = 0;
-    }
-    return (TRUE);
-}
-
-void
-clientUpdateUrgency (Client *c)
-{
-    g_return_if_fail (c != NULL);
-
-    TRACE ("entering clientUpdateUrgency");
-
-    FLAG_UNSET (c->xfwm_flags, XFWM_FLAG_SEEN_ACTIVE);
-    if (c->blink_timeout_id)
-    {
-        g_source_remove (c->blink_timeout_id);
-        frameQueueDraw (c, FALSE);
-    }
-    FLAG_UNSET (c->wm_flags, WM_FLAG_URGENT);
-
-    c->blink_timeout_id = 0;
-    c->blink_iterations = 0;
-    if ((c->wmhints) && (c->wmhints->flags & XUrgencyHint))
-    {
-        FLAG_SET (c->wm_flags, WM_FLAG_URGENT);
-        if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_VISIBLE))
-        {
-            c->blink_timeout_id =
-                g_timeout_add_full (G_PRIORITY_DEFAULT,
-                                    CLIENT_BLINK_TIMEOUT,
-                                    (GtkFunction) urgent_cb,
-                                    (gpointer) c, NULL);
-        }
-    }
-    if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_SEEN_ACTIVE)
-        && !FLAG_TEST (c->wm_flags, WM_FLAG_URGENT)
-        && (c != clientGetFocus ()))
-    {
-        FLAG_UNSET (c->xfwm_flags, XFWM_FLAG_SEEN_ACTIVE);
-        frameQueueDraw (c, FALSE);
-    }
-}
-
-void
-clientCoordGravitate (Client *c, int gravity, int mode, int *x, int *y)
-{
-    int dx, dy;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientCoordGravitate");
-
-    switch (gravity)
-    {
-        case CenterGravity:
-            dx = (c->border_width * 2) - ((frameLeft (c) +
-                    frameRight (c)) / 2);
-            dy = (c->border_width * 2) - ((frameTop (c) +
-                    frameBottom (c)) / 2);
-            break;
-        case NorthGravity:
-            dx = (c->border_width * 2) - ((frameLeft (c) +
-                    frameRight (c)) / 2);
-            dy = frameTop (c);
-            break;
-        case SouthGravity:
-            dx = (c->border_width * 2) - ((frameLeft (c) +
-                    frameRight (c)) / 2);
-            dy = (c->border_width * 2) - frameBottom (c);
-            break;
-        case EastGravity:
-            dx = (c->border_width * 2) - frameRight (c);
-            dy = (c->border_width * 2) - ((frameTop (c) +
-                    frameBottom (c)) / 2);
-            break;
-        case WestGravity:
-            dx = frameLeft (c);
-            dy = (c->border_width * 2) - ((frameTop (c) +
-                    frameBottom (c)) / 2);
-            break;
-        case NorthWestGravity:
-            dx = frameLeft (c);
-            dy = frameTop (c);
-            break;
-        case NorthEastGravity:
-            dx = (c->border_width * 2) - frameRight (c);
-            dy = frameTop (c);
-            break;
-        case SouthWestGravity:
-            dx = frameLeft (c);
-            dy = (c->border_width * 2) - frameBottom (c);
-            break;
-        case SouthEastGravity:
-            dx = (c->border_width * 2) - frameRight (c);
-            dy = (c->border_width * 2) - frameBottom (c);
-            break;
-        default:
-            dx = 0;
-            dy = 0;
-            break;
-    }
-    *x = *x + (dx * mode);
-    *y = *y + (dy * mode);
-}
-
-void
-clientAdjustCoordGravity (Client *c, int gravity, unsigned long *mask, XWindowChanges *wc)
-{
-    int tx, ty, dw, dh;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientAdjustCoordGravity");
-
-    tx = wc->x;
-    ty = wc->y;
-    clientCoordGravitate (c, gravity, APPLY, &tx, &ty);
-
-    switch (gravity)
-    {
-        case CenterGravity:
-            dw = (c->width  - wc->width)  / 2;
-            dh = (c->height - wc->height) / 2;
-            break;
-        case NorthGravity:
-            dw = (c->width - wc->width) / 2;
-            dh = 0;
-            break;
-        case SouthGravity:
-            dw = (c->width  - wc->width) / 2;
-            dh = (c->height - wc->height);
-            break;
-        case EastGravity:
-            dw = (c->width  - wc->width);
-            dh = (c->height - wc->height) / 2;
-            break;
-        case WestGravity:
-            dw = 0;
-            dh = (c->height - wc->height) / 2;
-            break;
-        case NorthWestGravity:
-            dw = 0;
-            dh = 0;
-            break;
-        case NorthEastGravity:
-            dw = (c->width - wc->width);
-            dh = 0;
-            break;
-        case SouthWestGravity:
-            dw = 0;
-            dh = (c->height - wc->height);
-            break;
-        case SouthEastGravity:
-            dw = (c->width  - wc->width);
-            dh = (c->height - wc->height);
-            break;
-        default:
-            dw = 0;
-            dh = 0;
-            break;
-    }
-
-    if (*mask & CWX)
-    {
-        wc->x = tx;
-    }
-    else if (*mask & CWWidth)
-    {
-        wc->x = c->x + dw;
-        *mask |= CWX;
-    }
-
-    if (*mask & CWY)
-    {
-        wc->y = ty;
-    }
-    else if (*mask & CWHeight)
-    {
-        wc->y = c->y + dh;
-        *mask |= CWY;
-    }
-}
-
-#define WIN_MOVED   (mask & (CWX | CWY))
-#define WIN_RESIZED (mask & (CWWidth | CWHeight))
-
-static void
-clientConfigureWindows (Client *c, XWindowChanges * wc, unsigned long mask, unsigned short flags)
-{
-    unsigned long change_mask_frame, change_mask_client;
-    XWindowChanges change_values;
-    DisplayInfo *display_info;
-    ScreenInfo *screen_info;
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    change_mask_frame = mask & (CWX | CWY | CWWidth | CWHeight);
-    change_mask_client = mask & (CWWidth | CWHeight);
-
-    if ((WIN_RESIZED) || (flags & CFG_FORCE_REDRAW))
-    {
-        frameDraw (c, (flags & CFG_FORCE_REDRAW));
-    }
-
-    if (flags & CFG_FORCE_REDRAW)
-    {
-        change_mask_client |= (CWX | CWY);
-    }
-
-    if (change_mask_frame & (CWX | CWY | CWWidth | CWHeight))
-    {
-        change_values.x = frameX (c);
-        change_values.y = frameY (c);
-        change_values.width = frameWidth (c);
-        change_values.height = frameHeight (c);
-        XConfigureWindow (display_info->dpy, c->frame, change_mask_frame, &change_values);
-    }
-
-    if (change_mask_client & (CWX | CWY | CWWidth | CWHeight))
-    {
-        change_values.x = frameLeft (c);
-        change_values.y = frameTop (c);
-        change_values.width = c->width;
-        change_values.height = c->height;
-        XConfigureWindow (display_info->dpy, c->window, change_mask_client, &change_values);
-    }
-    if (WIN_RESIZED)
-    {
-        compositorResizeWindow (display_info, c->frame, frameX (c), frameY (c), frameWidth (c), frameHeight (c));
-    }
-}
-
-void
-clientConfigure (Client *c, XWindowChanges * wc, unsigned long mask, unsigned short flags)
-{
-    XConfigureEvent ce;
-    int px, py, pwidth, pheight;
-
-    g_return_if_fail (c != NULL);
-    g_return_if_fail (c->window != None);
-
-    TRACE ("entering clientConfigure");
-    TRACE ("configuring client \"%s\" (0x%lx) %s, type %u", c->name,
-        c->window, flags & CFG_CONSTRAINED ? "constrained" : "not contrained", c->type);
-
-    px = c->x;
-    py = c->y;
-    pwidth = c->width;
-    pheight = c->height;
-
-    if (mask & CWX)
-    {
-        if (!FLAG_TEST (c->xfwm_flags, XFWM_FLAG_MOVING_RESIZING))
-        {
-            c->x = wc->x;
-        }
-    }
-    if (mask & CWY)
-    {
-        if (!FLAG_TEST (c->xfwm_flags, XFWM_FLAG_MOVING_RESIZING))
-        {
-            c->y = wc->y;
-        }
-    }
-    if (mask & CWWidth)
-    {
-        clientSetWidth (c, wc->width, flags & CFG_REQUEST);
-    }
-    if (mask & CWHeight)
-    {
-        clientSetHeight (c, wc->height, flags & CFG_REQUEST);
-    }
-    if (mask & CWBorderWidth)
-    {
-        c->border_width = wc->border_width;
-    }
-    if (mask & CWStackMode)
-    {
-        switch (wc->stack_mode)
-        {
-            /*
-             * Limitation: we don't support neither
-             * TopIf, BottomIf nor Opposite ...
-             */
-            case Above:
-                TRACE ("Above");
-                if (mask & CWSibling)
-                {
-                    clientRaise (c, wc->sibling);
-                }
-                else
-                {
-                    clientRaise (c, None);
-                }
-                break;
-            case Below:
-                TRACE ("Below");
-                if (mask & CWSibling)
-                {
-                    clientLower (c, wc->sibling);
-                }
-                else
-                {
-                    clientLower (c, None);
-                }
-
-                break;
-            case Opposite:
-            case TopIf:
-            case BottomIf:
-            default:
-                break;
-        }
-    }
-    mask &= ~(CWStackMode | CWSibling);
-
-    /* Keep control over what the application does. */
-    if (((flags & (CFG_CONSTRAINED | CFG_REQUEST)) == (CFG_CONSTRAINED | CFG_REQUEST))
-         && CONSTRAINED_WINDOW (c))
-    {
-        clientConstrainPos (c, flags & CFG_KEEP_VISIBLE);
-
-        if (c->x != px)
-        {
-            mask |= CWX;
-        }
-        else
-        {
-            mask &= ~CWX;
-        }
-
-        if (c->y != py)
-        {
-            mask |= CWY;
-        }
-        else
-        {
-            mask &= ~CWY;
-        }
-
-        if (c->width != pwidth)
-        {
-            mask |= CWWidth;
-        }
-        else
-        {
-            mask &= ~CWWidth;
-        }
-        if (c->height != pheight)
-        {
-            mask |= CWHeight;
-        }
-        else
-        {
-            mask &= ~CWHeight;
-        }
-    }
-
-    clientConfigureWindows (c, wc, mask, flags);
-    /*
-
-      We reparent the client window. According to the ICCCM spec, the
-      WM must send a senthetic event when the window is moved and not resized.
-
-      But, since we reparent the window, we must also send a synthetic
-      configure event when the window is moved and resized.
-
-      See this thread for the rational:
-      http://www.mail-archive.com/[e-mail]/msg00379.html
-
-      And specifically this post from Carsten Haitzler:
-      http://www.mail-archive.com/[e-mail]/msg00382.html
-
-     */
-    if ((WIN_MOVED) || (flags & CFG_NOTIFY) ||
-        ((flags & CFG_REQUEST) && !(WIN_MOVED || WIN_RESIZED)))
-    {
-        DBG ("Sending ConfigureNotify");
-        ce.type = ConfigureNotify;
-        ce.display = clientGetXDisplay (c);
-        ce.event = c->window;
-        ce.window = c->window;
-        ce.x = c->x;
-        ce.y = c->y;
-        ce.width = c->width;
-        ce.height = c->height;
-        ce.border_width = 0;
-        ce.above = c->frame;
-        ce.override_redirect = FALSE;
-        XSendEvent (clientGetXDisplay (c), c->window, FALSE,
-                    StructureNotifyMask, (XEvent *) & ce);
-    }
-#undef WIN_MOVED
-#undef WIN_RESIZED
-}
-
-void
-clientMoveResizeWindow (Client *c, XWindowChanges * wc, unsigned long mask)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    unsigned short flags;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientMoveResizeWindow");
-    TRACE ("client \"%s\" (0x%lx)", c->name, c->window);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-    if (c->type == WINDOW_DESKTOP)
-    {
-        /* Ignore stacking request for DESKTOP windows */
-        mask &= ~(CWSibling | CWStackMode);
-    }
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN)
-        || (FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED)
-            && (screen_info->params->borderless_maximize)))
-    {
-        /* Not allowed in fullscreen or maximzed mode */
-        mask &= ~(CWX | CWY | CWWidth | CWHeight);
-    }
-    /*clean up buggy requests that set all flags */
-    if ((mask & CWX) && (wc->x == c->x))
-    {
-        mask &= ~CWX;
-    }
-    if ((mask & CWY) && (wc->y == c->y))
-    {
-        mask &= ~CWY;
-    }
-    if ((mask & CWWidth) && (wc->width == c->width))
-    {
-        mask &= ~CWWidth;
-    }
-    if ((mask & CWHeight) && (wc->height == c->height))
-    {
-        mask &= ~CWHeight;
-    }
-
-    /* Still a move/resize after cleanup? */
-    flags = CFG_REQUEST;
-    if (mask & (CWX | CWY | CWWidth | CWHeight))
-    {
-        /* Clear any previously saved pos flag from screen resize */
-        FLAG_UNSET (c->xfwm_flags, XFWM_FLAG_SAVED_POS);
-
-        if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED))
-        {
-            clientRemoveMaximizeFlag (c);
-        }
-
-        flags |= CFG_REQUEST | CFG_CONSTRAINED;
-    }
-    if ((mask & (CWWidth | CWHeight)) && !(mask & (CWX | CWY)))
-    {
-        /*
-         * The client is resizing its window, but did not specify a
-         * position, make sure the window remains fully visible in that
-         *case so that the user does not have to relocate the window
-         */
-        flags |= CFG_KEEP_VISIBLE;
-    }
-    /*
-     * Let's say that if the client performs a XRaiseWindow, we show the window if focus
-     * stealing prevention is not activated, otherwise we just set the "demands attention"
-     * flag...
-     */
-    if ((mask & CWStackMode) && (wc->stack_mode == Above) && (wc->sibling == None) && !(c->type & WINDOW_TYPE_DONT_FOCUS))
-    {
-        Client *last_raised;
-
-        last_raised = clientGetLastRaise (screen_info);
-        if (last_raised && (c != last_raised))
-        {
-            if ((screen_info->params->prevent_focus_stealing) && (screen_info->params->activate_action == ACTIVATE_ACTION_NONE))
-            {
-                mask &= ~(CWSibling | CWStackMode);
-                TRACE ("Setting WM_STATE_DEMANDS_ATTENTION flag on \"%s\" (0x%lx)", c->name, c->window);
-                FLAG_SET (c->flags, CLIENT_FLAG_DEMANDS_ATTENTION);
-                clientSetNetState (c);
-            }
-            else
-            {
-                clientActivate (c, getXServerTime (display_info), FALSE);
-            }
-        }
-    }
-    /* And finally, configure the window */
-    clientConfigure (c, wc, mask, flags);
-}
-
-void
-clientGetMWMHints (Client *c, gboolean update)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    PropMwmHints *mwm_hints;
-    XWindowChanges wc;
-
-    g_return_if_fail (c != NULL);
-    g_return_if_fail (c->window != None);
-
-    TRACE ("entering clientGetMWMHints client \"%s\" (0x%lx)", c->name,
-        c->window);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    mwm_hints = getMotifHints (display_info, c->window);
-    if (mwm_hints)
-    {
-        if ((mwm_hints->flags & MWM_HINTS_DECORATIONS))
-        {
-            if (!FLAG_TEST (c->flags, CLIENT_FLAG_HAS_SHAPE))
-            {
-                if (mwm_hints->decorations & MWM_DECOR_ALL)
-                {
-                    FLAG_SET (c->xfwm_flags, XFWM_FLAG_HAS_BORDER | XFWM_FLAG_HAS_MENU);
-                }
-                else
-                {
-                    FLAG_UNSET (c->xfwm_flags, XFWM_FLAG_HAS_BORDER | XFWM_FLAG_HAS_MENU);
-                    FLAG_SET (c->xfwm_flags, (mwm_hints-> decorations & (MWM_DECOR_TITLE | MWM_DECOR_BORDER))
-                                             ? XFWM_FLAG_HAS_BORDER : 0);
-                    FLAG_SET (c->xfwm_flags, (mwm_hints->decorations & (MWM_DECOR_MENU))
-                                             ? XFWM_FLAG_HAS_MENU : 0);
-                    /*
-                       FLAG_UNSET(c->xfwm_flags, XFWM_FLAG_HAS_HIDE);
-                       FLAG_UNSET(c->xfwm_flags, XFWM_FLAG_HAS_MAXIMIZE);
-                       FLAG_SET(c->xfwm_flags, (mwm_hints->decorations & (MWM_DECOR_MINIMIZE)) ? XFWM_FLAG_HAS_HIDE : 0);
-                       FLAG_SET(c->xfwm_flags, (mwm_hints->decorations & (MWM_DECOR_MAXIMIZE)) ? XFWM_FLAG_HAS_MAXIMIZE : 0);
-                     */
-                }
-            }
-        }
-        /* The following is from Metacity : */
-        if (mwm_hints->flags & MWM_HINTS_FUNCTIONS)
-        {
-            if (!(mwm_hints->functions & MWM_FUNC_ALL))
-            {
-                FLAG_UNSET (c->xfwm_flags,
-                    XFWM_FLAG_HAS_CLOSE | XFWM_FLAG_HAS_HIDE |
-                    XFWM_FLAG_HAS_MAXIMIZE | XFWM_FLAG_HAS_MOVE |
-                    XFWM_FLAG_HAS_RESIZE);
-            }
-            else
-            {
-                FLAG_SET (c->xfwm_flags,
-                    XFWM_FLAG_HAS_CLOSE | XFWM_FLAG_HAS_HIDE |
-                    XFWM_FLAG_HAS_MAXIMIZE | XFWM_FLAG_HAS_MOVE |
-                    XFWM_FLAG_HAS_RESIZE);
-            }
-
-            if (mwm_hints->functions & MWM_FUNC_CLOSE)
-            {
-                FLAG_TOGGLE (c->xfwm_flags, XFWM_FLAG_HAS_CLOSE);
-            }
-            if (mwm_hints->functions & MWM_FUNC_MINIMIZE)
-            {
-                FLAG_TOGGLE (c->xfwm_flags, XFWM_FLAG_HAS_HIDE);
-            }
-            if (mwm_hints->functions & MWM_FUNC_MAXIMIZE)
-            {
-                FLAG_TOGGLE (c->xfwm_flags, XFWM_FLAG_HAS_MAXIMIZE);
-            }
-            if (mwm_hints->functions & MWM_FUNC_RESIZE)
-            {
-                FLAG_TOGGLE (c->xfwm_flags, XFWM_FLAG_HAS_RESIZE);
-            }
-            if (mwm_hints->functions & MWM_FUNC_MOVE)
-            {
-                FLAG_TOGGLE (c->xfwm_flags, XFWM_FLAG_HAS_MOVE);
-            }
-        }
-        g_free (mwm_hints);
-    }
-
-    if (update)
-    {
-        wc.x = c->x;
-        wc.y = c->y;
-        wc.width = c->width;
-        wc.height = c->height;
-
-        /* If client is maximized, we need to update its coordonates and size as well */
-        if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED))
-        {
-            GdkRectangle rect;
-            myScreenFindMonitorAtPoint (screen_info,
-                                        frameX (c) + (frameWidth (c) / 2),
-                                        frameY (c) + (frameHeight (c) / 2), &rect);
-            clientNewMaxSize (c, &wc, &rect, TILE_NONE);
-        }
-
-        clientConfigure (c, &wc, CWX | CWY | CWWidth | CWHeight, CFG_FORCE_REDRAW);
-
-        /* MWM hints can add or remove decorations, update NET_FRAME_EXTENTS accordingly */
-        setNetFrameExtents (display_info,
-                            c->window,
-                            frameTop (c),
-                            frameLeft (c),
-                            frameRight (c),
-                            frameBottom (c));
-    }
-}
-
-void
-clientGetWMNormalHints (Client *c, gboolean update)
-{
-    XWindowChanges wc;
-    unsigned long previous_value;
-    long dummy;
-
-    g_return_if_fail (c != NULL);
-    g_return_if_fail (c->window != None);
-
-    TRACE ("entering clientGetWMNormalHints client \"%s\" (0x%lx)", c->name,
-        c->window);
-
-    if (!c->size)
-    {
-        c->size = XAllocSizeHints ();
-    }
-    g_assert (c->size);
-
-    dummy = 0;
-    if (!XGetWMNormalHints (clientGetXDisplay (c), c->window, c->size, &dummy))
-    {
-        c->size->flags = 0;
-    }
-
-    /* Set/update gravity */
-    c->gravity = c->size->flags & PWinGravity ? c->size->win_gravity : NorthWestGravity;
-
-    previous_value = FLAG_TEST (c->xfwm_flags, XFWM_FLAG_IS_RESIZABLE);
-    FLAG_UNSET (c->xfwm_flags, XFWM_FLAG_IS_RESIZABLE);
-
-    wc.x = c->x;
-    wc.y = c->y;
-    wc.width = c->width;
-    wc.height = c->height;
-
-    if (!(c->size->flags & PMaxSize))
-    {
-        c->size->max_width = G_MAXINT;
-        c->size->max_height = G_MAXINT;
-        c->size->flags |= PMaxSize;
-    }
-
-    if (!(c->size->flags & PBaseSize))
-    {
-        c->size->base_width = 0;
-        c->size->base_height = 0;
-    }
-
-    if (!(c->size->flags & PMinSize))
-    {
-        if ((c->size->flags & PBaseSize))
-        {
-            c->size->min_width = c->size->base_width;
-            c->size->min_height = c->size->base_height;
-        }
-        else
-        {
-            c->size->min_width = 1;
-            c->size->min_height = 1;
-        }
-        c->size->flags |= PMinSize;
-    }
-
-    if (c->size->flags & PResizeInc)
-    {
-        if (c->size->width_inc < 1)
-        {
-            c->size->width_inc = 1;
-        }
-        if (c->size->height_inc < 1)
-        {
-            c->size->height_inc = 1;
-        }
-    }
-    else
-    {
-        c->size->width_inc = 1;
-        c->size->height_inc = 1;
-    }
-
-    if (c->size->flags & PAspect)
-    {
-        if (c->size->min_aspect.x < 1)
-        {
-            c->size->min_aspect.x = 1;
-        }
-        if (c->size->min_aspect.y < 1)
-        {
-            c->size->min_aspect.y = 1;
-        }
-        if (c->size->max_aspect.x < 1)
-        {
-            c->size->max_aspect.x = 1;
-        }
-        if (c->size->max_aspect.y < 1)
-        {
-            c->size->max_aspect.y = 1;
-        }
-    }
-    else
-    {
-        c->size->min_aspect.x = 1;
-        c->size->min_aspect.y = 1;
-        c->size->max_aspect.x = G_MAXINT;
-        c->size->max_aspect.y = G_MAXINT;
-    }
-
-    if (c->size->min_width < 1)
-    {
-        c->size->min_width = 1;
-    }
-    if (c->size->min_height < 1)
-    {
-        c->size->min_height = 1;
-    }
-    if (c->size->max_width < 1)
-    {
-        c->size->max_width = 1;
-    }
-    if (c->size->max_height < 1)
-    {
-        c->size->max_height = 1;
-    }
-    if (wc.width > c->size->max_width)
-    {
-        wc.width = c->size->max_width;
-    }
-    if (wc.height > c->size->max_height)
-    {
-        wc.height = c->size->max_height;
-    }
-    if (wc.width < c->size->min_width)
-    {
-        wc.width = c->size->min_width;
-    }
-    if (wc.height < c->size->min_height)
-    {
-        wc.height = c->size->min_height;
-    }
-
-    if ((c->size->min_width < c->size->max_width) ||
-        (c->size->min_height < c->size->max_height))
-    {
-        FLAG_SET (c->xfwm_flags, XFWM_FLAG_IS_RESIZABLE);
-    }
-
-    if (update)
-    {
-        if ((c->width != wc.width) || (c->height != wc.height))
-        {
-            if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED))
-            {
-                clientRemoveMaximizeFlag (c);
-            }
-            clientConfigure (c, &wc, CWX | CWY | CWWidth | CWHeight, CFG_CONSTRAINED | CFG_FORCE_REDRAW);
-        }
-        else if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_IS_RESIZABLE) != previous_value)
-        {
-            frameQueueDraw (c, FALSE);
-        }
-    }
-    else
-    {
-        c->width = wc.width;
-        c->height = wc.height;
-    }
-}
-
-void
-clientGetWMProtocols (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    unsigned int wm_protocols_flags;
-
-    g_return_if_fail (c != NULL);
-    g_return_if_fail (c->window != None);
-
-    TRACE ("entering clientGetWMProtocols client \"%s\" (0x%lx)", c->name,
-        c->window);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    wm_protocols_flags = getWMProtocols (display_info, c->window);
-    FLAG_SET (c->wm_flags,
-        (wm_protocols_flags & WM_PROTOCOLS_DELETE_WINDOW) ?
-        WM_FLAG_DELETE : 0);
-    FLAG_SET (c->wm_flags,
-        (wm_protocols_flags & WM_PROTOCOLS_TAKE_FOCUS) ?
-        WM_FLAG_TAKEFOCUS : 0);
-    /* KDE extension */
-    FLAG_SET (c->wm_flags,
-        (wm_protocols_flags & WM_PROTOCOLS_CONTEXT_HELP) ?
-        WM_FLAG_CONTEXT_HELP : 0);
-    /* Ping */
-    FLAG_SET (c->wm_flags,
-        (wm_protocols_flags & WM_PROTOCOLS_PING) ?
-        WM_FLAG_PING : 0);
-}
-
-static void
-clientFree (Client *c)
-{
-    g_return_if_fail (c != NULL);
-
-    TRACE ("entering clientFree");
-    TRACE ("freeing client \"%s\" (0x%lx)", c->name, c->window);
-
-    clientClearFocus (c);
-    if (clientGetLastRaise (c->screen_info) == c)
-    {
-        clientClearLastRaise (c->screen_info);
-    }
-    if (clientGetDelayedFocus () == c)
-    {
-        clientClearDelayedFocus ();
-    }
-    if (c->blink_timeout_id)
-    {
-        g_source_remove (c->blink_timeout_id);
-    }
-    if (c->icon_timeout_id)
-    {
-        g_source_remove (c->icon_timeout_id);
-    }
-    if (c->frame_timeout_id)
-    {
-        g_source_remove (c->frame_timeout_id);
-    }
-    if (c->ping_timeout_id)
-    {
-        clientRemoveNetWMPing (c);
-    }
-    if (c->name)
-    {
-        g_free (c->name);
-    }
-    if (c->hostname)
-    {
-        g_free (c->hostname);
-    }
-#ifdef HAVE_XSYNC
-    if (c->xsync_alarm != None)
-    {
-        clientDestroyXSyncAlarm (c);
-    }
-    if (c->xsync_timeout_id)
-    {
-        g_source_remove (c->xsync_timeout_id);
-    }
-#endif /* HAVE_XSYNC */
-#ifdef HAVE_LIBSTARTUP_NOTIFICATION
-    if (c->startup_id)
-    {
-        g_free (c->startup_id);
-    }
-#endif /* HAVE_LIBSTARTUP_NOTIFICATION */
-    if (c->size)
-    {
-        XFree (c->size);
-    }
-    if (c->wmhints)
-    {
-        XFree (c->wmhints);
-    }
-    if ((c->ncmap > 0) && (c->cmap_windows))
-    {
-        XFree (c->cmap_windows);
-    }
-    if (c->class.res_name)
-    {
-        XFree (c->class.res_name);
-    }
-    if (c->class.res_class)
-    {
-        XFree (c->class.res_class);
-    }
-    if (c->dialog_pid)
-    {
-        kill (c->dialog_pid, SIGKILL);
-    }
-    if (c->dialog_fd >= 0)
-    {
-        close (c->dialog_fd);
-    }
-
-    g_free (c);
-}
-
-static void
-clientApplyInitialState (Client *c)
-{
-    g_return_if_fail (c != NULL);
-
-    TRACE ("entering clientApplyInitialState");
-
-    /* We check that afterwards to make sure all states are now known */
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED))
-    {
-        if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_MAXIMIZE))
-        {
-            unsigned long mode = 0L;
-
-            TRACE ("Applying client's initial state: maximized");
-            mode = c->flags & CLIENT_FLAG_MAXIMIZED;
-
-            /* Unset fullscreen mode so that clientToggleMaximized() really change the state */
-            FLAG_UNSET (c->flags, CLIENT_FLAG_MAXIMIZED);
-            clientToggleMaximized (c, mode, FALSE);
-        }
-    }
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
-    {
-        TRACE ("Applying client's initial state: fullscreen");
-        clientUpdateFullscreenState (c);
-    }
-    if (FLAG_TEST_AND_NOT (c->flags, CLIENT_FLAG_ABOVE, CLIENT_FLAG_BELOW))
-    {
-        TRACE ("Applying client's initial state: above");
-        clientUpdateLayerState (c);
-    }
-    if (FLAG_TEST_AND_NOT (c->flags, CLIENT_FLAG_BELOW, CLIENT_FLAG_ABOVE))
-    {
-        TRACE ("Applying client's initial state: below");
-        clientUpdateLayerState (c);
-    }
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_STICKY) &&
-        FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_STICK))
-    {
-        TRACE ("Applying client's initial state: sticky");
-        clientStick (c, TRUE);
-    }
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
-    {
-        TRACE ("Applying client's initial state: shaded");
-        clientShade (c);
-    }
-}
-
-static gboolean
-clientCheckShape (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    int xws, yws, xbs, ybs;
-    unsigned wws, hws, wbs, hbs;
-    int boundingShaped, clipShaped;
-
-    g_return_val_if_fail (c != NULL, FALSE);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if (display_info->have_shape)
-    {
-        XShapeQueryExtents (display_info->dpy, c->window, &boundingShaped, &xws, &yws, &wws,
-                            &hws, &clipShaped, &xbs, &ybs, &wbs, &hbs);
-        return (boundingShaped != 0);
-    }
-    return FALSE;
-}
-
-static void
-clientUpdateIconPix (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    gint size;
-    GdkPixbuf *icon;
-    int i;
-
-    g_return_if_fail (c != NULL);
-    g_return_if_fail (c->window != None);
-
-    TRACE ("entering clientUpdateIconPix for \"%s\" (0x%lx)", c->name, c->window);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    for (i = 0; i < STATE_TOGGLED; i++)
-    {
-        xfwmPixmapFree (&c->appmenu[i]);
-    }
-
-    if (xfwmPixmapNone(&screen_info->buttons[MENU_BUTTON][ACTIVE]))
-    {
-        /* The current theme has no menu button */
-        return;
-    }
-
-    for (i = 0; i < STATE_TOGGLED; i++)
-    {
-        if (!xfwmPixmapNone(&screen_info->buttons[MENU_BUTTON][i]))
-        {
-            xfwmPixmapDuplicate (&screen_info->buttons[MENU_BUTTON][i], &c->appmenu[i]);
-        }
-    }
-    size = MIN (screen_info->buttons[MENU_BUTTON][ACTIVE].width,
-                screen_info->buttons[MENU_BUTTON][ACTIVE].height);
-
-    if (size > 1)
-    {
-        icon = getAppIcon (display_info, c->window, size, size);
-
-        for (i = 0; i < STATE_TOGGLED; i++)
-        {
-            if (!xfwmPixmapNone(&c->appmenu[i]))
-            {
-                xfwmPixmapRenderGdkPixbuf (&c->appmenu[i], icon);
-            }
-        }
-        g_object_unref (icon);
-    }
-}
-
-static gboolean
-update_icon_idle_cb (gpointer data)
-{
-    Client *c;
-
-    TRACE ("entering update_icon_idle_cb");
-
-    c = (Client *) data;
-    g_return_val_if_fail (c, FALSE);
-
-    clientUpdateIconPix (c);
-    if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_VISIBLE))
-    {
-        frameQueueDraw (c, FALSE);
-    }
-    c->icon_timeout_id = 0;
-
-    return (FALSE);
-}
-
-void
-clientUpdateIcon (Client *c)
-{
-    g_return_if_fail (c);
-
-    TRACE ("entering clientUpdateIcon for \"%s\" (0x%lx)", c->name, c->window);
-
-    if (c->icon_timeout_id == 0)
-    {
-        c->icon_timeout_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
-                                              update_icon_idle_cb, c, NULL);
-    }
-}
-
-void
-clientSaveSizePos (Client *c)
-{
-    g_return_if_fail (c != NULL);
-
-    if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ))
-    {
-        c->old_x = c->x;
-        c->old_width = c->width;
-    }
-
-    if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_VERT))
-    {
-        c->old_y = c->y;
-        c->old_height = c->height;
-    }
-}
-
-Client *
-clientFrame (DisplayInfo *display_info, Window w, gboolean recapture)
-{
-    ScreenInfo *screen_info;
-    XWindowAttributes attr;
-    XWindowChanges wc;
-    XSetWindowAttributes attributes;
-    Client *c = NULL;
-    gboolean shaped;
-    unsigned long valuemask;
-    long pid;
-    int i;
-
-    g_return_val_if_fail (w != None, NULL);
-    g_return_val_if_fail (display_info != NULL, NULL);
-
-    TRACE ("entering clientFrame");
-    TRACE ("framing client (0x%lx)", w);
-
-    gdk_error_trap_push ();
-    myDisplayGrabServer (display_info);
-
-    if (!XGetWindowAttributes (display_info->dpy, w, &attr))
-    {
-        g_warning ("Cannot get window attributes for window (0x%lx)", w);
-        myDisplayUngrabServer (display_info);
-        gdk_error_trap_pop ();
-        return NULL;
-    }
-
-    screen_info = myDisplayGetScreenFromRoot (display_info, attr.root);
-    if (!screen_info)
-    {
-        g_warning ("Cannot determine screen info from window (0x%lx)", w);
-        myDisplayUngrabServer (display_info);
-        gdk_error_trap_pop ();
-        return NULL;
-    }
-
-    if (w == screen_info->xfwm4_win)
-    {
-        TRACE ("Not managing our own event window");
-        compositorAddWindow (display_info, w, NULL);
-        myDisplayUngrabServer (display_info);
-        gdk_error_trap_pop ();
-        return NULL;
-    }
-
-#ifdef ENABLE_KDE_SYSTRAY_PROXY
-    if (checkKdeSystrayWindow (display_info, w))
-    {
-        TRACE ("Detected KDE systray windows");
-        if (screen_info->systray != None)
-        {
-            sendSystrayReqDock (display_info, w, screen_info->systray);
-            myDisplayUngrabServer (display_info);
-            gdk_error_trap_pop ();
-            return NULL;
-        }
-        TRACE ("No systray found for this screen");
-    }
-#endif /* ENABLE_KDE_SYSTRAY_PROXY */
-
-    if (attr.override_redirect)
-    {
-        TRACE ("Override redirect window 0x%lx", w);
-        compositorAddWindow (display_info, w, NULL);
-        myDisplayUngrabServer (display_info);
-        gdk_error_trap_pop ();
-        return NULL;
-    }
-
-    c = g_new0 (Client, 1);
-    if (!c)
-    {
-        TRACE ("Cannot allocate memory for the window structure");
-        myDisplayUngrabServer (display_info);
-        gdk_error_trap_pop ();
-        return NULL;
-    }
-
-    c->window = w;
-    c->screen_info = screen_info;
-    c->serial = screen_info->client_serial++;
-
-    /* Termination dialog */
-    c->dialog_pid = 0;
-    c->dialog_fd = -1;
-
-    getWindowName (display_info, c->window, &c->name);
-    getWindowHostname (display_info, c->window, &c->hostname);
-    getTransientFor (display_info, screen_info->xroot, c->window, &c->transient_for);
-    XChangeSaveSet(display_info->dpy, c->window, SetModeInsert);
-
-    /* Initialize structure */
-    c->size = NULL;
-    c->flags = 0L;
-    c->wm_flags = 0L;
-    c->xfwm_flags = XFWM_FLAG_INITIAL_VALUES;
-    c->x = attr.x;
-    c->y = attr.y;
-    c->width = attr.width;
-    c->height = attr.height;
-
-#ifdef HAVE_LIBSTARTUP_NOTIFICATION
-    c->startup_id = NULL;
-#endif /* HAVE_LIBSTARTUP_NOTIFICATION */
-
-#ifdef HAVE_XSYNC
-    c->xsync_waiting = FALSE;
-    c->xsync_enabled = FALSE;
-    c->xsync_counter = None;
-    c->xsync_alarm = None;
-    c->xsync_timeout_id = 0;
-    if (display_info->have_xsync)
-    {
-        getXSyncCounter (display_info, c->window, &c->xsync_counter);
-        if ((c->xsync_counter) && clientCreateXSyncAlarm (c))
-        {
-            c->xsync_enabled = TRUE;
-        }
-    }
-#endif /* HAVE_XSYNC */
-
-    clientGetWMNormalHints (c, FALSE);
-
-    c->size->x = c->x;
-    c->size->y = c->y;
-    c->size->width = c->width;
-    c->size->height = c->height;
-    c->previous_width = -1;
-    c->previous_height = -1;
-    c->border_width = attr.border_width;
-    c->cmap = attr.colormap;
-
-    shaped = clientCheckShape(c);
-    if (shaped)
-    {
-        FLAG_UNSET (c->xfwm_flags, XFWM_FLAG_HAS_BORDER);
-        FLAG_SET (c->flags, CLIENT_FLAG_HAS_SHAPE);
-    }
-
-    if (((c->size->flags & (PMinSize | PMaxSize)) != (PMinSize | PMaxSize))
-        || (((c->size->flags & (PMinSize | PMaxSize)) ==
-                (PMinSize | PMaxSize))
-            && ((c->size->min_width < c->size->max_width)
-                || (c->size->min_height < c->size->max_height))))
-    {
-        FLAG_SET (c->xfwm_flags, XFWM_FLAG_IS_RESIZABLE);
-    }
-
-    for (i = 0; i < BUTTON_COUNT; i++)
-    {
-        c->button_status[i] = BUTTON_STATE_NORMAL;
-    }
-
-    if (!XGetWMColormapWindows (display_info->dpy, c->window, &c->cmap_windows, &c->ncmap))
-    {
-        c->ncmap = 0;
-    }
-
-    c->fullscreen_monitors[0] = 0;
-    c->fullscreen_monitors[1] = 0;
-    c->fullscreen_monitors[2] = 0;
-    c->fullscreen_monitors[3] = 0;
-
-    /* Opacity for compositing manager */
-    c->opacity = NET_WM_OPAQUE;
-    getOpacity (display_info, c->window, &c->opacity);
-    c->opacity_applied = c->opacity;
-    c->opacity_flags = 0;
-
-    /* Keep count of blinking iterations */
-    c->blink_iterations = 0;
-
-    if (getOpacityLock (display_info, c->window))
-    {
-        FLAG_SET (c->xfwm_flags, XFWM_FLAG_OPACITY_LOCKED);
-    }
-
-    /* Timout for asynchronous icon update */
-    c->icon_timeout_id = 0;
-    /* Timout for asynchronous frame update */
-    c->frame_timeout_id = 0;
-    /* Timeout for blinking on urgency */
-    c->blink_timeout_id = 0;
-    /* Ping timeout  */
-    c->ping_timeout_id = 0;
-    /* Ping timeout  */
-    c->ping_time = 0;
-
-    c->class.res_name = NULL;
-    c->class.res_class = NULL;
-    XGetClassHint (display_info->dpy, w, &c->class);
-    c->wmhints = XGetWMHints (display_info->dpy, c->window);
-    c->group_leader = None;
-    if (c->wmhints)
-    {
-        if (c->wmhints->flags & WindowGroupHint)
-        {
-            c->group_leader = c->wmhints->window_group;
-        }
-    }
-    c->client_leader = getClientLeader (display_info, c->window);
-
-    TRACE ("\"%s\" (0x%lx) initial map_state = %s",
-                c->name, c->window,
-                (attr.map_state == IsUnmapped) ?
-                "IsUnmapped" :
-                (attr.map_state == IsViewable) ?
-                "IsViewable" :
-                (attr.map_state == IsUnviewable) ?
-                "IsUnviewable" :
-                "(unknown)");
-    if (attr.map_state != IsUnmapped)
-    {
-        /* Reparent will send us unmap/map events */
-        FLAG_SET (c->xfwm_flags, XFWM_FLAG_MAP_PENDING);
-    }
-    c->ignore_unmap = 0;
-    c->type = UNSET;
-    c->type_atom = None;
-
-    FLAG_SET (c->flags, START_ICONIC (c) ? CLIENT_FLAG_ICONIFIED : 0);
-    FLAG_SET (c->wm_flags, HINTS_ACCEPT_INPUT (c->wmhints) ? WM_FLAG_INPUT : 0);
-
-    clientGetWMProtocols (c);
-    clientGetMWMHints (c, FALSE);
-    c->win_layer = WIN_LAYER_NORMAL;
-    c->fullscreen_old_layer = c->win_layer;
-
-    /* net_wm_user_time standard */
-    c->user_time = 0;
-    c->user_time_win = getNetWMUserTimeWindow(display_info, c->window);
-    clientAddUserTimeWin (c);
-    clientGetUserTime (c);
-
-    /*client PID */
-    getHint (display_info, c->window, NET_WM_PID, (long *) &pid);
-    c->pid = (GPid) pid;
-    TRACE ("Client \"%s\" (0x%lx) PID = %i", c->name, c->window, c->pid);
-
-    /* Apply startup notification properties if available */
-    sn_client_startup_properties (c);
-
-    /* Reload from session */
-    if (sessionMatchWinToSM (c))
-    {
-        FLAG_SET (c->xfwm_flags, XFWM_FLAG_SESSION_MANAGED);
-    }
-
-    /* Beware, order of calls is important here ! */
-    clientGetNetState (c);
-    clientGetNetWmType (c);
-    clientGetInitialNetWmDesktop (c);
-    /* workarea will be updated when shown, no need to worry here */
-    clientGetNetStruts (c);
-
-    /* Once we know the type of window, we can initialize window position */
-    if (!FLAG_TEST (c->xfwm_flags, XFWM_FLAG_SESSION_MANAGED))
-    {
-        clientCoordGravitate (c, c->gravity, APPLY, &c->x, &c->y);
-        if ((attr.map_state == IsUnmapped))
-        {
-            clientInitPosition (c);
-        }
-    }
-
-    /*
-       Initialize "old" fields once the position is ensured, to avoid
-       initially maximized or fullscreen windows being placed offscreen
-       once de-maximized
-     */
-    c->old_x = c->x;
-    c->old_y = c->y;
-    c->old_width = c->width;
-    c->old_height = c->height;
-
-    c->fullscreen_old_x = c->x;
-    c->fullscreen_old_y = c->y;
-    c->fullscreen_old_width = c->width;
-    c->fullscreen_old_height = c->height;
-
-    /*
-       We must call clientApplyInitialState() after having placed the
-       window so that the inital position values are correctly set if the
-       inital state is maximize or fullscreen
-     */
-    clientApplyInitialState (c);
-
-    valuemask = CWEventMask|CWBitGravity|CWWinGravity;
-    attributes.event_mask = (FRAME_EVENT_MASK | POINTER_EVENT_MASK);
-    attributes.win_gravity = StaticGravity;
-    attributes.bit_gravity = StaticGravity;
-
-#ifdef HAVE_RENDER
-    if ((attr.depth == 32) && (display_info->have_render))
-    {
-        c->visual = attr.visual;
-        c->depth  = attr.depth;
-
-        attributes.colormap = attr.colormap;
-        attributes.background_pixmap = None;
-        attributes.border_pixel = 0;
-        attributes.background_pixel = 0;
-
-        valuemask |= CWColormap|CWBackPixmap|CWBackPixel|CWBorderPixel;
-    }
-    else
-    {
-        /* Default depth/visual */
-        c->visual = screen_info->visual;
-        c->depth  = screen_info->depth;
-    }
-#else  /* HAVE_RENDER */
-    /* We don't support multiple depth/visual w/out render */
-    c->visual = screen_info->visual;
-    c->depth  = screen_info->depth;
-#endif /* HAVE_RENDER */
-
-    c->frame =
-        XCreateWindow (display_info->dpy, screen_info->xroot, 0, 0, 1, 1, 0,
-        c->depth, InputOutput, c->visual, valuemask, &attributes);
-
-    XSelectInput (display_info->dpy, c->window, NoEventMask);
-    XSetWindowBorderWidth (display_info->dpy, c->window, 0);
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
-    {
-        XUnmapWindow (display_info->dpy, c->window);
-    }
-    XReparentWindow (display_info->dpy, c->window, c->frame, frameLeft (c), frameTop (c));
-    valuemask = CWEventMask;
-    attributes.event_mask = (CLIENT_EVENT_MASK);
-    XChangeWindowAttributes (display_info->dpy, c->window, valuemask, &attributes);
-    if (display_info->have_shape)
-    {
-        XShapeSelectInput (display_info->dpy, c->window, ShapeNotifyMask);
-    }
-
-    clientAddToList (c);
-    clientGrabButtons(c);
-
-    /* Initialize per client menu button pixmap */
-
-    for (i = 0; i < STATE_TOGGLED; i++)
-    {
-        xfwmPixmapInit (screen_info, &c->appmenu[i]);
-    }
-
-    for (i = 0; i < SIDE_TOP; i++) /* Keep SIDE_TOP for later */
-    {
-        xfwmWindowCreate (screen_info, c->visual, c->depth, c->frame,
-            &c->sides[i], NoEventMask,
-            myDisplayGetCursorResize(screen_info->display_info, CORNER_COUNT + i));
-    }
-
-    for (i = 0; i < CORNER_COUNT; i++)
-    {
-        xfwmWindowCreate (screen_info, c->visual, c->depth, c->frame,
-            &c->corners[i], NoEventMask,
-            myDisplayGetCursorResize(screen_info->display_info, i));
-    }
-
-    xfwmWindowCreate (screen_info, c->visual, c->depth, c->frame,
-        &c->title, NoEventMask, None);
-
-    /*create the top side window AFTER the title window since they overlap
-       and the top side window should be on top */
-
-    xfwmWindowCreate (screen_info, c->visual, c->depth, c->frame,
-        &c->sides[SIDE_TOP], NoEventMask,
-        myDisplayGetCursorResize(screen_info->display_info,
-        CORNER_COUNT + SIDE_TOP));
-
-    for (i = 0; i < BUTTON_COUNT; i++)
-    {
-        xfwmWindowCreate (screen_info, c->visual, c->depth, c->frame,
-            &c->buttons[i], BUTTON_EVENT_MASK, None);
-    }
-    clientUpdateIconPix (c);
-
-    /* Put the window on top to avoid XShape, that speeds up hw accelerated
-       GL apps dramatically */
-    XRaiseWindow (display_info->dpy, c->window);
-
-    TRACE ("now calling configure for the new window \"%s\" (0x%lx)", c->name, c->window);
-    wc.x = c->x;
-    wc.y = c->y;
-    wc.width = c->width;
-    wc.height = c->height;
-    clientConfigure (c, &wc, CWX | CWY | CWHeight | CWWidth, CFG_NOTIFY | CFG_FORCE_REDRAW);
-
-    /* Notify the compositor about this new window */
-    compositorAddWindow (display_info, c->frame, c);
-
-    if (!FLAG_TEST (c->flags, CLIENT_FLAG_ICONIFIED))
-    {
-        if ((c->win_workspace == screen_info->current_ws) ||
-            FLAG_TEST(c->flags, CLIENT_FLAG_STICKY))
-        {
-            if (recapture)
-            {
-                clientRaise (c, None);
-                clientShow (c, TRUE);
-                clientSortRing(c);
-            }
-            else
-            {
-                clientFocusNew(c);
-            }
-        }
-        else
-        {
-            clientRaise (c, None);
-            clientInitFocusFlag (c);
-            clientSetNetActions (c);
-        }
-    }
-    else
-    {
-        clientRaise (c, None);
-        setWMState (display_info, c->window, IconicState);
-        clientSetNetActions (c);
-    }
-    clientUpdateOpacity (c);
-    clientGrabMouseButton (c);
-    setNetFrameExtents (display_info, c->window, frameTop (c), frameLeft (c),
-                                                 frameRight (c), frameBottom (c));
-    clientSetNetState (c);
-
-    /* Window is reparented now, so we can safely release the grab
-     * on the server
-     */
-    myDisplayUngrabServer (display_info);
-    gdk_error_trap_pop ();
-
-    DBG ("client \"%s\" (0x%lx) is now managed", c->name, c->window);
-    DBG ("client_count=%d", screen_info->client_count);
-
-    return c;
-}
-
-void
-clientUnframe (Client *c, gboolean remap)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    XEvent ev;
-    int i;
-    gboolean reparented;
-
-    TRACE ("entering clientUnframe");
-    TRACE ("unframing client \"%s\" (0x%lx) [%s]",
-            c->name, c->window, remap ? "remap" : "no remap");
-
-    g_return_if_fail (c != NULL);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    clientRemoveFromList (c);
-    compositorSetClient (display_info, c->frame, NULL);
-
-    myDisplayGrabServer (display_info);
-    gdk_error_trap_push ();
-    clientRemoveUserTimeWin (c);
-    clientUngrabButtons (c);
-    XUnmapWindow (display_info->dpy, c->frame);
-    clientCoordGravitate (c, c->gravity, REMOVE, &c->x, &c->y);
-    XSelectInput (display_info->dpy, c->window, NoEventMask);
-    XChangeSaveSet(display_info->dpy, c->window, SetModeDelete);
-
-    reparented = XCheckTypedWindowEvent (display_info->dpy, c->window, ReparentNotify, &ev);
-
-    if (remap || !reparented)
-    {
-        XReparentWindow (display_info->dpy, c->window, c->screen_info->xroot, c->x, c->y);
-        XSetWindowBorderWidth (display_info->dpy, c->window, c->border_width);
-        if (remap)
-        {
-            compositorAddWindow (display_info, c->window, NULL);
-            XMapWindow (display_info->dpy, c->window);
-        }
-        else
-        {
-            XUnmapWindow (display_info->dpy, c->window);
-            setWMState (display_info, c->window, WithdrawnState);
-        }
-    }
-
-    if (!remap)
-    {
-        XDeleteProperty (display_info->dpy, c->window,
-                         display_info->atoms[NET_WM_STATE]);
-        XDeleteProperty (display_info->dpy, c->window,
-                         display_info->atoms[NET_WM_DESKTOP]);
-        XDeleteProperty (display_info->dpy, c->window,
-                         display_info->atoms[NET_WM_ALLOWED_ACTIONS]);
-    }
-
-    xfwmWindowDelete (&c->title);
-
-    for (i = 0; i < SIDE_COUNT; i++)
-    {
-        xfwmWindowDelete (&c->sides[i]);
-    }
-    for (i = 0; i < CORNER_COUNT; i++)
-    {
-        xfwmWindowDelete (&c->corners[i]);
-    }
-    for (i = 0; i < STATE_TOGGLED; i++)
-    {
-        xfwmPixmapFree (&c->appmenu[i]);
-    }
-    for (i = 0; i < BUTTON_COUNT; i++)
-    {
-        xfwmWindowDelete (&c->buttons[i]);
-    }
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_HAS_STRUT))
-    {
-        workspaceUpdateArea (c->screen_info);
-    }
-    XDestroyWindow (display_info->dpy, c->frame);
-
-    myDisplayUngrabServer (display_info);
-    gdk_error_trap_pop ();
-    clientFree (c);
-}
-
-void
-clientFrameAll (ScreenInfo *screen_info)
-{
-    DisplayInfo *display_info;
-    XWindowAttributes attr;
-    xfwmWindow shield;
-    Window w1, w2, *wins;
-    unsigned int count, i;
-
-    TRACE ("entering clientFrameAll");
-
-    display_info = screen_info->display_info;
-    clientSetFocus (screen_info, NULL, myDisplayGetCurrentTime (display_info), NO_FOCUS_FLAG);
-    xfwmWindowTemp (screen_info,
-                    NULL, 0,
-                    screen_info->xroot,
-                    &shield,
-                    0, 0,
-                    screen_info->width,
-                    screen_info->height,
-                    EnterWindowMask,
-                    FALSE);
-
-    XSync (display_info->dpy, FALSE);
-    myDisplayGrabServer (display_info);
-    XQueryTree (display_info->dpy, screen_info->xroot, &w1, &w2, &wins, &count);
-    for (i = 0; i < count; i++)
-    {
-        XGetWindowAttributes (display_info->dpy, wins[i], &attr);
-        if ((attr.map_state == IsViewable) && (attr.root == screen_info->xroot))
-        {
-            Client *c = clientFrame (display_info, wins[i], TRUE);
-            if ((c) && ((screen_info->params->raise_on_click) || (screen_info->params->click_to_focus)))
-            {
-                clientGrabMouseButton (c);
-            }
-        }
-        else
-        {
-             compositorAddWindow (display_info, wins[i], NULL);
-        }
-    }
-    if (wins)
-    {
-        XFree (wins);
-    }
-    clientFocusTop (screen_info, WIN_LAYER_FULLSCREEN, myDisplayGetCurrentTime (display_info));
-    xfwmWindowDelete (&shield);
-    myDisplayUngrabServer (display_info);
-    XSync (display_info->dpy, FALSE);
-}
-
-void
-clientUnframeAll (ScreenInfo *screen_info)
-{
-    DisplayInfo *display_info;
-    Client *c;
-    Window w1, w2, *wins;
-    unsigned int count, i;
-
-    TRACE ("entering clientUnframeAll");
-
-    display_info = screen_info->display_info;
-    clientSetFocus (screen_info, NULL, myDisplayGetCurrentTime (display_info), FOCUS_IGNORE_MODAL);
-    XSync (display_info->dpy, FALSE);
-    myDisplayGrabServer (display_info);
-    XQueryTree (display_info->dpy, screen_info->xroot, &w1, &w2, &wins, &count);
-    for (i = 0; i < count; i++)
-    {
-        c = myScreenGetClientFromWindow (screen_info, wins[i], SEARCH_FRAME);
-        if (c)
-        {
-            clientUnframe (c, TRUE);
-        }
-    }
-    myDisplayUngrabServer (display_info);
-    XSync(display_info->dpy, FALSE);
-    if (wins)
-    {
-        XFree (wins);
-    }
-}
-
-Client *
-clientGetFromWindow (Client *c, Window w, unsigned short mode)
-{
-    int b;
-
-    g_return_val_if_fail (w != None, NULL);
-    g_return_val_if_fail (c != NULL, NULL);
-    TRACE ("entering clientGetFromWindow");
-
-    if (mode & SEARCH_WINDOW)
-    {
-        if (c->window == w)
-        {
-            TRACE ("found \"%s\" (mode WINDOW)", c->name);
-            return (c);
-        }
-    }
-
-    if (mode & SEARCH_FRAME)
-    {
-        if (c->frame == w)
-        {
-            TRACE ("found \"%s\" (mode FRAME)", c->name);
-            return (c);
-        }
-    }
-
-    if (mode & SEARCH_WIN_USER_TIME)
-    {
-        if (c->user_time_win == w)
-        {
-            TRACE ("found \"%s\" (mode WIN_USER_TIME)", c->name);
-            return (c);
-        }
-    }
-
-    if (mode & SEARCH_BUTTON)
-    {
-        for (b = 0; b < BUTTON_COUNT; b++)
-        {
-            if (MYWINDOW_XWINDOW(c->buttons[b]) == w)
-            {
-                TRACE ("found \"%s\" (mode BUTTON)", c->name);
-                return (c);
-            }
-        }
-    }
-
-    TRACE ("no client found");
-
-    return NULL;
-}
-
-static void
-clientSetWorkspaceSingle (Client *c, guint ws)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-
-    g_return_if_fail (c != NULL);
-
-    TRACE ("entering clientSetWorkspaceSingle");
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if (ws > screen_info->workspace_count - 1)
-    {
-        ws = screen_info->workspace_count - 1;
-        TRACE ("value off limits, using %i instead", ws);
-    }
-
-    if (c->win_workspace != ws)
-    {
-        TRACE ("setting client \"%s\" (0x%lx) to current_ws %d", c->name, c->window, ws);
-        c->win_workspace = ws;
-        if (FLAG_TEST (c->flags, CLIENT_FLAG_STICKY))
-        {
-            setHint (display_info, c->window, NET_WM_DESKTOP, (unsigned long) ALL_WORKSPACES);
-        }
-        else
-        {
-            setHint (display_info, c->window, NET_WM_DESKTOP, (unsigned long) ws);
-        }
-    }
-    FLAG_SET (c->xfwm_flags, XFWM_FLAG_WORKSPACE_SET);
-}
-
-void
-clientSetWorkspace (Client *c, guint ws, gboolean manage_mapping)
-{
-    Client *c2;
-    GList *list_of_windows;
-    GList *list;
-    guint previous_ws;
-
-    g_return_if_fail (c != NULL);
-
-    TRACE ("entering clientSetWorkspace");
-
-    if (ws > c->screen_info->workspace_count - 1)
-    {
-        g_warning ("Requested workspace %d does not exist", ws);
-        return;
-    }
-
-    list_of_windows = clientListTransientOrModal (c);
-    for (list = list_of_windows; list; list = g_list_next (list))
-    {
-        c2 = (Client *) list->data;
-
-        if (c2->win_workspace != ws)
-        {
-            TRACE ("setting client \"%s\" (0x%lx) to current_ws %d", c->name, c->window, ws);
-
-            previous_ws = c2->win_workspace;
-            clientSetWorkspaceSingle (c2, ws);
-
-            if (manage_mapping && !FLAG_TEST (c2->flags, CLIENT_FLAG_ICONIFIED))
-            {
-                if (previous_ws == c2->screen_info->current_ws)
-                {
-                    clientWithdraw (c2, c2->screen_info->current_ws, FALSE);
-                }
-                if (FLAG_TEST (c2->flags, CLIENT_FLAG_STICKY) || (ws == c2->screen_info->current_ws))
-                {
-                    clientShow (c2, FALSE);
-                }
-            }
-        }
-    }
-    g_list_free (list_of_windows);
-}
-
-static void
-clientShowSingle (Client *c, gboolean deiconify)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-
-    g_return_if_fail (c != NULL);
-
-    if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_VISIBLE))
-    {
-        /* Should we map the window if it is visible? */
-        return;
-    }
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if ((c->win_workspace == screen_info->current_ws) || FLAG_TEST (c->flags, CLIENT_FLAG_STICKY))
-    {
-        TRACE ("showing client \"%s\" (0x%lx)", c->name, c->window);
-        FLAG_SET (c->xfwm_flags, XFWM_FLAG_VISIBLE);
-        XMapWindow (display_info->dpy, c->frame);
-        if (!FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
-        {
-            XMapWindow (display_info->dpy, c->window);
-        }
-        /* Adjust to urgency state as the window is visible */
-        clientUpdateUrgency (c);
-    }
-    if (deiconify)
-    {
-        FLAG_UNSET (c->flags, CLIENT_FLAG_ICONIFIED);
-        setWMState (display_info, c->window, NormalState);
-    }
-    clientSetNetActions (c);
-    clientSetNetState (c);
-}
-
-void
-clientShow (Client *c, gboolean deiconify)
-{
-    Client *c2;
-    GList *list_of_windows;
-    GList *list;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientShow \"%s\" (0x%lx)", c->name, c->window);
-
-    list_of_windows = clientListTransientOrModal (c);
-    for (list = g_list_last (list_of_windows); list; list = g_list_previous (list))
-    {
-        c2 = (Client *) list->data;
-        clientSetWorkspaceSingle (c2, c->win_workspace);
-        /* Ignore request before if the window is not yet managed */
-        if (!FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_MANAGED))
-        {
-            continue;
-        }
-        clientShowSingle (c2, deiconify);
-    }
-    g_list_free (list_of_windows);
-
-    /* Update working area as windows have been shown */
-    workspaceUpdateArea (c->screen_info);
-}
-
-static void
-clientWithdrawSingle (Client *c, GList *exclude_list, gboolean iconify)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-
-    g_return_if_fail (c != NULL);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    TRACE ("hiding client \"%s\" (0x%lx)", c->name, c->window);
-    clientPassFocus(c->screen_info, c, exclude_list);
-    if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_VISIBLE))
-    {
-        FLAG_UNSET (c->xfwm_flags, XFWM_FLAG_VISIBLE);
-        c->ignore_unmap++;
-        /* Adjust to urgency state as the window is not visible */
-        clientUpdateUrgency (c);
-    }
-    XUnmapWindow (display_info->dpy, c->window);
-    XUnmapWindow (display_info->dpy, c->frame);
-    if (iconify)
-    {
-        FLAG_SET (c->flags, CLIENT_FLAG_ICONIFIED);
-        setWMState (display_info, c->window, IconicState);
-        if (!screen_info->show_desktop)
-        {
-            clientSetLast (c);
-        }
-    }
-    clientSetNetActions (c);
-    clientSetNetState (c);
-}
-
-void
-clientWithdraw (Client *c, guint ws, gboolean iconify)
-{
-    Client *c2;
-    GList *list_of_windows;
-    GList *list;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientWithdraw \"%s\" (0x%lx)", c->name, c->window);
-
-    list_of_windows = clientListTransientOrModal (c);
-    for (list = list_of_windows; list; list = g_list_next (list))
-    {
-        c2 = (Client *) list->data;
-
-        /* Ignore request before if the window is not yet managed */
-        if (!FLAG_TEST (c2->xfwm_flags, XFWM_FLAG_MANAGED))
-        {
-            continue;
-        }
-
-        if (FLAG_TEST (c2->flags, CLIENT_FLAG_STICKY) && !iconify)
-        {
-            continue;
-        }
-
-        if (clientIsTransientOrModalForGroup (c2))
-        {
-
-            if (clientTransientOrModalHasAncestor (c2, c2->win_workspace))
-            {
-                /* Other ancestors for that transient for group are still
-                 * visible on current workspace, so don't hide it...
-                 */
-                continue;
-            }
-            if ((ws != c2->win_workspace) &&
-                clientTransientOrModalHasAncestor (c2, ws))
-            {
-                /* ws is used when transitioning between desktops, to avoid
-                   hiding a transient for group that will be shown again on the new
-                   workspace (transient for groups can be transients for multiple
-                   ancesors splitted across workspaces...)
-                 */
-                continue;
-            }
-        }
-        clientWithdrawSingle (c2, list_of_windows, iconify);
-    }
-    g_list_free (list_of_windows);
-
-    /* Update working area as windows have been hidden */
-    workspaceUpdateArea (c->screen_info);
-}
-
-void
-clientWithdrawAll (Client *c, guint ws)
-{
-    GList *list;
-    Client *c2;
-    ScreenInfo *screen_info;
-
-    g_return_if_fail (c != NULL);
-
-    TRACE ("entering clientWithdrawAll");
-
-    screen_info = c->screen_info;
-    for (list = screen_info->windows_stack; list; list = g_list_next (list))
-    {
-        c2 = (Client *) list->data;
-
-        if ((c2 != c)
-            && CLIENT_CAN_HIDE_WINDOW (c2)
-            && !clientIsTransientOrModal (c2))
-        {
-            if (((!c) && (c2->win_workspace == ws))
-                 || ((c) && !clientIsTransientOrModalFor (c, c2)
-                         && (c2->win_workspace == c->win_workspace)))
-            {
-                clientWithdraw (c2, ws, TRUE);
-            }
-        }
-    }
-}
-
-void
-clientClearAllShowDesktop (ScreenInfo *screen_info)
-{
-    GList *list;
-
-    TRACE ("entering clientClearShowDesktop");
-
-    if (screen_info->show_desktop)
-    {
-        for (list = screen_info->windows_stack; list; list = g_list_next (list))
-        {
-            Client *c = (Client *) list->data;
-            FLAG_UNSET (c->xfwm_flags, XFWM_FLAG_WAS_SHOWN);
-        }
-        screen_info->show_desktop = FALSE;
-        sendRootMessage (screen_info, NET_SHOWING_DESKTOP, screen_info->show_desktop,
-                         myDisplayGetCurrentTime (screen_info->display_info));
-    }
-}
-
-void
-clientToggleShowDesktop (ScreenInfo *screen_info)
-{
-    GList *list;
-
-    TRACE ("entering clientToggleShowDesktop");
-
-    clientSetFocus (screen_info, NULL,
-                    myDisplayGetCurrentTime (screen_info->display_info),
-                    FOCUS_IGNORE_MODAL);
-    if (screen_info->show_desktop)
-    {
-        for (list = screen_info->windows_stack; list; list = g_list_next (list))
-        {
-            Client *c = (Client *) list->data;
-            if ((c->type & WINDOW_REGULAR_FOCUSABLE)
-                && !FLAG_TEST (c->flags, CLIENT_FLAG_ICONIFIED | CLIENT_FLAG_SKIP_TASKBAR))
-            {
-                FLAG_SET (c->xfwm_flags, XFWM_FLAG_WAS_SHOWN);
-                clientWithdraw (c, c->win_workspace, TRUE);
-            }
-        }
-        clientFocusTop (screen_info, WIN_LAYER_DESKTOP, myDisplayGetCurrentTime (screen_info->display_info));
-    }
-    else
-    {
-        for (list = g_list_last(screen_info->windows_stack); list; list = g_list_previous (list))
-        {
-            Client *c = (Client *) list->data;
-            if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_WAS_SHOWN))
-            {
-                clientShow (c, TRUE);
-            }
-            FLAG_UNSET (c->xfwm_flags, XFWM_FLAG_WAS_SHOWN);
-        }
-        clientFocusTop (screen_info, WIN_LAYER_FULLSCREEN, myDisplayGetCurrentTime (screen_info->display_info));
-    }
-}
-
-void
-clientActivate (Client *c, guint32 timestamp, gboolean source_is_application)
-{
-    ScreenInfo *screen_info;
-    Client *focused;
-    Client *sibling;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientActivate \"%s\" (0x%lx)", c->name, c->window);
-
-    screen_info = c->screen_info;
-    sibling = clientGetTransientFor(c);
-    focused = clientGetFocus ();
-
-    if ((screen_info->current_ws == c->win_workspace) || (screen_info->params->activate_action != ACTIVATE_ACTION_NONE))
-    {
-        if ((focused) && (c != focused))
-        {
-            /* We might be able to avoid this if we are about to switch workspace */
-            clientAdjustFullscreenLayer (focused, FALSE);
-        }
-        if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_WAS_SHOWN))
-        {
-            /* We are explicitely activating a window that was shown before show-desktop */
-            clientClearAllShowDesktop (screen_info);
-        }
-        if (screen_info->current_ws != c->win_workspace)
-        {
-            if (screen_info->params->activate_action == ACTIVATE_ACTION_BRING)
-            {
-                clientSetWorkspace (c, screen_info->current_ws, TRUE);
-            }
-            else
-            {
-                workspaceSwitch (screen_info, c->win_workspace, NULL, FALSE, timestamp);
-            }
-        }
-        clientRaise (sibling, None);
-        clientShow (sibling, TRUE);
-        if (source_is_application || screen_info->params->click_to_focus || (c->type & WINDOW_TYPE_DONT_FOCUS))
-        {
-            /*
-               It's a bit tricky here, we want to honor the activate request only if:
-
-               - The window use the _NET_ACTIVE_WINDOW protocol and identify itself as an application,
-               - Or we use the click to focus model, in that case we focus the raised window anyway,
-               - Or the request comes from an application that we would not focus by default,
-                 such as panels for example
-             */
-            clientSetFocus (screen_info, c, timestamp, NO_FOCUS_FLAG);
-        }
-        clientSetLastRaise (c);
-    }
-    else
-    {
-        TRACE ("Setting WM_STATE_DEMANDS_ATTENTION flag on \"%s\" (0x%lx)", c->name, c->window);
-        FLAG_SET (c->flags, CLIENT_FLAG_DEMANDS_ATTENTION);
-        clientSetNetState (c);
-    }
-}
-
-void
-clientClose (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    guint32 timestamp;
-
-    g_return_if_fail (c != NULL);
-
-    TRACE ("entering clientClose");
-    TRACE ("closing client \"%s\" (0x%lx)", c->name, c->window);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-    timestamp = myDisplayGetCurrentTime (display_info);
-    timestamp = myDisplayGetTime (display_info, timestamp);
-
-    if (FLAG_TEST (c->wm_flags, WM_FLAG_DELETE))
-    {
-        sendClientMessage (screen_info, c->window, WM_DELETE_WINDOW, timestamp);
-    }
-    else
-    {
-        clientKill (c);
-    }
-    if (FLAG_TEST (c->wm_flags, WM_FLAG_PING))
-    {
-        clientSendNetWMPing (c, timestamp);
-    }
-}
-
-void
-clientKill (Client *c)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientKill");
-    TRACE ("killing client \"%s\" (0x%lx)", c->name, c->window);
-
-    XKillClient (clientGetXDisplay (c), c->window);
-}
-
-void
-clientTerminate (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientTerminate");
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if ((c->hostname) && (c->pid > 0))
-    {
-        if (!strcmp (display_info->hostname, c->hostname))
-        {
-            TRACE ("Sending client %s (pid %i) signal SIGKILL\n", c->name, c->pid);
-
-            if (kill (c->pid, SIGKILL) < 0)
-            {
-                g_warning ("Failed to kill client id %d: %s", c->pid, strerror (errno));
-            }
-        }
-    }
-
-    clientKill (c);
-}
-
-void
-clientEnterContextMenuState (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-
-    g_return_if_fail (c != NULL);
-
-    TRACE ("entering clientEnterContextMenuState");
-    TRACE ("Showing the what's this help for client \"%s\" (0x%lx)", c->name, c->window);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if (FLAG_TEST (c->wm_flags, WM_FLAG_CONTEXT_HELP))
-    {
-        sendClientMessage (c->screen_info, c->window, NET_WM_CONTEXT_HELP,
-                           myDisplayGetCurrentTime (display_info));
-    }
-}
-
-void
-clientSetLayer (Client *c, guint l)
-{
-    GList *list_of_windows = NULL;
-    GList *list = NULL;
-    Client *c2 = NULL;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientSetLayer for \"%s\" (0x%lx) on layer %d", c->name, c->window, l);
-
-    list_of_windows = clientListTransientOrModal (c);
-    for (list = list_of_windows; list; list = g_list_next (list))
-    {
-        c2 = (Client *) list->data;
-        if (c2->win_layer != l)
-        {
-            TRACE ("setting client \"%s\" (0x%lx) layer to %d", c2->name,
-                c2->window, l);
-            c2->win_layer = l;
-        }
-    }
-    g_list_free (list_of_windows);
-
-    if (clientGetLastRaise (c->screen_info) == c)
-    {
-        clientClearLastRaise (c->screen_info);
-    }
-
-    c2 = clientGetFocusOrPending ();
-    if (c2 && (c2 != c) && (c2->win_layer == c->win_layer))
-    {
-        TRACE ("Placing %s under %s", c->name, c2->name);
-        clientLower (c, c2->frame);
-    }
-    else
-    {
-       TRACE ("Placing %s on top of its layer %lu", c->name, c->win_layer);
-       clientRaise (c, None);
-    }
-}
-
-void
-clientShade (Client *c)
-{
-    XWindowChanges wc;
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    unsigned long mask;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientToggleShaded");
-    TRACE ("shading client \"%s\" (0x%lx)", c->name, c->window);
-
-    if (!FLAG_TEST (c->xfwm_flags, XFWM_FLAG_HAS_BORDER)
-        || FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
-    {
-        TRACE ("cowardly refusing to shade \"%s\" (0x%lx) because it has no border", c->name, c->window);
-        return;
-    }
-    else if (FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
-    {
-        TRACE ("\"%s\" (0x%lx) is already shaded", c->name, c->window);
-        return;
-    }
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    FLAG_SET (c->flags, CLIENT_FLAG_SHADED);
-    if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_MANAGED))
-    {
-        mask = (CWWidth | CWHeight);
-        if (clientConstrainPos (c, FALSE))
-        {
-            wc.x = c->x;
-            wc.y = c->y;
-            mask |= (CWX | CWY);
-        }
-
-        if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_VISIBLE))
-        {
-            c->ignore_unmap++;
-        }
-        /*
-         * Shading unmaps the client window. We therefore have to transfer focus to its frame
-         * so that focus doesn't return to root. clientSetFocus() will take care of focusing
-         * the window frame since the SHADED flag is now set.
-         */
-        if (c == clientGetFocus ())
-        {
-            clientSetFocus (screen_info, c, myDisplayGetCurrentTime (display_info), FOCUS_FORCE);
-        }
-        XUnmapWindow (display_info->dpy, c->window);
-
-        wc.width = c->width;
-        wc.height = c->height;
-        clientConfigure (c, &wc, mask, CFG_FORCE_REDRAW);
-    }
-    clientSetNetState (c);
-}
-
-void
-clientUnshade (Client *c)
-{
-    XWindowChanges wc;
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientToggleShaded");
-    TRACE ("shading/unshading client \"%s\" (0x%lx)", c->name, c->window);
-
-    if (!FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
-    {
-        TRACE ("\"%s\" (0x%lx) is not shaded", c->name, c->window);
-        return;
-    }
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    FLAG_UNSET (c->flags, CLIENT_FLAG_SHADED);
-    if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_MANAGED))
-    {
-        if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_VISIBLE))
-        {
-            XMapWindow (display_info->dpy, c->window);
-        }
-        /*
-         * Unshading will show the client window, so we need to focus it when unshading.
-         */
-        if (c == clientGetFocus ())
-        {
-            clientSetFocus (screen_info, c, myDisplayGetCurrentTime (display_info), FOCUS_FORCE);
-        }
-
-        wc.width = c->width;
-        wc.height = c->height;
-        clientConfigure (c, &wc, CWWidth | CWHeight, CFG_FORCE_REDRAW);
-    }
-    clientSetNetState (c);
-}
-
-void
-clientToggleShaded (Client *c)
-{
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_SHADED))
-    {
-        clientUnshade (c);
-    }
-    else
-    {
-        clientShade (c);
-    }
-}
-
-void
-clientStick (Client *c, gboolean include_transients)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    Client *c2;
-    GList *list_of_windows;
-    GList *list;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientStick");
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if (include_transients)
-    {
-        list_of_windows = clientListTransientOrModal (c);
-        for (list = list_of_windows; list; list = g_list_next (list))
-        {
-            c2 = (Client *) list->data;
-            TRACE ("Sticking client \"%s\" (0x%lx)", c2->name, c2->window);
-            FLAG_SET (c2->flags, CLIENT_FLAG_STICKY);
-            setHint (display_info, c2->window, NET_WM_DESKTOP, (unsigned long) ALL_WORKSPACES);
-            frameQueueDraw (c2, FALSE);
-        }
-        g_list_free (list_of_windows);
-    }
-    else
-    {
-        TRACE ("Sticking client \"%s\" (0x%lx)", c->name, c->window);
-        FLAG_SET (c->flags, CLIENT_FLAG_STICKY);
-        setHint (display_info, c->window, NET_WM_DESKTOP, (unsigned long) ALL_WORKSPACES);
-    }
-    clientSetWorkspace (c, screen_info->current_ws, TRUE);
-    clientSetNetState (c);
-}
-
-void
-clientUnstick (Client *c, gboolean include_transients)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    Client *c2;
-    GList *list_of_windows;
-    GList *list;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientUnstick");
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if (include_transients)
-    {
-        list_of_windows = clientListTransientOrModal (c);
-        for (list = list_of_windows; list; list = g_list_next (list))
-        {
-            c2 = (Client *) list->data;
-            TRACE ("Unsticking client \"%s\" (0x%lx)", c2->name, c2->window);
-            FLAG_UNSET (c2->flags, CLIENT_FLAG_STICKY);
-            setHint (display_info, c2->window, NET_WM_DESKTOP, (unsigned long) screen_info->current_ws);
-            frameQueueDraw (c2, FALSE);
-        }
-        g_list_free (list_of_windows);
-    }
-    else
-    {
-        TRACE ("Unsticking client \"%s\" (0x%lx)", c->name, c->window);
-        FLAG_UNSET (c->flags, CLIENT_FLAG_STICKY);
-        setHint (display_info, c->window, NET_WM_DESKTOP, (unsigned long) screen_info->current_ws);
-    }
-    clientSetWorkspace (c, screen_info->current_ws, TRUE);
-    clientSetNetState (c);
-}
-
-void
-clientToggleSticky (Client *c, gboolean include_transients)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientToggleSticky");
-    TRACE ("sticking/unsticking client \"%s\" (0x%lx)", c->name, c->window);
-
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_STICKY))
-    {
-        clientUnstick (c, include_transients);
-    }
-    else
-    {
-        clientStick (c, include_transients);
-    }
-}
-
-void
-clientUpdateFullscreenSize (Client *c)
-{
-    ScreenInfo *screen_info;
-    XWindowChanges wc;
-    GdkRectangle monitor, rect;
-    int i;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientUpdateFullscreenSize");
-    TRACE ("Update fullscreen size for client \"%s\" (0x%lx)", c->name, c->window);
-
-    screen_info = c->screen_info;
-
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
-    {
-        if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREN_MONITORS))
-        {
-            gdk_screen_get_monitor_geometry (screen_info->gscr, c->fullscreen_monitors[0], &rect);
-            for (i = 1; i < 4; i++)
-            {
-                gdk_screen_get_monitor_geometry (screen_info->gscr, c->fullscreen_monitors[i], &monitor);
-                gdk_rectangle_union (&rect, &monitor, &rect);
-            }
-        }
-        else
-        {
-            int cx, cy;
-
-            cx = frameX (c) + (frameWidth (c) / 2);
-            cy = frameY (c) + (frameHeight (c) / 2);
-
-            myScreenFindMonitorAtPoint (screen_info, cx, cy, &rect);
-        }
-
-        wc.x = rect.x;
-        wc.y = rect.y;
-        wc.width = rect.width;
-        wc.height = rect.height;
-    }
-
-    else
-    {
-        wc.x = c->fullscreen_old_x;
-        wc.y = c->fullscreen_old_y;
-        wc.width = c->fullscreen_old_width;
-        wc.height = c->fullscreen_old_height;
-    }
-
-    if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_MANAGED))
-    {
-        clientConfigure (c, &wc, CWX | CWY | CWWidth | CWHeight, CFG_FORCE_REDRAW);
-    }
-    else
-    {
-        c->x = wc.x;
-        c->y = wc.y;
-        c->height = wc.height;
-        c->width = wc.width;
-    }
-}
-
-void clientToggleFullscreen (Client *c)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientToggleFullscreen");
-    TRACE ("toggle fullscreen client \"%s\" (0x%lx)", c->name, c->window);
-
-    /*can we switch to full screen, does it make any sense? */
-    if (!FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN) && (c->size->flags & PMaxSize))
-    {
-        GdkRectangle rect;
-        int cx, cy;
-
-        cx = frameX (c) + (frameWidth (c) / 2);
-        cy = frameY (c) + (frameHeight (c) / 2);
-
-        myScreenFindMonitorAtPoint (c->screen_info, cx, cy, &rect);
-
-        if ((c->size->max_width < rect.width) || (c->size->max_height < rect.height))
-        {
-            return;
-        }
-    }
-
-    if (!clientIsTransientOrModal (c) && (c->type == WINDOW_NORMAL))
-    {
-        FLAG_TOGGLE (c->flags, CLIENT_FLAG_FULLSCREEN);
-        clientUpdateFullscreenState (c);
-    }
-}
-
-void clientSetFullscreenMonitor (Client *c, gint top, gint bottom, gint left, gint right)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    gint num_monitors;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientSetFullscreenMonitor");
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    num_monitors = gdk_screen_get_n_monitors (screen_info->gscr);
-    if ((top >= 0)    && (top < num_monitors)    &&
-        (bottom >= 0) && (bottom < num_monitors) &&
-        (left >= 0)   && (left < num_monitors)   &&
-        (right >= 0)  && (right < num_monitors))
-    {
-        c->fullscreen_monitors[0] = top;
-        c->fullscreen_monitors[1] = bottom;
-        c->fullscreen_monitors[2] = left;
-        c->fullscreen_monitors[3] = right;
-        FLAG_SET (c->flags, CLIENT_FLAG_FULLSCREN_MONITORS);
-    }
-    else
-    {
-        c->fullscreen_monitors[0] = 0;
-        c->fullscreen_monitors[1] = 0;
-        c->fullscreen_monitors[2] = 0;
-        c->fullscreen_monitors[3] = 0;
-        FLAG_UNSET (c->flags, CLIENT_FLAG_FULLSCREN_MONITORS);
-    }
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
-    {
-        clientUpdateFullscreenSize (c);
-    }
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREN_MONITORS))
-    {
-        setNetFullscreenMonitors (display_info, c->window, top, bottom, left, right);
-    }
-}
-
-void clientToggleLayerAbove (Client *c)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientToggleAbove");
-
-    if ((c->type & WINDOW_REGULAR_FOCUSABLE) &&
-        !clientIsTransientOrModal (c) &&
-        !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
-    {
-        FLAG_UNSET (c->flags, CLIENT_FLAG_BELOW);
-        FLAG_TOGGLE (c->flags, CLIENT_FLAG_ABOVE);
-        clientUpdateLayerState (c);
-    }
-}
-
-void clientToggleLayerBelow (Client *c)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientToggleBelow");
-
-    if ((c->type & WINDOW_REGULAR_FOCUSABLE) &&
-        !clientIsTransientOrModal (c) &&
-        !FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
-    {
-        FLAG_UNSET (c->flags, CLIENT_FLAG_ABOVE);
-        FLAG_TOGGLE (c->flags, CLIENT_FLAG_BELOW);
-        clientUpdateLayerState (c);
-    }
-}
-
-void clientSetLayerNormal (Client *c)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientSetLayerNormal");
-
-    if (!FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
-    {
-        FLAG_UNSET (c->flags, CLIENT_FLAG_ABOVE | CLIENT_FLAG_BELOW);
-        clientUpdateLayerState (c);
-    }
-}
-
-void
-clientRemoveMaximizeFlag (Client *c)
-{
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientRemoveMaximizeFlag");
-    TRACE ("Removing maximize flag on client \"%s\" (0x%lx)", c->name,
-        c->window);
-
-    FLAG_UNSET (c->flags, CLIENT_FLAG_MAXIMIZED);
-    frameQueueDraw (c, FALSE);
-    clientSetNetActions (c);
-    clientSetNetState (c);
-}
-
-static void
-clientNewMaxState (Client *c, XWindowChanges *wc, int mode)
-{
-    if (FLAG_TEST_ALL (mode, CLIENT_FLAG_MAXIMIZED))
-    {
-        /*
-         * We need to test specifically for full de-maximization
-         * otherwise it's too confusing when the window changes
-         * from horiz to vertical maximization or vice-versa.
-         */
-        if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED))
-        {
-            FLAG_UNSET (c->flags, CLIENT_FLAG_MAXIMIZED);
-            wc->x = c->old_x;
-            wc->y = c->old_y;
-            wc->width = c->old_width;
-            wc->height = c->old_height;
-
-            return;
-        }
-    }
-
-    if (FLAG_TEST (mode, CLIENT_FLAG_MAXIMIZED_HORIZ))
-    {
-        if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ))
-        {
-            FLAG_SET (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ);
-        }
-        else
-        {
-            FLAG_UNSET (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ);
-            wc->x = c->old_x;
-            wc->y = c->old_y;
-            wc->width = c->old_width;
-            wc->height = c->old_height;
-        }
-    }
-
-    if (FLAG_TEST (mode, CLIENT_FLAG_MAXIMIZED_VERT))
-    {
-        if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_VERT))
-        {
-            FLAG_SET (c->flags, CLIENT_FLAG_MAXIMIZED_VERT);
-        }
-        else
-        {
-            FLAG_UNSET (c->flags, CLIENT_FLAG_MAXIMIZED_VERT);
-            wc->x = c->old_x;
-            wc->y = c->old_y;
-            wc->width = c->old_width;
-            wc->height = c->old_height;
-        }
-    }
-}
-
-static gboolean
-clientNewMaxSize (Client *c, XWindowChanges *wc, GdkRectangle *rect, tilePositionType tile)
-{
-    ScreenInfo *screen_info;
-    int full_x, full_y, full_w, full_h;
-    int tmp_x, tmp_y, tmp_w, tmp_h;
-
-    tmp_x = frameX (c);
-    tmp_y = frameY (c);
-    tmp_h = frameHeight (c);
-    tmp_w = frameWidth (c);
-    screen_info = c->screen_info;
-
-    full_x = MAX (screen_info->params->xfwm_margins[STRUTS_LEFT], rect->x);
-    full_y = MAX (screen_info->params->xfwm_margins[STRUTS_TOP], rect->y);
-    full_w = MIN (screen_info->width - screen_info->params->xfwm_margins[STRUTS_RIGHT],
-                  rect->x + rect->width) - full_x;
-    full_h = MIN (screen_info->height - screen_info->params->xfwm_margins[STRUTS_BOTTOM],
-                  rect->y + rect->height) - full_y;
-
-    if (FLAG_TEST_ALL (c->flags, CLIENT_FLAG_MAXIMIZED))
-    {
-        /* Adjust size to the largest size available, not covering struts */
-        clientMaxSpace (screen_info, &full_x, &full_y, &full_w, &full_h);
-        wc->x = full_x + frameLeft (c);
-        wc->y = full_y + frameTop (c);
-        wc->width = full_w - frameLeft (c) - frameRight (c);
-        wc->height = full_h - frameTop (c) - frameBottom (c);
-
-        return ((wc->width <= c->size->max_width) && (wc->height <= c->size->max_height));
-    }
-
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_HORIZ))
-    {
-        /* Adjust size to the widest size available, for the current vertical position/height */
-        switch (tile)
-        {
-            case TILE_UP:
-                tmp_h = full_h / 2;
-                tmp_y = full_y;
-                clientMaxSpace (screen_info, &full_x, &tmp_y, &full_w, &tmp_h);
-                wc->y = tmp_y + frameTop (c);
-                wc->height = tmp_h - frameTop (c) - frameBottom (c);
-                break;
-            case TILE_DOWN:
-                tmp_h = full_h / 2;
-                tmp_y = full_y + full_h / 2;
-                clientMaxSpace (screen_info, &full_x, &tmp_y, &full_w, &tmp_h);
-                wc->y = tmp_y + frameTop (c);
-                wc->height = tmp_h - frameTop (c) - frameBottom (c);
-                break;
-            default:
-                clientMaxSpace (screen_info, &full_x, &tmp_y, &full_w, &tmp_h);
-                break;
-        }
-
-        wc->x = full_x + frameLeft (c);
-        wc->width = full_w - frameLeft (c) - frameRight (c);
-
-        return (wc->width <= c->size->max_width);
-    }
-
-    if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED_VERT))
-    {
-        /* Adjust size to the tallest size available, for the current horizontal position/width */
-        switch (tile)
-        {
-            case TILE_LEFT:
-                tmp_x = full_x;
-                tmp_w = full_w / 2;
-                clientMaxSpace (screen_info, &tmp_x, &full_y, &tmp_w, &full_h);
-                wc->x = tmp_x + frameLeft (c);
-                wc->width = tmp_w - frameLeft (c) - frameRight (c);
-                break;
-            case TILE_RIGHT:
-                tmp_x = full_x + full_w /2;
-                tmp_w = full_w / 2;
-                clientMaxSpace (screen_info, &tmp_x, &full_y, &tmp_w, &full_h);
-                wc->x = tmp_x + frameLeft (c);
-                wc->width = tmp_w - frameLeft (c) - frameRight (c);
-                break;
-            default:
-                clientMaxSpace (screen_info, &tmp_x, &full_y, &tmp_w, &full_h);
-                break;
-        }
-
-        wc->y = full_y + frameTop (c);
-        wc->height = full_h - frameTop (c) - frameBottom (c);
-
-        return (wc->height <= c->size->max_height);
-    }
-
-    return TRUE;
-}
-
-gboolean
-clientToggleMaximized (Client *c, int mode, gboolean restore_position)
-{
-    DisplayInfo *display_info;
-    ScreenInfo *screen_info;
-    XWindowChanges wc;
-    GdkRectangle rect;
-    unsigned long old_flags;
-
-    g_return_val_if_fail (c != NULL, FALSE);
-
-    TRACE ("entering clientToggleMaximized");
-    TRACE ("maximzing/unmaximizing client \"%s\" (0x%lx)", c->name, c->window);
-
-    if (!CLIENT_CAN_MAXIMIZE_WINDOW (c))
-    {
-        return FALSE;
-    }
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-    myScreenFindMonitorAtPoint (screen_info,
-                                frameX (c) + (frameWidth (c) / 2),
-                                frameY (c) + (frameHeight (c) / 2), &rect);
-
-    wc.x = c->x;
-    wc.y = c->y;
-    wc.width = c->width;
-    wc.height = c->height;
-
-    if (restore_position &&
-        FLAG_TEST (mode, CLIENT_FLAG_MAXIMIZED) &&
-        !FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED))
-    {
-        clientSaveSizePos (c);
-    }
-
-    old_flags = c->flags;
-
-    /* 1) Compute the new state */
-    clientNewMaxState (c, &wc, mode);
-
-    /* 2) Compute the new size, based on the state */
-    if (!clientNewMaxSize (c, &wc, &rect, TILE_NONE))
-    {
-        c->flags = old_flags;
-        return FALSE;
-    }
-
-    /* 3) Update size and position fields */
-    c->x = wc.x;
-    c->y = wc.y;
-    c->height = wc.height;
-    c->width = wc.width;
-
-    /* Maximizing may remove decoration on the side, update NET_FRAME_EXTENTS accordingly */
-    setNetFrameExtents (display_info,
-                        c->window,
-                        frameTop (c),
-                        frameLeft (c),
-                        frameRight (c),
-                        frameBottom (c));
-
-    /* Maximized windows w/out border cannot be resized, update allowed actions */
-    clientSetNetActions (c);
-    if (restore_position && FLAG_TEST (c->xfwm_flags, XFWM_FLAG_MANAGED))
-    {
-        clientConfigure (c, &wc, CWWidth | CWHeight | CWX | CWY, CFG_FORCE_REDRAW);
-    }
-    clientSetNetState (c);
-
-    return TRUE;
-}
-
-gboolean
-clientTile (Client *c, gint cx, gint cy, tilePositionType tile, gboolean send_configure)
-{
-    DisplayInfo *display_info;
-    ScreenInfo *screen_info;
-    XWindowChanges wc;
-    GdkRectangle rect;
-    unsigned long old_flags;
-    int mode;
-
-    g_return_val_if_fail (c != NULL, FALSE);
-
-    TRACE ("entering clientTile");
-    TRACE ("Tiling client \"%s\" (0x%lx)", c->name, c->window);
-
-    if (!CLIENT_CAN_TILE_WINDOW (c))
-    {
-        return FALSE;
-    }
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-    myScreenFindMonitorAtPoint (screen_info, cx, cy, &rect);
-
-    wc.x = c->x;
-    wc.y = c->y;
-    wc.width = c->width;
-    wc.height = c->height;
-
-    switch (tile)
-    {
-        case TILE_LEFT:
-        case TILE_RIGHT:
-            mode = CLIENT_FLAG_MAXIMIZED_VERT;
-            break;
-        case TILE_UP:
-        case TILE_DOWN:
-            mode = CLIENT_FLAG_MAXIMIZED_HORIZ;
-            break;
-        default:
-            return FALSE;
-            break;
-    }
-
-    if (!FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED))
-    {
-        clientSaveSizePos (c);
-    }
-
-    old_flags = c->flags;
-    FLAG_UNSET (c->flags, CLIENT_FLAG_MAXIMIZED);
-    clientNewMaxState (c, &wc, mode);
-    if (!clientNewMaxSize (c, &wc, &rect, tile))
-    {
-        c->flags = old_flags;
-        return FALSE;
-    }
-
-    c->x = wc.x;
-    c->y = wc.y;
-    c->height = wc.height;
-    c->width = wc.width;
-
-    if (send_configure)
-    {
-        setNetFrameExtents (display_info,
-                            c->window,
-                            frameTop (c),
-                            frameLeft (c),
-                            frameRight (c),
-                            frameBottom (c));
-
-        clientSetNetActions (c);
-
-        clientConfigure (c, &wc, CWWidth | CWHeight | CWX | CWY, CFG_FORCE_REDRAW);
-    }
-    clientSetNetState (c);
-
-    return TRUE;
-}
-
-void
-clientUpdateOpacity (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    Client *focused;
-    gboolean opaque;
-
-    g_return_if_fail (c != NULL);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-    if (!compositorIsUsable (display_info))
-    {
-        return;
-    }
-
-    focused = clientGetFocus ();
-    opaque = (FLAG_TEST(c->type, WINDOW_TYPE_DONT_PLACE | WINDOW_TYPE_DONT_FOCUS)
-              || (focused == c));
-
-    clientSetOpacity (c, c->opacity, OPACITY_INACTIVE, opaque ? 0 : OPACITY_INACTIVE);
-}
-
-void
-clientUpdateAllOpacity (ScreenInfo *screen_info)
-{
-    DisplayInfo *display_info;
-    Client *c;
-    guint i;
-
-    g_return_if_fail (screen_info != NULL);
-
-    display_info = screen_info->display_info;
-    if (!compositorIsUsable (display_info))
-    {
-        return;
-    }
-
-    for (c = screen_info->clients, i = 0; i < screen_info->client_count; c = c->next, ++i)
-    {
-        clientUpdateOpacity (c);
-    }
-}
-
-void
-clientSetOpacity (Client *c, guint opacity, guint clear, guint xor)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    guint applied;
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if (!compositorIsUsable (display_info))
-    {
-        return;
-    }
-
-    c->opacity_flags = (c->opacity_flags & ~clear) ^ xor;
-
-    if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_OPACITY_LOCKED))
-    {
-        applied = c->opacity;
-    }
-    else
-    {
-        long long multiplier = 1, divisor = 1;
-
-        c->opacity = applied = opacity;
-
-        if (FLAG_TEST (c->opacity_flags, OPACITY_MOVE))
-        {
-            multiplier *= c->screen_info->params->move_opacity;
-            divisor *= 100;
-        }
-        if (FLAG_TEST (c->opacity_flags, OPACITY_RESIZE))
-        {
-            multiplier *= c->screen_info->params->resize_opacity;
-            divisor *= 100;
-        }
-        if (FLAG_TEST (c->opacity_flags, OPACITY_INACTIVE))
-        {
-            multiplier *= c->screen_info->params->inactive_opacity;
-            divisor *= 100;
-        }
-
-        applied = (guint) ((long long) applied * multiplier / divisor);
-    }
-
-    if (applied != c->opacity_applied)
-    {
-        c->opacity_applied = applied;
-        compositorWindowSetOpacity (display_info, c->frame, applied);
-    }
-}
-
-void
-clientDecOpacity (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if (!compositorIsUsable (display_info))
-    {
-        return;
-    }
-
-    if ((c->opacity > OPACITY_SET_MIN) && !(FLAG_TEST (c->xfwm_flags, XFWM_FLAG_OPACITY_LOCKED)))
-    {
-         clientSetOpacity (c, c->opacity - OPACITY_SET_STEP, 0, 0);
-    }
-}
-
-void
-clientIncOpacity (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    if (!compositorIsUsable (display_info))
-    {
-        return;
-    }
-
-    if ((c->opacity < NET_WM_OPAQUE) && !(FLAG_TEST (c->xfwm_flags, XFWM_FLAG_OPACITY_LOCKED)))
-    {
-         guint opacity = c->opacity + OPACITY_SET_STEP;
-
-         if (opacity < OPACITY_SET_MIN)
-         {
-             opacity = NET_WM_OPAQUE;
-         }
-         clientSetOpacity (c, opacity, 0, 0);
-    }
-}
-
-/* Xrandr stuff: on screen size change, make sure all clients are still visible */
-void
-clientScreenResize(ScreenInfo *screen_info, gboolean fully_visible)
-{
-    Client *c = NULL;
-    GList *list, *list_of_windows;
-    XWindowChanges wc;
-    unsigned short configure_flags;
-
-    list_of_windows = clientGetStackList (screen_info);
-
-    if (!list_of_windows)
-    {
-        return;
-    }
-
-    /* Revalidate client struts */
-    for (list = list_of_windows; list; list = g_list_next (list))
-    {
-        c = (Client *) list->data;
-        if (FLAG_TEST (c->flags, CLIENT_FLAG_HAS_STRUT))
-        {
-            clientValidateNetStrut (c);
-        }
-    }
-
-    for (list = list_of_windows; list; list = g_list_next (list))
-    {
-        unsigned long maximization_flags = 0L;
-
-        c = (Client *) list->data;
-        if (!CONSTRAINED_WINDOW (c))
-        {
-            continue;
-        }
-
-        /* Recompute size and position of maximized windows */
-        if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED))
-        {
-            maximization_flags = c->flags & CLIENT_FLAG_MAXIMIZED;
-
-            /* Force an update by clearing the internal flags */
-            FLAG_UNSET (c->flags, CLIENT_FLAG_MAXIMIZED);
-            clientToggleMaximized (c, maximization_flags, FALSE);
-
-            wc.x = c->x;
-            wc.y = c->y;
-            wc.width = c->width;
-            wc.height = c->height;
-            clientConfigure (c, &wc, CWX | CWY | CWWidth | CWHeight, CFG_NOTIFY);
-        }
-        else if (FLAG_TEST (c->flags, CLIENT_FLAG_FULLSCREEN))
-        {
-            clientUpdateFullscreenSize (c);
-        }
-        else
-        {
-            configure_flags = CFG_CONSTRAINED | CFG_REQUEST;
-            if (fully_visible)
-            {
-                configure_flags |= CFG_KEEP_VISIBLE;
-            }
-            if (FLAG_TEST (c->xfwm_flags, XFWM_FLAG_SAVED_POS))
-            {
-                wc.x = c->saved_x;
-                wc.y = c->saved_y;
-            }
-            else
-            {
-                FLAG_SET (c->xfwm_flags, XFWM_FLAG_SAVED_POS);
-
-                c->saved_x = c->x;
-                c->saved_y = c->y;
-
-                wc.x = c->x;
-                wc.y = c->y;
-            }
-
-            clientConfigure (c, &wc, CWX | CWY, configure_flags);
-        }
-    }
-
-    g_list_free (list_of_windows);
-}
-
-void
-clientUpdateCursor (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    guint i;
-
-    g_return_if_fail (c != NULL);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    for (i = 0; i <= SIDE_TOP; i++)
-    {
-        xfwmWindowSetCursor (&c->sides[i],
-            myDisplayGetCursorResize(display_info, CORNER_COUNT + i));
-    }
-
-    for (i = 0; i < CORNER_COUNT; i++)
-    {
-        xfwmWindowSetCursor (&c->corners[i],
-            myDisplayGetCursorResize(display_info, i));
-    }
-}
-
-void
-clientUpdateAllCursor (ScreenInfo *screen_info)
-{
-    Client *c;
-    guint i;
-
-    g_return_if_fail (screen_info != NULL);
-
-    for (c = screen_info->clients, i = 0; i < screen_info->client_count; c = c->next, ++i)
-    {
-        clientUpdateCursor (c);
-    }
-}
-
-static eventFilterStatus
-clientButtonPressEventFilter (XEvent * xevent, gpointer data)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    Client *c;
-    ButtonPressData *passdata;
-    eventFilterStatus status;
-    int b;
-    gboolean pressed;
-
-    passdata = (ButtonPressData *) data;
-    c = passdata->c;
-    b = passdata->b;
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    /* Update the display time */
-    myDisplayUpdateCurrentTime (display_info, xevent);
-
-    status = EVENT_FILTER_STOP;
-    pressed = TRUE;
-
-    switch (xevent->type)
-    {
-        case EnterNotify:
-            if ((xevent->xcrossing.mode != NotifyGrab) && (xevent->xcrossing.mode != NotifyUngrab))
-            {
-                c->button_status[b] = BUTTON_STATE_PRESSED;
-                frameQueueDraw (c, FALSE);
-            }
-            break;
-        case LeaveNotify:
-            if ((xevent->xcrossing.mode != NotifyGrab) && (xevent->xcrossing.mode != NotifyUngrab))
-            {
-                c->button_status[b] = BUTTON_STATE_NORMAL;
-                frameQueueDraw (c, FALSE);
-            }
-            break;
-        case ButtonRelease:
-            pressed = FALSE;
-            break;
-        case UnmapNotify:
-            if (xevent->xunmap.window == c->window)
-            {
-                pressed = FALSE;
-                c->button_status[b] = BUTTON_STATE_NORMAL;
-            }
-            break;
-        case KeyPress:
-        case KeyRelease:
-            break;
-        default:
-            status = EVENT_FILTER_CONTINUE;
-            break;
-    }
-
-    if (!pressed)
-    {
-        TRACE ("event loop now finished");
-        gtk_main_quit ();
-    }
-
-    return status;
-}
-
-void
-clientButtonPress (Client *c, Window w, XButtonEvent * bev)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    ButtonPressData passdata;
-    int b, g1;
-
-    g_return_if_fail (c != NULL);
-    TRACE ("entering clientButtonPress");
-
-    for (b = 0; b < BUTTON_COUNT; b++)
-    {
-        if (MYWINDOW_XWINDOW (c->buttons[b]) == w)
-        {
-            break;
-        }
-    }
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-
-    g1 = XGrabPointer (display_info->dpy, w, FALSE,
-                       ButtonReleaseMask | EnterWindowMask | LeaveWindowMask,
-                       GrabModeAsync, GrabModeAsync,
-                       screen_info->xroot, None,
-                       myDisplayGetCurrentTime (display_info));
-
-    if (g1 != GrabSuccess)
-    {
-        TRACE ("grab failed in clientButtonPress");
-        gdk_beep ();
-        if (g1 == GrabSuccess)
-        {
-            XUngrabKeyboard (display_info->dpy, myDisplayGetCurrentTime (display_info));
-        }
-        return;
-    }
-
-    passdata.c = c;
-    passdata.b = b;
-
-    c->button_status[b] = BUTTON_STATE_PRESSED;
-    frameQueueDraw (c, FALSE);
-
-    TRACE ("entering button press loop");
-    eventFilterPush (display_info->xfilter, clientButtonPressEventFilter, &passdata);
-    gtk_main ();
-    eventFilterPop (display_info->xfilter);
-    TRACE ("leaving button press loop");
-
-    XUngrabPointer (display_info->dpy, myDisplayGetCurrentTime (display_info));
-
-    if (c->button_status[b] == BUTTON_STATE_PRESSED)
-    {
-        /*
-         * Button was pressed at the time, means the pointer was still within
-         * the button, so return to prelight if available, normal otherwise.
-         */
-        if (!xfwmPixmapNone(clientGetButtonPixmap(c, b, PRELIGHT)))
-        {
-            c->button_status[b] = BUTTON_STATE_PRELIGHT;
-        }
-        else
-        {
-            c->button_status[b] = BUTTON_STATE_NORMAL;
-        }
-
-        switch (b)
-        {
-            case HIDE_BUTTON:
-                if (CLIENT_CAN_HIDE_WINDOW (c))
-                {
-                    clientWithdraw (c, c->win_workspace, TRUE);
-                }
-                break;
-            case CLOSE_BUTTON:
-                clientClose (c);
-                break;
-            case MAXIMIZE_BUTTON:
-                if (CLIENT_CAN_MAXIMIZE_WINDOW (c))
-                {
-                    if (bev->button == Button1)
-                    {
-                        clientToggleMaximized (c, CLIENT_FLAG_MAXIMIZED, TRUE);
-                    }
-                    else if (bev->button == Button2)
-                    {
-                        clientToggleMaximized (c, CLIENT_FLAG_MAXIMIZED_VERT, TRUE);
-                    }
-                    else if (bev->button == Button3)
-                    {
-                        clientToggleMaximized (c, CLIENT_FLAG_MAXIMIZED_HORIZ, TRUE);
-                    }
-                }
-                break;
-            case SHADE_BUTTON:
-                clientToggleShaded (c);
-                break;
-            case STICK_BUTTON:
-                clientToggleSticky (c, TRUE);
-                break;
-            default:
-                break;
-        }
-        frameQueueDraw (c, FALSE);
-    }
-}
-
-xfwmPixmap *
-clientGetButtonPixmap (Client *c, int button, int state)
-{
-    ScreenInfo *screen_info;
-
-    TRACE ("entering clientGetButtonPixmap button=%i, state=%i", button, state);
-    screen_info = c->screen_info;
-    switch (button)
-    {
-        case MENU_BUTTON:
-            if ((screen_info->params->show_app_icon)
-                && (!xfwmPixmapNone(&c->appmenu[state])))
-            {
-                return &c->appmenu[state];
-            }
-            break;
-        case SHADE_BUTTON:
-            if (FLAG_TEST (c->flags, CLIENT_FLAG_SHADED)
-                && (!xfwmPixmapNone(&screen_info->buttons[SHADE_BUTTON][state + STATE_TOGGLED])))
-            {
-                return &screen_info->buttons[SHADE_BUTTON][state + STATE_TOGGLED];
-            }
-            return &screen_info->buttons[SHADE_BUTTON][state];
-            break;
-        case STICK_BUTTON:
-            if (FLAG_TEST (c->flags, CLIENT_FLAG_STICKY)
-                && (!xfwmPixmapNone(&screen_info->buttons[STICK_BUTTON][state + STATE_TOGGLED])))
-            {
-                return &screen_info->buttons[STICK_BUTTON][state + STATE_TOGGLED];
-            }
-            return &screen_info->buttons[STICK_BUTTON][state];
-            break;
-        case MAXIMIZE_BUTTON:
-            if (FLAG_TEST (c->flags, CLIENT_FLAG_MAXIMIZED)
-                && (!xfwmPixmapNone(&screen_info->buttons[MAXIMIZE_BUTTON][state + STATE_TOGGLED])))
-            {
-                return &screen_info->buttons[MAXIMIZE_BUTTON][state + STATE_TOGGLED];
-            }
-            return &screen_info->buttons[MAXIMIZE_BUTTON][state];
-            break;
-        default:
-            break;
-    }
-    return &screen_info->buttons[button][state];
-}
-
-int
-clientGetButtonState (Client *c, int button, int state)
-{
-    if (state == INACTIVE)
-    {
-        return (state);
-    }
-
-    if ((c->button_status[button] == BUTTON_STATE_PRESSED) &&
-        clientGetButtonPixmap (c, button, PRESSED))
-    {
-        return (PRESSED);
-    }
-
-    if ((c->button_status[button] == BUTTON_STATE_PRELIGHT) &&
-        clientGetButtonPixmap (c, button, PRELIGHT))
-    {
-        return (PRELIGHT);
-    }
-
-    return (ACTIVE);
-}
-
-
-Client *
-clientGetLeader (Client *c)
-{
-    TRACE ("entering clientGetLeader");
-    g_return_val_if_fail (c != NULL, NULL);
-
-    if (c->group_leader != None)
-    {
-        return myScreenGetClientFromWindow (c->screen_info, c->group_leader, SEARCH_WINDOW);
-    }
-    else if (c->client_leader != None)
-    {
-        return myScreenGetClientFromWindow (c->screen_info, c->client_leader, SEARCH_WINDOW);
-    }
-    return NULL;
-}
-
-#ifdef HAVE_LIBSTARTUP_NOTIFICATION
-char *
-clientGetStartupId (Client *c)
-{
-    ScreenInfo *screen_info;
-    DisplayInfo *display_info;
-    gboolean got_startup_id;
-
-    g_return_val_if_fail (c != NULL, NULL);
-    g_return_val_if_fail (c->window != None, NULL);
-
-    screen_info = c->screen_info;
-    display_info = screen_info->display_info;
-    got_startup_id = FALSE;
-
-    if (c->startup_id)
-    {
-        return (c->startup_id);
-    }
-
-    got_startup_id = getWindowStartupId (display_info, c->window, &c->startup_id);
-
-    if (!got_startup_id && (c->client_leader))
-    {
-        got_startup_id = getWindowStartupId (display_info, c->client_leader, &c->startup_id);
-    }
-
-    if (!got_startup_id && (c->group_leader))
-    {
-        got_startup_id = getWindowStartupId (display_info, c->group_leader, &c->startup_id);
-    }
-
-    return (c->startup_id);
-}
-#endif /* HAVE_LIBSTARTUP_NOTIFICATION */

=== removed file '.pc/applied-patches'
--- .pc/applied-patches	2013-12-03 15:24:16 +0000
+++ .pc/applied-patches	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-0004-Optimize-smart-placement-bug-5785.patch
-8563.patch

=== modified file 'ChangeLog'
--- ChangeLog	2013-08-08 22:00:03 +0000
+++ ChangeLog	2014-01-19 09:12:15 +0000
@@ -1,18 +1,1444 @@
-commit 3918e6b09eaeac51d23f2c4a4a08e52e06e60a1b
-Author: Nick Schermer <[e-mail]>
-Date:   Sun May 5 17:58:40 2013 +0200
-
-    Updates for release.
-
-commit 52e1ecd35ef750fbb86bd5b91b8030325a46bc9d
+commit 2b800f4f994e0e3951fc221933705051329b75bd
+Author: Nick Schermer <[e-mail]>
+Date:   Thu Dec 26 22:41:16 2013 +0100
+
+    Updates for release.
+
+commit d8c3df328934e865c92e8b2deb74f74b19a724b4
+Author: Nick Schermer <[e-mail]>
+Date:   Thu Dec 26 18:16:40 2013 +0100
+
+    Disable roll up feature by default (bug #10563).
+    
+    Probably a confusing feature for new users, the previous commit
+    made it easy to enable this again.
+
+commit a99c18c19ce6f17150818d6c0af23556fac1d454
+Author: Nick Schermer <[e-mail]>
+Date:   Thu Dec 26 18:13:27 2013 +0100
+
+    Add tweak setting to toggle roll up feature (bug #10563).
+
+commit 3dab5fb5d641606fd12fb710881af8a3d8858681
+Author: Nick Schermer <[e-mail]>
+Date:   Thu Dec 26 18:02:37 2013 +0100
+
+    Fix ordering of items in dialog.
+
+commit 7b091d1fbcc4489d1235865eef0d4ba5ba18b1e2
+Author: Walter Cheuk <[e-mail]>
+Date:   Sun Dec 15 12:32:22 2013 +0100
+
+    I18n: Add new translation zh_HK (100%).
+    
+    170 translated messages.
+    
+    Transifex (https://www.transifex.com/projects/p/xfce/).
+
+commit 75275c39b90f74fa05697ba13569b5d0cf527d79
+Author: Sveinn í Felli <[e-mail]>
+Date:   Thu Dec 12 12:31:59 2013 +0100
+
+    I18n: Update translation is (97%).
+    
+    165 translated messages, 5 untranslated messages.
+    
+    Transifex (https://www.transifex.com/projects/p/xfce/).
+
+commit ce5f008584302362f6374201432f91e3d950715d
+Author: Alistair Buxton <[e-mail]>
+Date:   Tue Dec 10 01:32:05 2013 +0000
+
+    Fix crash when compositor is compiled in but disabled.
+    
+    If user attempts to zoom in when compositor is disabled,
+    don't do anything. Also handle possible divide by zero
+    if the refresh rate is reported as zero.
+
+commit 51a982b74c9b48b9ae20d712127187119dad7a05
+Author: Nick Schermer <[e-mail]>
+Date:   Sat Dec 7 12:33:03 2013 +0100
+
+    Fix compiler warnings.
+
+commit e7da725aab39018f54383dc6e8a64eccd8793035
+Author: Alistair Buxton <[e-mail]>
+Date:   Sat Nov 16 16:25:35 2013 +0000
+
+    Implement zooming.
+    
+    This implements zooming when the compositor is enabled. To zoom in,
+    hold the key used to grab and move windows (usually alt) and scroll
+    up with the mouse wheel. Scroll down to zoom out.
+    
+    This works by transforming the offscreen buffer where windows are
+    composited when rendering it back to the screen.
+
+commit ab3de90429ae015e7f657f44f10f281120bbbe7a
+Author: Alistair Buxton <[e-mail]>
+Date:   Mon Nov 25 17:33:26 2013 +0000
+
+    Bring refresh_rate stuff outside of LIBDRM checks.
+    
+    We want to know the refresh rate even if libdrm is not used.
+
+commit f7fcb87de1f90210258026592dab472b14e189c1
+Author: Alistair Buxton <[e-mail]>
+Date:   Wed Nov 27 19:55:12 2013 +0000
+
+    Ignore when root atoms are unset.
+