/* Marco X property convenience routines */

* Copyright (C) 2001 Havoc Pennington

* Copyright (C) 2002 Red Hat Inc.

*

* Copyright 1987, 1988, 1998 The Open Group

* Copyright 1988 by Wyse Technology, Inc., San Jose, Ca,

* Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,

* 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

* 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., 51 Franklin St, Fifth Floor, Boston, MA

All Rights Reserved

provided that the above copyright notice appear in all copies and that

supporting documentation, and that the name Digital not be

used in advertising or publicity pertaining to distribution of the

PERFORMANCE OF THIS SOFTWARE.

******************************************************************/

const char *res_class;

const char *res_name;

MetaWindow *w;

if (expected_format == results->format &&

expected_type == results->type &&

(!must_have_items || results->n_items > 0))

meta_error_trap_push (results->display);

type_name = XGetAtomName (results->display->xdisplay, results->type);

expected_name = XGetAtomName (results->display->xdisplay, expected_type);

res_class = NULL;

res_name = NULL;

}

if (title == NULL)

title = "unknown";

if (res_name == NULL)

res_name = "unknown";

meta_warning (_("Window 0x%lx has property %s\nthat was expected to have type %s format %d\nand actually has type %s format %d n_items %d.\nThis is most likely an application bug, not a window manager bug.\nThe window has title=\"%s\" class=\"%s\" name=\"%s\"\n"),

results->xwindow,

prop_name ? prop_name : "(bad atom)",

XFree (results->prop);

results->prop = NULL;

}

return FALSE;

}

results->type = None;

results->bytes_after = 0;

results->format = 0;

meta_error_trap_push_with_return (display);

if (XGetWindowProperty (display->xdisplay, xwindow, xatom,

0, G_MAXLONG,

int *n_atoms_p)

{

if (!validate_or_free_results (results, 32, XA_ATOM, FALSE))

*atoms_p = (Atom*) results->prop;

*n_atoms_p = results->n_items;

return TRUE;

}

int *n_cardinals_p)

{

if (!validate_or_free_results (results, 32, XA_CARDINAL, FALSE))

*cardinals_p = (gulong*) results->prop;

*n_cardinals_p = results->n_items;

results->prop = NULL;

return TRUE;

}

{

int real_size, max_size;

#define MAX_ITEMS sizeof (MotifWmHints)/sizeof (gulong)

if (results->type == None || results->n_items <= 0)

{

XFree (results->prop);

results->prop = NULL;

}

return TRUE;

}

MotifWmHints **hints_p)

{

GetPropertyResults results;

*hints_p = NULL;

if (!get_property (display, xwindow, xatom, AnyPropertyType,

char **str_p)

{

*str_p = NULL;

if (!validate_or_free_results (results, 8, XA_STRING, FALSE))

return FALSE;

*str_p = (char*) results->prop;

results->prop = NULL;

return TRUE;

}

if (!get_property (display, xwindow, xatom, XA_STRING,

&results))

return FALSE;

return latin1_string_from_results (&results, str_p);

}

char **str_p)

{

*str_p = NULL;

if (!validate_or_free_results (results, 8,

results->display->atom_UTF8_STRING, FALSE))

return FALSE;

meta_XFree (name);

XFree (results->prop);

results->prop = NULL;

return FALSE;

}

*str_p = (char*) results->prop;

results->prop = NULL;

return TRUE;

}

int n_strings;

char **retval;

const char *p;

*str_p = NULL;

*n_str_p = 0;

if (!validate_or_free_results (results, 8,

results->display->atom_UTF8_STRING, FALSE))

return FALSE;

/* I'm not sure this is right, but I'm guessing the

* property is nul-separated

*/

if (results->prop[results->n_items - 1] != '\0')

++n_strings;

/* we're guaranteed that results->prop has a nul on the end

* by XGetWindowProperty

*/

retval = g_new0 (char*, n_strings + 1);

p = (char *)results->prop;

meta_XFree (name);

meta_XFree (results->prop);

results->prop = NULL;

g_strfreev (retval);

return FALSE;

}

retval[i] = g_strdup (p);

p = p + strlen (p) + 1;

++i;

}

*str_p = retval;

*n_str_p = i;

const char *val)

{

meta_error_trap_push (display);

xwindow, atom,

8, PropModeReplace, (guchar*) val, strlen (val));

meta_error_trap_pop (display, FALSE);

}

Window *window_p)

{

if (!validate_or_free_results (results, 32, XA_WINDOW, TRUE))

*window_p = *(Window*) results->prop;

XFree (results->prop);

return TRUE;

}

if (!validate_or_free_results (results, 32,

XA_CARDINAL,

TRUE))

*counter_p = *(XSyncCounter*) results->prop;

XFree (results->prop);

results->prop = NULL;

return TRUE;

}

#endif

GetPropertyResults results;

*window_p = None;

if (!get_property (display, xwindow, xatom, XA_WINDOW,

&results))

return FALSE;

gulong *cardinal_p)

{

if (!validate_or_free_results (results, 32, prop_type, TRUE))

*cardinal_p = *(gulong*) results->prop;

XFree (results->prop);

return TRUE;

}

XTextProperty tp;

*utf8_str_p = NULL;

tp.value = results->prop;

results->prop = NULL;

tp.encoding = results->type;

tp.format = results->format;

*utf8_str_p = meta_text_property_to_utf8 (results->display->xdisplay,

&tp);

if (tp.value != NULL)

XFree (tp.value);

return *utf8_str_p != NULL;

}

char **utf8_str_p)

{

GetPropertyResults results;

if (!get_property (display, xwindow, xatom, AnyPropertyType,

&results))

return FALSE;

{

XWMHints *hints;

xPropWMHints *raw;

*hints_p = NULL;

if (!validate_or_free_results (results, 32, XA_WM_HINTS, TRUE))

if (results->n_items < (NumPropWMHintsElements - 1))

{

meta_verbose ("WM_HINTS property too short: %d should be %d\n",

}

return FALSE;

}

hints = ag_Xmalloc0 (sizeof (XWMHints));

raw = (xPropWMHints*) results->prop;

hints->flags = raw->flags;

hints->input = (raw->input ? True : False);

hints->initial_state = cvtINT32toInt (raw->initialState);

GetPropertyResults results;

*hints_p = NULL;

if (!get_property (display, xwindow, xatom, XA_WM_HINTS,

&results))

return FALSE;

XClassHint *class_hint)

{

int len_name, len_class;

class_hint->res_class = NULL;

class_hint->res_name = NULL;

if (!validate_or_free_results (results, 8, XA_STRING, FALSE))

return FALSE;

len_name = strlen ((char *) results->prop);

if (! (class_hint->res_name = ag_Xmalloc (len_name+1)))

{

results->prop = NULL;

return FALSE;

}

strcpy (class_hint->res_name, (char *)results->prop);

if (len_name == (int) results->n_items)

len_name--;

len_class = strlen ((char *)results->prop + len_name + 1);

if (! (class_hint->res_class = ag_Xmalloc(len_class+1)))

{

XFree(class_hint->res_name);

results->prop = NULL;

return FALSE;

}

strcpy (class_hint->res_class, (char *)results->prop + len_name + 1);

XFree (results->prop);

results->prop = NULL;

return TRUE;

}

XClassHint *class_hint)

{

GetPropertyResults results;

class_hint->res_class = NULL;

class_hint->res_name = NULL;

if (!get_property (display, xwindow, xatom, XA_STRING,

&results))

return FALSE;

{

xPropSizeHints *raw;

XSizeHints *hints;

*hints_p = NULL;

*flags_p = 0;

if (!validate_or_free_results (results, 32, XA_WM_SIZE_HINTS, FALSE))

return FALSE;

raw = (xPropSizeHints*) results->prop;

hints = ag_Xmalloc (sizeof (XSizeHints));

/* XSizeHints misdeclares these as int instead of long */

hints->flags = raw->flags;

hints->x = cvtINT32toInt (raw->x);

}

hints->flags &= (*flags_p); /* get rid of unwanted bits */

XFree (results->prop);

results->prop = NULL;

*hints_p = hints;

return TRUE;

}

*hints_p = NULL;

*flags_p = 0;

if (!get_property (display, xwindow, xatom, XA_WM_SIZE_HINTS,

&results))

return FALSE;

{

GString *str;

const char *p;

str = g_string_new ("");

p = text;

meta_verbose ("Requesting %d properties of 0x%lx at once\n",

n_values, xwindow);

if (n_values == 0)

return;

tasks = g_new0 (AgGetPropertyTask*, n_values);

/* Start up tasks. The "values" array can have values

if (values[i].atom != None)

tasks[i] = get_task (display, xwindow,

values[i].atom, values[i].required_type);

++i;

/* Get replies for all our tasks */

meta_topic (META_DEBUG_SYNC, "Syncing to get %d GetProperty replies in %s\n",

n_values, G_STRFUNC);

XSync (display->xdisplay, False);

/* Collect results, should arrive in order requested */

i = 0;

while (i < n_values)

{

AgGetPropertyTask *task;

GetPropertyResults results;

if (tasks[i] == NULL)

{

/* Probably values[i].type was None, or ag_task_create()

values[i].type = META_PROP_VALUE_INVALID;

goto next;

}

task = ag_get_next_completed_task (display->xdisplay);

g_assert (task != NULL);

g_assert (ag_task_have_reply (task));

results.type = None;

results.bytes_after = 0;

results.format = 0;

if (ag_task_get_reply_and_free (task,

&results.type, &results.format,

&results.n_items,

{

switch (value->type)

{

break;

case META_PROP_VALUE_UTF8:

case META_PROP_VALUE_STRING:

break;

case META_PROP_VALUE_MOTIF_HINTS:

meta_XFree (value->v.motif_hints);

case META_PROP_VALUE_CARDINAL:

break;

break;

case META_PROP_VALUE_ATOM_LIST:

meta_XFree (value->v.atom_list.atoms);