/usr/src/RPM/BUILD/ctwm-4.1.0/ewmh.c

Go to the documentation of this file.

/*
 * Copyright 2014 Olaf Seibert
 */
 
/*
 * Implements some of the Extended Window Manager Hints, as (extremely
 * poorly) documented at
 * http://standards.freedesktop.org/wm-spec/wm-spec-1.3.html .
 * In fact, the wiki page that refers to that as being the current version
 * (http://www.freedesktop.org/wiki/Specifications/wm-spec/)
 * neglects to tell us there are newer versions 1.4 and 1.5 at
 * http://standards.freedesktop.org/wm-spec/wm-spec-1.5.html
 * (which has a listable directory that I discovered by accident).
 * The same wiki page also has lots of dead links to a CVS repository.
 * Nevertheless, it is where one ends up if one starts at
 * http://www.freedesktop.org/wiki/Specifications/ .
 *
 * EWMH is an extension to the ICCCM (Inter-Client Communication
 * Conventions Manual).
 * http://tronche.com/gui/x/icccm/
 *
 * To fill in lots of details, the source code of other window managers
 * has been consulted.
 */
 
#include "ctwm.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdint.h>
#include <assert.h>
 
#include <X11/Xatom.h>
#include <X11/extensions/shape.h>
 
#include "ctwm_atoms.h"
#include "ctwm_shutdown.h"
#include "ewmh_atoms.h"
#include "screen.h"
#include "events.h"
#include "event_handlers.h"
#include "functions_defs.h"
#include "icons.h"
#include "otp.h"
#include "image.h"
#include "list.h"
#include "functions.h"
#include "occupation.h"
#include "r_layout.h"
#include "util.h"
#include "vscreen.h"
#include "win_iconify.h"
#include "win_ops.h"
#include "win_resize.h"
#include "win_utils.h"
#include "workspace_utils.h"
 
/* #define DEBUG_EWMH */
 
Atom XEWMHAtom[NUM_EWMH_XATOMS];
 
#define NET_WM_STATE_REMOVE        0    /* remove/unset property */
#define NET_WM_STATE_ADD           1    /* add/set property */
#define NET_WM_STATE_TOGGLE        2    /* toggle property  */
 
#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT      0
#define _NET_WM_MOVERESIZE_SIZE_TOP          1
#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT     2
#define _NET_WM_MOVERESIZE_SIZE_RIGHT        3
#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT  4
#define _NET_WM_MOVERESIZE_SIZE_BOTTOM       5
#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT   6
#define _NET_WM_MOVERESIZE_SIZE_LEFT         7
#define _NET_WM_MOVERESIZE_MOVE              8   /* movement only */
#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD     9   /* size via keyboard */
#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD    10   /* move via keyboard */
#define _NET_WM_MOVERESIZE_CANCEL           11   /* cancel operation */
 
static Image *ExtractIcon(ScreenInfo *scr, unsigned long *prop, int width,
                          int height);
static void EwmhClientMessage_NET_WM_DESKTOP(XClientMessageEvent *msg);
static void EwmhClientMessage_NET_WM_STATE(XClientMessageEvent *msg);
static void EwmhClientMessage_NET_ACTIVE_WINDOW(XClientMessageEvent *msg);
static void EwmhClientMessage_NET_WM_MOVERESIZE(XClientMessageEvent *msg);
static void EwmhClientMessage_NET_CLOSE_WINDOW(XClientMessageEvent *msg);
static XEvent synth_btnevent_for_moveresize(TwmWindow *twm_win);
static unsigned long EwmhGetWindowProperty(Window w, Atom name, Atom type);
static void EwmhGetStrut(TwmWindow *twm_win, bool update);
static void EwmhRemoveStrut(TwmWindow *twm_win);
static void EwmhSet_NET_WORKAREA(ScreenInfo *scr);
static int EwmhGet_NET_WM_STATE(TwmWindow *twm_win);
static void EwmhClientMessage_NET_WM_STATEchange(TwmWindow *twm_win, int change,
                int newVal);
 
#define ALL_WORKSPACES  0xFFFFFFFFU
 
static void SendPropertyMessage(Window to, Window about,
                                Atom messagetype,
                                long l0, long l1, long l2, long l3, long l4,
                                long mask)
{
    XEvent e;
 
    e.xclient.type = ClientMessage;
    e.xclient.message_type = messagetype;
    e.xclient.display = dpy;
    e.xclient.window = about;
    e.xclient.format = 32;
    e.xclient.data.l[0] = l0;
    e.xclient.data.l[1] = l1;
    e.xclient.data.l[2] = l2;
    e.xclient.data.l[3] = l3;
    e.xclient.data.l[4] = l4;
 
    XSendEvent(dpy, to, False, mask, &e);
}
 
static void EwmhInitAtoms(void)
{
    XInternAtoms(dpy, XEWMHAtomNames, NUM_EWMH_XATOMS, False, XEWMHAtom);
}
 
static bool caughtError;
 
static int CatchError(Display *display, XErrorEvent *event)
{
    caughtError = true;
    return 0;
}
 
void EwmhInit(void)
{
    EwmhInitAtoms();
}
 
/*
 * Force-generate some event, so that we know the current time.
 *
 * Suggested in the ICCCM:
 * http://tronche.com/gui/x/icccm/sec-2.html#s-2.1
 */
 
static void GenerateTimestamp(ScreenInfo *scr)
{
    XEvent event;
    struct timespec tosleep;
    int timeout = 200;          /* 0.2 seconds in ms */
    int found;
 
    /* Sleep in 10ms chunks */
    tosleep.tv_sec  = 0;
    tosleep.tv_nsec = (10 * 1000 * 1000);
 
    if(EventTime > 0) {
        return;
    }
 
    XChangeProperty(dpy, scr->icccm_Window,
                    XA_WM_CLASS, XA_STRING,
                    8, PropModeAppend, NULL, 0);
 
    while(timeout > 0) {
        found = XCheckTypedWindowEvent(dpy, scr->icccm_Window, PropertyNotify, &event);
        if(found) {
            break;
        }
        nanosleep(&tosleep, NULL);
        timeout -= 10;
    }
 
    if(found) {
#ifdef DEBUG_EWMH
        fprintf(stderr, "GenerateTimestamp: time = %ld, timeout left = %d\n",
                event.xproperty.time, timeout);
#endif /* DEBUG_EWMH */
        if(EventTime < event.xproperty.time) {
            EventTime = event.xproperty.time;
        }
    }
}
 
/*
 * Perform the "replace the window manager" protocol, as vaguely hinted
 * at by the ICCCM section 4.3.
 * http://tronche.com/gui/x/icccm/sec-4.html#s-4.3
 *
 * We do want to run through this even if we're not running with
 * --replace ourselves, because it also sets up the bits for other
 * invocations to --replace us.
 *
 * TODO: convert the selection to atom VERSION.
 */
static bool EwmhReplaceWM(ScreenInfo *scr)
{
    char atomname[32];
    Atom wmAtom;
    Window selectionOwner;
 
    snprintf(atomname, sizeof(atomname), "WM_S%d", scr->screen);
    wmAtom = XInternAtom(dpy, atomname, False);
 
    selectionOwner = XGetSelectionOwner(dpy, wmAtom);
    if(selectionOwner == scr->icccm_Window) {
        selectionOwner = None;
    }
 
    if(selectionOwner != None) {
        XErrorHandler oldHandler;
 
        /*
         * Check if that owner still exists, and if it does, we want
         * StructureNotify-kind events from it.
         */
        caughtError = false;
        oldHandler = XSetErrorHandler(CatchError);
 
        XSelectInput(dpy, selectionOwner, StructureNotifyMask);
        XSync(dpy, False);
 
        XSetErrorHandler(oldHandler);
 
        if(caughtError) {
            selectionOwner = None;
        }
    }
 
    /*
     * If something else is owning things and we're not running
     * --replace, give up now and return failure.
     */
    if(selectionOwner != None && !CLarg.ewmh_replace) {
#ifdef DEBUG_EWMH
        fprintf(stderr, "A window manager is already running on screen %d\n",
                scr->screen);
#endif
        return false;
    }
 
    /* We're asked to --replace, so try to do so */
    XSetSelectionOwner(dpy, wmAtom, scr->icccm_Window, CurrentTime);
 
    if(XGetSelectionOwner(dpy, wmAtom) != scr->icccm_Window) {
        fprintf(stderr, "Did not get window manager selection on screen %d\n",
                scr->screen);
        return false;
    }
 
    /*
     * If there was a previous selection owner, wait for it
     * to go away.
     */
 
    if(selectionOwner != None) {
        int timeout = 10 * 1000;        /* 10 seconds in ms */
        XEvent event;
        struct timespec tosleep;
 
        /* Sleep in 100ms chunks */
        tosleep.tv_sec  = 0;
        tosleep.tv_nsec = (100 * 1000 * 1000);
 
        while(timeout > 0) {
 
            int found = XCheckTypedWindowEvent(dpy, selectionOwner, DestroyNotify, &event);
            if(found) {
                break;
            }
            nanosleep(&tosleep, NULL);
            timeout -= 100;
        }
 
        if(timeout <= 0) {
            fprintf(stderr, "Timed out waiting for other window manager "
                    "on screen %d to quit\n",
                    scr->screen);
            return false;
        }
    }
 
    /*
     * Send a message to confirm we're now managing the screen.
     * ICCCM, end of chapter 2, section "Manager Selections".
     * http://tronche.com/gui/x/icccm/sec-2.html#s-2.8
     *
     * ICCCM says StructureNotifyMask,
     * OpenBox says SubstructureNotifyMask.
     */
 
    GenerateTimestamp(scr);
 
    SendPropertyMessage(scr->XineramaRoot, scr->XineramaRoot,
                        XA_MANAGER, EventTime, wmAtom, scr->icccm_Window, 0, 0,
                        StructureNotifyMask);
 
    return true;
}
 
/*
 * This function is called very early in initialisation.
 *
 * Only scr->screen and scr->XineramaRoot are valid: we want to know if
 * it makes sense to continue with the full initialisation.
 *
 * Create the ICCCM window that owns the WM_Sn selection.
 */
bool EwmhInitScreenEarly(ScreenInfo *scr)
{
    XSetWindowAttributes attrib;
 
#ifdef DEBUG_EWMH
    fprintf(stderr, "EwmhInitScreenEarly: XCreateWindow\n");
#endif
    attrib.event_mask = PropertyChangeMask;
    attrib.override_redirect = True;
    scr->icccm_Window = XCreateWindow(dpy, scr->XineramaRoot,
                                      -100, -100, 1, 1, 0,
                                      CopyFromParent, InputOutput,
                                      CopyFromParent,
                                      CWEventMask | CWOverrideRedirect,
                                      &attrib);
 
    XMapWindow(dpy, scr->icccm_Window);
    XLowerWindow(dpy, scr->icccm_Window);
 
#ifdef DEBUG_EWMH
    fprintf(stderr, "EwmhInitScreenEarly: call EwmhReplaceWM\n");
#endif
    if(!EwmhReplaceWM(scr)) {
        XDestroyWindow(dpy, scr->icccm_Window);
        scr->icccm_Window = None;
 
#ifdef DEBUG_EWMH
        fprintf(stderr, "EwmhInitScreenEarly: return false\n");
#endif
        return false;
    }
 
#ifdef DEBUG_EWMH
    fprintf(stderr, "EwmhInitScreenEarly: return true\n");
#endif
    return true;
}
 
/*
 * This initialisation is called late, when scr has been set up
 * completely.
 */
void EwmhInitScreenLate(ScreenInfo *scr)
{
    long data[2];
 
    /* Set _NET_SUPPORTING_WM_CHECK on root window */
    data[0] = scr->icccm_Window;
    XChangeProperty(dpy, scr->XineramaRoot,
                    XA__NET_SUPPORTING_WM_CHECK, XA_WINDOW,
                    32, PropModeReplace,
                    (unsigned char *)data, 1);
 
    /*
     * Set properties on the window;
     * this also belongs with _NET_SUPPORTING_WM_CHECK
     */
    XChangeProperty(dpy, scr->icccm_Window,
                    XA__NET_WM_NAME, XA_UTF8_STRING,
                    8, PropModeReplace,
                    (unsigned char *)"ctwm", 4);
 
    data[0] = scr->icccm_Window;
    XChangeProperty(dpy, scr->icccm_Window,
                    XA__NET_SUPPORTING_WM_CHECK, XA_WINDOW,
                    32, PropModeReplace,
                    (unsigned char *)data, 1);
 
    /*
     * Add supported properties to the root window.
     */
    data[0] = 0;
    data[1] = 0;
    XChangeProperty(dpy, scr->XineramaRoot,
                    XA__NET_DESKTOP_VIEWPORT, XA_CARDINAL,
                    32, PropModeReplace,
                    (unsigned char *)data, 2);
 
    data[0] = scr->rootw;
    data[1] = scr->rooth;
    XChangeProperty(dpy, scr->XineramaRoot,
                    XA__NET_DESKTOP_GEOMETRY, XA_CARDINAL,
                    32, PropModeReplace,
                    (unsigned char *)data, 2);
 
    EwmhSet_NET_WORKAREA(scr);
 
    if(scr->workSpaceManagerActive) {
        data[0] = scr->workSpaceMgr.count;
    }
    else {
        data[0] = 1;
    }
 
    XChangeProperty(dpy, scr->XineramaRoot,
                    XA__NET_NUMBER_OF_DESKTOPS, XA_CARDINAL,
                    32, PropModeReplace,
                    (unsigned char *)data, 1);
 
    if(scr->workSpaceManagerActive) {
        /* TODO: this is for the first Virtual Screen only... */
        /*data[0] = scr->workSpaceMgr.workSpaceWindowList->currentwspc->number; */
        data[0] = 0;
    }
    else {
        data[0] = 0;
    }
    XChangeProperty(dpy, scr->XineramaRoot,
                    XA__NET_CURRENT_DESKTOP, XA_CARDINAL,
                    32, PropModeReplace,
                    (unsigned char *)data, 1);
 
    EwmhSet_NET_SHOWING_DESKTOP(0);
 
    long supported[30];
    int i = 0;
 
    supported[i++] = XA__NET_SUPPORTING_WM_CHECK;
    supported[i++] = XA__NET_DESKTOP_VIEWPORT;
    supported[i++] = XA__NET_NUMBER_OF_DESKTOPS;
    supported[i++] = XA__NET_CURRENT_DESKTOP;
    supported[i++] = XA__NET_DESKTOP_GEOMETRY;
    supported[i++] = XA__NET_WM_ICON;
    supported[i++] = XA__NET_WM_DESKTOP;
    supported[i++] = XA__NET_CLIENT_LIST;
    supported[i++] = XA__NET_CLIENT_LIST_STACKING;
    supported[i++] = XA__NET_WM_WINDOW_TYPE;
    supported[i++] = XA__NET_WM_WINDOW_TYPE_NORMAL;
    supported[i++] = XA__NET_WM_WINDOW_TYPE_DESKTOP;
    supported[i++] = XA__NET_WM_WINDOW_TYPE_DOCK;
    supported[i++] = XA__NET_WM_STRUT;
    supported[i++] = XA__NET_WM_STRUT_PARTIAL;
    supported[i++] = XA__NET_SHOWING_DESKTOP;
    supported[i++] = XA__NET_WM_STATE;
    supported[i++] = XA__NET_WM_STATE_MAXIMIZED_VERT;
    supported[i++] = XA__NET_WM_STATE_MAXIMIZED_HORZ;
    supported[i++] = XA__NET_WM_STATE_FULLSCREEN;
    supported[i++] = XA__NET_ACTIVE_WINDOW;
    supported[i++] = XA__NET_WORKAREA;
    supported[i++] = XA__NET_WM_MOVERESIZE;
    supported[i++] = XA__NET_WM_STATE_SHADED;
    supported[i++] = XA__NET_WM_STATE_ABOVE;
    supported[i++] = XA__NET_WM_STATE_BELOW;
    supported[i++] = XA__NET_CLOSE_WINDOW;
 
    XChangeProperty(dpy, scr->XineramaRoot,
                    XA__NET_SUPPORTED, XA_ATOM,
                    32, PropModeReplace,
                    (unsigned char *)supported, i);
}
 
 
#ifdef VSCREEN
/*
 * Set up the _NET_VIRTUAL_ROOTS property, which indicates that we're
 * using virtual root windows.
 * This applies only if we have multiple virtual screens.
 *
 * Also record this as a supported atom in _NET_SUPPORTED.
 *
 * Really, our virtual screens (with their virtual root windows) don't quite
 * fit in the EWMH idiom. Several root window properties (such as
 * _NET_CURRENT_DESKTOP) are more appropriate on the virtual root windows. But
 * that is not where other clients would look for them.
 *
 * The idea seems to be that the virtual roots as used for workspaces (desktops
 * in EWMH terminology) are only mapped one at a time.
 */
void EwmhInitVirtualRoots(ScreenInfo *scr)
{
    int numVscreens = scr->numVscreens;
 
    if(numVscreens > 1) {
        long *data;
        long d0;
        VirtualScreen *vs;
        int i;
 
        data = calloc(numVscreens, sizeof(long));
 
        for(vs = scr->vScreenList, i = 0;
                        vs != NULL && i < numVscreens;
                        vs = vs->next, i++) {
            data[i] = vs->window;
        }
 
        XChangeProperty(dpy, scr->XineramaRoot,
                        XA__NET_VIRTUAL_ROOTS, XA_WINDOW,
                        32, PropModeReplace,
                        (unsigned char *)data, numVscreens);
 
        /* This might fail, but what can we do about it? */
 
        free(data);
 
        d0 = XA__NET_VIRTUAL_ROOTS;
        XChangeProperty(dpy, scr->XineramaRoot,
                        XA__NET_SUPPORTED, XA_ATOM,
                        32, PropModeAppend,
                        (unsigned char *)&d0, 1);
    }
}
#endif
 
 
static void EwmhTerminateScreen(ScreenInfo *scr)
{
    XDeleteProperty(dpy, scr->XineramaRoot, XA__NET_SUPPORTED);
 
    /*
     * Don't delete scr->icccm_Window; let it be deleted automatically
     * when we terminate the X server connection. A replacement window
     * manager may want to start working immediately after it has
     * disappeared.
     */
}
 
/*
 * Clear everything that needs to be cleared before we exit.
 */
 
void EwmhTerminate(void)
{
    int scrnum;
    ScreenInfo *scr;
 
    for(scrnum = 0; scrnum < NumScreens; scrnum++) {
        if((scr = ScreenList[scrnum]) == NULL) {
            continue;
        }
        EwmhTerminateScreen(scr);
    }
}
 
/*
 * Event handler: lost the WM_Sn selection
 * (that's the only selection we have).
 */
 
void EwmhSelectionClear(XSelectionClearEvent *sev)
{
#ifdef DEBUG_EWMH
    fprintf(stderr, "sev->window = %x\n", (unsigned)sev->window);
#endif
    DoShutdown();
}
 
/*
 * When accepting client messages to the root window,
 * be accepting and accept both the real root window and the
 * current virtual screen.
 *
 * Should perhaps also accept any other virtual screen.
 */
bool EwmhClientMessage(XClientMessageEvent *msg)
{
    if(msg->format != 32) {
        return false;
    }
 
    /* Messages regarding any window */
    if(msg->message_type == XA__NET_WM_DESKTOP) {
        EwmhClientMessage_NET_WM_DESKTOP(msg);
        return true;
    }
    else if(msg->message_type == XA__NET_WM_STATE) {
        EwmhClientMessage_NET_WM_STATE(msg);
        return true;
    }
    else if(msg->message_type == XA__NET_ACTIVE_WINDOW) {
        EwmhClientMessage_NET_ACTIVE_WINDOW(msg);
        return true;
    }
    else if(msg->message_type == XA__NET_WM_MOVERESIZE) {
        EwmhClientMessage_NET_WM_MOVERESIZE(msg);
        return true;
    }
    else if(msg->message_type == XA__NET_CLOSE_WINDOW) {
        EwmhClientMessage_NET_CLOSE_WINDOW(msg);
        return true;
    }
 
    /* Messages regarding the root window */
    if(msg->window != Scr->XineramaRoot &&
                    msg->window != Scr->Root) {
#ifdef DEBUG_EWMH
        fprintf(stderr, "Received unrecognized client message: %s\n",
                XGetAtomName(dpy, msg->message_type));
#endif
        return false;
    }
 
    if(msg->message_type == XA__NET_CURRENT_DESKTOP) {
        GotoWorkSpaceByNumber(Scr->currentvs, msg->data.l[0]);
        return true;
    }
    else if(msg->message_type == XA__NET_SHOWING_DESKTOP) {
        ShowBackground(Scr->currentvs, msg->data.l[0] ? 1 : 0);
        return true;
    }
    else {
#ifdef DEBUG_EWMH
        fprintf(stderr, "Received unrecognized client message about root window: %s\n",
                XGetAtomName(dpy, msg->message_type));
#endif
    }
 
    return false;
}
 
/*
 * The format of the _NET_WM_ICON property is
 *
 * [0] width
 * [1] height
 *     height repetitions of
 *         row, which is
 *              width repetitions of
 *                      pixel: ARGB
 * repeat for next size.
 *
 * Some icons can be 256x256 CARDINALs which is 65536 CARDINALS!
 * Therefore we fetch in pieces and skip the pixels of large icons
 * until needed.
 *
 * First scan all sizes. Keep a record of the closest smaller and larger
 * size. At the end, choose from one of those.
 * Finally, go and fetch the pixel data.
 */
 
Image *EwmhGetIcon(ScreenInfo *scr, TwmWindow *twm_win)
{
    int fetch_offset;
    Atom actual_type;
    int actual_format;
    unsigned long nitems, bytes_after;
    unsigned long *prop;
 
    int wanted_area;
    int smaller, larger;
    int offset;
    int smaller_offset, larger_offset;
    int i;
 
    int width, height;
 
    fetch_offset = 0;
    if(XGetWindowProperty(dpy, twm_win->w, XA__NET_WM_ICON,
                          fetch_offset, 8 * 1024, False, XA_CARDINAL,
                          &actual_type, &actual_format, &nitems,
                          &bytes_after, (unsigned char **)&prop) != Success || nitems == 0) {
        return NULL;
    }
 
    if(actual_format != 32) {
        XFree(prop);
        return NULL;
    }
 
#ifdef DEBUG_EWMH
    fprintf(stderr, "_NET_WM_ICON data fetched\n");
#endif
    /*
     * Usually the icons are square, but that is not a rule.
     * So we measure the area instead.
     *
     * Approach wanted size from both directions and at the end,
     * choose the "nearest".
     */
    wanted_area = Scr->PreferredIconWidth * Scr->PreferredIconHeight;
    smaller = 0;
    larger = 999999;
    smaller_offset = -1;
    larger_offset = -1;
    i = 0;
 
    for(;;) {
        offset = i;
 
        int w = prop[i++];
        int h = prop[i++];
        int size = w * h;
 
        const int area = w * h;
 
#ifdef DEBUG_EWMH
        fprintf(stderr, "[%d+%d] w=%d h=%d\n", fetch_offset, offset, w, h);
#endif
 
 
        if(area == wanted_area) {
#ifdef DEBUG_EWMH
            fprintf(stderr, "exact match [%d+%d=%d] w=%d h=%d\n", fetch_offset, offset,
                    fetch_offset + offset, w, h);
#endif /* DEBUG_EWMH */
            smaller_offset = fetch_offset + offset;
            smaller = area;
            larger_offset = -1;
            break;
        }
        else if(area < wanted_area) {
            if(area > smaller) {
#ifdef DEBUG_EWMH
                fprintf(stderr, "increase smaller, was [%d]\n", smaller_offset);
#endif /* DEBUG_EWMH */
                smaller = area;
                smaller_offset = fetch_offset + offset;
            }
        }
        else {   /* area > wanted_area */
            if(area < larger) {
#ifdef DEBUG_EWMH
                fprintf(stderr, "decrease larger, was [%d]\n", larger_offset);
#endif /* DEBUG_EWMH */
                larger = area;
                larger_offset = fetch_offset + offset;
            }
        }
 
        if(i + size + 2 > nitems) {
#ifdef DEBUG_EWMH
            fprintf(stderr, "not enough data: %d + %d > %ld \n", i, size, nitems);
#endif /* DEBUG_EWMH */
 
            if(i + size + 2 <= nitems + bytes_after / 4) {
                /* we can fetch some more... */
                XFree(prop);
                fetch_offset += i + size;
                if(XGetWindowProperty(dpy, twm_win->w, XA__NET_WM_ICON,
                                      fetch_offset, 8 * 1024, False, XA_CARDINAL,
                                      &actual_type, &actual_format, &nitems,
                                      &bytes_after, (unsigned char **)&prop) != Success) {
                    continue;
                }
                i = 0;
                continue;
            }
            break;
        }
        i += size;
    }
 
    /*
     * Choose which icon approximates our desired size best.
     */
    int area = 0;
    ALLOW_DEAD_STORE(area); // all branches below init it
 
    if(smaller_offset >= 0) {
        if(larger_offset >= 0) {
            /* choose the nearest */
#ifdef DEBUG_EWMH
            fprintf(stderr, "choose nearest %d %d\n", smaller, larger);
#endif /* DEBUG_EWMH */
            if((double)larger / wanted_area > (double)wanted_area / smaller) {
                offset = smaller_offset;
                area = smaller;
            }
            else {
                offset = larger_offset;
                area = larger;
            }
        }
        else {
            /* choose smaller */
#ifdef DEBUG_EWMH
            fprintf(stderr, "choose smaller (only) %d\n", smaller);
#endif /* DEBUG_EWMH */
            offset = smaller_offset;
            area = smaller;
        }
    }
    else if(larger_offset >= 0) {
        /* choose larger */
#ifdef DEBUG_EWMH
        fprintf(stderr, "choose larger (only) %d\n", larger);
#endif /* DEBUG_EWMH */
        offset = larger_offset;
        area = larger;
    }
    else {
        /* no icons found at all? */
#ifdef DEBUG_EWMH
        fprintf(stderr, "nothing to choose from\n");
#endif /* DEBUG_EWMH */
        XFree(prop);
        return NULL;
    }
 
    /*
     * Now fetch the pixels.
     */
 
#ifdef DEBUG_EWMH
    fprintf(stderr, "offset = %d fetch_offset = %d\n", offset, fetch_offset);
    fprintf(stderr, "offset + 2 + area = %d fetch_offset + nitems = %ld\n",
            offset + 2 + area, fetch_offset + nitems);
#endif /* DEBUG_EWMH */
    if(offset < fetch_offset ||
                    offset + 2 + area > fetch_offset + nitems) {
        XFree(prop);
        fetch_offset = offset;
#ifdef DEBUG_EWMH
        fprintf(stderr, "refetching from %d\n", fetch_offset);
#endif /* DEBUG_EWMH */
        if(XGetWindowProperty(dpy, twm_win->w, XA__NET_WM_ICON,
                              fetch_offset, 2 + area, False, XA_CARDINAL,
                              &actual_type, &actual_format, &nitems,
                              &bytes_after, (unsigned char **)&prop) != Success) {
            return NULL;
        }
    }
 
    i = offset - fetch_offset;
    width = prop[i++];
    height = prop[i++];
#ifdef DEBUG_EWMH
    fprintf(stderr, "Chosen [%d] w=%d h=%d area=%d\n", offset, width, height, area);
#endif /* DEBUG_EWMH */
    assert(width * height == area);
 
    Image *image = ExtractIcon(scr, &prop[i], width, height);
 
    XFree(prop);
 
    return image;
}
 
static uint16_t *buffer_16bpp;
static uint32_t *buffer_32bpp;
 
static void convert_for_16(int w, int x, int y, int argb)
{
    int r = (argb >> 16) & 0xFF;
    int g = (argb >>  8) & 0xFF;
    int b = (argb >>  0) & 0xFF;
    buffer_16bpp [y * w + x] = ((r >> 3) << 11) + ((g >> 2) << 5) + (b >> 3);
}
 
static void convert_for_32(int w, int x, int y, int argb)
{
    buffer_32bpp [y * w + x] = argb & 0x00FFFFFF;
}
 
static Image *ExtractIcon(ScreenInfo *scr, unsigned long *prop, int width,
                          int height)
{
    XImage *ximage;
    void (*store_data)(int w, int x, int y, int argb);
    int x, y, transparency;
    int rowbytes;
    unsigned char *maskbits;
 
    GC gc;
    Pixmap pixret;
    Pixmap mask;
    Image *image;
    int i;
 
    ximage = NULL;
 
    /** XXX sort of duplicated from util.c:LoadJpegImage() */
    if(scr->d_depth == 16) {
        store_data = convert_for_16;
        buffer_16bpp = malloc(width * height * sizeof(buffer_16bpp[0]));
        buffer_32bpp = NULL;
        ximage = XCreateImage(dpy, CopyFromParent, scr->d_depth, ZPixmap, 0,
                              (char *) buffer_16bpp, width, height, 16, width * 2);
    }
    else if(scr->d_depth == 24 || scr->d_depth == 32) {
        store_data = convert_for_32;
        buffer_32bpp = malloc(width * height * sizeof(buffer_32bpp[0]));
        buffer_16bpp = NULL;
        ximage = XCreateImage(dpy, CopyFromParent, scr->d_depth, ZPixmap, 0,
                              (char *) buffer_32bpp, width, height, 32, width * 4);
    }
    else {
#ifdef DEBUG_EWMH
        fprintf(stderr, "Screen unsupported depth for 32-bit icon: %d\n", scr->d_depth);
#endif /* DEBUG_EWMH */
        XFree(prop);
        return NULL;
    }
    if(ximage == NULL) {
#ifdef DEBUG_EWMH
        fprintf(stderr, "cannot create image for icon\n");
#endif /* DEBUG_EWMH */
        XFree(prop);
        return NULL;
    }
 
    transparency = 0;
    rowbytes = (width + 7) / 8;
    maskbits = calloc(height, rowbytes);
 
    /*
     * Copy all ARGB pixels to the pixmap (the RGB part), and the bitmap (the
     * Alpha, or opaqueness part). If any pixels are transparent, we're going
     * to need a shape.
     */
    i = 0;
    for(y = 0; y < height; y++) {
        for(x = 0; x < width; x++) {
            unsigned long argb = prop[i++];
            store_data(width, x, y, argb);
            int opaque = ((argb >> 24) & 0xFF) >= 0x80; /* arbitrary cutoff */
            if(opaque) {
                maskbits [rowbytes * y + (x / 8)] |= 0x01 << (x % 8);
            }
            else {
                transparency = 1;
            }
        }
    }
 
    gc = DefaultGC(dpy, scr->screen);
    pixret = XCreatePixmap(dpy, scr->Root, width, height, scr->d_depth);
    XPutImage(dpy, pixret, gc, ximage, 0, 0, 0, 0, width, height);
    XDestroyImage(ximage);  /* also frees buffer_{16,32}bpp */
    ximage = NULL;
 
    mask = None;
    if(transparency) {
        mask = XCreatePixmapFromBitmapData(dpy, scr->Root, (char *)maskbits,
                                           width, height, 1, 0, 1);
    }
    free(maskbits);
 
    image = AllocImage();
    image->width  = width;
    image->height = height;
    image->pixmap = pixret;
    image->mask   = mask;
 
    return image;
}
 
/*
 * Handle a PropertyNotify on _NET_WM_ICON.
 */
static void EwmhHandle_NET_WM_ICONNotify(XPropertyEvent *event,
                TwmWindow *twm_win)
{
    unsigned long valuemask;                /* mask for create windows */
    XSetWindowAttributes attributes;        /* attributes for create windows */
    Icon *icon = twm_win->icon;
    int x;
 
#ifdef DEBUG_EWMH
    fprintf(stderr, "EwmhHandlePropertyNotify: NET_WM_ICON\n");
#endif /* DEBUG_EWMH */
    /*
     * If there is no icon yet, we'll look at this property
     * later, if and when we do create an icon.
     */
    if(!icon || icon->match != match_net_wm_icon) {
#ifdef DEBUG_EWMH
        fprintf(stderr, "no icon, or not match_net_wm_icon\n");
#endif /* DEBUG_EWMH */
        return;
    }
 
    Image *image = EwmhGetIcon(Scr, twm_win);
 
    /* TODO: de-duplicate with handling of XA_WM_HINTS */
    {
        Image *old_image = icon->image;
        icon->image = image;
        FreeImage(old_image);
    }
 
 
    if(twm_win->icon->bm_w) {
        XDestroyWindow(dpy, twm_win->icon->bm_w);
    }
 
    valuemask = CWBackPixmap;
    attributes.background_pixmap = image->pixmap;
 
    x = GetIconOffset(twm_win->icon);
    twm_win->icon->bm_w =
            XCreateWindow(dpy, twm_win->icon->w, x, 0,
                          twm_win->icon->width,
                          twm_win->icon->height,
                          0, Scr->d_depth,
                          CopyFromParent, Scr->d_visual,
                          valuemask, &attributes);
 
    if(image->mask) {
        XShapeCombineMask(dpy, twm_win->icon->bm_w, ShapeBounding, 0, 0, image->mask,
                          ShapeSet);
        XShapeCombineMask(dpy, twm_win->icon->w,    ShapeBounding, x, 0, image->mask,
                          ShapeSet);
    }
    else {
        XRectangle rect;
 
        rect.x      = x;
        rect.y      = 0;
        rect.width  = twm_win->icon->width;
        rect.height = twm_win->icon->height;
        XShapeCombineRectangles(dpy, twm_win->icon->w, ShapeBounding, 0,
                                0, &rect, 1, ShapeUnion, 0);
    }
    XMapSubwindows(dpy, twm_win->icon->w);
    RedoIconName(twm_win);
}
 
/*
 * Handle a PropertyNotify on _NET_WM_STRUT(PARTIAL).
 */
static void EwmhHandle_NET_WM_STRUTNotify(XPropertyEvent *event,
                TwmWindow *twm_win)
{
    EwmhGetStrut(twm_win, true);
}
 
/*
 * Handle a _NET_WM_STATE ClientMessage.
 */
static int atomToFlag(Atom a)
{
#ifdef DEBUG_EWMH
# define CRWARN(x) fprintf(stderr, "atomToFlag: ignoring " #x "\n")
#else
# define CRWARN(x) (void)0
#endif
#define CHKNRET(st) \
        if(a == XA__NET_WM_##st) { \
                if(LookInNameList(Scr->EWMHIgnore, #st)) { \
                        CRWARN(st); \
                        return 0; \
                } \
                return EWMH_##st; \
        }
 
    /* Check (potentially ignoring) various flags we know */
    CHKNRET(STATE_MAXIMIZED_VERT);
    CHKNRET(STATE_MAXIMIZED_HORZ);
    CHKNRET(STATE_FULLSCREEN);
    CHKNRET(STATE_SHADED);
    CHKNRET(STATE_ABOVE);
    CHKNRET(STATE_BELOW);
 
#undef CHKNRET
#undef CRWARN
 
    /* Else we don't recognize it */
    return 0;
}
 
 
/*
 * Handle the NET_WM_STATE client message.
 * It can change 1 or 2 values represented in NET_WM_STATE.
 * The second change is allowed
 * specifically for (re)setting horizontal and vertical maximalisation in
 * one go. Treat that as a special case.
 */
static void EwmhClientMessage_NET_WM_STATE(XClientMessageEvent *msg)
{
    Window w = msg->window;
    TwmWindow *twm_win;
    int change, change1, change2, newValue;
 
    twm_win = GetTwmWindow(w);
 
    if(twm_win == NULL) {
        return;
    }
 
    /*
     * Due to EWMHIgnore, it's possible to wind up with change1=0 and
     * change2=something, so swap 'em if that happens.
     */
    change1 = atomToFlag(msg->data.l[1]);
    change2 = atomToFlag(msg->data.l[2]);
    if(change1 == 0 && change2 != 0) {
        change1 = change2;
        change2 = 0;
    }
    change = change1 | change2;
 
    switch(msg->data.l[0]) {
        case NET_WM_STATE_REMOVE:
#ifdef DEBUG_EWMH
            printf("NET_WM_STATE_REMOVE: ");
#endif
            newValue = 0;
            break;
        case NET_WM_STATE_ADD:
#ifdef DEBUG_EWMH
            printf("NET_WM_STATE_ADD: ");
#endif
            newValue = change;
            break;
        case NET_WM_STATE_TOGGLE:
#ifdef DEBUG_EWMH
            printf("NET_WM_STATE_TOGGLE: ");
#endif
            newValue = ~twm_win->ewmhFlags & change;
            break;
        default:
#ifdef DEBUG_EWMH
            printf("invalid operation in NET_WM_STATE: %ld\n", msg->data.l[0]);
#endif
            return;
    }
#ifdef DEBUG_EWMH
    printf("%s and %s\n", XGetAtomName(dpy, msg->data.l[1]),
           XGetAtomName(dpy, msg->data.l[2]));
#endif
 
    /*
     * Special-case the horizontal and vertical zoom.
     * You can turn them both on or both off, but no other combinations
     * are done as a unit.
     */
    if(change == (EWMH_STATE_MAXIMIZED_VERT | EWMH_STATE_MAXIMIZED_HORZ) &&
                    (newValue == 0 || newValue == change)) {
        EwmhClientMessage_NET_WM_STATEchange(twm_win, change, newValue);
    }
    else {
        EwmhClientMessage_NET_WM_STATEchange(twm_win, change1, newValue & change1);
        if(change2 != 0) {
            EwmhClientMessage_NET_WM_STATEchange(twm_win, change2, newValue & change2);
        }
    }
}
 
/*
 * change - bitmask of settings that possibly change. Only one bit is
 *                      set in this, with the possible exception of
 *                      *MAXIMIZED_{VERT,HORIZ} which can be set together.
 * newValue - bits with the new values; only valid bits are the ones
 *                      in change.
 */
static void EwmhClientMessage_NET_WM_STATEchange(TwmWindow *twm_win, int change,
                int newValue)
{
    /* Now check what we need to change */
 
    if(change & (EWMH_STATE_MAXIMIZED_VERT | EWMH_STATE_MAXIMIZED_HORZ |
                    EWMH_STATE_FULLSCREEN)) {
        int newZoom = ZOOM_NONE;
 
        switch(newValue) {
            case 0:
                newZoom = twm_win->zoomed;      /* turn off whatever zoom */
                break;
            case EWMH_STATE_MAXIMIZED_VERT:
                newZoom = F_ZOOM;
                break;
            case EWMH_STATE_MAXIMIZED_HORZ:
                newZoom = F_HORIZOOM;
                break;
            case EWMH_STATE_MAXIMIZED_HORZ | EWMH_STATE_MAXIMIZED_VERT:
                newZoom = F_FULLZOOM;
                break;
            case EWMH_STATE_FULLSCREEN:
                newZoom = F_FULLSCREENZOOM;
                break;
        }
        fullzoom(twm_win, newZoom);
    }
    else if(change & EWMH_STATE_SHADED) {
#ifdef DEBUG_EWMH
        printf("EWMH_STATE_SHADED: newValue: %d old: %d\n", newValue,
               twm_win->ewmhFlags & EWMH_STATE_SHADED);
#endif
        if((twm_win->ewmhFlags & EWMH_STATE_SHADED) ^ newValue) {
            /* Toggle the shade/squeeze state */
#ifdef DEBUG_EWMH
            printf("EWMH_STATE_SHADED: change it\n");
#endif
            Squeeze(twm_win);
        }
    }
    else if(change & (EWMH_STATE_ABOVE | EWMH_STATE_BELOW)) {
        /*
         * Other changes call into ctwm code, which in turn calls back to
         * EWMH code to update the ewmhFlags and the property.  This one
         * we handle completely internally.
         */
        unsigned omask = 0, oval = 0;
        const int prepri = OtpEffectivePriority(twm_win);
 
        /* Which bits are we changing and what to? */
#define DOBIT(fld) do { \
          if(change   & EWMH_STATE_##fld) { omask |= OTP_AFLAG_##fld; } \
          if(newValue & EWMH_STATE_##fld) { oval  |= OTP_AFLAG_##fld; } \
        } while(0)
 
        DOBIT(ABOVE);
        DOBIT(BELOW);
 
#undef DOBIT
 
        /* Update OTP as necessary */
        OtpSetAflagMask(twm_win, omask, oval);
        if(OtpEffectivePriority(twm_win) != prepri) {
            OtpRestackWindow(twm_win);
        }
 
        /* Set the EWMH property back on the window */
        EwmhSet_NET_WM_STATE(twm_win, change);
    }
}
 
/*
 * Handle the _NET_ACTIVE_WINDOW client message.
 * Pagers would send such a message to "activate" a window.
 *
 * What does "activate" really mean? It isn't properly described.
 *
 * Let's presume that it means that the window is de-iconified and gets
 * focus.  The mouse may be moved to it (but not all window button apps
 * do that).  But is it always raised or should that depend on the
 * RaiseOnWarp option?
 */
static void EwmhClientMessage_NET_ACTIVE_WINDOW(XClientMessageEvent *msg)
{
    Window w = msg->window;
    TwmWindow *twm_win;
 
    twm_win = GetTwmWindow(w);
 
    if(twm_win == NULL) {
        return;
    }
 
    if(!twm_win->mapped) {
        DeIconify(twm_win);
    }
#if 0
    WarpToWindow(twm_win, Scr->RaiseOnWarp /* True ? */);
#else
    /*
     * Keep the mouse pointer where it is (typically the dock).
     * WarpToWindow() would change the current workspace if needed to go
     * to the window. But pagers would only send this message for
     * windows in the current workspace, I expect.
     */
    if(Scr->RaiseOnWarp) {
        AutoRaiseWindow(twm_win);
    }
    SetFocus(twm_win, msg->data.l[1]);
#endif
}
 
/*
 * Ugly implementation of _NET_WM_MOVERESIZE.
 *
 * window = window to be moved or resized
 * message_type = _NET_WM_MOVERESIZE
 * format = 32
 * data.l[0] = x_root
 * data.l[1] = y_root
 * data.l[2] = direction
 * data.l[3] = button
 * data.l[4] = source indication
 */
static void EwmhClientMessage_NET_WM_MOVERESIZE(XClientMessageEvent *msg)
{
    TwmWindow *twm_win;
 
    twm_win = GetTwmWindow(msg->window);
 
    if(twm_win == NULL) {
        return;
    }
 
    if(!twm_win->mapped) {
        DeIconify(twm_win);
    }
 
    switch(msg->data.l[2]) {
        case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:
        case _NET_WM_MOVERESIZE_SIZE_TOP:
        case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:
        case _NET_WM_MOVERESIZE_SIZE_RIGHT:
        case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
        case _NET_WM_MOVERESIZE_SIZE_BOTTOM:
        case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
        case _NET_WM_MOVERESIZE_SIZE_LEFT:
        case _NET_WM_MOVERESIZE_SIZE_KEYBOARD: {
            /* Fake up as if we triggered f.resize on it */
            XEvent xevent = synth_btnevent_for_moveresize(twm_win);
 
            /*
             * The resize won't actually start until we cross the cursor
             * over a border.  Perhaps we should find the nearest corner,
             * and pre-warp the cursor there?  That may be less friendly
             * for the user, since it might not be as predictable, and
             * having the cursor zoom off without warning is probably a
             * little surprising...
             */
            ExecuteFunction(F_RESIZE, "", twm_win->frame, twm_win,
                            &xevent, C_WINDOW, false);
 
            /*
             * It's not guaranteed that this actually began as a button
             * press, but our implementation is expecting the button to
             * be held down all through the move, so that
             * ExecuteFunction() won't actually end until there's a
             * button release of some kind, which will trigger
             * HandleButtonRelease() properly.  So we don't need to call
             * it ourselves.
             */
 
            break;
        }
        case _NET_WM_MOVERESIZE_MOVE:
        case _NET_WM_MOVERESIZE_MOVE_KEYBOARD: {
            /* Fake up as if we triggered f.move on it */
            XEvent xevent = synth_btnevent_for_moveresize(twm_win);
            ExecuteFunction(F_MOVE, "", twm_win->frame, twm_win,
                            &xevent, C_WINDOW, false);
 
            /* X-ref HandleButtonRelease() discussion above */
            break;
        }
        case _NET_WM_MOVERESIZE_CANCEL:
            /*
             * TODO: check if the twm_win is the same.
             * TODO: check how to make this actually work.
             *
             * As currently implemented, I don't believe we ever need to
             * do anything here.  All the needed cleanup should happen in
             * our ButtonRelease handler.
             */
            break;
    }
}
 
static XEvent
synth_btnevent_for_moveresize(TwmWindow *twm_win)
{
    XEvent xevent;
    Window root = twm_win->parent_vs->window;
    Window child = twm_win->w;
    int x_root = twm_win->frame_x;
    int y_root = twm_win->frame_y;
    int x_win  = 0;
    int y_win  = 0;
    unsigned int dummy_mask;
 
    /* Find the pointer */
    XQueryPointer(dpy, twm_win->frame, &root, &child, &x_root, &y_root,
                  &x_win, &y_win, &dummy_mask);
 
    /* Synthesize a button event */
    xevent.type = ButtonPress;
    xevent.xbutton.root = root;
    xevent.xbutton.window = child;
    xevent.xbutton.x_root = x_root;
    xevent.xbutton.y_root = y_root;
    xevent.xbutton.x = x_win;
    xevent.xbutton.y = y_win;
    xevent.xbutton.time = EventTime;
 
    return xevent;
}
 
 
/*
 * Implementation of _NET_CLOSE_WINDOW
 *
 * window = window to be closed
 * message_type = _NET_CLOSE_WINDOW
 * format = 32
 * data.l[0] = timestamp
 * data.l[1] = source indication:
 *             0 Clients that support only older version of this spec
 *             1 for normal applications, and
 *             2 for pagers and other Clients that represent direct user actions
 * data.l[2] = 0
 * data.l[3] = 0
 * data.l[4] = 0
 */
static void EwmhClientMessage_NET_CLOSE_WINDOW(XClientMessageEvent *msg)
{
    TwmWindow *tmp_win;
 
    tmp_win = GetTwmWindow(msg->window);
 
    if(tmp_win != NULL) {
        ButtonPressed = -1;
        ExecuteFunction(F_DELETE, NULL, msg->window, tmp_win,
                        (XEvent *)msg, C_NO_CONTEXT, 0);
    }
}
 
/*
 * Handle any PropertyNotify.
 */
int EwmhHandlePropertyNotify(XPropertyEvent *event, TwmWindow *twm_win)
{
    if(event->atom == XA__NET_WM_ICON) {
        EwmhHandle_NET_WM_ICONNotify(event, twm_win);
        return 1;
    }
    else if(event->atom == XA__NET_WM_STRUT_PARTIAL ||
                    event->atom == XA__NET_WM_STRUT) {
        EwmhHandle_NET_WM_STRUTNotify(event, twm_win);
        return 1;
    }
    else if(event->atom == XA__NET_WM_NAME) {
        char *prop = GetWMPropertyString(twm_win->w, XA__NET_WM_NAME);
        if(prop == NULL) {
            FreeWMPropertyString(twm_win->names.net_wm_name);
            twm_win->names.net_wm_name = NULL;
            apply_window_name(twm_win);
            return 1;
        }
 
        if(twm_win->names.net_wm_name != NULL
                        && strcmp(twm_win->names.net_wm_name, prop) == 0) {
            /* No change, just free and skip out */
            free(prop);
            return 1;
        }
 
        /* It's changing, free the old and bring in the new */
        FreeWMPropertyString(twm_win->names.net_wm_name);
        twm_win->names.net_wm_name = prop;
 
        /* Kick the reset process */
        apply_window_name(twm_win);
        return 1;
    }
    else if(event->atom == XA__NET_WM_ICON_NAME) {
        char *prop = GetWMPropertyString(twm_win->w, XA__NET_WM_ICON_NAME);
        if(prop == NULL) {
            FreeWMPropertyString(twm_win->names.net_wm_icon_name);
            twm_win->names.net_wm_icon_name = NULL;
            apply_window_icon_name(twm_win);
            return 1;
        }
 
        if(twm_win->names.net_wm_icon_name != NULL
                        && strcmp(twm_win->names.net_wm_icon_name, prop) == 0) {
            /* No change, just free and skip out */
            free(prop);
            return 1;
        }
 
        /* It's changing, free the old and bring in the new */
        FreeWMPropertyString(twm_win->names.net_wm_icon_name);
        twm_win->names.net_wm_icon_name = prop;
 
        /* Kick the reset process */
        apply_window_icon_name(twm_win);
        return 1;
    }
 
    return 0;
}
 
/*
 * Set the _NET_WM_DESKTOP property for the current workspace.
 */
void EwmhSet_NET_WM_DESKTOP(TwmWindow *twm_win)
{
    WorkSpace *ws;
 
    VirtualScreen *vs = twm_win->vs;
    if(vs != NULL) {
        ws = vs->wsw->currentwspc;
    }
    else {
        ws = NULL;
    }
 
    EwmhSet_NET_WM_DESKTOP_ws(twm_win, ws);
}
 
/*
 * Set the _NET_WM_DESKTOP property for the given workspace.
 */
void EwmhSet_NET_WM_DESKTOP_ws(TwmWindow *twm_win, WorkSpace *ws)
{
    unsigned long workspaces[MAXWORKSPACE];
    int n = 0;
 
    if(!Scr->workSpaceManagerActive) {
        workspaces[n++] = 0;
    }
    else if(twm_win->occupation == fullOccupation) {
        workspaces[n++] = ALL_WORKSPACES;
    }
    else {
        /*
         * Our windows can occupy multiple workspaces ("virtual desktops" in
         * EWMH terminology) at once. Extend the _NET_WM_DESKTOP property
         * by setting it to multiple CARDINALs if this occurs.
         * Put the currently visible workspace (if any) first, since typical
         * pager apps don't know about this.
         */
        int occupation = twm_win->occupation;
 
        /*
         * Set visible workspace number.
         */
        if(ws != NULL) {
            int wsn = ws->number;
 
            workspaces[n++] = wsn;
            occupation &= ~(1 << wsn);
        }
 
        /*
         * Set any other workspace numbers.
         */
        if(occupation != 0) {
            int i;
            int mask = 1;
 
            for(i = 0; i < MAXWORKSPACE; i++) {
                if(occupation & mask) {
                    workspaces[n++] = i;
                }
                mask <<= 1;
            }
        }
    }
 
    XChangeProperty(dpy, twm_win->w,
                    XA__NET_WM_DESKTOP, XA_CARDINAL,
                    32, PropModeReplace,
                    (unsigned char *)workspaces, n);
}
 
 
static unsigned long EwmhGetWindowProperty(Window w, Atom name, Atom type)
{
    Atom actual_type;
    int actual_format;
    unsigned long nitems, bytes_after;
    unsigned long *prop;
    unsigned long value;
 
    if(XGetWindowProperty(dpy, w, name,
                          0, 1, False, type,
                          &actual_type, &actual_format, &nitems,
                          &bytes_after, (unsigned char **)&prop) != Success) {
        return 0;
    }
 
    if(actual_format == 32) {
        if(nitems >= 1) {
            value = prop[0];
        }
        else {
            value = 0;
        }
    }
    else {
        value = 0;
    }
 
    XFree(prop);
    return value;
}
 
/*
 * Simple function to get multiple properties of format 32.
 * If it fails, returns NULL, and *nitems_return == 0.
 */
 
static unsigned long *EwmhGetWindowProperties(Window w, Atom name, Atom type,
                unsigned long *nitems_return)
{
    Atom actual_type;
    int actual_format;
    unsigned long bytes_after;
    unsigned long *prop;
 
    if(XGetWindowProperty(dpy, w, name,
                          0, 8192, False, type,
                          &actual_type, &actual_format, nitems_return,
                          &bytes_after, (unsigned char **)&prop) != Success) {
        *nitems_return = 0;
        return NULL;
    }
 
    if(actual_format != 32) {
        XFree(prop);
        prop = NULL;
        *nitems_return = 0;
    }
 
    return prop;
}
 
int EwmhGetOccupation(TwmWindow *twm_win)
{
    unsigned long nitems;
    unsigned long *prop;
    int occupation;
 
    occupation = 0;
 
    prop = EwmhGetWindowProperties(twm_win->w,
                                   XA__NET_WM_DESKTOP, XA_CARDINAL, &nitems);
 
    if(prop) {
        int i;
        for(i = 0; i < nitems; i++) {
            unsigned int val = prop[i];
            if(val == ALL_WORKSPACES) {
                occupation = fullOccupation;
            }
            else if(val < Scr->workSpaceMgr.count) {
                occupation |= 1 << val;
            }
            else {
                occupation |= 1 << (Scr->workSpaceMgr.count - 1);
            }
        }
 
        occupation &= fullOccupation;
 
        XFree(prop);
    }
 
    return occupation;
}
 
/*
 * The message to change the desktop of a window doesn't recognize
 * that it may be in more than one.
 *
 * Therefore the following heuristic is applied:
 * - the window is removed from the workspace where it is visible (if any);
 * - it is added to the given workspace;
 * - other occupation bits are left unchanged.
 *
 * If asked to put it on a too high numbered workspace, put it on
 * the highest possible.
 */
static void EwmhClientMessage_NET_WM_DESKTOP(XClientMessageEvent *msg)
{
    Window w = msg->window;
    TwmWindow *twm_win;
    int occupation;
    VirtualScreen *vs;
    unsigned int val;
 
    twm_win = GetTwmWindow(w);
 
    if(twm_win == NULL) {
        return;
    }
 
    occupation = twm_win->occupation;
 
    /* Remove from visible workspace */
    if((vs = twm_win->vs) != NULL) {
        occupation &= ~(1 << vs->wsw->currentwspc->number);
    }
 
    val = (unsigned int)msg->data.l[0];
 
    /* Add to requested workspace (or to all) */
    if(val == ALL_WORKSPACES) {
        occupation = fullOccupation;
    }
    else if(val < Scr->workSpaceMgr.count) {
        occupation |= 1 << val;
    }
    else {
        occupation |= 1 << (Scr->workSpaceMgr.count - 1);
    }
 
    ChangeOccupation(twm_win, occupation);
}
 
/*
 * Delete all properties that should be removed from a withdrawn
 * window.
 */
void EwmhUnmapNotify(TwmWindow *twm_win)
{
    XDeleteProperty(dpy, twm_win->w, XA__NET_WM_DESKTOP);
}
 
/*
 * Add a new window to _NET_CLIENT_LIST.
 * Newer windows are always added at the end.
 *
 * Look at new_win->iconmanagerlist as an optimization for
 * !LookInList(Scr->IconMgrNoShow, new_win->name, &new_win->class)).
 */
void EwmhAddClientWindow(TwmWindow *new_win)
{
    if(Scr->ewmh_CLIENT_LIST_size == 0) {
        return;
    }
    if(new_win->iconmanagerlist != NULL &&
                    !new_win->iswspmgr &&
                    !new_win->isiconmgr) {
        Scr->ewmh_CLIENT_LIST_used++;
        if(Scr->ewmh_CLIENT_LIST_used > Scr->ewmh_CLIENT_LIST_size) {
            long *tp;
            int tsz = Scr->ewmh_CLIENT_LIST_size;
 
            Scr->ewmh_CLIENT_LIST_size *= 2;
            tp = realloc(Scr->ewmh_CLIENT_LIST,
                         sizeof(long) * Scr->ewmh_CLIENT_LIST_size);
            if(tp == NULL) {
                Scr->ewmh_CLIENT_LIST_size = tsz;
                fprintf(stderr, "Unable to allocate memory for EWMH client list.\n");
                return;
            }
            Scr->ewmh_CLIENT_LIST = tp;
        }
        if(Scr->ewmh_CLIENT_LIST) {
            Scr->ewmh_CLIENT_LIST[Scr->ewmh_CLIENT_LIST_used - 1] = new_win->w;
        }
        else {
            Scr->ewmh_CLIENT_LIST_size = 0;
            fprintf(stderr, "Unable to allocate memory for EWMH client list.\n");
            return;
        }
        XChangeProperty(dpy, Scr->Root, XA__NET_CLIENT_LIST, XA_WINDOW, 32,
                        PropModeReplace, (unsigned char *)Scr->ewmh_CLIENT_LIST,
                        Scr->ewmh_CLIENT_LIST_used);
    }
}
 
void EwmhDeleteClientWindow(TwmWindow *old_win)
{
    int i;
 
    if(old_win->ewmhFlags & EWMH_HAS_STRUT) {
        EwmhRemoveStrut(old_win);
    }
 
    /*
     * Remove the window from _NET_CLIENT_LIST.
     */
    if(Scr->ewmh_CLIENT_LIST_size == 0) {
        return;
    }
    for(i = Scr->ewmh_CLIENT_LIST_used - 1; i >= 0; i--) {
        if(Scr->ewmh_CLIENT_LIST[i] == old_win->w) {
            memmove(&Scr->ewmh_CLIENT_LIST[i],
                    &Scr->ewmh_CLIENT_LIST[i + 1],
                    (Scr->ewmh_CLIENT_LIST_used - 1 - i) * sizeof(Scr->ewmh_CLIENT_LIST[0]));
            Scr->ewmh_CLIENT_LIST_used--;
            if(Scr->ewmh_CLIENT_LIST_used &&
                            (Scr->ewmh_CLIENT_LIST_used * 3) < Scr->ewmh_CLIENT_LIST_size) {
                Scr->ewmh_CLIENT_LIST_size /= 2;
                Scr->ewmh_CLIENT_LIST = realloc(Scr->ewmh_CLIENT_LIST,
                                                sizeof((Scr->ewmh_CLIENT_LIST[0])) * Scr->ewmh_CLIENT_LIST_size);
                /* memory shrinking, shouldn't have problems */
            }
            break;
        }
    }
    /* If window was not found, there is no need to update the property. */
    if(i >= 0) {
        XChangeProperty(dpy, Scr->Root, XA__NET_CLIENT_LIST, XA_WINDOW, 32,
                        PropModeReplace, (unsigned char *)Scr->ewmh_CLIENT_LIST,
                        Scr->ewmh_CLIENT_LIST_used);
    }
}
 
/*
 * Similar to EwmhAddClientWindow() and EwmhDeleteClientWindow(),
 * but the windows are in stacking order.
 * Therefore we look at the OTPs, which are by definition in the correct order.
 */
 
void EwmhSet_NET_CLIENT_LIST_STACKING(void)
{
    int size;
    unsigned long *prop;
    TwmWindow *twm_win;
    int i;
 
    /* Expect the same number of windows as in the _NET_CLIENT_LIST */
    size = Scr->ewmh_CLIENT_LIST_used + 10;
    prop = calloc(size, sizeof(unsigned long));
    if(prop == NULL) {
        return;
    }
 
    i = 0;
    for(twm_win = OtpBottomWin();
                    twm_win != NULL;
                    twm_win = OtpNextWinUp(twm_win)) {
        if(twm_win->iconmanagerlist != NULL &&
                        !twm_win->iswspmgr &&
                        !twm_win->isiconmgr) {
            prop[i] = twm_win->w;
            i++;
            if(i > size) {
                fprintf(stderr, "Too many stacked windows\n");
                break;
            }
        }
    }
 
    if(i != Scr->ewmh_CLIENT_LIST_used) {
        fprintf(stderr, "Incorrect number of stacked windows: %d (expected %d)\n",
                i, Scr->ewmh_CLIENT_LIST_used);
    }
 
    XChangeProperty(dpy, Scr->Root, XA__NET_CLIENT_LIST_STACKING, XA_WINDOW, 32,
                    PropModeReplace, (unsigned char *)prop, i);
 
    free(prop);
}
 
void EwmhSet_NET_ACTIVE_WINDOW(Window w)
{
    unsigned long prop[1];
 
    prop[0] = w;
 
    XChangeProperty(dpy, Scr->Root, XA__NET_ACTIVE_WINDOW, XA_WINDOW, 32,
                    PropModeReplace, (unsigned char *)prop, 1);
}
 
/*
 * Get window properties as relevant when the window is initially mapped.
 *
 * So far, only NET_WM_WINDOW_TYPE and _NET_WM_STRUT_PARTIAL.
 * In particular, most of the initial value of _NET_WM_STATE is ignored. TODO.
 *
 * Also do any generic initialisation needed to EWMH-specific fields
 * in a TwmWindow.
 */
void EwmhGetProperties(TwmWindow *twm_win)
{
    twm_win->ewmhFlags = 0;
 
    Atom type = EwmhGetWindowProperty(twm_win->w, XA__NET_WM_WINDOW_TYPE, XA_ATOM);
 
    if(type == XA__NET_WM_WINDOW_TYPE_DESKTOP) {
        twm_win->ewmhWindowType = wt_Desktop;
    }
    else if(type == XA__NET_WM_WINDOW_TYPE_DOCK) {
        twm_win->ewmhWindowType = wt_Dock;
    }
    else {
        twm_win->ewmhWindowType = wt_Normal;
    }
    EwmhGetStrut(twm_win, false);
    /* Only the 3 listed states are supported for now */
    twm_win->ewmhFlags |= EwmhGet_NET_WM_STATE(twm_win) &
                          (EWMH_STATE_ABOVE | EWMH_STATE_BELOW | EWMH_STATE_SHADED);
}
 
/* Only used in initially mapping a window */
int EwmhGetInitPriority(TwmWindow *twm_win)
{
    switch(twm_win->ewmhWindowType) {
        case wt_Desktop:
            return EWMH_PRI_DESKTOP;
        case wt_Dock:
            return EWMH_PRI_DOCK;
        default:
            return 0;
    }
}
 
bool EwmhHasBorder(TwmWindow *twm_win)
{
    switch(twm_win->ewmhWindowType) {
        case wt_Desktop:
        case wt_Dock:
            return false;
        default:
            return true;
    }
}
 
bool EwmhHasTitle(TwmWindow *twm_win)
{
    switch(twm_win->ewmhWindowType) {
        case wt_Desktop:
        case wt_Dock:
            return false;
        default:
            return true;
    }
}
 
bool EwmhOnWindowRing(TwmWindow *twm_win)
{
    switch(twm_win->ewmhWindowType) {
        case wt_Desktop:
        case wt_Dock:
            return false;
        default:
            return true;
    }
}
 
/*
 * Recalculate the effective border values from the remembered struts.
 * Interestingly it is not documented how to do that.
 * Usually only one dock is present on each side, so it shouldn't matter
 * too much, but I presume that maximizing the values is the thing to do.
 */
static void EwmhRecalculateStrut(void)
{
    int left   = 0;
    int right  = 0;
    int top    = 0;
    int bottom = 0;
    EwmhStrut *strut = Scr->ewmhStruts;
 
    while(strut != NULL) {
        left   = max(left,   strut->left);
        right  = max(right,  strut->right);
        top    = max(top,    strut->top);
        bottom = max(bottom, strut->bottom);
 
        strut  = strut->next;
    }
 
    Scr->BorderLeft   = left;
    Scr->BorderRight  = right;
    Scr->BorderTop    = top;
    Scr->BorderBottom = bottom;
 
    // Bordered layout may have changed
    Scr->BorderedLayout = RLayoutCopyCropped(Scr->Layout,
                          left, right, top, bottom);
    if(Scr->BorderedLayout == NULL) {
        Scr->BorderedLayout = Scr->Layout;        // nothing to crop
    }
 
    EwmhSet_NET_WORKAREA(Scr);
}
/*
 * Check _NET_WM_STRUT_PARTIAL or _NET_WM_STRUT.
 * These are basically automatic settings for Border{Left,Right,Top,Bottom}.
 *
 * If any values are found, collect them in a list of strut values
 * belonging to Scr.  When a window is added or removed that has struts,
 * the new effective value must be calculated.  The expectation is that
 * at most a handful of windows will have struts.
 *
 * If update is true, this is called as an update for an existing window.
 */
static void EwmhGetStrut(TwmWindow *twm_win, bool update)
{
    unsigned long nitems;
    unsigned long *prop;
    EwmhStrut *strut;
 
    prop = EwmhGetWindowProperties(twm_win->w,
                                   XA__NET_WM_STRUT_PARTIAL, XA_CARDINAL,
                                   &nitems);
    if(prop == NULL) {
        prop = EwmhGetWindowProperties(twm_win->w,
                                       XA__NET_WM_STRUT, XA_CARDINAL,  &nitems);
        if(prop == NULL) {
            return;
        }
    }
 
 
    if(nitems < 4) {
#ifdef DEBUG_EWMH
        /* This happens a lot, despite returning Success ??? */
        printf("struts: prop = %p, nitems = %ld\n", prop, nitems);
#endif
        XFree(prop);
        return;
    }
#ifdef DEBUG_EWMH
    printf("struts: left %ld, right %ld, top %ld, bottom %ld\n",
           prop[0], prop[1], prop[2], prop[3]);
#endif
 
    /*
     * If there were no struts before, the user configured margins are set
     * in Border{Left,Right,Top,Bottom}. In order not to lose those values
     * when recalculating them, convert them to struts for a dummy window.
     */
 
    if(Scr->ewmhStruts == NULL &&
                    (Scr->BorderLeft |
                     Scr->BorderRight |
                     Scr->BorderTop |
                     Scr->BorderBottom) != 0) {
        strut = calloc(1, sizeof(EwmhStrut));
        if(strut == NULL) {
            XFree(prop);
            return;
        }
 
        strut->next   = NULL;
        strut->win    = NULL;
        strut->left   = Scr->BorderLeft;
        strut->right  = Scr->BorderRight;
        strut->top    = Scr->BorderTop;
        strut->bottom = Scr->BorderBottom;
 
        Scr->ewmhStruts = strut;
    }
 
    strut = NULL;
 
    /*
     * Find the struts of the window that we're supposed to be updating.
     * If not found, there is no problem: we'll just allocate a new
     * record.
     */
 
    if(update) {
        strut = Scr->ewmhStruts;
 
        while(strut != NULL) {
            if(strut->win == twm_win) {
                break;
            }
            strut = strut->next;
        }
    }
 
    /*
     * If needed, allocate a new struts record and link it in.
     */
    if(strut == NULL) {
        strut = calloc(1, sizeof(EwmhStrut));
        if(strut == NULL) {
            XFree(prop);
            return;
        }
 
        strut->next = Scr->ewmhStruts;
        Scr->ewmhStruts = strut;
    }
 
    strut->win    = twm_win;
    strut->left   = prop[0];
    strut->right  = prop[1];
    strut->top    = prop[2];
    strut->bottom = prop[3];
 
    XFree(prop);
 
    /*
     * Mark this window as having contributed some struts.
     * This can be checked and undone when the window is deleted.
     */
    twm_win->ewmhFlags |= EWMH_HAS_STRUT;
 
    EwmhRecalculateStrut();
}
 
/*
 * Remove the struts associated with the given window from the
 * remembered list. If found, recalculate the effective borders.
 */
static void EwmhRemoveStrut(TwmWindow *twm_win)
{
    EwmhStrut **prev = &Scr->ewmhStruts;
    EwmhStrut *strut = Scr->ewmhStruts;
 
    while(strut != NULL) {
        if(strut->win == twm_win) {
            twm_win->ewmhFlags &= ~EWMH_HAS_STRUT;
 
            *prev = strut->next;
            free(strut);
 
            EwmhRecalculateStrut();
 
            break;
        }
        prev = &strut->next;
        strut = strut->next;
    }
}
 
 
/**
 * Set _NET_FRAME_EXTENTS property.
 * This tells the client how much space is being taken up by the window
 * decorations.  Some clients may need this information to position other
 * windows on top of themselves.  e.g., Firefox's form autofill and
 * context menu will be positioned a bit wrong (high, by the height of
 * the titlebar) without this.
 */
void EwmhSet_NET_FRAME_EXTENTS(TwmWindow *twm_win)
{
    long data[4];
    const long w = twm_win->frame_bw3D + twm_win->frame_bw;
 
    data[0] = w; // left
    data[1] = w; // right
    data[2] = twm_win->title_height + w; // top
    data[3] = w; // bottom
 
    XChangeProperty(dpy, twm_win->w,
                    XA__NET_FRAME_EXTENTS, XA_CARDINAL,
                    32, PropModeReplace,
                    (unsigned char *)data, 4);
}
 
 
void EwmhSet_NET_SHOWING_DESKTOP(int state)
{
    unsigned long prop[1];
 
    prop[0] = state;
 
    XChangeProperty(dpy, Scr->XineramaRoot, XA__NET_SHOWING_DESKTOP, XA_CARDINAL,
                    32,
                    PropModeReplace, (unsigned char *)prop, 1);
}
 
/*
 * Set _NET_WM_STATE.
 *
 * TwmWindow.ewmhFlags keeps track of the atoms that should be in
 * the list, so that we don't have to fetch or recalculate them all.
 *
 * XXX It's not clear that the theoretical performance gain and edge-case
 * bug avoidance of the 'changes' arg is worth the complexity and
 * edge-case bug creation it brings.  Consider removing it.
 */
void EwmhSet_NET_WM_STATE(TwmWindow *twm_win, int changes)
{
    unsigned long prop[10];
    int flags;
    int i;
 
    if(changes & EWMH_STATE_MAXIMIZED_VERT) {
        int newFlags = 0;
 
        switch(twm_win->zoomed) {
            case F_FULLZOOM:
                newFlags = EWMH_STATE_MAXIMIZED_VERT |
                           EWMH_STATE_MAXIMIZED_HORZ;
                break;
            case F_ZOOM:
            case F_LEFTZOOM:
            case F_RIGHTZOOM:
                newFlags = EWMH_STATE_MAXIMIZED_VERT;
                break;
            case F_HORIZOOM:
            case F_TOPZOOM:
            case F_BOTTOMZOOM:
                newFlags = EWMH_STATE_MAXIMIZED_HORZ;
                break;
            case F_FULLSCREENZOOM:
                newFlags = EWMH_STATE_FULLSCREEN;
                break;
        }
 
        twm_win->ewmhFlags &= ~(EWMH_STATE_MAXIMIZED_VERT |
                                EWMH_STATE_MAXIMIZED_HORZ |
                                EWMH_STATE_FULLSCREEN);
        twm_win->ewmhFlags |= newFlags;
    }
 
    if(changes & EWMH_STATE_SHADED) {
        if(twm_win->squeezed) {
            twm_win->ewmhFlags |= EWMH_STATE_SHADED;
        }
        else {
            twm_win->ewmhFlags &= ~EWMH_STATE_SHADED;
        }
    }
 
    if(changes & (EWMH_STATE_ABOVE | EWMH_STATE_BELOW)) {
        int pri = OtpEffectiveDisplayPriority(twm_win);
 
        twm_win->ewmhFlags &= ~(EWMH_STATE_ABOVE | EWMH_STATE_BELOW);
 
        /*
         * If it's a DOCK or DESKTOP, and where we expect those to be, we
         * consider that there's nothing to tell it.  Otherwise, we tell
         * it ABOVE/BELOW based on where it effectively is.
         */
        if(twm_win->ewmhWindowType == wt_Dock && pri == EWMH_PRI_DOCK) {
            pri = 0;
        }
        if(twm_win->ewmhWindowType == wt_Desktop && pri == EWMH_PRI_DESKTOP) {
            pri = 0;
        }
 
        if(pri > 0) {
            twm_win->ewmhFlags |= EWMH_STATE_ABOVE;
        }
        else if(pri < 0) {
            twm_win->ewmhFlags |= EWMH_STATE_BELOW;
        }
    }
 
    flags = twm_win->ewmhFlags;
    i = 0;
 
    if(flags & EWMH_STATE_MAXIMIZED_VERT) {
        prop[i++] = XA__NET_WM_STATE_MAXIMIZED_VERT;
    }
    if(flags & EWMH_STATE_MAXIMIZED_HORZ) {
        prop[i++] = XA__NET_WM_STATE_MAXIMIZED_HORZ;
    }
    if(flags & EWMH_STATE_FULLSCREEN) {
        prop[i++] = XA__NET_WM_STATE_FULLSCREEN;
    }
    if(flags & EWMH_STATE_SHADED) {
        prop[i++] = XA__NET_WM_STATE_SHADED;
    }
    if(flags & EWMH_STATE_ABOVE) {
        prop[i++] = XA__NET_WM_STATE_ABOVE;
    }
    if(flags & EWMH_STATE_BELOW) {
        prop[i++] = XA__NET_WM_STATE_BELOW;
    }
 
    XChangeProperty(dpy, twm_win->w, XA__NET_WM_STATE, XA_ATOM, 32,
                    PropModeReplace, (unsigned char *)prop, i);
}
 
/*
 * Get the initial state of _NET_WM_STATE.
 *
 * Only some of the flags are supported when initially creating a window.
 */
static int EwmhGet_NET_WM_STATE(TwmWindow *twm_win)
{
    int flags = 0;
    unsigned long *prop;
    unsigned long nitems;
    int i;
 
    prop = EwmhGetWindowProperties(twm_win->w, XA__NET_WM_STATE, XA_ATOM, &nitems);
 
    if(prop) {
        for(i = 0; i < nitems; i++) {
            flags |= atomToFlag(prop[i]);
        }
 
        XFree(prop);
    }
 
    return flags;
}
 
/*
 * Set _NET_WORKAREA.
 */
static void EwmhSet_NET_WORKAREA(ScreenInfo *scr)
{
    unsigned long prop[4];
 
    /* x */ prop[0] = scr->BorderLeft;
    /* y */ prop[1] = scr->BorderTop;
    /* w */ prop[2] = scr->rootw - scr->BorderLeft - scr->BorderRight;
    /* h */ prop[3] = scr->rooth - scr->BorderTop - scr->BorderBottom;
 
    XChangeProperty(dpy, Scr->XineramaRoot, XA__NET_WORKAREA, XA_CARDINAL, 32,
                    PropModeReplace, (unsigned char *)prop, 4);
}