Fix ExplainWindowPlacement when using "NoUSPosition" style.

[fvwm.git] / fvwm / gnome.c

/* -*-c-*- */
/*
 * GNOME WM Compliance adapted for fvwm
 * Properties set on the root window (or desktop window)
 *
 * Even though the rest of fvwm is GPL consider this file
 * Public Domain - use it however you see fit to make
 * your WM GNOME compiant
 *
 * written by Raster
 * adapted for fvwm by Jay Painter <jpaint@gnu.org>
 */
#include "config.h"

#include <stdio.h>
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif

#include <X11/Xlib.h>
#include <X11/Xmd.h>
#include <X11/Xatom.h>

#include "libs/fvwmlib.h"
#include "libs/Parse.h"
#include "fvwm.h"
#include "externs.h"
#include "cursor.h"
#include "functions.h"
#include "commands.h"
#include "misc.h"
#include "screen.h"
#include "gnome.h"
#include "move_resize.h"
#include "stack.h"
#include "update.h"
#include "style.h"
#include "virtual.h"
#include "window_flags.h"
#include "borders.h"
#include "decorations.h"


/*
 * Properties set on the root window (or desktop window)
 */

/* WIN_AREA CARD32[2] contains the current desktop area X,Y */
#define XA_WIN_AREA                        "_WIN_AREA"

/* WIN_AREA CARD32[2] contains the current desktop area size WxH */
#define XA_WIN_AREA_COUNT                        "_WIN_AREA_COUNT"

/* array of atoms - atom being one of the following atoms */
#define XA_WIN_PROTOCOLS                   "_WIN_PROTOCOLS"

/* array of iocn in various sizes */
/* Type: array of CARD32 */
/*       first item is icon count (n) */
/*       second item is icon record length (in CARD32s) */
/*       this is followed by (n) icon records as follows */
/*           pixmap (XID) */
/*           mask (XID) */
/*           width (CARD32) */
/*           height (CARD32) */
/*           depth (of pixmap, mask is assumed to be of depth 1) (CARD32) */
/*           drawable (screen root drawable of pixmap) (XID) */
/*           ... additional fields can be added at the end of this list */
#define XA_WIN_ICONS                    "_WIN_ICONS"

/* WIN_WORKSPACE CARD32 contains the current desktop number */
#define XA_WIN_WORKSPACE                   "_WIN_WORKSPACE"
/* WIN_WORKSPACE_COUNT CARD32 contains the number of desktops */
#define XA_WIN_WORKSPACE_COUNT             "_WIN_WORKSPACE_COUNT"

/* WIN_WORKSPACE_NAMES StringList (Text Property) of workspace names */
/* unused by enlightenment */
#define XA_WIN_WORKSPACE_NAMES             "_WIN_WORKSPACE_NAMES"

/* *** Don't use this.. iffy at best. ** */
/* The available work area for client windows. The WM can set this and the WM */
/* and/or clients may change it at any time. If it is changed the WM and/or  */
/* clients should honor the changes. If this property does not exist a client */
/* or WM can create it. */
/*
 * CARD32              min_x;
 * CARD32              min_y;
 * CARD32              max_x;
 * CARD32              max_y;
 */
#define XA_WIN_WORKAREA                    "_WIN_WORKAREA"
/* array of 4 CARD32's */

/* This is a list of window id's the WM is currently managing - primarily */
/* for being able to have external "tasklist" apps */
#define XA_WIN_CLIENT_LIST                 "_WIN_CLIENT_LIST"
/* array of N XID's */

/*
 * Properties on client windows
 */

/* The layer the window exists in */
/*      0 = Desktop */
/*      1 = Below */
/*      2 = Normal (default app layer) */
/*      4 = OnTop */
/*      6 = Dock (always on top - for panel) */
/* The app sets this alone, not the WM. If this property changes the WM */
/* should comply and change the appearance/behavior of the Client window */
/* if this hint does not exist the WM Will create it on the Client window */
#define WIN_LAYER_DESKTOP                0
#define WIN_LAYER_BELOW                  2
#define WIN_LAYER_NORMAL                 4
#define WIN_LAYER_ONTOP                  6
#define WIN_LAYER_DOCK                   8
#define WIN_LAYER_ABOVE_DOCK             10
#define WIN_LAYER_MENU                   12
#define XA_WIN_LAYER                     "_WIN_LAYER"
/* WIN_LAYER = CARD32 */

/* flags for the window's state. The WM will change these as needed when */
/* state changes. If the property contains info on client map, E will modify */
/* the windows state accordingly. if the Hint does not exist the WM will */
/* create it on the client window. 0 for the bit means off, 1 means on. */
/* unused (default) values are 0 */

/* removed Minimized - no explanation of what it really means - ambiguity */
/* should not be here if not clear */
#define WIN_STATE_STICKY          (1<<0) /* everyone knows sticky */
#define WIN_STATE_RESERVED_BIT1   (1<<1) /* removed minimize here */
#define WIN_STATE_MAXIMIZED_VERT  (1<<2) /* window in maximized V state */
#define WIN_STATE_MAXIMIZED_HORIZ (1<<3) /* window in maximized H state */
#define WIN_STATE_HIDDEN          (1<<4) /* not on taskbar but window visible */
#define WIN_STATE_SHADED          (1<<5) /* shaded (NeXT style) */
#define WIN_STATE_HID_WORKSPACE   (1<<6) /* not on current desktop */
#define WIN_STATE_HID_TRANSIENT   (1<<7) /* Owner of transient is hidden */
#define WIN_STATE_FIXED_POSITION  (1<<8) /* window is fixed in position even */
#define WIN_STATE_ARRANGE_IGNORE  (1<<9) /* ignore for auto arranging */
/* when scrolling about large */
/* virtual desktops ala fvwm */
#define XA_WIN_STATE              "_WIN_STATE"
/* WIN_STATE = CARD32 */

/* Preferences for behavior for app */
/* ONLY the client sets this */
#define WIN_HINTS_SKIP_FOCUS      (1<<0) /* "alt-tab" skips this win */
#define WIN_HINTS_SKIP_WINLIST    (1<<1) /* not in win list */
#define WIN_HINTS_SKIP_TASKBAR    (1<<2) /* not on taskbar */
#define WIN_HINTS_GROUP_TRANSIENT (1<<3) /* ??????? */
#define WIN_HINTS_FOCUS_ON_CLICK  (1<<4) /* app only accepts focus when clicked
                                          */
#define XA_WIN_HINTS                     "_WIN_HINTS"
/* WIN_HINTS = CARD32 */

/* Application state - also "color reactiveness" - the app can keep changing */
/* this property when it changes its state and the WM or monitoring program */
/* will pick this up and dpylay somehting accordingly. ONLY the client sets */
/* this. */
#define WIN_APP_STATE_NONE                 0
#define WIN_APP_STATE_ACTIVE1              1
#define WIN_APP_STATE_ACTIVE2              2
#define WIN_APP_STATE_ERROR1               3
#define WIN_APP_STATE_ERROR2               4
#define WIN_APP_STATE_FATAL_ERROR1         5
#define WIN_APP_STATE_FATAL_ERROR2         6
#define WIN_APP_STATE_IDLE1                7
#define WIN_APP_STATE_IDLE2                8
#define WIN_APP_STATE_WAITING1             9
#define WIN_APP_STATE_WAITING2             10
#define WIN_APP_STATE_WORKING1             11
#define WIN_APP_STATE_WORKING2             12
#define WIN_APP_STATE_NEED_USER_INPUT1     13
#define WIN_APP_STATE_NEED_USER_INPUT2     14
#define WIN_APP_STATE_STRUGGLING1          15
#define WIN_APP_STATE_STRUGGLING2          16
#define WIN_APP_STATE_DISK_TRAFFIC1        17
#define WIN_APP_STATE_DISK_TRAFFIC2        18
#define WIN_APP_STATE_NETWORK_TRAFFIC1     19
#define WIN_APP_STATE_NETWORK_TRAFFIC2     20
#define WIN_APP_STATE_OVERLOADED1          21
#define WIN_APP_STATE_OVERLOADED2          22
#define WIN_APP_STATE_PERCENT000_1         23
#define WIN_APP_STATE_PERCENT000_2         24
#define WIN_APP_STATE_PERCENT010_1         25
#define WIN_APP_STATE_PERCENT010_2         26
#define WIN_APP_STATE_PERCENT020_1         27
#define WIN_APP_STATE_PERCENT020_2         28
#define WIN_APP_STATE_PERCENT030_1         29
#define WIN_APP_STATE_PERCENT030_2         30
#define WIN_APP_STATE_PERCENT040_1         31
#define WIN_APP_STATE_PERCENT040_2         32
#define WIN_APP_STATE_PERCENT050_1         33
#define WIN_APP_STATE_PERCENT050_2         34
#define WIN_APP_STATE_PERCENT060_1         35
#define WIN_APP_STATE_PERCENT060_2         36
#define WIN_APP_STATE_PERCENT070_1         37
#define WIN_APP_STATE_PERCENT070_2         38
#define WIN_APP_STATE_PERCENT080_1         39
#define WIN_APP_STATE_PERCENT080_2         40
#define WIN_APP_STATE_PERCENT090_1         41
#define WIN_APP_STATE_PERCENT090_2         42
#define WIN_APP_STATE_PERCENT100_1         43
#define WIN_APP_STATE_PERCENT100_2         44
#define XA_WIN_APP_STATE                   "_WIN_APP_STATE"
/* WIN_APP_STATE = CARD32 */

/* Expanded space occupied - this is the area on screen the app's window */
/* will occupy when "expanded" - ie if you have a button on an app that */
/* "hides" it by reducing its size, this is the geometry of the expanded */
/* window - so the window manager can allow for this when doign auto */
/* positioing of client windows assuming the app can at any point use this */
/* this area and thus try and keep it clear. ONLY the client sets this */
/*
 * CARD32              x;
 * CARD32              y;
 * CARD32              width;
 * CARD32              height;
 */
#define XA_WIN_EXPANDED_SIZE               "_WIN_EXPANDED_SIZE"
/* array of 4 CARD32's */

/* CARD32 that contians the desktop number the application is on If the */
/* application's state is "sticky" it is irrelevant. Only the WM should */
/* change this. */
#define XA_WIN_WORKSPACE                   "_WIN_WORKSPACE"

/* This atom is a 32-bit integer that is either 0 or 1 (currently). */
/* 0 denotes everything is as per usual but 1 denotes that ALL configure */
/* requests by the client on the client window with this property are */
/* not just a simple "moving" of the window, but the result of a user */
/* moving the window BUT the client handling that interaction by moving */
/* its own window. The window manager should respond accordingly by assuming */
/* any configure requests for this window whilst this atom is "active" in */
/* the "1" state are a client move and should handle flipping desktops if */
/* the window is being dragged "off screem" or across desktop boundaries */
/* etc. This atom is ONLY ever set by the client */
#define XA_WIN_CLIENT_MOVING               "_WIN_CLIENT_MOVING"
/* WIN_CLIENT_MOVING = CARD32 */

/* Designed for checking if the WIN_ supporting WM is still there  */
/* and kicking about - basically check this property - check the window */
/* ID it points to - then check that window Id has this property too */
/* if that is the case the WIN_ supporting WM is there and alive and the */
/* list of WIN_PROTOCOLS is valid */
#define XA_WIN_SUPPORTING_WM_CHECK         "_WIN_SUPPORTING_WM_CHECK"
/* CARD32 */

/* for root window button clicks */
#define XA_WIN_DESKTOP_BUTTON_PROXY        "_WIN_DESKTOP_BUTTON_PROXY"
/* CARD32 */


/* for the root window clicks */
static Window __button_proxy = 0;


/* how many desks does gnome know about */
static int gnome_max_desk = 1;

static int atom_size(int format)
{
        if (format == 32)
        {
                return sizeof(long);
        }
        else
        {
                return (format >> 3);
        }
}

static void *
AtomGet(Window win, Atom to_get, Atom type, int *size)
{
        unsigned char *retval;
        Atom type_ret;
        unsigned long bytes_after, num_ret;
        int format_ret;
        long length;
        void *data;

        retval = NULL;
        length = 0x7fffffff;
        XGetWindowProperty(
                dpy, win, to_get, 0L, length, False, type, &type_ret,
                &format_ret, &num_ret, &bytes_after, &retval);

        if ((retval) && (num_ret > 0) && (format_ret > 0))
        {
                int asize;

                asize = atom_size(format_ret);
                data = safemalloc(num_ret * asize);
                if (data)
                {
                        memcpy(data, retval, num_ret * asize);
                }
                XFree(retval);
                *size = num_ret * (format_ret >> 3);
                return data;
        }

        return NULL;
}


/*** GET WINDOW PROPERTIES ***/

#if 0
static void
GNOME_GetHintIcons(FvwmWindow *fwin)
{
        Atom atom_get;
        long *retval;
        int size;
        int i;
        Pixmap pmap;
        Pixmap mask;

        atom_get = XInternAtom(dpy, XA_WIN_ICONS, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_PIXMAP, &size);
        if (retval)
        {
                int n;

                n = size / atom_size(32);
                for (i = 0; i < n; i += 2)
                {
                        pmap = retval[i];
                        mask = retval[i + 1];
                }
                free(retval);
        }

        return;
}

static void
GNOME_GetHintLayer(FvwmWindow *fwin)
{
        Atom atom_get;
        long *retval;
        int size;

        atom_get = XInternAtom(dpy, XA_WIN_LAYER, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
        if (retval)
        {
                set_layer(fwin, *retval);
                free(retval);
        }

        return;
}

static void
GNOME_GetHintState(FvwmWindow *fwin)
{
        Atom atom_get;
        long *retval;
        int size;

        atom_get = XInternAtom(dpy, XA_WIN_STATE, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
        if (retval)
        {
                if (*retval & WIN_STATE_STICKY)
                {
                        SET_STICKY(fwin, 1);
                }

                if (*retval & WIN_STATE_SHADED)
                {
                        /* Fixme: how do we find out the correct shade
                         * direction here? */
                        SET_SHADED(fwin, 1);
                        SET_SHADED_DIR(fwin, DIR_N);
                }

                if (*retval & WIN_STATE_FIXED_POSITION)
                {
                        SET_FIXED(fwin, 1);
                }

                free(retval);
        }

        return;
}

static void
GNOME_GetHintAppState(FvwmWindow *fwin)
{
        Atom atom_get;
        unsigned char *retval;
        int size;

        /* have nothing interesting to do with an app state (lamp) right now */
        atom_get = XInternAtom(dpy, XA_WIN_APP_STATE, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
        if (retval)
        {
                free(retval);
        }

        return;
}

static void
GNOME_GetHintDesktop(FvwmWindow *fwin)
{
        Atom atom_get;
        unsigned char *retval;
        int size;
        int *desk;

        atom_get = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
        if (retval)
        {
                desk = (int *)retval;
                fwin->Desk = *desk;

                /* XXX: hide window if it's not on the current desktop! */
                free(retval);
        }

        return;
}

static void
GNOME_GetHint(FvwmWindow *fwin)
{
        Atom atom_get;
        int *retval;
        int size;

        atom_get = XInternAtom(dpy, XA_WIN_HINTS, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
        if (retval)
        {
                if (*retval & WIN_HINTS_SKIP_WINLIST)
                {
                        SET_DO_SKIP_WINDOW_LIST(fwin, 1);
                }
                /* XXX: unimplimented */
                if (*retval & WIN_HINTS_SKIP_TASKBAR)
                {
                        ;
                }
                if (*retval & WIN_HINTS_SKIP_FOCUS)
                {
                        ;
                }
                if (*retval & WIN_HINTS_FOCUS_ON_CLICK)
                {
                        ;
                }
                /* if (*retval & WIN_HINTS_DO_NOT_COVER);*/

                free(retval);
        }

        return;
}

static void
GNOME_GetExpandedSize(FvwmWindow *fwin)
{
        Atom atom_get;
        long *retval;
        int size;

        /* unimplimented */
        int expanded_x, expanded_y, expanded_width, expanded_height;

        atom_get = XInternAtom(dpy, XA_WIN_EXPANDED_SIZE, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
        if (retval)
        {
                expanded_x = retval[0];
                expanded_y = retval[1];
                expanded_width = retval[2];
                expanded_height = retval[3];
                free(retval);
        }

        return;
}

void
GNOME_GetHints(FvwmWindow *fwin)
{
        if (DO_IGNORE_GNOME_HINTS(fwin))
        {
                return;
        }
        GNOME_GetHintDesktop(fwin);
        GNOME_GetHintIcons(fwin);
        GNOME_GetHintLayer(fwin);
        GNOME_GetHintState(fwin);
        GNOME_GetHintAppState(fwin);
        GNOME_GetHint(fwin);
        GNOME_GetExpandedSize(fwin);

        return;
}
#endif

void
GNOME_SetHints(FvwmWindow *fwin)
{
        Atom atom_set;
        long val;

        atom_set = XInternAtom(dpy, XA_WIN_STATE, False);
        val = 0;

        if (IS_STICKY_ACROSS_PAGES(fwin) && IS_STICKY_ACROSS_DESKS(fwin))
        {
                val |= WIN_STATE_STICKY;
        }
        if (IS_SHADED(fwin))
        {
                val |= WIN_STATE_SHADED;
        }
        if (!is_function_allowed(F_MOVE, NULL, fwin, RQORIG_PROGRAM_US, False))
        {
                val |= WIN_STATE_FIXED_POSITION;
        }
        XChangeProperty(
                dpy, FW_W(fwin), atom_set, XA_CARDINAL, 32, PropModeReplace,
                (unsigned char *)&val, 1);

        return;
}


/* this duplicates most of the above... and it assumes
   that style is inizialized to zero.
*/
void
GNOME_GetStyle (FvwmWindow *fwin, window_style *style)
{
        Atom atom_get;
        unsigned char *retval;
        int size;

        if (S_DO_IGNORE_GNOME_HINTS(SCF(*style)))
        {
                return;
        }
        /* Desktop */
        atom_get = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
        if (retval)
        {
                SSET_START_DESK(*style, *(int*)retval);
                /* Allow special case of -1 to work. */
                if (SGET_START_DESK(*style) > -1)
                {
                        SSET_START_DESK(*style, SGET_START_DESK(*style) + 1);
                }
                style->flags.use_start_on_desk = 1;
                style->flag_mask.use_start_on_desk = 1;
                free(retval);
        }

        /* Icons - not implemented */

        /* Layer */
        atom_get = XInternAtom(dpy, XA_WIN_LAYER, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
        if (retval)
        {
                SSET_LAYER(*style, *(int*)retval);
                style->flags.use_layer = (SGET_LAYER(*style) >= 0) ? 1 : 0;
                style->flag_mask.use_layer = 1;
                free(retval);
        }

        /* State */
        atom_get = XInternAtom(dpy, XA_WIN_STATE, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
        if (retval)
        {
                if (*(int*)retval & WIN_STATE_STICKY)
                {
                        S_SET_IS_STICKY_ACROSS_PAGES(SCF(*style), 1);
                        S_SET_IS_STICKY_ACROSS_PAGES(SCM(*style), 1);
                        S_SET_IS_STICKY_ACROSS_PAGES(SCC(*style), 1);
                        S_SET_IS_STICKY_ACROSS_DESKS(SCF(*style), 1);
                        S_SET_IS_STICKY_ACROSS_DESKS(SCM(*style), 1);
                        S_SET_IS_STICKY_ACROSS_DESKS(SCC(*style), 1);
                }

                if (*(int*)retval & WIN_STATE_SHADED)
                {
                        /* unimplemented, since we don't have a
                           start_shaded flag. SM code relies on a
                           separate do_shade flag, but that is ugly.
                        */
                }

                if ((*(int*)retval & WIN_STATE_FIXED_POSITION))
                {
                        S_SET_IS_FIXED(SCF(*style), 1);
                        S_SET_IS_FIXED(SCM(*style), 1);
                        S_SET_IS_FIXED(SCC(*style), 1);
                }

                free(retval);
        }

        /* App state - not implemented */

        /* Hints */
        atom_get = XInternAtom(dpy, XA_WIN_HINTS, False);
        retval = AtomGet(FW_W(fwin), atom_get, XA_CARDINAL, &size);
        if (retval)
        {
                if (*retval & WIN_HINTS_SKIP_WINLIST)
                {
                        S_SET_DO_WINDOW_LIST_SKIP(SCF(*style), 1);
                        S_SET_DO_WINDOW_LIST_SKIP(SCM(*style), 1);
                        S_SET_DO_WINDOW_LIST_SKIP(SCC(*style), 1);
                }

                free(retval);
        }

        /* Expanded size - not implemented */

        return;
}


/*** SET WINDOW PROPERTIES ***/
void
GNOME_SetDesk(FvwmWindow *fwin)
{
        Atom atom_set;
        long val;

        atom_set = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
        val = fwin->Desk;
        if (val >= gnome_max_desk)
        {
                GNOME_SetDeskCount();
        }
        XChangeProperty(
                dpy, FW_W(fwin), atom_set, XA_CARDINAL, 32, PropModeReplace,
                (unsigned char *)&val, 1);

        return;
}


void
GNOME_SetLayer(FvwmWindow *fwin)
{
        Atom atom_set;
        long val;

        atom_set = XInternAtom(dpy, XA_WIN_LAYER, False);
        val = get_layer(fwin);
        XChangeProperty(
                dpy, FW_W(fwin), atom_set, XA_CARDINAL, 32, PropModeReplace,
                (unsigned char *)&val, 1);

        return;
}


/*** INITIALIZE GNOME WM SUPPORT ***/

/* sets the virtual desktop grid properties */
void
GNOME_SetAreaCount(void)
{
        Atom atom_set;
        long val[2];

        atom_set = XInternAtom(dpy, XA_WIN_AREA_COUNT, False);
        val[0] = (Scr.VxMax + Scr.MyDisplayWidth) / Scr.MyDisplayWidth;
        val[1] = (Scr.VyMax + Scr.MyDisplayHeight) / Scr.MyDisplayHeight;
        XChangeProperty(
                dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
                (unsigned char *)val, 2);

        return;
}


/* sets the property indicating the current virtual desktop
 * location
 */
void
GNOME_SetCurrentArea(void)
{
        Atom atom_set;
        long val[2];

        atom_set = XInternAtom(dpy, XA_WIN_AREA, False);
        val[0] = Scr.Vx / Scr.MyDisplayWidth;
        val[1] = Scr.Vy / Scr.MyDisplayHeight;
        XChangeProperty(
                dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
                (unsigned char *)val, 2);

        return;
}

/* FIXME: what to do about negative desks ? */
/* ignore them! */
void
GNOME_SetDeskCount(void)
{
        Atom atom_set;
        long val;
        FvwmWindow *t;

        atom_set = XInternAtom(dpy, XA_WIN_WORKSPACE_COUNT, False);
        val = 0;
        if (Scr.CurrentDesk > 0)
        {
                val = Scr.CurrentDesk;
        }
        for (t = get_next_window_in_stack_ring(&Scr.FvwmRoot);
             t != &Scr.FvwmRoot; t = get_next_window_in_stack_ring(t))
        {
                if (t->Desk > val)
                {
                        val = t->Desk;
                }
        }
        val++;
        if (gnome_max_desk > val)
        {
                val = gnome_max_desk;
        }
        XChangeProperty(
                dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
                (unsigned char *)&val, 1);

        return;
}


/* XXX: this function is hard-coded to one! -JMP */
void
GNOME_SetCurrentDesk(void)
{
        Atom atom_set;
        long val;

        atom_set = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
        val = (long) Scr.CurrentDesk;
        if (val >= gnome_max_desk)
        {
                GNOME_SetDeskCount();
        }
        XChangeProperty(
                dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
                (unsigned char *)&val, 1);
        GNOME_SetCurrentArea();

        return;
}


/* sets the names assigned to the desktops */
void
GNOME_SetDeskNames(void)
{
        Atom atom_set;
        XTextProperty text;
        char *names[1];

        atom_set = XInternAtom(dpy, XA_WIN_WORKSPACE_NAMES, False);
        names[0] = "GNOME Desktop";
        if (XStringListToTextProperty(names, 1, &text))
        {
                XSetTextProperty(dpy, Scr.Root, &text, atom_set);
                XFree(text.value);
        }

        return;
}


void
GNOME_SetClientList(void)
{
        Atom atom_set;
        Window *wl=NULL;
        int displayed=0;
        int i = 0;
        FvwmWindow *t;

        /* Find out how many window pointers we need to store, allocate
         * the space and go through the list again to actually store them.
         */
        for (t = Scr.FvwmRoot.next; t; t = t->next)
        {
                if (!DO_SKIP_WINDOW_LIST(t))
                {
                        displayed++;
                }
        }
        if(displayed)
        {
                wl=(Window*)safemalloc(sizeof(Window*)*displayed);
                for (t = Scr.FvwmRoot.next; t; t = t->next)
                {
                        if (!DO_SKIP_WINDOW_LIST(t))
                        {
                                wl[i++] = FW_W(t);
                        }
                }
        }
        /* Update X */
        atom_set = XInternAtom(dpy, XA_WIN_CLIENT_LIST, False);
        XChangeProperty(
                dpy, Scr.Root, atom_set, XA_CARDINAL, 32,
                PropModeReplace, (unsigned char *)wl, i);
        if(wl)
                free(wl);

        return;
}

void
GNOME_SetWinArea(FvwmWindow *w)
{
        Atom atom_set;
        long val[2];

        atom_set = XInternAtom(dpy, XA_WIN_AREA, False);

        if (!DO_SKIP_WINDOW_LIST(w))
        {
                if (IsRectangleOnThisPage(&(w->g.frame), w->Desk))
                {
                        val[0] = Scr.Vx / Scr.MyDisplayWidth;
                        val[1] = Scr.Vy / Scr.MyDisplayHeight;
                }
                else
                {
                        val[0] = (w->g.frame.x + Scr.Vx) / Scr.MyDisplayWidth;
                        if (val[0] < 0 &&
                            w->g.frame.x + Scr.Vx + w->g.frame.width > 0)
                        {
                                val[0] = 0;
                        }
                        val[1] = (w->g.frame.y + Scr.Vy) / Scr.MyDisplayHeight;
                        if (val[1] < 0 &&
                            w->g.frame.y + Scr.Vy + w->g.frame.height > 0)
                        {
                                val[1] = 0;
                        }
                }
                XChangeProperty(
                        dpy, FW_W(w), atom_set, XA_CARDINAL, 32,
                        PropModeReplace, (unsigned char *)val, 2);
        }

        return;
}

void
GNOME_Init(void)
{
        int i;
        Atom atom_set, list[11];
        long val;

        atom_set = XInternAtom(dpy, XA_WIN_PROTOCOLS, False);
        /* these indicate what GNOME compliance properties have been
         * implemented */
        i = 0;
        list[i++] = XInternAtom(dpy, XA_WIN_LAYER, False);
        list[i++] = XInternAtom(dpy, XA_WIN_STATE, False);
        list[i++] = XInternAtom(dpy, XA_WIN_HINTS, False);
        /* list[i++] = XInternAtom(dpy, XA_WIN_APP_STATE, False); */
        /* list[i++] = XInternAtom(dpy, XA_WIN_EXPANDED_SIZE, False); */
        /* list[i++] = XInternAtom(dpy, XA_WIN_ICONS, False); */
        list[i++] = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
        list[i++] = XInternAtom(dpy, XA_WIN_WORKSPACE_COUNT, False);
        list[i++] = XInternAtom(dpy, XA_WIN_WORKSPACE_NAMES, False);
        list[i++] = XInternAtom(dpy, XA_WIN_CLIENT_LIST, False);
        list[i++] = XInternAtom(dpy, XA_WIN_DESKTOP_BUTTON_PROXY, False);
        XChangeProperty(
                dpy, Scr.Root, atom_set, XA_ATOM, 32, PropModeReplace,
                (unsigned char *)list, i);

        /*--------------------------------------------------------------------
          why use two windows when one does just fine ?
          --------------------------------------------------------------------*/
        /* create a window which is a child of the root window and set the
         * XA_WIN_SUPPORTING_WM_CHECK property on it, and also set the
         * same property on the root window with the window ID of of the
         * window we just created
         */
        __button_proxy = XCreateWindow(dpy, Scr.Root, -10, -10, 10, 10, 0, 0,
                                       InputOnly, CopyFromParent, 0, NULL);
        atom_set = XInternAtom(dpy, XA_WIN_SUPPORTING_WM_CHECK, False);
        val = __button_proxy;
        XChangeProperty(
                dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
                (unsigned char *)&val, 1);
        XChangeProperty(
                dpy, __button_proxy, atom_set, XA_CARDINAL, 32,
                PropModeReplace, (unsigned char *)&val, 1);

        /* create a window which is the child of the root window for proxying
         * root window clicks
         */
        atom_set = XInternAtom(dpy, XA_WIN_DESKTOP_BUTTON_PROXY, False);
        XChangeProperty(
                dpy, Scr.Root, atom_set, XA_CARDINAL, 32,
                PropModeReplace, (unsigned char *)&val, 1);
        XChangeProperty(
                dpy, __button_proxy, atom_set, XA_CARDINAL, 32,
                PropModeReplace, (unsigned char *)&val, 1);

        /* some initial settings */
        GNOME_SetDeskCount();
        GNOME_SetCurrentDesk();
        GNOME_SetDeskNames();
        GNOME_SetAreaCount();
        GNOME_SetCurrentArea();
        GNOME_SetClientList();

        return;
}


/*-----------------------------------------------------------------------
  tell gnome how many desks to show
  -----------------------------------------------------------------------*/
void
CMD_GnomeShowDesks(F_CMD_ARGS)
{
        int n;
        Atom atom_set;
        long val[1];

        atom_set = XInternAtom(dpy, XA_WIN_WORKSPACE_COUNT, False);
        DBUG("GNOME_ShowDesks","Routine Entered");
        n = GetIntegerArguments(action, NULL, (int *)val, 1);
        if(n != 1)
        {
                fvwm_msg(ERR, "GnomeShowDesks", "requires one argument");
                return;
        }
        gnome_max_desk = val[0];
        XChangeProperty(
                dpy, Scr.Root, atom_set, XA_CARDINAL, 32, PropModeReplace,
                (unsigned char *)(&val[0]), 1);

        return;
}


/*** RECIVING MESSAGES ***/
int
GNOME_ProcessClientMessage(const exec_context_t *exc)
{
        Atom a;
        FvwmWindow *fw = exc->w.fw;
        XEvent *ev = exc->x.etrigger;
        long p0 = 0;
        long p1 = 0;
        const char* invalid_req = "---";
        const char* invalid_prop = "---";

        if (fw != NULL  && DO_IGNORE_GNOME_HINTS(fw))
        {
                return 0;
        }
        a = XInternAtom(dpy, XA_WIN_AREA, False);
        if (ev->xclient.message_type == a)
        {
                /* convert to integer grid */
                p0 = ev->xclient.data.l[0] * Scr.MyDisplayWidth;
                p1 = ev->xclient.data.l[1] * Scr.MyDisplayHeight;
                if (p0 < 0 || p0 > 0x7fffffff || p1 < 0 || p1 > 0x7fffffff)
                {
                        invalid_prop = "page";
                        invalid_req = "_WIN_AREA";
                        goto err_msg;
                }
                MoveViewport(p0, p1, 1);

                return 1;
        }
        a = XInternAtom(dpy, XA_WIN_WORKSPACE, False);
        if (ev->xclient.message_type == a)
        {
                p0 = ev->xclient.data.l[0];
                if (p0 < 0 || p0 > 0x7fffffff)
                {
                        invalid_prop = "desk";
                        invalid_req = "_WIN_WORKSPACE";
                        goto err_msg;
                }
                goto_desk(p0);

                return 1;
        }
        a = XInternAtom(dpy, XA_WIN_LAYER, False);
        if (ev->xclient.message_type == a && fw)
        {
                p0 = ev->xclient.data.l[0];
                if (p0 < 0 || p0 > 0x7fffffff)
                {
                        invalid_prop = "layer";
                        invalid_req = "_WIN_LAYER";
                        goto err_msg;
                }
                new_layer(fw, p0);

                return 1;
        }
        a = XInternAtom(dpy, XA_WIN_STATE, False);
        if (ev->xclient.message_type == a && fw)
        {
                GNOME_HandlePropRequest(
                        exc, ev->xclient.data.l[0], ev->xclient.data.l[1]);

                return 1;
        }

        return 0;

  err_msg:
        fvwm_msg(
                WARN, "GNOME_ProcessClientMessage",
                "The application window (id %#lx)\n"
                "  \"%s\" has requested an invalid %s (%ld, %ld)\n"
                "  using a %s client message.\n"
                "    fvwm is ignoring this request.\n",
                fw ? FW_W(fw) : 0, fw ? fw->name.name : "(none)", invalid_prop,
                p0, p1, invalid_req);
        fvwm_msg_report_app_and_workers();

        return 0;

}

void GNOME_HandlePropRequest(
        const exec_context_t *exc, unsigned int propm, unsigned int prop)
{
        Atom atype;
        Atom a;
        int aformat;
        FvwmWindow *fwin;
        unsigned char *indi;
        unsigned long nitems, bytes_remain, oldprop;
        indi = (unsigned char *)&oldprop;
        DBUG("HandleGnomePropRequest","Routine Entered");

        a = XInternAtom(dpy, XA_WIN_STATE, False);

        for (fwin = Scr.FvwmRoot.next; fwin; fwin = fwin->next)
        {
                if (FW_W(fwin) == exc->w.w)
                {
                        break;
                }
        }
        /*--------------------------------------------------------------------
          First change the props on the window so the gnome app knows we did
          something.
          --------------------------------------------------------------------*/
#ifdef FVWM_DEBUG_MSGS
        fvwm_msg(
                DBG, "HandleGnomePropRequest", "window is %d", (int)FW_W(fwin));
#endif
        if (fwin == NULL)
        {
                return;
        }
        if (DO_IGNORE_GNOME_HINTS(fwin))
        {
                return;
        }

#ifdef FVWM_DEBUG_MSGS
        fvwm_msg(DBG, "HandleGnomePropRequest", "prop req is %d", prop);
        fvwm_msg(DBG, "HandleGnomePropRequest", "propm req is %d", propm);
#endif
        XGetWindowProperty(dpy, FW_W(fwin), a, 0L, 3L, False, a,
                           &atype, &aformat, &nitems, &bytes_remain, &indi);
        oldprop &= ~(propm);
        oldprop |= (propm & prop);
#ifdef FVWM_DEBUG_MSGS
        fvwm_msg(
                DBG, "HandleGnomePropRequest", "oldprop req is %d",
                (int)oldprop);
#endif
        XChangeProperty(
                dpy, FW_W(fwin), a, XA_CARDINAL, 32, PropModeReplace,
                (unsigned char *)&oldprop, 1);

        /*--------------------------------------------------------------------
          Then apply the requests
          --------------------------------------------------------------------*/

        /*--------------------------------------------------------------------
          Sticky
          --------------------------------------------------------------------*/
        if (propm & WIN_STATE_STICKY)
        {
                if (prop & WIN_STATE_STICKY)
                {
                        SET_STICKY_ACROSS_PAGES(fwin, 1);
                        SET_STICKY_ACROSS_DESKS(fwin, 1);
                }
                else
                {
                        SET_STICKY_ACROSS_PAGES(fwin, 0);
                        SET_STICKY_ACROSS_DESKS(fwin, 0);
                }
                border_draw_decorations(
                        fwin, PART_TITLE, (Scr.Hilite==fwin), True, CLEAR_ALL,
                        NULL, NULL);
        }
        /*--------------------------------------------------------------------
          WindowShade
          -------------------------------------------------------------------*/
        if (propm & WIN_STATE_SHADED)
        {
                if (prop & WIN_STATE_SHADED)
                {
                        /* shade up */
                        execute_function_override_window(
                                NULL, exc, "WindowShade True", 0, fwin);
                }
                else
                {
                        /* shade down */
                        execute_function_override_window(
                                NULL, exc, "WindowShade False", 0, fwin);
                }
        }

        return;
}

void
GNOME_ProxyButtonEvent(const XEvent *ev)
{
        switch (ev->type)
        {
        case ButtonPress:
                XUngrabPointer(dpy, CurrentTime);
                FSendEvent(
                        dpy, __button_proxy, False, SubstructureNotifyMask,
                        (XEvent *)ev);
                break;

        case ButtonRelease:
                FSendEvent(
                        dpy, __button_proxy, False, SubstructureNotifyMask,
                        (XEvent *)ev);
                break;
        }

        return;
}


/* this is the function entered into fvwm's functions table */
void
CMD_GnomeButton(F_CMD_ARGS)
{
        /* send off the button press event */
        GNOME_ProxyButtonEvent(exc->x.etrigger);

        return;
}