trunk/rdesktop/ewmhints.c

/*
   rdesktop: A Remote Desktop Protocol client.

   Support functions for Extended Window Manager Hints,
   http://www.freedesktop.org/standards/wm-spec.html

   Copyright (C) Matthew Chapman 1999-2002
   
   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 "rdesktop.h"
#include <X11/Xlib.h>

extern Display *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(display, propname, True);
        if (property == None)
        {
                fprintf(stderr, "Atom %s does not exist\n", propname);
                return (-1);
        }

        result = XGetWindowProperty(display, DefaultRootWindow(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()
{
        unsigned long nitems_return;
        uint32 *prop_return;
        int current_desktop;

        if (get_property_value("_NET_CURRENT_DESKTOP", 1, &nitems_return,
                               (unsigned char **) &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;
        uint32 *prop_return;
        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,
                               (unsigned char **) &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;

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

        XFree(prop_return);

        return (0);

}
1	astrand	263	/*
2			rdesktop: A Remote Desktop Protocol client.
3
4			Support functions for Extended Window Manager Hints,
5			http://www.freedesktop.org/standards/wm-spec.html
6
7			Copyright (C) Matthew Chapman 1999-2002
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 "rdesktop.h"
25			#include <X11/Xlib.h>
26
27			extern Display *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(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(display, DefaultRootWindow(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()
91			{
92			unsigned long nitems_return;
93			uint32 *prop_return;
94			int current_desktop;
95
96			if (get_property_value("_NET_CURRENT_DESKTOP", 1, &nitems_return,
97			(unsigned char **) &prop_return) < 0)
98			return (-1);
99
100			if (nitems_return != 1)
101			{
102			fprintf(stderr, "_NET_CURRENT_DESKTOP has bad length\n");
103			return (-1);
104			}
105
106			current_desktop = *prop_return;
107			XFree(prop_return);
108			return current_desktop;
109			}
110
111			/*
112			Get workarea geometry
113			Returns zero on success, -1 on error
114			*/
115
116			int
117			get_current_workarea(uint32 * x, uint32 * y, uint32 * width, uint32 * height)
118			{
119			int current_desktop;
120			unsigned long nitems_return;
121			uint32 *prop_return;
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,
129			(unsigned char **) &prop_return) < 0)
130			return (-1);
131
132			if (nitems_return % 4)
133			{
134			fprintf(stderr, "_NET_WORKAREA has odd length\n");
135			return (-1);
136			}
137
138			current_desktop = get_current_desktop();
139
140			if (current_desktop < 0)
141			return -1;
142
143			x = prop_return[current_desktop 4 + net_workarea_x_offset];
144			y = prop_return[current_desktop 4 + net_workarea_y_offset];
145			width = prop_return[current_desktop 4 + net_workarea_width_offset];
146			height = prop_return[current_desktop 4 + net_workarea_height_offset];
147
148			XFree(prop_return);
149
150			return (0);
151
152			}