Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

gwmh.c @ 15821

Visit:

Revision 15821, 66.0 KB checked in by ghudson, 24 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r15820, which included commits to RCS files with non-trunk default branches.

Rev	Line
[15820]	1	/* gwmh.c - GNOME WM interaction helper functions
	2	* Copyright (C) 1999 Tim Janik
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version 2
	7	* of the License, or (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU Library General Public
	15	* License along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
	17	*
	18	* this code is heavily based on the original gnomepager_applet
	19	* implementation of The Rasterman (Carsten Haitzler) <raster@rasterman.com>
	20	*/
	21	#include <gwmh.h>
	22
	23	#include <gstc.h>
	24	#include <gdk/gdkx.h>
	25
	26	#include <X11/Xmd.h>
	27	#include <X11/Xlib.h>
	28	#include <X11/Xatom.h>
	29
	30
	31	/* --- defines --- */
	32	#define TASK_XROOT(task) ((task)->sroot ? GSTC_PARENT_XWINDOW ((task)->sroot) : 0)
	33	#define GDK_WINDOW_IS_FOREIGN(w) (((GdkWindowPrivate*) (w))->window_type == GDK_WINDOW_FOREIGN)
	34	#define GDK_WINDOW_IS_DESTROYED(w) (((GdkWindowPrivate*) (w))->destroyed)
	35
	36
	37	/* --- preinitialized Atoms --- */
	38	gulong GWMHA_WIN_SUPPORTING_WM_CHECK = 0;
	39	gulong GWMHA_WIN_PROTOCOLS = 0;
	40	gulong GWMHA_WIN_LAYER = 0;
	41	gulong GWMHA_WIN_STATE = 0;
	42	gulong GWMHA_WIN_HINTS = 0;
	43	gulong GWMHA_WIN_APP_STATE = 0;
	44	gulong GWMHA_WIN_EXPANDED_SIZE = 0;
	45	gulong GWMHA_WIN_ICONS = 0;
	46	gulong GWMHA_WIN_WORKSPACE = 0;
	47	gulong GWMHA_WIN_WORKSPACE_COUNT = 0;
	48	gulong GWMHA_WIN_WORKSPACE_NAMES = 0;
	49	gulong GWMHA_WIN_CLIENT_LIST = 0;
	50	gulong GWMHA_WIN_AREA = 0;
	51	gulong GWMHA_WIN_AREA_COUNT = 0;
	52	gulong GWMHA_WIN_UNIFIED_AREA = 0;
	53	static gulong XA_WM_STATE = 0;
	54	static gulong XA_WM_PROTOCOLS = 0;
	55	static gulong XA_WM_DELETE_WINDOW = 0;
	56	static gulong XA_WM_TAKE_FOCUS = 0;
	57	static gulong XA_ENLIGHTENMENT_DESKTOP = 0;
	58	static gulong XA_KWM_WIN_ICON = 0;
	59	static gulong XA_COMPOUND_TEXT = 0;
	60
	61	static const struct {
	62	gulong *atom;
	63	const gchar *atom_name;
	64	} gwmh_atoms[] = {
	65	{ &GWMHA_WIN_PROTOCOLS, "_WIN_PROTOCOLS", },
	66	{ &GWMHA_WIN_EXPANDED_SIZE, "_WIN_EXPANDED_SIZE", },
	67	{ &GWMHA_WIN_ICONS, "_WIN_ICONS", },
	68	{ &GWMHA_WIN_WORKSPACE, "_WIN_WORKSPACE", },
	69	{ &GWMHA_WIN_WORKSPACE_COUNT, "_WIN_WORKSPACE_COUNT", },
	70	{ &GWMHA_WIN_WORKSPACE_NAMES, "_WIN_WORKSPACE_NAMES", },
	71	{ &GWMHA_WIN_CLIENT_LIST, "_WIN_CLIENT_LIST", },
	72	{ &GWMHA_WIN_AREA, "_WIN_AREA", },
	73	{ &GWMHA_WIN_AREA_COUNT, "_WIN_AREA_COUNT", },
	74	{ &GWMHA_WIN_UNIFIED_AREA, "_WIN_UNIFIED_AREA", },
	75	#define N_GWMHA_IGNORE_ATOMS (10)
	76	{ &GWMHA_WIN_LAYER, "_WIN_LAYER", },
	77	{ &GWMHA_WIN_APP_STATE, "_WIN_APP_STATE", },
	78	{ &GWMHA_WIN_STATE, "_WIN_STATE", },
	79	{ &GWMHA_WIN_HINTS, "_WIN_HINTS", },
	80	{ &GWMHA_WIN_SUPPORTING_WM_CHECK, "_WIN_SUPPORTING_WM_CHECK", },
	81	{ &XA_WM_STATE, "WM_STATE", },
	82	{ &XA_WM_PROTOCOLS, "WM_PROTOCOLS", },
	83	{ &XA_WM_DELETE_WINDOW, "WM_DELETE_WINDOW", },
	84	{ &XA_WM_TAKE_FOCUS, "WM_TAKE_FOCUS", },
	85	{ &XA_ENLIGHTENMENT_DESKTOP, "ENLIGHTENMENT_DESKTOP", },
	86	{ &XA_KWM_WIN_ICON, "KWM_WIN_ICON", },
	87	{ &XA_COMPOUND_TEXT, "COMPOUND_TEXT", },
	88	};
	89
	90
	91	/* --- prototypes --- */
	92	static gpointer get_typed_property_data (Display *xdisplay,
	93	Window xwindow,
	94	Atom property,
	95	Atom requested_type,
	96	gint *size_p,
	97	guint expected_format);
	98	static gboolean wm_protocol_check_support (Window xwin,
	99	Atom check_atom);
	100	static gboolean send_client_message_2L (Window recipient,
	101	Window event_window,
	102	Atom message_type,
	103	long event_mask,
	104	glong long1,
	105	glong long2);
	106	static gboolean send_client_message_3L (Window recipient,
	107	Window event_window,
	108	Atom message_type,
	109	long event_mask,
	110	glong long1,
	111	glong long2,
	112	glong long3);
	113	static gboolean send_client_message_5L (Window recipient,
	114	Window event_window,
	115	Atom message_type,
	116	long event_mask,
	117	glong long1,
	118	glong long2,
	119	glong long3,
	120	glong long4,
	121	glong long5);
	122	static void get_task_root_and_frame (GwmhTask *task);
	123	static GdkWindow* gdk_window_ref_from_xid (Window xwin);
	124	static guint gwmh_property_atom2info (Atom atom,
	125	gboolean per_task);
	126	static void gwmh_task_queue_full (GwmhTask *task,
	127	GwmhTaskInfoMask imask,
	128	GwmhTaskInfoMask notify_mask);
	129	static void gwmh_desk_update (GwmhDeskInfoMask imask);
	130	static gboolean gwmh_task_update (GwmhTask *task,
	131	GwmhTaskInfoMask imask,
	132	gboolean skip_notify);
	133	static void gwmh_desk_notify (GwmhDeskInfoMask imask);
	134	static void gwmh_task_notify (GwmhTask *task,
	135	GwmhTaskNotifyType ntype,
	136	GwmhTaskInfoMask imask);
	137	static GwmhTask* task_new (GdkWindow *gdkwindow);
	138	static void task_delete (GwmhTask *task);
	139	static gboolean client_list_sync (guint32 *xwindows_ids,
	140	guint n_ids);
	141	static GdkFilterReturn task_event_monitor (GdkXEvent *gdk_xevent,
	142	GdkEvent *event,
	143	gpointer task_pointer);
	144	static GdkFilterReturn task_event_monitor_frame_wrapper (GdkXEvent, GdkEvent, gpointer);
	145	static GdkFilterReturn root_event_monitor (GdkXEvent *gdk_xevent,
	146	GdkEvent *event,
	147	gpointer gdk_root);
	148	static guint32* hack_a_client_list (Display *display,
	149	Window xroot,
	150	guint *_n_clients);
	151
	152
	153	/* --- variables --- */
	154	static Window gwmh_gnome_wm_win = None;
	155	static gboolean gwmh_need_reboot = FALSE;
	156	static GHookList gwmh_desk_hook_list = { 0, };
	157	static GHookList gwmh_task_hook_list = { 0, };
	158	static GSList *gwmh_task_update_queue = NULL;
	159	static guint gwmh_syncs_frozen = 0;
	160	static guint gwmh_idle_handler_id = 0;
	161	static GwmhDeskInfoMask gwmh_desk_update_queued = 0;
	162	static guint *gwmh_harea_cache = NULL;
	163	static guint *gwmh_varea_cache = NULL;
	164	static GwmhDesk gwmh_desk = {
	165	0 /* n_desktops */,
	166	0 /* n_hareas */,
	167	0 /* n_vareas */,
	168	NULL /* desktop_names */,
	169	0 /* current_desktop */,
	170	0 /* current_harea */,
	171	0 /* current_varea */,
	172	NULL /* client_list */,
	173	FALSE /* detected_gnome_wm */,
	174	FALSE /* unified_area */,
	175	};
	176	static gboolean gwmh_hack_think_unified_area = FALSE;
	177	static gboolean gwmh_hack_violate_client_msg = TRUE;
	178
	179
	180	/* --- functions --- */
	181	static inline gint
	182	gwmh_string_equals (const gchar *string1,
	183	const gchar *string2)
	184	{
	185	if (string1 && string2)
	186	return strcmp (string1, string2) == 0;
	187	else
	188	return string1 == string2;
	189	}
	190
	191	static inline void
	192	gwmh_sync (void)
	193	{
	194	if (!gwmh_syncs_frozen)
	195	gdk_flush ();
	196	}
	197
	198	static inline void
	199	gwmh_thaw_syncs (void)
	200	{
	201	if (gwmh_syncs_frozen)
	202	gwmh_syncs_frozen--;
	203	gwmh_sync ();
	204	}
	205
	206	static inline void
	207	gwmh_freeze_syncs (void)
	208	{
	209	gwmh_syncs_frozen++;
	210	}
	211
	212	gboolean
	213	gwmh_init (void)
	214	{
	215	static volatile guint n_init_calls = 0;
	216	XWindowAttributes attribs = { 0, };
	217	guint32 *property_data;
	218	gint size = 0;
	219	guint i;
	220
	221	n_init_calls++;
	222	if (n_init_calls == 1)
	223	{
	224	GdkWindow *window;
	225
	226	/* initialize hook lists */
	227	g_hook_list_init (&gwmh_desk_hook_list, sizeof (GHook));
	228	g_hook_list_init (&gwmh_task_hook_list, sizeof (GHook));
	229
	230	/* setup the root window event monitor */
	231	window = gdk_window_ref_from_xid (GDK_ROOT_WINDOW ());
	232	if (!window)
	233	g_error (G_GNUC_PRETTY_FUNCTION "(): root window id %ld invalid? bad bad...",
	234	GDK_ROOT_WINDOW ());
	235	gdk_window_add_filter (window,
	236	root_event_monitor,
	237	window);
	238	}
	239
	240	/* first kill remaining tasks with notification */
	241	while (gwmh_desk.client_list)
	242	task_delete (gwmh_desk.client_list->data);
	243
	244	/* initialize desk structure */
	245	for (i = 0; i < gwmh_desk.n_desktops; i++)
	246	g_free (gwmh_desk.desktop_names[i]);
	247	gwmh_desk.n_desktops = 1;
	248	gwmh_desk.n_hareas = 1;
	249	gwmh_desk.n_vareas = 1;
	250	gwmh_desk.desktop_names = g_renew (gchar*,
	251	gwmh_desk.desktop_names,
	252	gwmh_desk.n_desktops);
	253	gwmh_harea_cache = g_renew (guint,
	254	gwmh_harea_cache,
	255	gwmh_desk.n_desktops);
	256	gwmh_varea_cache = g_renew (guint,
	257	gwmh_varea_cache,
	258	gwmh_desk.n_desktops);
	259	for (i = 0; i < gwmh_desk.n_desktops; i++)
	260	{
	261	gwmh_desk.desktop_names[i] = NULL;
	262	gwmh_harea_cache[i] = 0;
	263	gwmh_varea_cache[i] = 0;
	264	}
	265	gwmh_desk.current_desktop = 0;
	266	gwmh_desk.current_harea = 0;
	267	gwmh_desk.current_varea = 0;
	268	gwmh_desk.detected_gnome_wm = FALSE;
	269	gwmh_desk.unified_area = FALSE;
	270
	271	/* setup preinitialized atoms */
	272	for (i = 0; i < sizeof (gwmh_atoms) / sizeof (gwmh_atoms[0]); i++)
	273	*gwmh_atoms[i].atom = gdk_atom_intern (gwmh_atoms[i].atom_name, FALSE);
	274
	275	gdk_error_trap_push ();
	276
	277	/* set event mask for events on root window */
	278	XGetWindowAttributes (GDK_DISPLAY (),
	279	GDK_ROOT_WINDOW (),
	280	&attribs);
	281	XSelectInput (GDK_DISPLAY (),
	282	GDK_ROOT_WINDOW (),
	283	attribs.your_event_mask \|
	284	StructureNotifyMask \|
	285	PropertyChangeMask);
	286	gdk_flush ();
	287
	288	/* check for a GNOME window manager */
	289	gwmh_gnome_wm_win = None;
	290	property_data = get_typed_property_data (GDK_DISPLAY (),
	291	GDK_ROOT_WINDOW (),
	292	GWMHA_WIN_SUPPORTING_WM_CHECK,
	293	XA_CARDINAL,
	294	&size, 32);
	295	if (property_data)
	296	{
	297	Window check_window = property_data[0];
	298	guint32 *wm_check_data;
	299
	300	wm_check_data = get_typed_property_data (GDK_DISPLAY (),
	301	check_window,
	302	GWMHA_WIN_SUPPORTING_WM_CHECK,
	303	XA_CARDINAL,
	304	&size, 32);
	305	if (wm_check_data && wm_check_data[0] == check_window)
	306	gwmh_gnome_wm_win = check_window;
	307	g_free (wm_check_data);
	308	g_free (property_data);
	309	}
	310	gwmh_desk.detected_gnome_wm = gwmh_gnome_wm_win != None;
	311
	312	/* we ignore certain GWMH properties if there's no GNOME compliant wm
	313	* mostly, so we don't get fooled by stale properties
	314	*/
	315	if (!gwmh_gnome_wm_win)
	316	for (i = 0; i < N_GWMHA_IGNORE_ATOMS; i++)
	317	*gwmh_atoms[i].atom = None;
	318
	319	gwmh_syncs_frozen = 0;
	320	gwmh_sync ();
	321
	322	gdk_error_trap_pop ();
	323
	324	/* in case handlers are already setup, they need to know about wm changes,
	325	* and our new structure setup
	326	*/
	327	gwmh_desk_notify (GWMH_DESK_INFO_ALL \| GWMH_DESK_INFO_BOOTUP);
	328
	329	/* and recheck everything from queue handler */
	330	gwmh_desk_queue_update (GWMH_DESK_INFO_FORCE_EVERYTHING);
	331
	332	return gwmh_gnome_wm_win;
	333	}
	334
	335	static GdkWindow*
	336	gdk_window_ref_from_xid (Window xwin)
	337	{
	338	GdkWindow *window;
	339
	340	/* the xid maybe invalid already, in that case we return NULL */
	341	window = gdk_window_lookup (xwin);
	342	if (!window)
	343	window = gdk_window_foreign_new (xwin);
	344	else
	345	gdk_window_ref (window);
	346
	347	return window;
	348	}
	349
	350	static gpointer
	351	get_typed_property_data (Display *xdisplay,
	352	Window xwindow,
	353	Atom property,
	354	Atom requested_type,
	355	gint *size_p,
	356	guint expected_format)
	357	{
	358	static const guint prop_buffer_lengh = 1024 * 1024;
	359	unsigned char *prop_data = NULL;
	360	Atom type_returned = 0;
	361	unsigned long nitems_return = 0, bytes_after_return = 0;
	362	int format_returned = 0;
	363	gpointer data = NULL;
	364	gboolean abort = FALSE;
	365
	366	g_return_val_if_fail (size_p != NULL, NULL);
	367	*size_p = 0;
	368
	369	gdk_error_trap_push ();
	370
	371	abort = XGetWindowProperty (xdisplay,
	372	xwindow,
	373	property,
	374	0, prop_buffer_lengh,
	375	False,
	376	requested_type,
	377	&type_returned, &format_returned,
	378	&nitems_return,
	379	&bytes_after_return,
	380	&prop_data) != Success;
	381	if (gdk_error_trap_pop () \|\|
	382	type_returned == None)
	383	abort++;
	384	if (!abort &&
	385	requested_type != AnyPropertyType &&
	386	requested_type != type_returned)
	387	{
	388	/* aparently this can happen for some properties of broken apps, be silent */
	389	abort++;
	390	}
	391	if (!abort && bytes_after_return)
	392	{
	393	g_warning (G_GNUC_PRETTY_FUNCTION "(): Eeek, property has more than %u bytes, stored on harddisk?",
	394	prop_buffer_lengh);
	395	abort++;
	396	}
	397	if (!abort && expected_format && expected_format != format_returned)
	398	{
	399	g_warning (G_GNUC_PRETTY_FUNCTION "(): Expected format (%u) unmatched (%d), programmer was drunk?",
	400	expected_format, format_returned);
	401	abort++;
	402	}
	403	if (!abort && prop_data && nitems_return && format_returned)
	404	{
	405	switch (format_returned)
	406	{
	407	case 32:
	408	size_p = nitems_return 4;
	409	if (sizeof (gulong) == 8)
	410	{
	411	guint32 i, mem = g_malloc0 (size_p + 1);
	412	gulong prop_longs = (gulong) prop_data;
	413
	414	for (i = 0; i < *size_p / 4; i++)
	415	mem[i] = prop_longs[i];
	416	data = mem;
	417	}
	418	break;
	419	case 16:
	420	size_p = nitems_return 2;
	421	break;
	422	case 8:
	423	*size_p = nitems_return;
	424	break;
	425	default:
	426	g_warning ("Unknown property data format with %d bits (extraterrestrial?)",
	427	format_returned);
	428	break;
	429	}
	430	if (!data && *size_p)
	431	{
	432	guint8 *mem = NULL;
	433
	434	if (format_returned == 8 && type_returned == XA_COMPOUND_TEXT)
	435	{
	436	gchar **tlist = NULL;
	437	gint count = gdk_text_property_to_text_list (type_returned, 8, prop_data,
	438	nitems_return, &tlist);
	439
	440	if (count && tlist && tlist[0])
	441	{
	442	mem = (guint8 *)g_strdup (tlist[0]);
	443	size_p = strlen ((char )mem);
	444	}
	445	if (tlist)
	446	gdk_free_text_list (tlist);
	447	}
	448	if (!mem)
	449	{
	450	mem = g_malloc (*size_p + 1);
	451	memcpy (mem, prop_data, *size_p);
	452	mem[*size_p] = 0;
	453	}
	454	data = mem;
	455	}
	456	}
	457
	458	if (prop_data)
	459	XFree (prop_data);
	460
	461	return data;
	462	}
	463
	464	static gboolean
	465	wm_protocol_check_support (Window xwin,
	466	Atom check_atom)
	467	{
	468	Atom *pdata = NULL;
	469	guint32 *gdata = NULL;
	470	int n_pids = 0;
	471	gboolean is_supported = FALSE;
	472	guint i, n_gids = 0;
	473
	474	gdk_error_trap_push ();
	475
	476	if (!XGetWMProtocols (GDK_DISPLAY (),
	477	xwin,
	478	&pdata,
	479	&n_pids))
	480	{
	481	gint size = 0;
	482
	483	gdata = get_typed_property_data (GDK_DISPLAY (),
	484	xwin,
	485	XA_WM_PROTOCOLS,
	486	XA_WM_PROTOCOLS,
	487	&size, 32);
	488	n_gids = size / 4;
	489	}
	490
	491	gdk_error_trap_pop ();
	492
	493	for (i = 0; i < n_pids; i++)
	494	if (pdata[i] == check_atom)
	495	{
	496	is_supported = TRUE;
	497	break;
	498	}
	499	if (pdata)
	500	XFree (pdata);
	501	if (!is_supported)
	502	for (i = 0; i < n_gids; i++)
	503	if (gdata[i] == check_atom)
	504	{
	505	is_supported = TRUE;
	506	break;
	507	}
	508	g_free (gdata);
	509
	510	return is_supported;
	511	}
	512
	513	static gboolean
	514	send_client_message_2L (Window recipient,
	515	Window event_window,
	516	Atom message_type,
	517	long event_mask,
	518	glong long1,
	519	glong long2)
	520	{
	521	return send_client_message_5L (recipient, event_window, message_type, event_mask, long1, long2, 0, 0, 0);
	522	}
	523
	524	static gboolean
	525	send_client_message_3L (Window recipient,
	526	Window event_window,
	527	Atom message_type,
	528	long event_mask,
	529	glong long1,
	530	glong long2,
	531	glong long3)
	532	{
	533	return send_client_message_5L (recipient, event_window, message_type, event_mask, long1, long2, long3, 0, 0);
	534	}
	535
	536	static gboolean
	537	send_client_message_5L (Window recipient,
	538	Window event_window,
	539	Atom message_type,
	540	long event_mask,
	541	glong long1,
	542	glong long2,
	543	glong long3,
	544	glong long4,
	545	glong long5)
	546	{
	547	XEvent xevent = { 0, };
	548
	549	/* g_return_val_if_fail (n_longs < 6, FALSE); */
	550
	551	xevent.type = ClientMessage;
	552	xevent.xclient.window = event_window;
	553	xevent.xclient.message_type = message_type;
	554	xevent.xclient.format = 32;
	555	xevent.xclient.data.l[0] = long1;
	556	xevent.xclient.data.l[1] = long2;
	557	xevent.xclient.data.l[2] = long3;
	558	xevent.xclient.data.l[3] = long4;
	559	xevent.xclient.data.l[4] = long5;
	560
	561	gdk_error_trap_push ();
	562
	563	XSendEvent (GDK_DISPLAY (), recipient, False, event_mask, &xevent);
	564	gwmh_sync ();
	565
	566	return !gdk_error_trap_pop ();
	567	}
	568
	569	GdkWindow*
	570	gwmh_root_put_atom_window (const gchar *atom_name,
	571	GdkWindowType window_type,
	572	GdkWindowClass window_class,
	573	GdkEventMask event_mask)
	574	{
	575	GdkAtom atom;
	576	GdkWindow *window;
	577	GdkWindowAttr attributes;
	578	guint attributes_mask;
	579	Window xwin;
	580
	581	g_return_val_if_fail (atom_name != NULL, NULL);
	582
	583	atom = gdk_atom_intern (atom_name, FALSE);
	584	attributes.window_type = window_type;
	585	attributes.wclass = window_class;
	586	attributes.x = -99;
	587	attributes.y = -99;
	588	attributes.width = 1;
	589	attributes.height = 1;
	590	attributes.event_mask = event_mask;
	591	attributes_mask = GDK_WA_X \| GDK_WA_Y;
	592
	593	window = gdk_window_new (NULL, &attributes, attributes_mask);
	594	xwin = GDK_WINDOW_XWINDOW (window);
	595	gdk_property_change (GDK_ROOT_PARENT (),
	596	atom,
	597	XA_WINDOW, 32,
	598	GDK_PROP_MODE_REPLACE,
	599	(guchar*) &xwin, 1);
	600	gdk_property_change (window,
	601	atom,
	602	XA_WINDOW, 32,
	603	GDK_PROP_MODE_REPLACE,
	604	(guchar*) &xwin, 1);
	605
	606	return window;
	607	}
	608
	609	static void
	610	get_task_root_and_frame (GwmhTask *task)
	611	{
	612	Window *children = NULL, xframe = 0;
	613	Window xwin = task->xwin, xparent = xwin, xroot = xwin;
	614	guint size = 0;
	615
	616	gdk_error_trap_push ();
	617
	618	while (XQueryTree (GDK_DISPLAY (), xwin, &xroot, &xparent, &children, &size))
	619	{
	620	guint32 *value;
	621
	622	if (children)
	623	{
	624	XFree (children);
	625	children = NULL;
	626	}
	627
	628	xframe = xwin;
	629	xwin = xparent;
	630	if (xparent == xroot)
	631	break;
	632
	633	value = get_typed_property_data (GDK_DISPLAY (),
	634	xparent,
	635	XA_ENLIGHTENMENT_DESKTOP,
	636	XA_CARDINAL,
	637	&size, 0);
	638	if (value)
	639	{
	640	g_free (value);
	641	break;
	642	}
	643	}
	644
	645	if (gdk_error_trap_pop ())
	646	{
	647	xparent = None;
	648	xframe = None;
	649	/* aparently this can happen if a window is destructed shortly after
	650	* creation, just be silent.
	651	* g_warning (G_GNUC_PRETTY_FUNCTION "(): task window id %ld invalid?", task->xwin);
	652	*/
	653	}
	654
	655	if (!task->sroot \|\| GSTC_PARENT_XWINDOW (task->sroot) != xparent)
	656	{
	657	GdkWindow *window;
	658
	659	if (task->sroot)
	660	{
	661	gstc_parent_delete_watch (task->sroot);
	662	task->sroot = NULL;
	663	}
	664
	665	if (xparent)
	666	{
	667	window = gdk_window_ref_from_xid (xparent);
	668	if (window)
	669	{
	670	task->sroot = gstc_parent_add_watch (window);
	671	gdk_window_unref (window);
	672	}
	673	}
	674	}
	675
	676	if (task->xframe != xframe)
	677	{
	678	if (task->gdkframe)
	679	{
	680	gdk_window_remove_filter (task->gdkframe, task_event_monitor_frame_wrapper, task);
	681	gdk_window_unref (task->gdkframe);
	682	task->gdkframe = NULL;
	683	}
	684
	685	task->xframe = xframe;
	686	if (xframe)
	687	{
	688	XWindowAttributes attribs = { 0, };
	689
	690	task->gdkframe = gdk_window_ref_from_xid (task->xframe);
	691	if (task->gdkframe)
	692	{
	693	gdk_window_add_filter (task->gdkframe, task_event_monitor_frame_wrapper, task);
	694
	695	/* select events */
	696	gdk_error_trap_push ();
	697	XGetWindowAttributes (GDK_DISPLAY (),
	698	task->xframe,
	699	&attribs);
	700	XSelectInput (GDK_DISPLAY (),
	701	task->xframe,
	702	attribs.your_event_mask \|
	703	StructureNotifyMask);
	704	gwmh_sync ();
	705	gdk_error_trap_pop ();
	706	}
	707	}
	708	}
	709	}
	710
	711	static GdkFilterReturn
	712	root_event_monitor (GdkXEvent *gdk_xevent,
	713	GdkEvent *event,
	714	gpointer gdk_root)
	715	{
	716	XEvent *xevent = gdk_xevent;
	717
	718	switch (xevent->type)
	719	{
	720	GwmhDeskInfoMask imask;
	721
	722	case MapNotify:
	723	case UnmapNotify:
	724	case CirculateNotify:
	725	case ReparentNotify:
	726	case DestroyNotify:
	727	if (!gwmh_gnome_wm_win)
	728	gwmh_desk_queue_update (GWMH_DESK_INFO_CLIENT_LIST);
	729	if (gwmh_gnome_wm_win == xevent->xdestroywindow.window)
	730	{
	731	gwmh_need_reboot = TRUE;
	732	gwmh_desk_queue_update (GWMH_DESK_INFO_FORCE_EVERYTHING);
	733	}
	734	break;
	735	case PropertyNotify:
	736	imask = gwmh_property_atom2info (xevent->xproperty.atom, FALSE);
	737	if (imask)
	738	gwmh_desk_queue_update (imask);
	739	if (xevent->xproperty.atom == GWMHA_WIN_SUPPORTING_WM_CHECK)
	740	{
	741	gwmh_need_reboot = TRUE;
	742	gwmh_desk_queue_update (GWMH_DESK_INFO_FORCE_EVERYTHING);
	743	}
	744	break;
	745	default:
	746	break;
	747	}
	748
	749	return GDK_FILTER_CONTINUE;
	750	}
	751
	752	static GdkFilterReturn
	753	task_event_monitor_frame_wrapper (GdkXEvent *gdk_xevent,
	754	GdkEvent *event,
	755	gpointer task_pointer)
	756	{
	757	return task_event_monitor (gdk_xevent, event, task_pointer);
	758	}
	759
	760	static GdkFilterReturn
	761	task_event_monitor (GdkXEvent *gdk_xevent,
	762	GdkEvent *event,
	763	gpointer task_pointer)
	764	{
	765	GwmhTask *task = task_pointer;
	766	XEvent *xevent = gdk_xevent;
	767	GwmhTaskInfoMask imask = 0;
	768	GwmhTaskInfoMask ichanges = 0;
	769
	770	switch (xevent->type)
	771	{
	772	case ConfigureNotify:
	773	if (xevent->xconfigure.window == task->xwin)
	774	{
	775	task->win_x = xevent->xconfigure.x;
	776	task->win_y = xevent->xconfigure.y;
	777	task->win_width = xevent->xconfigure.width;
	778	task->win_height = xevent->xconfigure.height;
	779	ichanges \|= GWMH_TASK_INFO_WIN_GEO;
	780	}
	781	else if (xevent->xconfigure.window == task->xframe &&
	782	!xevent->xconfigure.send_event /* fvwm sends bogus sent_event configures */)
	783	{
	784	task->frame_x = xevent->xconfigure.x;
	785	task->frame_y = xevent->xconfigure.y;
	786	task->frame_width = xevent->xconfigure.width;
	787	task->frame_height = xevent->xconfigure.height;
	788	ichanges \|= GWMH_TASK_INFO_FRAME_GEO;
	789	}
	790	break;
	791	case PropertyNotify:
	792	imask = gwmh_property_atom2info (xevent->xproperty.atom, TRUE);
	793	break;
	794	case ReparentNotify:
	795	/* refetch frame and root window */
	796	imask = GWMH_TASK_INFO_DESKTOP \| GWMH_TASK_INFO_AREA;
	797	/* fall through */
	798	case MapNotify:
	799	case UnmapNotify:
	800	case CirculateNotify:
	801	case DestroyNotify:
	802	if (!gwmh_gnome_wm_win)
	803	{
	804	imask = GWMH_TASK_INFO_ALL;
	805	gwmh_desk_queue_update (GWMH_DESK_INFO_CLIENT_LIST);
	806	}
	807	if (GWMH_TASK_FOCUSED (task) && (xevent->type == UnmapNotify \|\|
	808	xevent->type == DestroyNotify))
	809	{
	810	task->focused = FALSE;
	811	ichanges \|= GWMH_TASK_INFO_FOCUSED;
	812	}
	813	break;
	814	case FocusOut:
	815	if (GWMH_TASK_FOCUSED (task) && (xevent->xfocus.detail != NotifyPointer &&
	816	xevent->xfocus.detail != NotifyInferior))
	817	{
	818	task->focused = FALSE;
	819	ichanges \|= GWMH_TASK_INFO_FOCUSED;
	820	}
	821	break;
	822	case FocusIn:
	823	if (!GWMH_TASK_FOCUSED (task))
	824	{
	825	task->focused = TRUE;
	826	ichanges \|= GWMH_TASK_INFO_FOCUSED;
	827	}
	828	break;
	829	default:
	830	break;
	831	}
	832
	833	if (!gwmh_gnome_wm_win && (ichanges \|\| imask))
	834	imask = GWMH_TASK_INFO_ALL;
	835
	836	if (imask \|\| ichanges)
	837	gwmh_task_queue_full (task, imask, ichanges);
	838
	839	return GDK_FILTER_CONTINUE;
	840	}
	841
	842	static guint
	843	gwmh_property_atom2info (Atom atom,
	844	gboolean per_task)
	845	{
	846	static const Atom gwmh_XA_WM_HINTS = XA_WM_HINTS;
	847	static const Atom gwmh_XA_WM_NAME = XA_WM_NAME;
	848	static const Atom gwmh_XA_WM_ICON_NAME = XA_WM_ICON_NAME;
	849
	850	static const struct {
	851	const Atom *atom_p;
	852	guint iflag;
	853	} desk_atom_masks[] = {
	854	/* GwmhDeskInfoMask */
	855	{ &GWMHA_WIN_CLIENT_LIST, GWMH_DESK_INFO_CLIENT_LIST, },
	856	{ &GWMHA_WIN_AREA, GWMH_DESK_INFO_CURRENT_AREA, },
	857	{ &GWMHA_WIN_AREA_COUNT, GWMH_DESK_INFO_N_AREAS, },
	858	{ &GWMHA_WIN_WORKSPACE, GWMH_DESK_INFO_CURRENT_DESKTOP, },
	859	{ &GWMHA_WIN_WORKSPACE_NAMES, GWMH_DESK_INFO_DESKTOP_NAMES, },
	860	{ &GWMHA_WIN_WORKSPACE_COUNT, GWMH_DESK_INFO_N_DESKTOPS, },
	861	{ &GWMHA_WIN_UNIFIED_AREA, GWMH_DESK_INFO_N_AREAS, },
	862	}, task_atom_masks[] = {
	863	/* GwmhTaskInfoMask */
	864	{ &GWMHA_WIN_APP_STATE, GWMH_TASK_INFO_APP_STATE, },
	865	{ &GWMHA_WIN_STATE, GWMH_TASK_INFO_GSTATE, },
	866	{ &GWMHA_WIN_HINTS, GWMH_TASK_INFO_GHINTS, },
	867	{ &GWMHA_WIN_LAYER, GWMH_TASK_INFO_LAYER, },
	868	{ &GWMHA_WIN_AREA, GWMH_TASK_INFO_AREA, },
	869	{ &GWMHA_WIN_WORKSPACE, GWMH_TASK_INFO_DESKTOP, },
	870	{ &XA_WM_STATE, GWMH_TASK_INFO_ICONIFIED, },
	871	{ &gwmh_XA_WM_HINTS, GWMH_TASK_INFO_WM_HINTS, },
	872	{ &gwmh_XA_WM_NAME, GWMH_TASK_INFO_MISC, },
	873	{ &gwmh_XA_WM_ICON_NAME, GWMH_TASK_INFO_MISC, },
	874	};
	875	guint i;
	876
	877	if (per_task)
	878	{
	879	for (i = 0; i < sizeof (task_atom_masks) / sizeof (task_atom_masks[0]); i++)
	880	if (*task_atom_masks[i].atom_p == atom)
	881	return task_atom_masks[i].iflag;
	882	}
	883	else
	884	{
	885	for (i = 0; i < sizeof (desk_atom_masks) / sizeof (desk_atom_masks[0]); i++)
	886	if (*desk_atom_masks[i].atom_p == atom)
	887	return desk_atom_masks[i].iflag;
	888	}
	889
	890	return 0;
	891	}
	892
	893	static void
	894	gwmh_desk_update (GwmhDeskInfoMask imask)
	895	{
	896	GdkWindow *window = GDK_ROOT_PARENT ();
	897	Display *xdisplay = GDK_WINDOW_XDISPLAY (window);
	898	Window xwindow = GDK_WINDOW_XWINDOW (window);
	899	GwmhDeskInfoMask ichanges = 0;
	900	gboolean force_everything = FALSE;
	901
	902	gdk_error_trap_push ();
	903
	904	if (imask & GWMH_DESK_INFO_N_DESKTOPS)
	905	{
	906	gint size = 0;
	907	guint32 *n_data;
	908	guint n_desktops;
	909
	910	n_data = get_typed_property_data (xdisplay, xwindow,
	911	GWMHA_WIN_WORKSPACE_COUNT,
	912	XA_CARDINAL,
	913	&size, 32);
	914	n_desktops = MAX (1, n_data ? n_data[0] : 0);
	915	g_free (n_data);
	916	if (n_desktops != gwmh_desk.n_desktops)
	917	{
	918	guint i, old_n = gwmh_desk.n_desktops;
	919
	920	gwmh_desk.n_desktops = n_desktops;
	921	ichanges \|= GWMH_DESK_INFO_N_DESKTOPS;
	922
	923	for (i = gwmh_desk.n_desktops; i < old_n; i++)
	924	g_free (gwmh_desk.desktop_names[i]);
	925	gwmh_desk.desktop_names = g_renew (gchar*,
	926	gwmh_desk.desktop_names,
	927	gwmh_desk.n_desktops);
	928	gwmh_harea_cache = g_renew (guint,
	929	gwmh_harea_cache,
	930	gwmh_desk.n_desktops);
	931	gwmh_varea_cache = g_renew (guint,
	932	gwmh_varea_cache,
	933	gwmh_desk.n_desktops);
	934	for (i = old_n; i < gwmh_desk.n_desktops; i++)
	935	{
	936	gwmh_desk.desktop_names[i] = NULL;
	937	gwmh_harea_cache[i] = 0;
	938	gwmh_varea_cache[i] = 0;
	939	}
	940	if (old_n < gwmh_desk.n_desktops)
	941	imask \|= GWMH_DESK_INFO_DESKTOP_NAMES;
	942	}
	943	imask \|= GWMH_DESK_INFO_CURRENT_DESKTOP;
	944	}
	945
	946	if (imask & GWMH_DESK_INFO_N_AREAS)
	947	{
	948	gint size = 0;
	949	guint32 *size_data;
	950	guint n_hareas, n_vareas;
	951
	952	/* FIXME: this should be a property check for UNIFIED_AREA */
	953	if (gwmh_hack_think_unified_area != gwmh_desk.unified_area)
	954	{
	955	ichanges \|= GWMH_DESK_INFO_CURRENT_AREA \| GWMH_DESK_INFO_N_AREAS;
	956	gwmh_desk.unified_area = gwmh_hack_think_unified_area;
	957	}
	958
	959	size_data = get_typed_property_data (xdisplay, xwindow,
	960	GWMHA_WIN_AREA_COUNT,
	961	XA_CARDINAL,
	962	&size, 32);
	963	n_hareas = MAX (1, size_data ? size_data[0] : 0);
	964	n_vareas = MAX (1, size_data ? size_data[1] : 0);
	965	g_free (size_data);
	966	if (n_hareas != gwmh_desk.n_hareas \|\|
	967	n_vareas != gwmh_desk.n_vareas)
	968	{
	969	guint i;
	970
	971	gwmh_desk.n_hareas = n_hareas;
	972	gwmh_desk.n_vareas = n_vareas;
	973	ichanges \|= GWMH_DESK_INFO_N_AREAS;
	974
	975	for (i = 0; i < gwmh_desk.n_desktops; i++)
	976	{
	977	gwmh_harea_cache[i] = MIN (gwmh_harea_cache[i], gwmh_desk.n_hareas - 1);
	978	gwmh_varea_cache[i] = MIN (gwmh_varea_cache[i], gwmh_desk.n_vareas - 1);
	979	}
	980	}
	981	imask \|= GWMH_DESK_INFO_CURRENT_AREA;
	982	}
	983
	984	if (imask & GWMH_DESK_INFO_DESKTOP_NAMES)
	985	{
	986	XTextProperty text_property = { 0, };
	987	guint i = 0;
	988
	989	if (XGetTextProperty (xdisplay, xwindow,
	990	&text_property,
	991	GWMHA_WIN_WORKSPACE_NAMES))
	992	{
	993	gchar **property_strings = NULL;
	994	int n_strings = 0;
	995
	996	if (XTextPropertyToStringList (&text_property,
	997	&property_strings,
	998	&n_strings))
	999	{
	1000
	1001	for (; i < MIN (n_strings, gwmh_desk.n_desktops); i++)
	1002	{
	1003	if (!gwmh_string_equals (gwmh_desk.desktop_names[i],
	1004	property_strings[i]))
	1005	{
	1006	g_free (gwmh_desk.desktop_names[i]);
	1007	gwmh_desk.desktop_names[i] = g_strdup (property_strings[i]);
	1008	ichanges \|= GWMH_DESK_INFO_DESKTOP_NAMES;
	1009	}
	1010	}
	1011
	1012	if (property_strings)
	1013	XFreeStringList (property_strings);
	1014	}
	1015
	1016	if (text_property.value)
	1017	XFree (text_property.value);
	1018	}
	1019
	1020	for (; i < gwmh_desk.n_desktops; i++)
	1021	if (gwmh_desk.desktop_names[i])
	1022	{
	1023	g_free (gwmh_desk.desktop_names[i]);
	1024	gwmh_desk.desktop_names[i] = NULL;
	1025	ichanges \|= GWMH_DESK_INFO_DESKTOP_NAMES;
	1026	}
	1027	}
	1028
	1029	if (imask & GWMH_DESK_INFO_CURRENT_DESKTOP)
	1030	{
	1031	gint size = 0;
	1032	guint32 *indx;
	1033	guint current_desktop;
	1034
	1035	indx = get_typed_property_data (xdisplay, xwindow,
	1036	GWMHA_WIN_WORKSPACE,
	1037	XA_CARDINAL,
	1038	&size, 32);
	1039	current_desktop = MIN (indx ? indx[0] : 0, gwmh_desk.n_desktops - 1);
	1040	g_free (indx);
	1041	if (current_desktop != gwmh_desk.current_desktop)
	1042	{
	1043	gwmh_desk.current_desktop = current_desktop;
	1044	ichanges \|= GWMH_DESK_INFO_CURRENT_DESKTOP;
	1045	}
	1046	imask \|= GWMH_DESK_INFO_CURRENT_AREA;
	1047	}
	1048
	1049	if (imask & GWMH_DESK_INFO_CURRENT_AREA)
	1050	{
	1051	gint size = 0;
	1052	guint32 *indx_data;
	1053	guint i, harea, varea;
	1054
	1055	indx_data = get_typed_property_data (xdisplay, xwindow,
	1056	GWMHA_WIN_AREA,
	1057	XA_CARDINAL,
	1058	&size, 32);
	1059	harea = MIN (indx_data ? indx_data[0] : 0, gwmh_desk.n_hareas - 1);
	1060	varea = MIN (indx_data ? indx_data[1] : 0, gwmh_desk.n_vareas - 1);
	1061	g_free (indx_data);
	1062	if (harea != gwmh_desk.current_harea \|\|
	1063	varea != gwmh_desk.current_varea)
	1064	{
	1065	gwmh_desk.current_harea = harea;
	1066	gwmh_desk.current_varea = varea;
	1067	ichanges \|= GWMH_DESK_INFO_CURRENT_AREA;
	1068	}
	1069	if (gwmh_harea_cache[gwmh_desk.current_desktop] != gwmh_desk.current_harea \|\|
	1070	gwmh_varea_cache[gwmh_desk.current_desktop] != gwmh_desk.current_varea)
	1071	{
	1072	gwmh_harea_cache[gwmh_desk.current_desktop] = gwmh_desk.current_harea;
	1073	gwmh_varea_cache[gwmh_desk.current_desktop] = gwmh_desk.current_varea;
	1074	ichanges \|= GWMH_DESK_INFO_CURRENT_AREA;
	1075	}
	1076	if (gwmh_desk.unified_area && (ichanges & GWMH_DESK_INFO_CURRENT_AREA))
	1077	for (i = 0; i < gwmh_desk.n_desktops; i++)
	1078	{
	1079	gwmh_harea_cache[i] = gwmh_desk.current_harea;
	1080	gwmh_varea_cache[i] = gwmh_desk.current_varea;
	1081	}
	1082	}
	1083
	1084	if (imask & GWMH_DESK_INFO_CLIENT_LIST)
	1085	{
	1086	guint n_tasks = 0;
	1087	gint size = 0;
	1088	guint32 *task_ids;
	1089
	1090	if (!gwmh_gnome_wm_win)
	1091	task_ids = hack_a_client_list (xdisplay, xwindow, &n_tasks);
	1092	else
	1093	{
	1094	task_ids = get_typed_property_data (xdisplay, xwindow,
	1095	GWMHA_WIN_CLIENT_LIST,
	1096	XA_CARDINAL,
	1097	&size, 32);
	1098	n_tasks = size / 4;
	1099	}
	1100	if (client_list_sync (task_ids, n_tasks))
	1101	ichanges \|= GWMH_DESK_INFO_CLIENT_LIST;
	1102	g_free (task_ids);
	1103	}
	1104
	1105	gdk_error_trap_pop ();
	1106
	1107	force_everything = (imask & GWMH_DESK_INFO_HACK_FLAG) != 0;
	1108
	1109	gwmh_desk_update_queued &= ~imask;
	1110
	1111	if ((ichanges & (GWMH_DESK_INFO_CURRENT_DESKTOP \|
	1112	GWMH_DESK_INFO_CURRENT_AREA)) \|\|
	1113	force_everything)
	1114	{
	1115	GList *node;
	1116
	1117	for (node = gwmh_desk.client_list; node; node = node->next)
	1118	{
	1119	GwmhTask *task = node->data;
	1120
	1121	if (force_everything)
	1122	gwmh_task_queue_update (task, GWMH_TASK_INFO_ALL);
	1123	else if (GWMH_TASK_STICKY (task))
	1124	gwmh_task_queue_update (task, (GWMH_TASK_INFO_DESKTOP \|
	1125	GWMH_TASK_INFO_AREA));
	1126	}
	1127	}
	1128
	1129	if (force_everything)
	1130	gwmh_desk_notify (GWMH_DESK_INFO_ALL);
	1131	else if (ichanges)
	1132	gwmh_desk_notify (ichanges);
	1133	}
	1134
	1135	static gboolean
	1136	gwmh_task_update (GwmhTask *task,
	1137	GwmhTaskInfoMask imask,
	1138	gboolean skip_notify)
	1139	{
	1140	Display *xdisplay = GDK_WINDOW_XDISPLAY (task->gdkwindow);
	1141	Window xwindow = task->xwin;
	1142	gint size;
	1143	GwmhTaskInfoMask ichanges = 0;
	1144	GwmhDeskInfoMask desk_imask_queued;
	1145	gboolean was_queued;
	1146
	1147	desk_imask_queued = gwmh_desk_update_queued & (GWMH_DESK_INFO_N_DESKTOPS \|
	1148	GWMH_DESK_INFO_N_AREAS \|
	1149	GWMH_DESK_INFO_CURRENT_DESKTOP \|
	1150	GWMH_DESK_INFO_CURRENT_AREA \|
	1151	GWMH_DESK_INFO_HACK_FLAG);
	1152	if (desk_imask_queued)
	1153	gwmh_desk_update (desk_imask_queued);
	1154
	1155	gdk_error_trap_push ();
	1156
	1157	if (imask & GWMH_TASK_INFO_GSTATE)
	1158	{
	1159	guint32 *flags;
	1160	GwmhState gstate;
	1161	gboolean was_sticky = GWMH_TASK_STICKY (task);
	1162
	1163	flags = get_typed_property_data (xdisplay, xwindow,
	1164	GWMHA_WIN_STATE,
	1165	XA_CARDINAL,
	1166	&size, 32);
	1167	gstate = flags ? flags[0] : 0;
	1168	g_free (flags);
	1169	if (task->gstate != gstate)
	1170	{
	1171	task->gstate = gstate;
	1172	ichanges \|= GWMH_TASK_INFO_GSTATE;
	1173	}
	1174	if (was_sticky != GWMH_TASK_STICKY (task))
	1175	imask \|= GWMH_TASK_INFO_DESKTOP \| GWMH_TASK_INFO_AREA;
	1176	}
	1177
	1178	/* we need to feature this right at the beginning,
	1179	* to complete the task_new () process
	1180	*/
	1181	if (imask & (GWMH_TASK_INFO_DESKTOP \| GWMH_TASK_INFO_AREA))
	1182	{
	1183	Window xroot = task->sroot ? GSTC_PARENT_XWINDOW (task->sroot) : 0;
	1184	Window xframe = task->xframe;
	1185
	1186	get_task_root_and_frame (task);
	1187	if (!task->xframe \|\| !task->sroot)
	1188	{
	1189	/* eek, that's ugly, we need to get rid of this task as
	1190	* soon as possible, but not right here.
	1191	*/
	1192	gwmh_desk_queue_update (GWMH_DESK_INFO_CLIENT_LIST);
	1193	return FALSE;
	1194	}
	1195	if (task->xframe != xframe \|\|
	1196	(task->sroot ? GSTC_PARENT_XWINDOW (task->sroot) : 0) != !xroot)
	1197	imask \|= (GWMH_TASK_INFO_DESKTOP \|
	1198	GWMH_TASK_INFO_AREA \|
	1199	(task->xframe != xframe ? GWMH_TASK_INFO_FRAME_GEO : 0));
	1200	}
	1201
	1202	if (imask & GWMH_TASK_INFO_MISC)
	1203	{
	1204	gchar *name;
	1205
	1206	name = get_typed_property_data (xdisplay, xwindow,
	1207	XA_WM_NAME,
	1208	XA_STRING,
	1209	&size, 8);
	1210	if (!name && !size)
	1211	name = get_typed_property_data (xdisplay, xwindow,
	1212	XA_WM_NAME,
	1213	XA_COMPOUND_TEXT,
	1214	&size, 8);
	1215	if (!gwmh_string_equals (task->name, name))
	1216	{
	1217	g_free (task->name);
	1218	task->name = g_strdup (name);
	1219	ichanges \|= GWMH_TASK_INFO_MISC;
	1220	}
	1221	g_free (name);
	1222
	1223	name = get_typed_property_data (xdisplay, xwindow,
	1224	XA_WM_ICON_NAME,
	1225	XA_STRING,
	1226	&size, 8);
	1227	if (!name && !size)
	1228	name = get_typed_property_data (xdisplay, xwindow,
	1229	XA_WM_ICON_NAME,
	1230	XA_COMPOUND_TEXT,
	1231	&size, 8);
	1232	if (!gwmh_string_equals (task->icon_name, name))
	1233	{
	1234	g_free (task->icon_name);
	1235	task->icon_name = g_strdup (name);
	1236	ichanges \|= GWMH_TASK_INFO_MISC;
	1237	}
	1238	g_free (name);
	1239	}
	1240
	1241	if (imask & GWMH_TASK_INFO_FOCUSED)
	1242	{
	1243	Window focus;
	1244	int revert_to;
	1245	gboolean focused;
	1246
	1247	XGetInputFocus (xdisplay, &focus, &revert_to);
	1248	focused = task->xwin == focus;
	1249	if (focused != GWMH_TASK_FOCUSED (task))
	1250	{
	1251	if (task->focused)
	1252	g_message ("%ssetting focus according to XGetInputFocus() for %ld",
	1253	!focused ? "re" : "",
	1254	task->xwin);
	1255	task->focused = focused;
	1256	ichanges \|= GWMH_TASK_INFO_FOCUSED;
	1257	}
	1258	}
	1259
	1260	if (imask & GWMH_TASK_INFO_ICONIFIED)
	1261	{
	1262	gint32 *state;
	1263	gboolean iconified;
	1264
	1265	state = get_typed_property_data (xdisplay, xwindow,
	1266	XA_WM_STATE,
	1267	XA_WM_STATE,
	1268	&size, 32);
	1269	iconified = state && state[0] == IconicState;
	1270	g_free (state);
	1271	if (iconified != task->iconified)
	1272	{
	1273	task->iconified = iconified;
	1274	ichanges \|= GWMH_TASK_INFO_ICONIFIED;
	1275	}
	1276	}
	1277
	1278	if (imask & GWMH_TASK_INFO_GHINTS)
	1279	{
	1280	guint32 *ghint_data;
	1281	GwmhHints ghints;
	1282
	1283	ghint_data = get_typed_property_data (xdisplay, xwindow,
	1284	GWMHA_WIN_HINTS,
	1285	XA_CARDINAL,
	1286	&size, 32);
	1287	ghints = ghint_data ? ghint_data[0] : 0;
	1288	g_free (ghint_data);
	1289	if (task->ghints != ghints)
	1290	{
	1291	task->ghints = ghints;
	1292	ichanges \|= GWMH_TASK_INFO_GHINTS;
	1293	}
	1294	}
	1295
	1296	if (imask & GWMH_TASK_INFO_APP_STATE)
	1297	{
	1298	guint32 *state_data;
	1299	GnomeWinAppState app_state;
	1300
	1301	state_data = get_typed_property_data (xdisplay, xwindow,
	1302	GWMHA_WIN_APP_STATE,
	1303	XA_CARDINAL,
	1304	&size, 32);
	1305	app_state = state_data ? state_data[0] : 0;
	1306	g_free (state_data);
	1307	if (app_state != task->app_state)
	1308	{
	1309	task->app_state = app_state;
	1310	ichanges \|= GWMH_TASK_INFO_APP_STATE;
	1311	}
	1312	}
	1313
	1314	if (imask & GWMH_TASK_INFO_DESKTOP)
	1315	{
	1316	guint desktop;
	1317
	1318	if (!GWMH_TASK_STICKY (task))
	1319	{
	1320	guint32 *indx = get_typed_property_data (xdisplay, xwindow,
	1321	GWMHA_WIN_WORKSPACE,
	1322	XA_CARDINAL,
	1323	&size, 32);
	1324	desktop = MIN (indx ? indx[0] : 0, gwmh_desk.n_desktops - 1);
	1325	g_free (indx);
	1326	}
	1327	else
	1328	desktop = gwmh_desk.current_desktop;
	1329	if (desktop != task->desktop)
	1330	{
	1331	task->last_desktop = task->desktop;
	1332	task->desktop = desktop;
	1333	ichanges \|= GWMH_TASK_INFO_DESKTOP;
	1334	}
	1335	}
	1336
	1337	if (imask & GWMH_TASK_INFO_AREA)
	1338	{
	1339	guint harea, varea;
	1340
	1341	if (!GWMH_TASK_STICKY (task))
	1342	{
	1343	guint32 *coords = get_typed_property_data (xdisplay, xwindow,
	1344	GWMHA_WIN_AREA,
	1345	XA_CARDINAL,
	1346	&size, 32);
	1347	harea = MIN (coords ? coords[0] : 0, gwmh_desk.n_hareas - 1);
	1348	varea = MIN (coords ? coords[1] : 0, gwmh_desk.n_vareas - 1);
	1349	g_free (coords);
	1350	}
	1351	else
	1352	{
	1353	harea = gwmh_desk.current_harea;
	1354	varea = gwmh_desk.current_varea;
	1355	}
	1356	if (task->harea != harea \|\| task->varea != varea)
	1357	{
	1358	task->last_harea = task->harea;
	1359	task->last_varea = task->varea;
	1360	task->harea = harea;
	1361	task->varea = varea;
	1362	ichanges \|= GWMH_TASK_INFO_AREA;
	1363	imask \|= GWMH_TASK_INFO_ALLOCATION;
	1364	}
	1365	}
	1366
	1367	if (imask & GWMH_TASK_INFO_LAYER)
	1368	{
	1369	guint32 *layer_data;
	1370	guint layer;
	1371
	1372	layer_data = get_typed_property_data (xdisplay, xwindow,
	1373	GWMHA_WIN_LAYER,
	1374	XA_CARDINAL,
	1375	&size, 32);
	1376	layer = layer_data ? layer_data[0] : 0;
	1377	g_free (layer_data);
	1378	if (layer != task->layer)
	1379	{
	1380	task->last_layer = task->layer;
	1381	task->layer = layer;
	1382	ichanges \|= GWMH_TASK_INFO_LAYER;
	1383	}
	1384	}
	1385
	1386	if (imask & GWMH_TASK_INFO_ALLOCATION)
	1387	{
	1388	Window dummy_win;
	1389	gint x = 0, y = 0;
	1390	guint border, depth, width = 0, height = 0;
	1391
	1392	if (imask & GWMH_TASK_INFO_FRAME_GEO)
	1393	{
	1394	XGetGeometry (xdisplay, task->xframe,
	1395	&dummy_win,
	1396	&x, &y,
	1397	&width, &height,
	1398	&border, &depth);
	1399	XTranslateCoordinates (xdisplay, task->xframe,
	1400	TASK_XROOT (task),
	1401	0, 0,
	1402	&x, &y,
	1403	&dummy_win);
	1404	if (task->frame_x != x \|\| task->frame_y != y \|\|
	1405	task->frame_width != width \|\| task->frame_height != height)
	1406	{
	1407	task->frame_x = x;
	1408	task->frame_y = y;
	1409	task->frame_width = width;
	1410	task->frame_height = height;
	1411	ichanges \|= GWMH_TASK_INFO_FRAME_GEO;
	1412	}
	1413	}
	1414	if (imask & GWMH_TASK_INFO_WIN_GEO)
	1415	{
	1416	x = 0;
	1417	y = 0;
	1418	width = 0;
	1419	height = 0;
	1420	XGetGeometry (xdisplay, task->xwin,
	1421	&dummy_win,
	1422	&x, &y,
	1423	&width, &height,
	1424	&border, &depth);
	1425	XTranslateCoordinates (xdisplay, task->xwin,
	1426	TASK_XROOT (task),
	1427	0, 0,
	1428	&x, &y,
	1429	&dummy_win);
	1430	if (task->win_x != x \|\| task->win_y != y \|\|
	1431	task->win_width != width \|\| task->win_height != height)
	1432	{
	1433	task->win_x = x;
	1434	task->win_y = y;
	1435	task->win_width = width;
	1436	task->win_height = height;
	1437	ichanges \|= GWMH_TASK_INFO_WIN_GEO;
	1438	}
	1439	}
	1440	}
	1441
	1442	if (imask & GWMH_TASK_INFO_UNOTIFY)
	1443	{
	1444	ichanges \|= imask & GWMH_TASK_INFO_UNOTIFY;
	1445	}
	1446
	1447	gdk_error_trap_pop ();
	1448
	1449	#if 0
	1450	if (GWMH_TASK_STICKY (task))
	1451	g_print ("sticky window %ld (%d:%d,%d) has frame %ld at %d, %d, %d, %d\n",
	1452	task->xwin,
	1453	task->desktop, task->harea, task->varea,
	1454	task->xframe,
	1455	task->frame_x, task->frame_y,
	1456	task->frame_width, task->frame_height);
	1457	#endif
	1458
	1459	was_queued = GWMH_TASK_UPDATE_QUEUED (task);
	1460	task->imask_queued &= ~imask;
	1461	if (skip_notify)
	1462	task->imask_notify \|= ichanges;
	1463	else
	1464	{
	1465	ichanges \|= task->imask_notify;
	1466	task->imask_notify = 0;
	1467	}
	1468
	1469	if (was_queued && !GWMH_TASK_UPDATE_QUEUED (task))
	1470	gwmh_task_update_queue = g_slist_remove (gwmh_task_update_queue, task);
	1471
	1472	if (!skip_notify && ichanges)
	1473	gwmh_task_notify (task, GWMH_NOTIFY_INFO_CHANGED, ichanges);
	1474
	1475	return TRUE;
	1476	}
	1477
	1478	static gboolean
	1479	gwmh_idle_handler (gpointer data)
	1480	{
	1481	if (gwmh_need_reboot)
	1482	{
	1483	gwmh_need_reboot = FALSE;
	1484	gwmh_idle_handler_id = 0;
	1485	gwmh_init ();
	1486	return FALSE;
	1487	}
	1488
	1489	if (gwmh_desk_update_queued)
	1490	gwmh_desk_update (gwmh_desk_update_queued);
	1491
	1492	while (gwmh_task_update_queue)
	1493	{
	1494	GSList *node = gwmh_task_update_queue;
	1495	GwmhTask *task = node->data;
	1496	GwmhTaskInfoMask imask = task->imask_queued;
	1497
	1498	gwmh_task_update_queue = node->next;
	1499	g_slist_free_1 (node);
	1500
	1501	task->imask_queued = 0;
	1502	gwmh_task_update (task, imask, FALSE);
	1503	}
	1504
	1505	gwmh_idle_handler_id = 0;
	1506
	1507	if (gwmh_desk_update_queued)
	1508	gwmh_desk_update (gwmh_desk_update_queued);
	1509
	1510	return FALSE;
	1511	}
	1512
	1513	void
	1514	gwmh_desk_queue_update (GwmhDeskInfoMask imask)
	1515	{
	1516	gwmh_task_queue_full (NULL, 0, 0);
	1517
	1518	gwmh_desk_update_queued \|= imask;
	1519	}
	1520
	1521	static void
	1522	gwmh_task_queue_full (GwmhTask *task,
	1523	GwmhTaskInfoMask imask,
	1524	GwmhTaskInfoMask notify_mask)
	1525	{
	1526	if (!gwmh_idle_handler_id)
	1527	gwmh_idle_handler_id = gtk_idle_add_priority (GWMH_PRIORITY_UPDATE,
	1528	gwmh_idle_handler,
	1529	NULL);
	1530	if (task)
	1531	{
	1532	gboolean was_queued = GWMH_TASK_UPDATE_QUEUED (task);
	1533
	1534	task->imask_queued \|= imask;
	1535	task->imask_notify \|= notify_mask;
	1536
	1537	if (!was_queued && GWMH_TASK_UPDATE_QUEUED (task))
	1538	gwmh_task_update_queue = g_slist_prepend (gwmh_task_update_queue, task);
	1539	}
	1540	}
	1541
	1542	void
	1543	gwmh_task_queue_update (GwmhTask *task,
	1544	GwmhTaskInfoMask imask)
	1545	{
	1546	g_return_if_fail (task != NULL);
	1547
	1548	gwmh_task_queue_full (task, imask, 0);
	1549	}
	1550
	1551	guint
	1552	gwmh_desk_notifier_add (GwmhDeskNotifierFunc func,
	1553	gpointer func_data)
	1554	{
	1555	GHook *hook;
	1556
	1557	g_return_val_if_fail (func != NULL, 0);
	1558
	1559	hook = g_hook_alloc (&gwmh_desk_hook_list);
	1560	hook->func = func;
	1561	hook->data = func_data;
	1562	g_hook_prepend (&gwmh_desk_hook_list, hook);
	1563
	1564	return hook->hook_id;
	1565	}
	1566
	1567	guint
	1568	gwmh_task_notifier_add (GwmhTaskNotifierFunc func,
	1569	gpointer func_data)
	1570	{
	1571	GHook *hook;
	1572
	1573	g_return_val_if_fail (func != NULL, 0);
	1574
	1575	hook = g_hook_alloc (&gwmh_task_hook_list);
	1576	hook->func = func;
	1577	hook->data = func_data;
	1578	g_hook_prepend (&gwmh_task_hook_list, hook);
	1579
	1580	return hook->hook_id;
	1581	}
	1582
	1583	void
	1584	gwmh_desk_notifier_remove (guint id)
	1585	{
	1586	g_return_if_fail (id > 0);
	1587
	1588	if (!g_hook_destroy (&gwmh_desk_hook_list, id))
	1589	g_warning (G_GNUC_PRETTY_FUNCTION "(): unable to remove notifier (%d)",
	1590	id);
	1591	}
	1592
	1593	void
	1594	gwmh_task_notifier_remove (guint id)
	1595	{
	1596	g_return_if_fail (id > 0);
	1597
	1598	if (!g_hook_destroy (&gwmh_task_hook_list, id))
	1599	g_warning (G_GNUC_PRETTY_FUNCTION "(): unable to remove notifier (%d)",
	1600	id);
	1601	}
	1602
	1603	static gboolean
	1604	match_hook (GHook *hook,
	1605	gpointer data_p)
	1606	{
	1607	gpointer *data = data_p;
	1608
	1609	return hook->func == data[0] && hook->data == data[1];
	1610	}
	1611
	1612	void
	1613	gwmh_desk_notifier_remove_func (GwmhDeskNotifierFunc func,
	1614	gpointer func_data)
	1615	{
	1616	GHook *hook;
	1617	gpointer data[2];
	1618
	1619	g_return_if_fail (func != NULL);
	1620
	1621	data[0] = func;
	1622	data[1] = func_data;
	1623	hook = g_hook_find (&gwmh_desk_hook_list, TRUE, match_hook, data);
	1624	if (hook)
	1625	g_hook_destroy_link (&gwmh_desk_hook_list, hook);
	1626	else
	1627	g_warning (G_GNUC_PRETTY_FUNCTION "(): unable to remove notifier <%p> (%p)",
	1628	func, func_data);
	1629	}
	1630
	1631	void
	1632	gwmh_task_notifier_remove_func (GwmhTaskNotifierFunc func,
	1633	gpointer func_data)
	1634	{
	1635	GHook *hook;
	1636	gpointer data[2];
	1637
	1638	g_return_if_fail (func != NULL);
	1639
	1640	data[0] = func;
	1641	data[1] = func_data;
	1642	hook = g_hook_find (&gwmh_task_hook_list, TRUE, match_hook, data);
	1643	if (hook)
	1644	g_hook_destroy_link (&gwmh_task_hook_list, hook);
	1645	else
	1646	g_warning (G_GNUC_PRETTY_FUNCTION "(): unable to remove notifier <%p> (%p)",
	1647	func, func_data);
	1648	}
	1649
	1650	static gboolean
	1651	desk_marshaller (GHook *hook,
	1652	gpointer data_p)
	1653	{
	1654	gpointer *data = data_p;
	1655	GwmhDeskNotifierFunc func = hook->func;
	1656
	1657	return func (hook->data,
	1658	&gwmh_desk,
	1659	GPOINTER_TO_UINT (data[0]));
	1660	}
	1661
	1662	static void
	1663	gwmh_desk_notify (GwmhDeskInfoMask imask)
	1664	{
	1665	gpointer data[1];
	1666
	1667	data[0] = GUINT_TO_POINTER (imask);
	1668
	1669	g_hook_list_marshal_check (&gwmh_desk_hook_list, TRUE, desk_marshaller, data);
	1670	}
	1671
	1672	static gboolean
	1673	task_marshaller (GHook *hook,
	1674	gpointer data_p)
	1675	{
	1676	gpointer *data = data_p;
	1677	GwmhTaskNotifierFunc func = hook->func;
	1678
	1679	return func (hook->data,
	1680	data[0],
	1681	GPOINTER_TO_UINT (data[1]),
	1682	GPOINTER_TO_UINT (data[2]));
	1683	}
	1684
	1685	static void
	1686	gwmh_task_notify (GwmhTask *task,
	1687	GwmhTaskNotifyType ntype,
	1688	GwmhTaskInfoMask imask)
	1689	{
	1690	gpointer data[3];
	1691
	1692	g_return_if_fail (task != NULL);
	1693	g_return_if_fail (ntype < GWMH_NOTIFY_LAST);
	1694
	1695	data[0] = task;
	1696	data[1] = GUINT_TO_POINTER (ntype);
	1697	data[2] = ntype == GWMH_NOTIFY_INFO_CHANGED ? GUINT_TO_POINTER (imask) : 0;
	1698
	1699	g_hook_list_marshal_check (&gwmh_task_hook_list, TRUE, task_marshaller, data);
	1700	}
	1701
	1702	static GwmhTask*
	1703	task_new (GdkWindow *window)
	1704	{
	1705	GwmhTask *task;
	1706	XWindowAttributes attribs;
	1707
	1708	g_return_val_if_fail (window != NULL, NULL);
	1709
	1710	task = g_new0 (GwmhTask, 1);
	1711	gwmh_desk.client_list = g_list_prepend (gwmh_desk.client_list, task);
	1712	task->name = NULL;
	1713	task->icon_name = NULL;
	1714	task->frame_x = -1;
	1715	task->frame_y = -1;
	1716	task->win_x = -1;
	1717	task->win_y = -1;
	1718	task->gdkwindow = window;
	1719	gdk_window_ref (window);
	1720	task->gdkframe = NULL;
	1721	g_datalist_init (&task->datalist);
	1722	task->xwin = GDK_WINDOW_XWINDOW (window);
	1723
	1724	/* monitor events on the GdkWindow */
	1725	if (task->gdkwindow)
	1726	gdk_window_add_filter (task->gdkwindow, task_event_monitor, task);
	1727	/* select events */
	1728	gdk_error_trap_push ();
	1729	XGetWindowAttributes (GDK_DISPLAY (), task->xwin, &attribs);
	1730	XSelectInput (GDK_DISPLAY (),
	1731	task->xwin,
	1732	attribs.your_event_mask \|
	1733	PropertyChangeMask \|
	1734	FocusChangeMask \|
	1735	StructureNotifyMask);
	1736	gwmh_sync ();
	1737	gdk_error_trap_pop ();
	1738
	1739	/* gwmh_task_update () will do this for us:
	1740	* get_task_root_and_frame (task);
	1741	*/
	1742	if (gwmh_task_update (task, GWMH_TASK_INFO_ALL, TRUE))
	1743	{
	1744	gwmh_task_notify (task, GWMH_NOTIFY_NEW, 0);
	1745	gwmh_task_update (task, 0, FALSE);
	1746
	1747	return task;
	1748	}
	1749	else
	1750	{
	1751	task_delete (task);
	1752
	1753	return NULL;
	1754	}
	1755	}
	1756
	1757	static void
	1758	task_delete (GwmhTask *task)
	1759	{
	1760	GSList list, wlist = NULL;
	1761
	1762	g_return_if_fail (g_list_find (gwmh_desk.client_list, task));
	1763
	1764	/* reset event masks for still existing windows */
	1765	wlist = g_slist_prepend (wlist, gdk_window_ref_from_xid (task->xframe));
	1766	wlist = g_slist_prepend (wlist, gdk_window_ref_from_xid (task->xwin));
	1767	gdk_error_trap_push ();
	1768	for (list = wlist; list; list = list->next)
	1769	{
	1770	GdkWindow *window = list->data;
	1771
	1772	if (window)
	1773	{
	1774	if (GDK_WINDOW_IS_FOREIGN (window) &&
	1775	!GDK_WINDOW_IS_DESTROYED (window))
	1776	{
	1777	XWindowAttributes attribs = { 0, };
	1778
	1779	XGetWindowAttributes (GDK_WINDOW_XDISPLAY (window),
	1780	GDK_WINDOW_XWINDOW (window),
	1781	&attribs);
	1782	XSelectInput (GDK_WINDOW_XDISPLAY (window),
	1783	GDK_WINDOW_XWINDOW (window),
	1784	attribs.your_event_mask &
	1785	~(StructureNotifyMask \| FocusChangeMask \| PropertyChangeMask));
	1786	}
	1787	gdk_window_unref (window);
	1788	}
	1789	}
	1790	gwmh_sync ();
	1791	g_slist_free (wlist);
	1792	gdk_error_trap_pop ();
	1793
	1794	gwmh_task_notify (task, GWMH_NOTIFY_DESTROY, 0);
	1795	g_datalist_clear (&task->datalist);
	1796
	1797	gdk_window_remove_filter (task->gdkwindow, task_event_monitor, task);
	1798	gdk_window_unref (task->gdkwindow);
	1799	if (task->gdkframe)
	1800	{
	1801	gdk_window_remove_filter (task->gdkframe, task_event_monitor_frame_wrapper, task);
	1802	gdk_window_unref (task->gdkframe);
	1803	}
	1804	if (task->sroot)
	1805	gstc_parent_delete_watch (task->sroot);
	1806	if (GWMH_TASK_UPDATE_QUEUED (task))
	1807	gwmh_task_update_queue = g_slist_remove (gwmh_task_update_queue, task);
	1808	gwmh_desk.client_list = g_list_remove (gwmh_desk.client_list, task);
	1809	g_free (task->name);
	1810	task->name = "DELETED";
	1811	g_free (task->icon_name);
	1812	task->icon_name = NULL;
	1813
	1814	if (g_list_find (gwmh_desk.client_list, task))
	1815	g_error ("deleted task still in client_list\n"); /* FIXME */
	1816	if (g_slist_find (gwmh_task_update_queue, task))
	1817	g_error ("deleted task still in queue\n"); /* FIXME */
	1818
	1819	g_free (task);
	1820	}
	1821
	1822	static gboolean
	1823	client_list_sync (guint32 *xwindow_ids,
	1824	guint n_ids)
	1825	{
	1826	guint i;
	1827	GList node, client_list = NULL;
	1828	gboolean clients_changed = FALSE;
	1829
	1830	node = gwmh_desk.client_list;
	1831	while (node)
	1832	{
	1833	GwmhTask *task = node->data;
	1834	gboolean found_client = FALSE;
	1835
	1836	node = node->next;
	1837
	1838	for (i = 0; i < n_ids; i++)
	1839	if (xwindow_ids[i] == task->xwin)
	1840	{
	1841	n_ids--;
	1842	xwindow_ids[i] = xwindow_ids[n_ids];
	1843	client_list = g_list_prepend (client_list, task);
	1844	found_client = TRUE;
	1845	break;
	1846	}
	1847	if (!found_client)
	1848	{
	1849	task_delete (task);
	1850	clients_changed = TRUE;
	1851	}
	1852	}
	1853
	1854	for (i = 0; i < n_ids; i++)
	1855	{
	1856	GdkWindow *window = gdk_window_ref_from_xid (xwindow_ids[i]);
	1857
	1858	if (window)
	1859	{
	1860	GwmhTask *task = task_new (window);
	1861
	1862	if (task)
	1863	{
	1864	client_list = g_list_prepend (client_list, task);
	1865	clients_changed = TRUE;
	1866	}
	1867	gdk_window_unref (window);
	1868	}
	1869	}
	1870
	1871	g_assert (g_list_length (gwmh_desk.client_list) == g_list_length (client_list)); /* FIXME */
	1872	if (clients_changed)
	1873	{
	1874	g_list_free (gwmh_desk.client_list);
	1875	gwmh_desk.client_list = client_list;
	1876	}
	1877	else
	1878	g_list_free (client_list);
	1879
	1880	return clients_changed;
	1881	}
	1882
	1883	GwmhTask*
	1884	gwmh_task_from_window (GdkWindow *window)
	1885	{
	1886	GList *node;
	1887
	1888	g_return_val_if_fail (window != NULL, NULL);
	1889
	1890	for (node = gwmh_desk.client_list; node; node = node->next)
	1891	{
	1892	GwmhTask *task = node->data;
	1893
	1894	if (task->gdkwindow == window)
	1895	return task;
	1896	}
	1897
	1898	return NULL;
	1899	}
	1900
	1901	void
	1902	gwmh_task_set_qdata_full (GwmhTask *task,
	1903	GQuark quark,
	1904	gpointer data,
	1905	GDestroyNotify destroy)
	1906	{
	1907	g_return_if_fail (task != NULL);
	1908
	1909	g_datalist_id_set_data_full (&task->datalist, quark, data, destroy);
	1910	}
	1911
	1912	gpointer
	1913	gwmh_task_get_qdata (GwmhTask *task,
	1914	GQuark quark)
	1915	{
	1916	g_return_val_if_fail (task != NULL, NULL);
	1917
	1918	return g_datalist_id_get_data (&task->datalist, quark);
	1919	}
	1920
	1921	gpointer
	1922	gwmh_task_steal_qdata (GwmhTask *task,
	1923	GQuark quark)
	1924	{
	1925	gpointer data;
	1926
	1927	g_return_val_if_fail (task != NULL, NULL);
	1928
	1929	data = g_datalist_id_get_data (&task->datalist, quark);
	1930	if (data)
	1931	g_datalist_id_remove_no_notify (&task->datalist, quark);
	1932
	1933	return data;
	1934	}
	1935
	1936	void
	1937	gwmh_task_kill (GwmhTask *task)
	1938	{
	1939	g_return_if_fail (task != NULL);
	1940
	1941	gdk_error_trap_push ();
	1942	XKillClient (GDK_DISPLAY (), task->xwin);
	1943	gwmh_sync ();
	1944	gdk_error_trap_pop ();
	1945	}
	1946
	1947	void
	1948	gwmh_task_get_frame_area_pos (GwmhTask *task,
	1949	gint *x_p,
	1950	gint *y_p)
	1951
	1952	{
	1953	gint x, y;
	1954	gint swidth = gdk_screen_width ();
	1955	gint sheight = gdk_screen_height ();
	1956
	1957	g_return_if_fail (task != NULL);
	1958
	1959	/* convert from current_area relative into task->area relative */
	1960
	1961	x = task->frame_x + (gwmh_harea_cache[task->desktop] - task->harea) * swidth;
	1962	y = task->frame_y + (gwmh_varea_cache[task->desktop] - task->varea) * sheight;
	1963	if (x_p)
	1964	*x_p = x;
	1965	if (y_p)
	1966	*y_p = y;
	1967	}
	1968
	1969	gboolean
	1970	gwmh_task_close (GwmhTask *task)
	1971	{
	1972	gboolean can_delete = FALSE;
	1973
	1974	g_return_val_if_fail (task != NULL, FALSE);
	1975
	1976	can_delete = wm_protocol_check_support (task->xwin, XA_WM_DELETE_WINDOW);
	1977
	1978	if (can_delete)
	1979	can_delete = send_client_message_2L (task->xwin, task->xwin,
	1980	XA_WM_PROTOCOLS,
	1981	0,
	1982	XA_WM_DELETE_WINDOW, CurrentTime);
	1983
	1984	return can_delete;
	1985	}
	1986
	1987	void
	1988	gwmh_task_iconify (GwmhTask *task)
	1989	{
	1990	g_return_if_fail (task != NULL);
	1991
	1992	gdk_error_trap_push ();
	1993	XIconifyWindow (GDK_DISPLAY (), task->xwin, DefaultScreen (GDK_DISPLAY ()));
	1994	gwmh_sync ();
	1995	gdk_error_trap_pop ();
	1996	}
	1997
	1998	void
	1999	gwmh_task_deiconify (GwmhTask *task)
	2000	{
	2001	g_return_if_fail (task != NULL);
	2002
	2003	if (gwmh_task_update (task, GWMH_TASK_INFO_ICONIFIED, FALSE) &&
	2004	GWMH_TASK_ICONIFIED (task))
	2005	{
	2006	gdk_error_trap_push ();
	2007
	2008	XMapWindow (GDK_DISPLAY (), task->xwin);
	2009
	2010	gwmh_sync ();
	2011	gdk_error_trap_pop ();
	2012	}
	2013	}
	2014
	2015	void
	2016	gwmh_task_focus (GwmhTask *task)
	2017	{
	2018	g_return_if_fail (task != NULL);
	2019
	2020	if (!gwmh_task_update (task, GWMH_TASK_INFO_FOCUSED, FALSE))
	2021	return;
	2022
	2023	if (wm_protocol_check_support (task->xwin, XA_WM_TAKE_FOCUS))
	2024	send_client_message_2L (task->xwin, task->xwin,
	2025	XA_WM_PROTOCOLS,
	2026	0,
	2027	XA_WM_TAKE_FOCUS, CurrentTime);
	2028
	2029	if (!GWMH_TASK_FOCUSED (task))
	2030	{
	2031	gdk_error_trap_push ();
	2032
	2033	XSetInputFocus (GDK_DISPLAY (), task->xwin, RevertToPointerRoot, CurrentTime);
	2034
	2035	gwmh_sync ();
	2036	gdk_error_trap_pop ();
	2037	}
	2038	}
	2039
	2040	void
	2041	gwmh_task_show (GwmhTask *task)
	2042	{
	2043	g_return_if_fail (task != NULL);
	2044
	2045	if (!gwmh_task_update (task,
	2046	(GWMH_TASK_INFO_ICONIFIED \|
	2047	GWMH_TASK_INFO_FOCUSED \|
	2048	GWMH_TASK_INFO_GSTATE),
	2049	FALSE))
	2050	return;
	2051
	2052	if (!GWMH_TASK_SKIP_FOCUS (task) &&
	2053	wm_protocol_check_support (task->xwin, XA_WM_TAKE_FOCUS))
	2054	send_client_message_2L (task->xwin, task->xwin,
	2055	XA_WM_PROTOCOLS,
	2056	0,
	2057	XA_WM_TAKE_FOCUS, CurrentTime);
	2058
	2059	gdk_error_trap_push ();
	2060
	2061	if (GWMH_TASK_ICONIFIED (task))
	2062	XMapWindow (GDK_DISPLAY (), task->xwin);
	2063	if (!GWMH_TASK_SKIP_FOCUS (task) && !GWMH_TASK_FOCUSED (task))
	2064	XSetInputFocus (GDK_DISPLAY (), task->xwin, RevertToPointerRoot, CurrentTime);
	2065	XRaiseWindow (GDK_DISPLAY (), task->xwin);
	2066	if (GWMH_TASK_SHADED (task))
	2067	send_client_message_3L (GDK_ROOT_WINDOW (), task->xwin,
	2068	GWMHA_WIN_STATE,
	2069	SubstructureNotifyMask,
	2070	GWMH_STATE_SHADED, 0, CurrentTime);
	2071
	2072	gwmh_sync ();
	2073
	2074	gdk_error_trap_pop ();
	2075	}
	2076
	2077	void
	2078	gwmh_task_raise (GwmhTask *task)
	2079	{
	2080	g_return_if_fail (task != NULL);
	2081
	2082	gdk_error_trap_push ();
	2083
	2084	XRaiseWindow (GDK_DISPLAY (), task->xwin);
	2085	gwmh_sync ();
	2086
	2087	gdk_error_trap_pop ();
	2088	}
	2089
	2090	void
	2091	gwmh_task_set_gstate_flags (GwmhTask *task,
	2092	GwmhState flags)
	2093	{
	2094	g_return_if_fail (task != NULL);
	2095
	2096	if (!gwmh_task_update (task, GWMH_TASK_INFO_GSTATE, FALSE))
	2097	return;
	2098
	2099	if ((GWMH_TASK_GSTATE (task) & flags) != flags)
	2100	send_client_message_3L (GDK_ROOT_WINDOW (), task->xwin,
	2101	GWMHA_WIN_STATE,
	2102	SubstructureNotifyMask,
	2103	flags, flags, CurrentTime);
	2104	}
	2105
	2106	void
	2107	gwmh_task_unset_gstate_flags (GwmhTask *task,
	2108	GwmhState flags)
	2109	{
	2110	g_return_if_fail (task != NULL);
	2111
	2112	if (!gwmh_task_update (task, GWMH_TASK_INFO_GSTATE, FALSE))
	2113	return;
	2114
	2115	if (GWMH_TASK_GSTATE (task) & flags)
	2116	send_client_message_3L (GDK_ROOT_WINDOW (), task->xwin,
	2117	GWMHA_WIN_STATE,
	2118	SubstructureNotifyMask,
	2119	flags, 0, CurrentTime);
	2120	}
	2121
	2122	void
	2123	gwmh_task_set_ghint_flags (GwmhTask *task,
	2124	GwmhHints flags)
	2125	{
	2126	g_return_if_fail (task != NULL);
	2127
	2128	if (!gwmh_task_update (task, GWMH_TASK_INFO_GHINTS, FALSE))
	2129	return;
	2130
	2131	if ((GWMH_TASK_GHINTS (task) & flags) != flags)
	2132	send_client_message_3L (GDK_ROOT_WINDOW (), task->xwin,
	2133	GWMHA_WIN_HINTS,
	2134	SubstructureNotifyMask,
	2135	flags, flags, CurrentTime);
	2136	}
	2137
	2138	void
	2139	gwmh_task_unset_ghint_flags (GwmhTask *task,
	2140	GwmhHints flags)
	2141	{
	2142	g_return_if_fail (task != NULL);
	2143
	2144	if (!gwmh_task_update (task, GWMH_TASK_INFO_GHINTS, FALSE))
	2145	return;
	2146
	2147	if (GWMH_TASK_GHINTS (task) & flags)
	2148	send_client_message_3L (GDK_ROOT_WINDOW (), task->xwin,
	2149	GWMHA_WIN_HINTS,
	2150	SubstructureNotifyMask,
	2151	flags, 0, CurrentTime);
	2152	}
	2153
	2154	void
	2155	gwmh_task_set_app_state (GwmhTask *task,
	2156	GnomeWinAppState app_state)
	2157	{
	2158	g_return_if_fail (task != NULL);
	2159
	2160	if (!gwmh_task_update (task, GWMH_TASK_INFO_APP_STATE, FALSE))
	2161	return;
	2162
	2163	if (GWMH_TASK_APP_STATE (task) != app_state)
	2164	send_client_message_2L (GDK_ROOT_WINDOW (), task->xwin,
	2165	GWMHA_WIN_APP_STATE,
	2166	SubstructureNotifyMask,
	2167	app_state, CurrentTime);
	2168	}
	2169
	2170	void
	2171	gwmh_task_get_mini_icon (GwmhTask *task,
	2172	GdkPixmap **pixmap,
	2173	GdkBitmap **mask)
	2174	{
	2175	GdkGC *gc;
	2176	GdkGCPrivate *gc_private;
	2177	GdkPixmapPrivate *private;
	2178	guint32 *atomdata;
	2179	Window xwindow = task->xwin;
	2180	Window root;
	2181	int x, y;
	2182	guint b, width, height, depth;
	2183	gint size;
	2184	Display *xdisplay;
	2185
	2186	g_return_if_fail (task != NULL);
	2187	g_return_if_fail (pixmap != NULL);
	2188	g_return_if_fail (mask != NULL);
	2189
	2190	xdisplay = GDK_WINDOW_XDISPLAY (task->gdkwindow);
	2191
	2192	atomdata = get_typed_property_data (xdisplay,
	2193	xwindow,
	2194	XA_KWM_WIN_ICON,
	2195	XA_KWM_WIN_ICON,
	2196	&size,
	2197	32);
	2198	if (!atomdata \|\| !atomdata[0] \|\| !size)
	2199	{
	2200	*pixmap = NULL;
	2201	*mask = NULL;
	2202
	2203	return;
	2204	}
	2205
	2206	/* Get icon size and depth */
	2207	XGetGeometry (xdisplay, (Drawable) atomdata[0], &root, &x, &y,
	2208	&width, &height, &b, &depth);
	2209
	2210	/* Create a new GdkPixmap and copy the mini icon pixmap to it */
	2211	*pixmap = gdk_pixmap_new (NULL, width, height, depth);
	2212	gc = gdk_gc_new (*pixmap);
	2213	gc_private = (GdkGCPrivate*) gc;
	2214	private = (GdkPixmapPrivate) pixmap;
	2215	XCopyArea (private->xdisplay, atomdata[0], private->xwindow, gc_private->xgc,
	2216	0, 0, width, height, 0, 0);
	2217	gdk_gc_destroy (gc);
	2218
	2219	/* get mask size and depth */
	2220	XGetGeometry (xdisplay, (Drawable)atomdata[1], &root, &x, &y,
	2221	&width, &height, &b, &depth);
	2222
	2223	/* Create a new GdkBitmap and copy the mini icon mask to it */
	2224	*mask = gdk_pixmap_new (NULL, width, height, 1);
	2225	gc = gdk_gc_new (*mask);
	2226	gc_private = (GdkGCPrivate*) gc;
	2227	private = (GdkPixmapPrivate) mask;
	2228	XCopyArea (private->xdisplay, atomdata[1], private->xwindow, gc_private->xgc,
	2229	0, 0, width, height, 0, 0);
	2230	gdk_gc_destroy (gc);
	2231	g_free (atomdata);
	2232	}
	2233
	2234	void
	2235	gwmh_task_set_layer (GwmhTask *task,
	2236	GwmhLayer layer)
	2237	{
	2238	g_return_if_fail (task != NULL);
	2239
	2240	if (!gwmh_task_update (task, GWMH_TASK_INFO_LAYER, FALSE))
	2241	return;
	2242
	2243	if (task->layer != layer)
	2244	send_client_message_2L (GDK_ROOT_WINDOW (), task->xwin,
	2245	GWMHA_WIN_LAYER,
	2246	SubstructureNotifyMask,
	2247	layer, CurrentTime);
	2248	}
	2249
	2250	void
	2251	gwmh_task_set_area (GwmhTask *task,
	2252	guint desktop,
	2253	guint harea,
	2254	guint varea)
	2255	{
	2256	g_return_if_fail (task != NULL);
	2257
	2258	if (!gwmh_task_update (task, GWMH_TASK_INFO_DESKTOP \| GWMH_TASK_INFO_AREA, FALSE))
	2259	return;
	2260
	2261	if (desktop >= gwmh_desk.n_desktops \|\|
	2262	harea >= gwmh_desk.n_hareas \|\|
	2263	varea >= gwmh_desk.n_vareas \|\|
	2264	(desktop == task->desktop &&
	2265	harea == task->harea &&
	2266	varea == task->varea))
	2267	return;
	2268
	2269	gwmh_sync ();
	2270
	2271	/* ugly hack for buggy window managers
	2272	* that violate the spec and expect us to modify properties directly
	2273	*/
	2274	if (gwmh_hack_violate_client_msg)
	2275	{
	2276	long data[2];
	2277
	2278	gdk_error_trap_push ();
	2279
	2280	data[0] = desktop;
	2281	if (desktop != task->desktop)
	2282	XChangeProperty (GDK_DISPLAY (), task->xwin, GWMHA_WIN_WORKSPACE,
	2283	XA_CARDINAL, 32, PropModeReplace, (unsigned char*) data, 1);
	2284
	2285	data[0] = harea;
	2286	data[1] = varea;
	2287	XChangeProperty (GDK_DISPLAY (), task->xwin, GWMHA_WIN_AREA,
	2288	XA_CARDINAL, 32, PropModeReplace, (unsigned char*) data, 2);
	2289
	2290	gdk_error_trap_pop ();
	2291	}
	2292	else
	2293	{
	2294	gwmh_freeze_syncs ();
	2295	if (desktop != task->desktop)
	2296	send_client_message_2L (GDK_ROOT_WINDOW (), task->xwin,
	2297	GWMHA_WIN_WORKSPACE,
	2298	SubstructureNotifyMask,
	2299	desktop, CurrentTime);
	2300	send_client_message_3L (GDK_ROOT_WINDOW (), task->xwin,
	2301	GWMHA_WIN_AREA,
	2302	SubstructureNotifyMask,
	2303	harea, varea, CurrentTime);
	2304	gwmh_thaw_syncs ();
	2305	}
	2306	}
	2307
	2308	void
	2309	gwmh_task_set_desktop (GwmhTask *task,
	2310	guint desktop)
	2311	{
	2312	g_return_if_fail (task != NULL);
	2313
	2314	if (!gwmh_task_update (task, GWMH_TASK_INFO_DESKTOP, FALSE) \|\|
	2315	desktop >= gwmh_desk.n_desktops \|\| task->desktop == desktop)
	2316	return;
	2317
	2318	/* ugly hack for buggy window managers
	2319	* that violate the spec and expect us to modify properties directly
	2320	*/
	2321	if (gwmh_hack_violate_client_msg)
	2322	{
	2323	long data[2];
	2324
	2325	gdk_error_trap_push ();
	2326
	2327	data[0] = desktop;
	2328	if (desktop != task->desktop)
	2329	XChangeProperty (GDK_DISPLAY (), task->xwin, GWMHA_WIN_WORKSPACE,
	2330	XA_CARDINAL, 32, PropModeReplace, (unsigned char*) data, 1);
	2331
	2332	gdk_error_trap_pop ();
	2333	}
	2334	else
	2335	send_client_message_2L (GDK_ROOT_WINDOW (), task->xwin,
	2336	GWMHA_WIN_WORKSPACE,
	2337	SubstructureNotifyMask,
	2338	desktop, CurrentTime);
	2339	}
	2340
	2341	GwmhDesk*
	2342	gwmh_desk_get_config (void)
	2343	{
	2344	return &gwmh_desk;
	2345	}
	2346
	2347	void
	2348	gwmh_window_send_client_message (GdkWindow *window,
	2349	gulong atom,
	2350	gulong long1,
	2351	gulong long2,
	2352	gulong long3,
	2353	gulong long4,
	2354	gulong long5)
	2355	{
	2356	g_return_if_fail (window != NULL);
	2357	g_return_if_fail (atom > 0);
	2358
	2359	if (!GDK_WINDOW_IS_DESTROYED (window))
	2360	send_client_message_5L (GDK_ROOT_WINDOW (),
	2361	GDK_WINDOW_XWINDOW (window),
	2362	atom,
	2363	SubstructureNotifyMask,
	2364	long1, long2, long3, long4, long5);
	2365	}
	2366
	2367	void
	2368	gwmh_desk_guess_desktop_area (guint desktop,
	2369	guint *harea,
	2370	guint *varea)
	2371	{
	2372	if (harea)
	2373	*harea = 0;
	2374	if (varea)
	2375	*varea = 0;
	2376	g_return_if_fail (desktop < gwmh_desk.n_desktops);
	2377
	2378	if (harea)
	2379	*harea = gwmh_harea_cache ? gwmh_harea_cache[desktop] : 1;
	2380	if (varea)
	2381	*varea = gwmh_varea_cache ? gwmh_varea_cache[desktop] : 1;
	2382	}
	2383
	2384	void
	2385	gwmh_desk_set_current_desktop (guint desktop)
	2386	{
	2387	g_return_if_fail (desktop < gwmh_desk.n_desktops);
	2388
	2389	gwmh_desk_update (GWMH_DESK_INFO_CURRENT_DESKTOP);
	2390
	2391	if (desktop >= gwmh_desk.n_desktops \|\|
	2392	desktop == gwmh_desk.current_desktop)
	2393	return;
	2394
	2395	send_client_message_2L (GDK_ROOT_WINDOW (), GDK_ROOT_WINDOW (),
	2396	GWMHA_WIN_WORKSPACE,
	2397	SubstructureNotifyMask,
	2398	desktop, CurrentTime);
	2399	}
	2400
	2401	void
	2402	gwmh_desk_set_hack_values (gboolean unified_area,
	2403	gboolean violate_client_msg)
	2404	{
	2405	gwmh_hack_think_unified_area = unified_area != FALSE;
	2406	gwmh_hack_violate_client_msg = violate_client_msg != FALSE;
	2407
	2408	gwmh_desk_update (GWMH_DESK_INFO_N_AREAS);
	2409	}
	2410
	2411	void
	2412	gwmh_desk_set_current_area (guint desktop,
	2413	guint harea,
	2414	guint varea)
	2415	{
	2416	gwmh_desk_update (GWMH_DESK_INFO_CURRENT_DESKTOP \|
	2417	GWMH_DESK_INFO_CURRENT_AREA);
	2418
	2419	if (desktop >= gwmh_desk.n_desktops \|\|
	2420	harea >= gwmh_desk.n_hareas \|\|
	2421	varea >= gwmh_desk.n_vareas \|\|
	2422	(desktop == gwmh_desk.current_desktop &&
	2423	harea == gwmh_desk.current_harea &&
	2424	varea == gwmh_desk.current_varea))
	2425	return;
	2426
	2427	gwmh_sync ();
	2428	gwmh_freeze_syncs ();
	2429	if (desktop != gwmh_desk.current_desktop)
	2430	send_client_message_2L (GDK_ROOT_WINDOW (), GDK_ROOT_WINDOW (),
	2431	GWMHA_WIN_WORKSPACE,
	2432	SubstructureNotifyMask,
	2433	desktop, CurrentTime);
	2434	send_client_message_3L (GDK_ROOT_WINDOW (), GDK_ROOT_WINDOW (),
	2435	GWMHA_WIN_AREA,
	2436	SubstructureNotifyMask,
	2437	harea, varea, CurrentTime);
	2438	gwmh_thaw_syncs ();
	2439	}
	2440
	2441	void
	2442	gwmh_desk_set_desktop_name (guint desktop,
	2443	const gchar *name)
	2444	{
	2445	gchar *old_name;
	2446
	2447	g_return_if_fail (desktop < gwmh_desk.n_desktops);
	2448
	2449	gwmh_desk_update (GWMH_DESK_INFO_DESKTOP_NAMES);
	2450
	2451	if (desktop >= gwmh_desk.n_desktops)
	2452	return;
	2453
	2454	old_name = (gwmh_desk.desktop_names[desktop]
	2455	? gwmh_desk.desktop_names[desktop]
	2456	: "");
	2457	if (!gwmh_string_equals (name, old_name))
	2458	{
	2459	g_warning ("gwmh_desk_set_desktop_name() unimplemented");
	2460	}
	2461	}
	2462
	2463	GList*
	2464	gwmh_task_list_get (void)
	2465	{
	2466	return gwmh_desk.client_list;
	2467	}
	2468
	2469	GList*
	2470	gwmh_task_list_stack_sort (GList *task_list)
	2471	{
	2472	GstcParent *sroot_cache = NULL;
	2473	GSList slist, sparent_list = NULL;
	2474	GList node, stacked_tasks = NULL;
	2475
	2476	for (node = task_list; node; node = node->next)
	2477	{
	2478	GwmhTask *task = node->data;
	2479
	2480	if (sroot_cache == task->sroot)
	2481	continue;
	2482	sroot_cache = task->sroot;
	2483	if (task->sroot &&
	2484	!g_slist_find (sparent_list, task->sroot))
	2485	sparent_list = g_slist_prepend (sparent_list, task->sroot);
	2486	}
	2487	sparent_list = g_slist_reverse (sparent_list);
	2488
	2489	node = NULL;
	2490	for (slist = sparent_list; slist; slist = slist->next)
	2491	{
	2492	GstcParent *sparent = slist->data;
	2493	guint i;
	2494
	2495	for (i = 0; i < sparent->n_children; i++)
	2496	for (node = task_list; node; node = node->next)
	2497	{
	2498	GwmhTask *task = node->data;
	2499
	2500	if (task->xframe == sparent->children[i])
	2501	{
	2502	if (node->prev)
	2503	node->prev->next = node->next;
	2504	else
	2505	task_list = node->next;
	2506	if (node->next)
	2507	node->next->prev = node->prev;
	2508
	2509	if (stacked_tasks)
	2510	stacked_tasks->prev = node;
	2511	node->next = stacked_tasks;
	2512	node->prev = NULL;
	2513	stacked_tasks = node;
	2514
	2515	break;
	2516	}
	2517	}
	2518	}
	2519	g_slist_free (sparent_list);
	2520
	2521	node = g_list_last (task_list);
	2522	stacked_tasks = g_list_reverse (stacked_tasks);
	2523	if (node)
	2524	{
	2525	if (stacked_tasks)
	2526	stacked_tasks->prev = node;
	2527	node->next = stacked_tasks;
	2528	stacked_tasks = task_list;
	2529	}
	2530
	2531	return stacked_tasks;
	2532	}
	2533
	2534	static gboolean
	2535	check_client (Display *display,
	2536	Window xwindow,
	2537	Atom state_atom)
	2538	{
	2539	gboolean valid_client = TRUE;
	2540
	2541	if (valid_client)
	2542	{
	2543	Atom dummy1;
	2544	int format = 0;
	2545	unsigned long dummy2, nitems = 0, *prop = NULL;
	2546
	2547	XGetWindowProperty (display, xwindow, state_atom, 0, 1024, False, state_atom,
	2548	&dummy1, &format, &nitems, &dummy2, (unsigned char **) &prop);
	2549	if (prop)
	2550	{
	2551	valid_client = format == 32 && nitems > 0 && (prop[0] == NormalState \|\|
	2552	prop[0] == IconicState);
	2553	XFree (prop);
	2554	}
	2555	}
	2556
	2557	if (valid_client)
	2558	{
	2559	XWindowAttributes attributes = { 0, };
	2560
	2561	XGetWindowAttributes (display, xwindow, &attributes);
	2562	valid_client = (attributes.class == InputOutput &&
	2563	attributes.map_state == IsViewable);
	2564	}
	2565
	2566	if (valid_client)
	2567	{
	2568	XWMHints *hints = XGetWMHints (display, xwindow);
	2569
	2570	valid_client &= hints && (hints->flags & InputHint) && hints->input;
	2571	if (hints)
	2572	XFree (hints);
	2573	}
	2574
	2575	return valid_client;
	2576	}
	2577
	2578	static Window
	2579	find_input_client (Display *display,
	2580	Window xwindow,
	2581	Atom state_atom)
	2582	{
	2583	Window dummy1, dummy2, *children = NULL;
	2584	unsigned int n_children = 0;
	2585	guint i;
	2586
	2587	if (check_client (display, xwindow, state_atom))
	2588	return xwindow;
	2589
	2590	if (!XQueryTree (display, xwindow, &dummy1, &dummy2, &children, &n_children) \|\| !children)
	2591	return None;
	2592
	2593	for (i = 0; i < n_children; i++)
	2594	{
	2595	xwindow = find_input_client (display, children[i], state_atom);
	2596	if (xwindow)
	2597	break;
	2598	}
	2599
	2600	XFree (children);
	2601
	2602	return xwindow;
	2603	}
	2604
	2605	static guint32*
	2606	hack_a_client_list (Display *display,
	2607	Window xroot,
	2608	guint *_n_clients)
	2609	{
	2610	Window xwindow, dummy, *children = NULL;
	2611	unsigned int n_children = 0;
	2612	guint i, n_clients = 0;
	2613	guint32 *clients = NULL;
	2614
	2615	*_n_clients = 0;
	2616
	2617	gdk_error_trap_push ();
	2618
	2619	XGrabServer (display);
	2620
	2621	if (!XQueryTree (display, xroot, &xwindow, &dummy, &children, &n_children) \|\| !children)
	2622	{
	2623	XUngrabServer (display);
	2624	return NULL;
	2625	}
	2626
	2627	for (i = 0; i < n_children; i++)
	2628	{
	2629	xwindow = find_input_client (display,
	2630	children[i],
	2631	XInternAtom (display, "WM_STATE", False));
	2632	if (xwindow)
	2633	{
	2634	n_clients++;
	2635	clients = g_renew (guint32, clients, n_clients);
	2636	clients[n_clients - 1] = xwindow;
	2637	}
	2638	}
	2639
	2640	XUngrabServer (display);
	2641
	2642	XFree (children);
	2643
	2644	*_n_clients = n_clients;
	2645
	2646	gdk_error_trap_pop ();
	2647
	2648	return clients;
	2649	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/third/gnome-core/panel/gwmh.c @ 15821

Download in other formats: