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 "rdesktop.h"

extern Display *g_display;

/* 
   Get window property value (32 bit format) 
   Returns zero on success, -1 on error
*/
static int
get_property_value(char *propname, long max_length,
                   unsigned long *nitems_return, unsigned char **prop_return)
{
        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, DefaultRootWindow(g_display), 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)
        {
                fprintf(stderr, "Root 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("_NET_CURRENT_DESKTOP", 1, &nitems_return, &prop_return) < 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("_NET_WORKAREA", max_prop_length, &nitems_return, &prop_return) < 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);

}


#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	/* -- c-basic-offset: 8 --
2	rdesktop: A Remote Desktop Protocol client.
3
4	Support functions for Extended Window Manager Hints,
5	http://www.freedesktop.org/wiki/Standards_2fwm_2dspec
6
7	Copyright (C) Peter Astrand <astrand@cendio.se> 2005
8
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	#include <X11/Xlib.h>
25	#include "rdesktop.h"
26
27	extern Display *g_display;
28
29	/*
30	Get window property value (32 bit format)
31	Returns zero on success, -1 on error
32	*/
33	static int
34	get_property_value(char *propname, long max_length,
35	unsigned long nitems_return, unsigned char *prop_return)
36	{
37	int result;
38	Atom property;
39	Atom actual_type_return;
40	int actual_format_return;
41	unsigned long bytes_after_return;
42
43	property = XInternAtom(g_display, propname, True);
44	if (property == None)
45	{
46	fprintf(stderr, "Atom %s does not exist\n", propname);
47	return (-1);
48	}
49
50	result = XGetWindowProperty(g_display, DefaultRootWindow(g_display), property, 0, /* long_offset */
51	max_length, /* long_length */
52	False, /* delete */
53	AnyPropertyType, /* req_type */
54	&actual_type_return,
55	&actual_format_return,
56	nitems_return, &bytes_after_return, prop_return);
57
58	if (result != Success)
59	{
60	fprintf(stderr, "XGetWindowProperty failed\n");
61	return (-1);
62	}
63
64	if (actual_type_return == None \|\| actual_format_return == 0)
65	{
66	fprintf(stderr, "Root window is missing property %s\n", propname);
67	return (-1);
68	}
69
70	if (bytes_after_return)
71	{
72	fprintf(stderr, "%s is too big for me\n", propname);
73	return (-1);
74	}
75
76	if (actual_format_return != 32)
77	{
78	fprintf(stderr, "%s has bad format\n", propname);
79	return (-1);
80	}
81
82	return (0);
83	}
84
85	/*
86	Get current desktop number
87	Returns -1 on error
88	*/
89	static int
90	get_current_desktop(void)
91	{
92	unsigned long nitems_return;
93	unsigned char *prop_return;
94	int current_desktop;
95
96	if (get_property_value("_NET_CURRENT_DESKTOP", 1, &nitems_return, &prop_return) < 0)
97	return (-1);
98
99	if (nitems_return != 1)
100	{
101	fprintf(stderr, "_NET_CURRENT_DESKTOP has bad length\n");
102	return (-1);
103	}
104
105	current_desktop = *prop_return;
106	XFree(prop_return);
107	return current_desktop;
108	}
109
110	/*
111	Get workarea geometry
112	Returns zero on success, -1 on error
113	*/
114
115	int
116	get_current_workarea(uint32 * x, uint32 * y, uint32 * width, uint32 * height)
117	{
118	int current_desktop;
119	unsigned long nitems_return;
120	unsigned char *prop_return;
121	uint32 *return_words;
122	const uint32 net_workarea_x_offset = 0;
123	const uint32 net_workarea_y_offset = 1;
124	const uint32 net_workarea_width_offset = 2;
125	const uint32 net_workarea_height_offset = 3;
126	const uint32 max_prop_length = 32 * 4; /* Max 32 desktops */
127
128	if (get_property_value("_NET_WORKAREA", max_prop_length, &nitems_return, &prop_return) < 0)
129	return (-1);
130
131	if (nitems_return % 4)
132	{
133	fprintf(stderr, "_NET_WORKAREA has odd length\n");
134	return (-1);
135	}
136
137	current_desktop = get_current_desktop();
138
139	if (current_desktop < 0)
140	return -1;
141
142	return_words = (uint32 *) prop_return;
143
144	x = return_words[current_desktop 4 + net_workarea_x_offset];
145	y = return_words[current_desktop 4 + net_workarea_y_offset];
146	width = return_words[current_desktop 4 + net_workarea_width_offset];
147	height = return_words[current_desktop 4 + net_workarea_height_offset];
148
149	XFree(prop_return);
150
151	return (0);
152
153	}
154
155
156	#if 0
157
158	/* FIXME: _NET_MOVERESIZE_WINDOW is for pagers, not for
159	applications. We should implement _NET_WM_MOVERESIZE instead */
160
161	int
162	ewmh_net_moveresize_window(Window wnd, int x, int y, int width, int height)
163	{
164	Status status;
165	XEvent xevent;
166	Atom moveresize;
167
168	moveresize = XInternAtom(g_display, "_NET_MOVERESIZE_WINDOW", False);
169	if (!moveresize)
170	{
171	return -1;
172	}
173
174	xevent.type = ClientMessage;
175	xevent.xclient.window = wnd;
176	xevent.xclient.message_type = moveresize;
177	xevent.xclient.format = 32;
178	xevent.xclient.data.l[0] = StaticGravity \| (1 << 8) \| (1 << 9) \| (1 << 10) \| (1 << 11);
179	xevent.xclient.data.l[1] = x;
180	xevent.xclient.data.l[2] = y;
181	xevent.xclient.data.l[3] = width;
182	xevent.xclient.data.l[4] = height;
183
184	status = XSendEvent(g_display, DefaultRootWindow(g_display), False,
185	SubstructureNotifyMask \| SubstructureRedirectMask, &xevent);
186	if (!status)
187	return -1;
188	return 0;
189	}
190
191	#endif