trunk/rdesktop/ewmhints.c

/* -*- c-basic-offset: 8 -*-
   rdesktop: A Remote Desktop Protocol client.

   Support functions for Extended Window Manager Hints,
   http://www.freedesktop.org/wiki/Standards_2fwm_2dspec

   Copyright (C) Peter Astrand <astrand@cendio.se> 2005
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include "rdesktop.h"

#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  */

extern Display *g_display;

static Atom g_net_wm_state_maximized_vert_atom, g_net_wm_state_maximized_horz_atom,
        g_net_wm_state_hidden_atom, g_net_wm_name_atom, g_utf8_string_atom,
        g_net_wm_state_skip_taskbar_atom, g_net_wm_state_skip_pager_atom, g_net_wm_state_modal_atom;

Atom g_net_wm_state_atom, g_net_wm_desktop_atom;

/* 
   Get window property value (32 bit format) 
   Returns zero on success, -1 on error
*/
static int
get_property_value(Window wnd, char *propname, long max_length,
                   unsigned long *nitems_return, unsigned char **prop_return, int nowarn)
{
        int result;
        Atom property;
        Atom actual_type_return;
        int actual_format_return;
        unsigned long bytes_after_return;

        property = XInternAtom(g_display, propname, True);
        if (property == None)
        {
                fprintf(stderr, "Atom %s does not exist\n", propname);
                return (-1);
        }

        result = XGetWindowProperty(g_display, wnd, property, 0,        /* long_offset */
                                    max_length, /* long_length */
                                    False,      /* delete */
                                    AnyPropertyType,    /* req_type */
                                    &actual_type_return,
                                    &actual_format_return,
                                    nitems_return, &bytes_after_return, prop_return);

        if (result != Success)
        {
                fprintf(stderr, "XGetWindowProperty failed\n");
                return (-1);
        }

        if (actual_type_return == None || actual_format_return == 0)
        {
                if (!nowarn)
                        fprintf(stderr, "Window is missing property %s\n", propname);
                return (-1);
        }

        if (bytes_after_return)
        {
                fprintf(stderr, "%s is too big for me\n", propname);
                return (-1);
        }

        if (actual_format_return != 32)
        {
                fprintf(stderr, "%s has bad format\n", propname);
                return (-1);
        }

        return (0);
}

/* 
   Get current desktop number
   Returns -1 on error
*/
static int
get_current_desktop(void)
{
        unsigned long nitems_return;
        unsigned char *prop_return;
        int current_desktop;

        if (get_property_value
            (DefaultRootWindow(g_display), "_NET_CURRENT_DESKTOP", 1, &nitems_return,
             &prop_return, 0) < 0)
                return (-1);

        if (nitems_return != 1)
        {
                fprintf(stderr, "_NET_CURRENT_DESKTOP has bad length\n");
                return (-1);
        }

        current_desktop = *prop_return;
        XFree(prop_return);
        return current_desktop;
}

/*
  Get workarea geometry
  Returns zero on success, -1 on error
 */

int
get_current_workarea(uint32 * x, uint32 * y, uint32 * width, uint32 * height)
{
        int current_desktop;
        unsigned long nitems_return;
        unsigned char *prop_return;
        uint32 *return_words;
        const uint32 net_workarea_x_offset = 0;
        const uint32 net_workarea_y_offset = 1;
        const uint32 net_workarea_width_offset = 2;
        const uint32 net_workarea_height_offset = 3;
        const uint32 max_prop_length = 32 * 4;  /* Max 32 desktops */

        if (get_property_value
            (DefaultRootWindow(g_display), "_NET_WORKAREA", max_prop_length, &nitems_return,
             &prop_return, 0) < 0)
                return (-1);

        if (nitems_return % 4)
        {
                fprintf(stderr, "_NET_WORKAREA has odd length\n");
                return (-1);
        }

        current_desktop = get_current_desktop();

        if (current_desktop < 0)
                return -1;

        return_words = (uint32 *) prop_return;

        *x = return_words[current_desktop * 4 + net_workarea_x_offset];
        *y = return_words[current_desktop * 4 + net_workarea_y_offset];
        *width = return_words[current_desktop * 4 + net_workarea_width_offset];
        *height = return_words[current_desktop * 4 + net_workarea_height_offset];

        XFree(prop_return);

        return (0);

}


void
ewmh_init()
{
        /* FIXME: Use XInternAtoms */
        g_net_wm_state_maximized_vert_atom =
                XInternAtom(g_display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
        g_net_wm_state_maximized_horz_atom =
                XInternAtom(g_display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
        g_net_wm_state_hidden_atom = XInternAtom(g_display, "_NET_WM_STATE_HIDDEN", False);
        g_net_wm_state_skip_taskbar_atom =
                XInternAtom(g_display, "_NET_WM_STATE_SKIP_TASKBAR", False);
        g_net_wm_state_skip_pager_atom = XInternAtom(g_display, "_NET_WM_STATE_SKIP_PAGER", False);
        g_net_wm_state_modal_atom = XInternAtom(g_display, "_NET_WM_STATE_MODAL", False);
        g_net_wm_state_atom = XInternAtom(g_display, "_NET_WM_STATE", False);
        g_net_wm_desktop_atom = XInternAtom(g_display, "_NET_WM_DESKTOP", False);
        g_net_wm_name_atom = XInternAtom(g_display, "_NET_WM_NAME", False);
        g_utf8_string_atom = XInternAtom(g_display, "UTF8_STRING", False);
}


/* 
   Get the window state: normal/minimized/maximized. 
*/
#ifndef MAKE_PROTO
int
ewmh_get_window_state(Window w)
{
        unsigned long nitems_return;
        unsigned char *prop_return;
        uint32 *return_words;
        unsigned long item;
        BOOL maximized_vert, maximized_horz, hidden;

        maximized_vert = maximized_horz = hidden = False;

        if (get_property_value(w, "_NET_WM_STATE", 64, &nitems_return, &prop_return, 0) < 0)
                return SEAMLESSRDP_NORMAL;

        return_words = (uint32 *) prop_return;

        for (item = 0; item < nitems_return; item++)
        {
                if (return_words[item] == g_net_wm_state_maximized_vert_atom)
                        maximized_vert = True;
                if (return_words[item] == g_net_wm_state_maximized_horz_atom)
                        maximized_horz = True;
                if (return_words[item] == g_net_wm_state_hidden_atom)
                        hidden = True;
        }

        XFree(prop_return);

        if (maximized_vert && maximized_horz)
                return SEAMLESSRDP_MAXIMIZED;
        else if (hidden)
                return SEAMLESSRDP_MINIMIZED;
        else
                return SEAMLESSRDP_NORMAL;
}

static int
ewmh_modify_state(Window wnd, int add, Atom atom1, Atom atom2)
{
        Status status;
        XEvent xevent;

        int result;
        unsigned long nitems;
        unsigned char *props;
        uint32 state = WithdrawnState;

        /* The spec states that the window manager must respect any
           _NET_WM_STATE attributes on a withdrawn window. In order words, we
           modify the attributes directly for withdrawn windows and ask the WM
           to do it for active windows. */
        result = get_property_value(wnd, "WM_STATE", 64, &nitems, &props, 1);
        if ((result >= 0) && nitems)
        {
                state = *(uint32 *) props;
                XFree(props);
        }

        if (state == WithdrawnState)
        {
                if (add)
                {
                        Atom atoms[2];

                        atoms[0] = atom1;
                        nitems = 1;
                        if (atom2)
                        {
                                atoms[1] = atom2;
                                nitems = 2;
                        }

                        XChangeProperty(g_display, wnd, g_net_wm_state_atom, XA_ATOM,
                                        32, PropModeAppend, (unsigned char *) atoms, nitems);
                }
                else
                {
                        Atom *atoms;
                        int i;

                        if (get_property_value(wnd, "_NET_WM_STATE", 64, &nitems, &props, 1) < 0)
                                return 0;

                        atoms = (Atom *) props;

                        for (i = 0; i < nitems; i++)
                        {
                                if ((atoms[i] == atom1) || (atom2 && (atoms[i] == atom2)))
                                {
                                        if (i != (nitems - 1))
                                                memmove(&atoms[i], &atoms[i + 1],
                                                        sizeof(Atom) * (nitems - i - 1));
                                        nitems--;
                                        i--;
                                }
                        }

                        XChangeProperty(g_display, wnd, g_net_wm_state_atom, XA_ATOM,
                                        32, PropModeReplace, (unsigned char *) atoms, nitems);

                        XFree(props);
                }

                return 0;
        }

        xevent.type = ClientMessage;
        xevent.xclient.window = wnd;
        xevent.xclient.message_type = g_net_wm_state_atom;
        xevent.xclient.format = 32;
        if (add)
                xevent.xclient.data.l[0] = _NET_WM_STATE_ADD;
        else
                xevent.xclient.data.l[0] = _NET_WM_STATE_REMOVE;
        xevent.xclient.data.l[1] = atom1;
        xevent.xclient.data.l[2] = atom2;
        xevent.xclient.data.l[3] = 0;
        xevent.xclient.data.l[4] = 0;
        status = XSendEvent(g_display, DefaultRootWindow(g_display), False,
                            SubstructureNotifyMask | SubstructureRedirectMask, &xevent);
        if (!status)
                return -1;

        return 0;
}

/* 
   Set the window state: normal/minimized/maximized. 
   Returns -1 on failure. 
*/
int
ewmh_change_state(Window wnd, int state)
{
        /*
         * Deal with the max atoms
         */
        if (state == SEAMLESSRDP_MAXIMIZED)
        {
                if (ewmh_modify_state
                    (wnd, 1, g_net_wm_state_maximized_vert_atom,
                     g_net_wm_state_maximized_horz_atom) < 0)
                        return -1;
        }
        else
        {
                if (ewmh_modify_state
                    (wnd, 0, g_net_wm_state_maximized_vert_atom,
                     g_net_wm_state_maximized_horz_atom) < 0)
                        return -1;
        }

        return 0;
}


int
ewmh_get_window_desktop(Window wnd)
{
        unsigned long nitems_return;
        unsigned char *prop_return;
        int desktop;

        if (get_property_value(wnd, "_NET_WM_DESKTOP", 1, &nitems_return, &prop_return, 0) < 0)
                return (-1);

        if (nitems_return != 1)
        {
                fprintf(stderr, "_NET_WM_DESKTOP has bad length\n");
                return (-1);
        }

        desktop = *prop_return;
        XFree(prop_return);
        return desktop;
}


int
ewmh_move_to_desktop(Window wnd, unsigned int desktop)
{
        Status status;
        XEvent xevent;

        xevent.type = ClientMessage;
        xevent.xclient.window = wnd;
        xevent.xclient.message_type = g_net_wm_desktop_atom;
        xevent.xclient.format = 32;
        xevent.xclient.data.l[0] = desktop;
        xevent.xclient.data.l[1] = 0;
        xevent.xclient.data.l[2] = 0;
        xevent.xclient.data.l[3] = 0;
        xevent.xclient.data.l[4] = 0;
        status = XSendEvent(g_display, DefaultRootWindow(g_display), False,
                            SubstructureNotifyMask | SubstructureRedirectMask, &xevent);
        if (!status)
                return -1;

        return 0;
}

void
ewmh_set_wm_name(Window wnd, const char *title)
{
        int len;

        len = strlen(title);
        XChangeProperty(g_display, wnd, g_net_wm_name_atom, g_utf8_string_atom,
                        8, PropModeReplace, (unsigned char *) title, len);
}


int
ewmh_set_window_popup(Window wnd)
{
        if (ewmh_modify_state
            (wnd, 1, g_net_wm_state_skip_taskbar_atom, g_net_wm_state_skip_pager_atom) < 0)
                return -1;
        return 0;
}

int
ewmh_set_window_modal(Window wnd)
{
        if (ewmh_modify_state(wnd, 1, g_net_wm_state_modal_atom, 0) < 0)
                return -1;
        return 0;
}

#endif /* MAKE_PROTO */


#if 0

/* FIXME: _NET_MOVERESIZE_WINDOW is for pagers, not for
   applications. We should implement _NET_WM_MOVERESIZE instead */

int
ewmh_net_moveresize_window(Window wnd, int x, int y, int width, int height)
{
        Status status;
        XEvent xevent;
        Atom moveresize;

        moveresize = XInternAtom(g_display, "_NET_MOVERESIZE_WINDOW", False);
        if (!moveresize)
        {
                return -1;
        }

        xevent.type = ClientMessage;
        xevent.xclient.window = wnd;
        xevent.xclient.message_type = moveresize;
        xevent.xclient.format = 32;
        xevent.xclient.data.l[0] = StaticGravity | (1 << 8) | (1 << 9) | (1 << 10) | (1 << 11);
        xevent.xclient.data.l[1] = x;
        xevent.xclient.data.l[2] = y;
        xevent.xclient.data.l[3] = width;
        xevent.xclient.data.l[4] = height;

        status = XSendEvent(g_display, DefaultRootWindow(g_display), False,
                            SubstructureNotifyMask | SubstructureRedirectMask, &xevent);
        if (!status)
                return -1;
        return 0;
}

#endif
1	astrand	963	/* -- c-basic-offset: 8 --
2	astrand	263	rdesktop: A Remote Desktop Protocol client.
3
4			Support functions for Extended Window Manager Hints,
5	astrand	1013	http://www.freedesktop.org/wiki/Standards_2fwm_2dspec
6	astrand	263
7	astrand	1013	Copyright (C) Peter Astrand <astrand@cendio.se> 2005
8	astrand	263
9			This program is free software; you can redistribute it and/or modify
10			it under the terms of the GNU General Public License as published by
11			the Free Software Foundation; either version 2 of the License, or
12			(at your option) any later version.
13
14			This program is distributed in the hope that it will be useful,
15			but WITHOUT ANY WARRANTY; without even the implied warranty of
16			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			GNU General Public License for more details.
18
19			You should have received a copy of the GNU General Public License
20			along with this program; if not, write to the Free Software
21			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22			*/
23
24	astrand	266	#include <X11/Xlib.h>
25	astrand	1199	#include <X11/Xatom.h>
26			#include <X11/Xutil.h>
27	astrand	263	#include "rdesktop.h"
28
29	astrand	1199	#define _NET_WM_STATE_REMOVE 0 /* remove/unset property */
30			#define _NET_WM_STATE_ADD 1 /* add/set property */
31			#define _NET_WM_STATE_TOGGLE 2 /* toggle property */
32
33	jsorg71	450	extern Display *g_display;
34	astrand	263
35	astrand	1199	static Atom g_net_wm_state_maximized_vert_atom, g_net_wm_state_maximized_horz_atom,
36			g_net_wm_state_hidden_atom, g_net_wm_name_atom, g_utf8_string_atom,
37			g_net_wm_state_skip_taskbar_atom, g_net_wm_state_skip_pager_atom, g_net_wm_state_modal_atom;
38
39			Atom g_net_wm_state_atom, g_net_wm_desktop_atom;
40
41	astrand	263	/*
42			Get window property value (32 bit format)
43			Returns zero on success, -1 on error
44			*/
45			static int
46	astrand	1199	get_property_value(Window wnd, char *propname, long max_length,
47			unsigned long nitems_return, unsigned char *prop_return, int nowarn)
48	astrand	263	{
49			int result;
50			Atom property;
51			Atom actual_type_return;
52			int actual_format_return;
53			unsigned long bytes_after_return;
54
55	jsorg71	450	property = XInternAtom(g_display, propname, True);
56	astrand	263	if (property == None)
57			{
58			fprintf(stderr, "Atom %s does not exist\n", propname);
59			return (-1);
60			}
61
62	astrand	1199	result = XGetWindowProperty(g_display, wnd, property, 0, /* long_offset */
63	astrand	263	max_length, /* long_length */
64			False, /* delete */
65			AnyPropertyType, /* req_type */
66			&actual_type_return,
67			&actual_format_return,
68			nitems_return, &bytes_after_return, prop_return);
69
70			if (result != Success)
71			{
72			fprintf(stderr, "XGetWindowProperty failed\n");
73			return (-1);
74			}
75
76			if (actual_type_return == None \|\| actual_format_return == 0)
77			{
78	astrand	1199	if (!nowarn)
79			fprintf(stderr, "Window is missing property %s\n", propname);
80	astrand	263	return (-1);
81			}
82
83			if (bytes_after_return)
84			{
85			fprintf(stderr, "%s is too big for me\n", propname);
86			return (-1);
87			}
88
89			if (actual_format_return != 32)
90			{
91			fprintf(stderr, "%s has bad format\n", propname);
92			return (-1);
93			}
94
95			return (0);
96			}
97
98			/*
99			Get current desktop number
100			Returns -1 on error
101			*/
102			static int
103	matthewc	300	get_current_desktop(void)
104	astrand	263	{
105			unsigned long nitems_return;
106	astrand	464	unsigned char *prop_return;
107	astrand	263	int current_desktop;
108
109	astrand	1199	if (get_property_value
110			(DefaultRootWindow(g_display), "_NET_CURRENT_DESKTOP", 1, &nitems_return,
111			&prop_return, 0) < 0)
112	astrand	263	return (-1);
113
114			if (nitems_return != 1)
115			{
116			fprintf(stderr, "_NET_CURRENT_DESKTOP has bad length\n");
117			return (-1);
118			}
119
120			current_desktop = *prop_return;
121			XFree(prop_return);
122			return current_desktop;
123			}
124
125			/*
126			Get workarea geometry
127			Returns zero on success, -1 on error
128			*/
129
130			int
131			get_current_workarea(uint32 * x, uint32 * y, uint32 * width, uint32 * height)
132			{
133			int current_desktop;
134			unsigned long nitems_return;
135	astrand	464	unsigned char *prop_return;
136			uint32 *return_words;
137	astrand	263	const uint32 net_workarea_x_offset = 0;
138			const uint32 net_workarea_y_offset = 1;
139			const uint32 net_workarea_width_offset = 2;
140			const uint32 net_workarea_height_offset = 3;
141			const uint32 max_prop_length = 32 * 4; /* Max 32 desktops */
142
143	astrand	1199	if (get_property_value
144			(DefaultRootWindow(g_display), "_NET_WORKAREA", max_prop_length, &nitems_return,
145			&prop_return, 0) < 0)
146	astrand	263	return (-1);
147
148			if (nitems_return % 4)
149			{
150			fprintf(stderr, "_NET_WORKAREA has odd length\n");
151			return (-1);
152			}
153
154			current_desktop = get_current_desktop();
155
156			if (current_desktop < 0)
157			return -1;
158
159	astrand	468	return_words = (uint32 *) prop_return;
160	astrand	263
161	astrand	464	x = return_words[current_desktop 4 + net_workarea_x_offset];
162			y = return_words[current_desktop 4 + net_workarea_y_offset];
163			width = return_words[current_desktop 4 + net_workarea_width_offset];
164			height = return_words[current_desktop 4 + net_workarea_height_offset];
165
166	astrand	263	XFree(prop_return);
167
168			return (0);
169
170			}
171	astrand	1013
172
173	astrand	1199
174			void
175			ewmh_init()
176			{
177			/* FIXME: Use XInternAtoms */
178			g_net_wm_state_maximized_vert_atom =
179			XInternAtom(g_display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
180			g_net_wm_state_maximized_horz_atom =
181			XInternAtom(g_display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
182			g_net_wm_state_hidden_atom = XInternAtom(g_display, "_NET_WM_STATE_HIDDEN", False);
183			g_net_wm_state_skip_taskbar_atom =
184			XInternAtom(g_display, "_NET_WM_STATE_SKIP_TASKBAR", False);
185			g_net_wm_state_skip_pager_atom = XInternAtom(g_display, "_NET_WM_STATE_SKIP_PAGER", False);
186			g_net_wm_state_modal_atom = XInternAtom(g_display, "_NET_WM_STATE_MODAL", False);
187			g_net_wm_state_atom = XInternAtom(g_display, "_NET_WM_STATE", False);
188			g_net_wm_desktop_atom = XInternAtom(g_display, "_NET_WM_DESKTOP", False);
189			g_net_wm_name_atom = XInternAtom(g_display, "_NET_WM_NAME", False);
190			g_utf8_string_atom = XInternAtom(g_display, "UTF8_STRING", False);
191			}
192
193
194			/*
195			Get the window state: normal/minimized/maximized.
196			*/
197			#ifndef MAKE_PROTO
198			int
199			ewmh_get_window_state(Window w)
200			{
201			unsigned long nitems_return;
202			unsigned char *prop_return;
203			uint32 *return_words;
204			unsigned long item;
205			BOOL maximized_vert, maximized_horz, hidden;
206
207			maximized_vert = maximized_horz = hidden = False;
208
209			if (get_property_value(w, "_NET_WM_STATE", 64, &nitems_return, &prop_return, 0) < 0)
210			return SEAMLESSRDP_NORMAL;
211
212			return_words = (uint32 *) prop_return;
213
214			for (item = 0; item < nitems_return; item++)
215			{
216			if (return_words[item] == g_net_wm_state_maximized_vert_atom)
217			maximized_vert = True;
218			if (return_words[item] == g_net_wm_state_maximized_horz_atom)
219			maximized_horz = True;
220			if (return_words[item] == g_net_wm_state_hidden_atom)
221			hidden = True;
222			}
223
224			XFree(prop_return);
225
226			if (maximized_vert && maximized_horz)
227			return SEAMLESSRDP_MAXIMIZED;
228			else if (hidden)
229			return SEAMLESSRDP_MINIMIZED;
230			else
231			return SEAMLESSRDP_NORMAL;
232			}
233
234			static int
235			ewmh_modify_state(Window wnd, int add, Atom atom1, Atom atom2)
236			{
237			Status status;
238			XEvent xevent;
239
240			int result;
241			unsigned long nitems;
242			unsigned char *props;
243	astrand	1225	uint32 state = WithdrawnState;
244	astrand	1199
245			/* The spec states that the window manager must respect any
246			_NET_WM_STATE attributes on a withdrawn window. In order words, we
247			modify the attributes directly for withdrawn windows and ask the WM
248			to do it for active windows. */
249			result = get_property_value(wnd, "WM_STATE", 64, &nitems, &props, 1);
250			if ((result >= 0) && nitems)
251			{
252			state = (uint32 ) props;
253			XFree(props);
254			}
255
256	astrand	1225	if (state == WithdrawnState)
257	astrand	1199	{
258			if (add)
259			{
260			Atom atoms[2];
261
262			atoms[0] = atom1;
263			nitems = 1;
264			if (atom2)
265			{
266			atoms[1] = atom2;
267			nitems = 2;
268			}
269
270			XChangeProperty(g_display, wnd, g_net_wm_state_atom, XA_ATOM,
271			32, PropModeAppend, (unsigned char *) atoms, nitems);
272			}
273			else
274			{
275			Atom *atoms;
276			int i;
277
278			if (get_property_value(wnd, "_NET_WM_STATE", 64, &nitems, &props, 1) < 0)
279			return 0;
280
281			atoms = (Atom *) props;
282
283			for (i = 0; i < nitems; i++)
284			{
285			if ((atoms[i] == atom1) \|\| (atom2 && (atoms[i] == atom2)))
286			{
287			if (i != (nitems - 1))
288			memmove(&atoms[i], &atoms[i + 1],
289			sizeof(Atom) * (nitems - i - 1));
290			nitems--;
291			i--;
292			}
293			}
294
295			XChangeProperty(g_display, wnd, g_net_wm_state_atom, XA_ATOM,
296			32, PropModeReplace, (unsigned char *) atoms, nitems);
297
298			XFree(props);
299			}
300
301			return 0;
302			}
303
304			xevent.type = ClientMessage;
305			xevent.xclient.window = wnd;
306			xevent.xclient.message_type = g_net_wm_state_atom;
307			xevent.xclient.format = 32;
308			if (add)
309			xevent.xclient.data.l[0] = _NET_WM_STATE_ADD;
310			else
311			xevent.xclient.data.l[0] = _NET_WM_STATE_REMOVE;
312			xevent.xclient.data.l[1] = atom1;
313			xevent.xclient.data.l[2] = atom2;
314			xevent.xclient.data.l[3] = 0;
315			xevent.xclient.data.l[4] = 0;
316			status = XSendEvent(g_display, DefaultRootWindow(g_display), False,
317			SubstructureNotifyMask \| SubstructureRedirectMask, &xevent);
318			if (!status)
319			return -1;
320
321			return 0;
322			}
323
324			/*
325			Set the window state: normal/minimized/maximized.
326			Returns -1 on failure.
327			*/
328			int
329			ewmh_change_state(Window wnd, int state)
330			{
331			/*
332			* Deal with the max atoms
333			*/
334			if (state == SEAMLESSRDP_MAXIMIZED)
335			{
336			if (ewmh_modify_state
337			(wnd, 1, g_net_wm_state_maximized_vert_atom,
338			g_net_wm_state_maximized_horz_atom) < 0)
339			return -1;
340			}
341			else
342			{
343			if (ewmh_modify_state
344			(wnd, 0, g_net_wm_state_maximized_vert_atom,
345			g_net_wm_state_maximized_horz_atom) < 0)
346			return -1;
347			}
348
349			return 0;
350			}
351
352
353			int
354			ewmh_get_window_desktop(Window wnd)
355			{
356			unsigned long nitems_return;
357			unsigned char *prop_return;
358			int desktop;
359
360			if (get_property_value(wnd, "_NET_WM_DESKTOP", 1, &nitems_return, &prop_return, 0) < 0)
361			return (-1);
362
363			if (nitems_return != 1)
364			{
365			fprintf(stderr, "_NET_WM_DESKTOP has bad length\n");
366			return (-1);
367			}
368
369			desktop = *prop_return;
370			XFree(prop_return);
371			return desktop;
372			}
373
374
375			int
376			ewmh_move_to_desktop(Window wnd, unsigned int desktop)
377			{
378			Status status;
379			XEvent xevent;
380
381			xevent.type = ClientMessage;
382			xevent.xclient.window = wnd;
383			xevent.xclient.message_type = g_net_wm_desktop_atom;
384			xevent.xclient.format = 32;
385			xevent.xclient.data.l[0] = desktop;
386			xevent.xclient.data.l[1] = 0;
387			xevent.xclient.data.l[2] = 0;
388			xevent.xclient.data.l[3] = 0;
389			xevent.xclient.data.l[4] = 0;
390			status = XSendEvent(g_display, DefaultRootWindow(g_display), False,
391			SubstructureNotifyMask \| SubstructureRedirectMask, &xevent);
392			if (!status)
393			return -1;
394
395			return 0;
396			}
397
398			void
399			ewmh_set_wm_name(Window wnd, const char *title)
400			{
401			int len;
402
403			len = strlen(title);
404			XChangeProperty(g_display, wnd, g_net_wm_name_atom, g_utf8_string_atom,
405			8, PropModeReplace, (unsigned char *) title, len);
406			}
407
408
409			int
410			ewmh_set_window_popup(Window wnd)
411			{
412			if (ewmh_modify_state
413			(wnd, 1, g_net_wm_state_skip_taskbar_atom, g_net_wm_state_skip_pager_atom) < 0)
414			return -1;
415			return 0;
416			}
417
418			int
419			ewmh_set_window_modal(Window wnd)
420			{
421			if (ewmh_modify_state(wnd, 1, g_net_wm_state_modal_atom, 0) < 0)
422			return -1;
423			return 0;
424			}
425
426			#endif /* MAKE_PROTO */
427
428
429	astrand	1013	#if 0
430
431			/* FIXME: _NET_MOVERESIZE_WINDOW is for pagers, not for
432			applications. We should implement _NET_WM_MOVERESIZE instead */
433
434			int
435			ewmh_net_moveresize_window(Window wnd, int x, int y, int width, int height)
436			{
437			Status status;
438			XEvent xevent;
439			Atom moveresize;
440
441			moveresize = XInternAtom(g_display, "_NET_MOVERESIZE_WINDOW", False);
442			if (!moveresize)
443			{
444			return -1;
445			}
446
447			xevent.type = ClientMessage;
448			xevent.xclient.window = wnd;
449			xevent.xclient.message_type = moveresize;
450			xevent.xclient.format = 32;
451			xevent.xclient.data.l[0] = StaticGravity \| (1 << 8) \| (1 << 9) \| (1 << 10) \| (1 << 11);
452			xevent.xclient.data.l[1] = x;
453			xevent.xclient.data.l[2] = y;
454			xevent.xclient.data.l[3] = width;
455			xevent.xclient.data.l[4] = height;
456
457			status = XSendEvent(g_display, DefaultRootWindow(g_display), False,
458			SubstructureNotifyMask \| SubstructureRedirectMask, &xevent);
459			if (!status)
460			return -1;
461			return 0;
462			}
463
464			#endif