* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
- * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#include "config.h"
+
+#include "gdkproperty.h"
+#include "gdkmain.h"
+#include "gdkprivate.h"
+#include "gdkinternals.h"
+#include "gdkselection.h"
+#include "gdkprivate-x11.h"
+#include "gdkdisplay-x11.h"
+#include "gdkscreen-x11.h"
+
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <string.h>
-#include "gdkx.h"
-#include "gdkproperty.h"
-#include "gdkprivate.h"
-GdkAtom
-gdk_atom_intern (const gchar *atom_name,
- gint only_if_exists)
+/**
+ * SECTION:properties
+ * @Short_description: Functions to manipulate properties on windows
+ * @Title: Properties and Atoms
+ *
+ * Each window under X can have any number of associated
+ * <firstterm>properties</firstterm> attached to it.
+ * Properties are arbitrary chunks of data identified by
+ * <firstterm>atom</firstterm>s. (An <firstterm>atom</firstterm>
+ * is a numeric index into a string table on the X server. They are used
+ * to transfer strings efficiently between clients without
+ * having to transfer the entire string.) A property
+ * has an associated type, which is also identified
+ * using an atom.
+ *
+ * A property has an associated <firstterm>format</firstterm>,
+ * an integer describing how many bits are in each unit
+ * of data inside the property. It must be 8, 16, or 32.
+ * When data is transferred between the server and client,
+ * if they are of different endianesses it will be byteswapped
+ * as necessary according to the format of the property.
+ * Note that on the client side, properties of format 32
+ * will be stored with one unit per <emphasis>long</emphasis>,
+ * even if a long integer has more than 32 bits on the platform.
+ * (This decision was apparently made for Xlib to maintain
+ * compatibility with programs that assumed longs were 32
+ * bits, at the expense of programs that knew better.)
+ *
+ * The functions in this section are used to add, remove
+ * and change properties on windows, to convert atoms
+ * to and from strings and to manipulate some types of
+ * data commonly stored in X window properties.
+ */
+
+
+static GPtrArray *virtual_atom_array;
+static GHashTable *virtual_atom_hash;
+
+static const gchar xatoms_string[] =
+ /* These are all the standard predefined X atoms */
+ "\0" /* leave a space for None, even though it is not a predefined atom */
+ "PRIMARY\0"
+ "SECONDARY\0"
+ "ARC\0"
+ "ATOM\0"
+ "BITMAP\0"
+ "CARDINAL\0"
+ "COLORMAP\0"
+ "CURSOR\0"
+ "CUT_BUFFER0\0"
+ "CUT_BUFFER1\0"
+ "CUT_BUFFER2\0"
+ "CUT_BUFFER3\0"
+ "CUT_BUFFER4\0"
+ "CUT_BUFFER5\0"
+ "CUT_BUFFER6\0"
+ "CUT_BUFFER7\0"
+ "DRAWABLE\0"
+ "FONT\0"
+ "INTEGER\0"
+ "PIXMAP\0"
+ "POINT\0"
+ "RECTANGLE\0"
+ "RESOURCE_MANAGER\0"
+ "RGB_COLOR_MAP\0"
+ "RGB_BEST_MAP\0"
+ "RGB_BLUE_MAP\0"
+ "RGB_DEFAULT_MAP\0"
+ "RGB_GRAY_MAP\0"
+ "RGB_GREEN_MAP\0"
+ "RGB_RED_MAP\0"
+ "STRING\0"
+ "VISUALID\0"
+ "WINDOW\0"
+ "WM_COMMAND\0"
+ "WM_HINTS\0"
+ "WM_CLIENT_MACHINE\0"
+ "WM_ICON_NAME\0"
+ "WM_ICON_SIZE\0"
+ "WM_NAME\0"
+ "WM_NORMAL_HINTS\0"
+ "WM_SIZE_HINTS\0"
+ "WM_ZOOM_HINTS\0"
+ "MIN_SPACE\0"
+ "NORM_SPACE\0"
+ "MAX_SPACE\0"
+ "END_SPACE\0"
+ "SUPERSCRIPT_X\0"
+ "SUPERSCRIPT_Y\0"
+ "SUBSCRIPT_X\0"
+ "SUBSCRIPT_Y\0"
+ "UNDERLINE_POSITION\0"
+ "UNDERLINE_THICKNESS\0"
+ "STRIKEOUT_ASCENT\0"
+ "STRIKEOUT_DESCENT\0"
+ "ITALIC_ANGLE\0"
+ "X_HEIGHT\0"
+ "QUAD_WIDTH\0"
+ "WEIGHT\0"
+ "POINT_SIZE\0"
+ "RESOLUTION\0"
+ "COPYRIGHT\0"
+ "NOTICE\0"
+ "FONT_NAME\0"
+ "FAMILY_NAME\0"
+ "FULL_NAME\0"
+ "CAP_HEIGHT\0"
+ "WM_CLASS\0"
+ "WM_TRANSIENT_FOR\0"
+ /* Below here, these are our additions. Increment N_CUSTOM_PREDEFINED
+ * if you add any.
+ */
+ "CLIPBOARD\0" /* = 69 */
+;
+
+static const gint xatoms_offset[] = {
+ 0, 1, 9, 19, 23, 28, 35, 44, 53, 60, 72, 84,
+ 96, 108, 120, 132, 144, 156, 165, 170, 178, 185, 189, 201,
+ 218, 232, 245, 258, 274, 287, 301, 313, 320, 329, 336, 347,
+ 356, 374, 387, 400, 408, 424, 438, 452, 462, 473, 483, 493,
+ 507, 521, 533, 545, 564, 584, 601, 619, 632, 641, 652, 659,
+ 670, 681, 691, 698, 708, 720, 730, 741, 750, 767
+};
+
+#define N_CUSTOM_PREDEFINED 1
+
+#define ATOM_TO_INDEX(atom) (GPOINTER_TO_UINT(atom))
+#define INDEX_TO_ATOM(atom) ((GdkAtom)GUINT_TO_POINTER(atom))
+
+static void
+insert_atom_pair (GdkDisplay *display,
+ GdkAtom virtual_atom,
+ Atom xatom)
+{
+ GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
+
+ if (!display_x11->atom_from_virtual)
+ {
+ display_x11->atom_from_virtual = g_hash_table_new (g_direct_hash, NULL);
+ display_x11->atom_to_virtual = g_hash_table_new (g_direct_hash, NULL);
+ }
+
+ g_hash_table_insert (display_x11->atom_from_virtual,
+ GDK_ATOM_TO_POINTER (virtual_atom),
+ GUINT_TO_POINTER (xatom));
+ g_hash_table_insert (display_x11->atom_to_virtual,
+ GUINT_TO_POINTER (xatom),
+ GDK_ATOM_TO_POINTER (virtual_atom));
+}
+
+static Atom
+lookup_cached_xatom (GdkDisplay *display,
+ GdkAtom atom)
{
- GdkAtom retval;
- static GHashTable *atom_hash = NULL;
+ GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
+
+ if (ATOM_TO_INDEX (atom) < G_N_ELEMENTS (xatoms_offset) - N_CUSTOM_PREDEFINED)
+ return ATOM_TO_INDEX (atom);
- g_return_val_if_fail (atom_name != NULL, GDK_NONE);
+ if (display_x11->atom_from_virtual)
+ return GPOINTER_TO_UINT (g_hash_table_lookup (display_x11->atom_from_virtual,
+ GDK_ATOM_TO_POINTER (atom)));
+
+ return None;
+}
+
+/**
+ * gdk_x11_atom_to_xatom_for_display:
+ * @display: A #GdkDisplay
+ * @atom: A #GdkAtom, or %GDK_NONE
+ *
+ * Converts from a #GdkAtom to the X atom for a #GdkDisplay
+ * with the same string value. The special value %GDK_NONE
+ * is converted to %None.
+ *
+ * Return value: the X atom corresponding to @atom, or %None
+ *
+ * Since: 2.2
+ **/
+Atom
+gdk_x11_atom_to_xatom_for_display (GdkDisplay *display,
+ GdkAtom atom)
+{
+ Atom xatom = None;
+
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), None);
+
+ if (atom == GDK_NONE)
+ return None;
- if (!atom_hash)
- atom_hash = g_hash_table_new (g_str_hash, g_str_equal);
+ if (gdk_display_is_closed (display))
+ return None;
- retval = GPOINTER_TO_UINT (g_hash_table_lookup (atom_hash, atom_name));
- if (!retval)
+ xatom = lookup_cached_xatom (display, atom);
+
+ if (!xatom)
{
- retval = XInternAtom (gdk_display, atom_name, only_if_exists);
+ char *name;
+
+ g_return_val_if_fail (ATOM_TO_INDEX (atom) < virtual_atom_array->len, None);
- if (retval != None)
- g_hash_table_insert (atom_hash,
- g_strdup (atom_name),
- GUINT_TO_POINTER (retval));
+ name = g_ptr_array_index (virtual_atom_array, ATOM_TO_INDEX (atom));
+
+ xatom = XInternAtom (GDK_DISPLAY_XDISPLAY (display), name, FALSE);
+ insert_atom_pair (display, atom, xatom);
}
- return retval;
+ return xatom;
}
-gchar*
-gdk_atom_name (GdkAtom atom)
+void
+_gdk_x11_precache_atoms (GdkDisplay *display,
+ const gchar * const *atom_names,
+ gint n_atoms)
{
- gchar *t;
- gchar *name;
- gint old_error_warnings;
+ Atom *xatoms;
+ GdkAtom *atoms;
+ const gchar **xatom_names;
+ gint n_xatoms;
+ gint i;
+
+ xatoms = g_new (Atom, n_atoms);
+ xatom_names = g_new (const gchar *, n_atoms);
+ atoms = g_new (GdkAtom, n_atoms);
+
+ n_xatoms = 0;
+ for (i = 0; i < n_atoms; i++)
+ {
+ GdkAtom atom = gdk_atom_intern_static_string (atom_names[i]);
+ if (lookup_cached_xatom (display, atom) == None)
+ {
+ atoms[n_xatoms] = atom;
+ xatom_names[n_xatoms] = atom_names[i];
+ n_xatoms++;
+ }
+ }
+
+ if (n_xatoms)
+ XInternAtoms (GDK_DISPLAY_XDISPLAY (display),
+ (char **)xatom_names, n_xatoms, False, xatoms);
+
+ for (i = 0; i < n_xatoms; i++)
+ insert_atom_pair (display, atoms[i], xatoms[i]);
+
+ g_free (xatoms);
+ g_free (xatom_names);
+ g_free (atoms);
+}
+
+/**
+ * gdk_x11_atom_to_xatom:
+ * @atom: A #GdkAtom
+ *
+ * Converts from a #GdkAtom to the X atom for the default GDK display
+ * with the same string value.
+ *
+ * Return value: the X atom corresponding to @atom.
+ **/
+Atom
+gdk_x11_atom_to_xatom (GdkAtom atom)
+{
+ return gdk_x11_atom_to_xatom_for_display (gdk_display_get_default (), atom);
+}
- /* If this atom doesn't exist, we'll die with an X error unless
- we take precautions */
+/**
+ * gdk_x11_xatom_to_atom_for_display:
+ * @display: A #GdkDisplay
+ * @xatom: an X atom
+ *
+ * Convert from an X atom for a #GdkDisplay to the corresponding
+ * #GdkAtom.
+ *
+ * Return value: (transfer none): the corresponding #GdkAtom.
+ *
+ * Since: 2.2
+ **/
+GdkAtom
+gdk_x11_xatom_to_atom_for_display (GdkDisplay *display,
+ Atom xatom)
+{
+ GdkX11Display *display_x11;
+ GdkAtom virtual_atom = GDK_NONE;
+
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), GDK_NONE);
+
+ if (xatom == None)
+ return GDK_NONE;
- old_error_warnings = gdk_error_warnings;
- gdk_error_warnings = 0;
- gdk_error_code = 0;
- t = XGetAtomName (gdk_display, atom);
- gdk_error_warnings = old_error_warnings;
+ if (gdk_display_is_closed (display))
+ return GDK_NONE;
- if (gdk_error_code)
+ display_x11 = GDK_X11_DISPLAY (display);
+
+ if (xatom < G_N_ELEMENTS (xatoms_offset) - N_CUSTOM_PREDEFINED)
+ return INDEX_TO_ATOM (xatom);
+
+ if (display_x11->atom_to_virtual)
+ virtual_atom = GDK_POINTER_TO_ATOM (g_hash_table_lookup (display_x11->atom_to_virtual,
+ GUINT_TO_POINTER (xatom)));
+
+ if (!virtual_atom)
{
- if (t)
- XFree (t);
+ /* If this atom doesn't exist, we'll die with an X error unless
+ * we take precautions
+ */
+ char *name;
+ gdk_x11_display_error_trap_push (display);
+ name = XGetAtomName (GDK_DISPLAY_XDISPLAY (display), xatom);
+ if (gdk_x11_display_error_trap_pop (display))
+ {
+ g_warning (G_STRLOC " invalid X atom: %ld", xatom);
+ }
+ else
+ {
+ virtual_atom = gdk_atom_intern (name, FALSE);
+ XFree (name);
+
+ insert_atom_pair (display, virtual_atom, xatom);
+ }
+ }
- return NULL;
+ return virtual_atom;
+}
+
+/**
+ * gdk_x11_xatom_to_atom:
+ * @xatom: an X atom for the default GDK display
+ *
+ * Convert from an X atom for the default display to the corresponding
+ * #GdkAtom.
+ *
+ * Return value: (transfer none): the corresponding G#dkAtom.
+ **/
+GdkAtom
+gdk_x11_xatom_to_atom (Atom xatom)
+{
+ return gdk_x11_xatom_to_atom_for_display (gdk_display_get_default (), xatom);
+}
+
+static void
+virtual_atom_check_init (void)
+{
+ if (!virtual_atom_hash)
+ {
+ gint i;
+
+ virtual_atom_hash = g_hash_table_new (g_str_hash, g_str_equal);
+ virtual_atom_array = g_ptr_array_new ();
+
+ for (i = 0; i < G_N_ELEMENTS (xatoms_offset); i++)
+ {
+ g_ptr_array_add (virtual_atom_array, (gchar *)(xatoms_string + xatoms_offset[i]));
+ g_hash_table_insert (virtual_atom_hash, (gchar *)(xatoms_string + xatoms_offset[i]),
+ GUINT_TO_POINTER (i));
+ }
}
- else
+}
+
+GdkAtom
+_gdk_x11_display_manager_atom_intern (GdkDisplayManager *manager,
+ const gchar *atom_name,
+ gboolean dup)
+{
+ GdkAtom result;
+
+ virtual_atom_check_init ();
+
+ result = GDK_POINTER_TO_ATOM (g_hash_table_lookup (virtual_atom_hash, atom_name));
+ if (!result)
{
- name = g_strdup (t);
- if (t)
- XFree (t);
-
- return name;
+ result = INDEX_TO_ATOM (virtual_atom_array->len);
+
+ g_ptr_array_add (virtual_atom_array, dup ? g_strdup (atom_name) : (gchar *)atom_name);
+ g_hash_table_insert (virtual_atom_hash,
+ g_ptr_array_index (virtual_atom_array,
+ ATOM_TO_INDEX (result)),
+ GDK_ATOM_TO_POINTER (result));
}
+
+ return result;
}
-gint
-gdk_property_get (GdkWindow *window,
- GdkAtom property,
- GdkAtom type,
- gulong offset,
- gulong length,
- gint pdelete,
- GdkAtom *actual_property_type,
- gint *actual_format_type,
- gint *actual_length,
- guchar **data)
+static const gchar *
+get_atom_name (GdkAtom atom)
{
- Display *xdisplay;
- Window xwindow;
+ virtual_atom_check_init ();
+
+ if (ATOM_TO_INDEX (atom) < virtual_atom_array->len)
+ return g_ptr_array_index (virtual_atom_array, ATOM_TO_INDEX (atom));
+ else
+ return NULL;
+}
+
+
+gchar *
+_gdk_x11_display_manager_get_atom_name (GdkDisplayManager *manager,
+ GdkAtom atom)
+{
+ return g_strdup (get_atom_name (atom));
+}
+
+/**
+ * gdk_x11_get_xatom_by_name_for_display:
+ * @display: a #GdkDisplay
+ * @atom_name: a string
+ *
+ * Returns the X atom for a #GdkDisplay corresponding to @atom_name.
+ * This function caches the result, so if called repeatedly it is much
+ * faster than XInternAtom(), which is a round trip to the server each time.
+ *
+ * Return value: a X atom for a #GdkDisplay
+ *
+ * Since: 2.2
+ **/
+Atom
+gdk_x11_get_xatom_by_name_for_display (GdkDisplay *display,
+ const gchar *atom_name)
+{
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), None);
+ return gdk_x11_atom_to_xatom_for_display (display,
+ gdk_atom_intern (atom_name, FALSE));
+}
+
+/**
+ * gdk_x11_get_xatom_by_name:
+ * @atom_name: a string
+ *
+ * Returns the X atom for GDK's default display corresponding to @atom_name.
+ * This function caches the result, so if called repeatedly it is much
+ * faster than XInternAtom(), which is a round trip to the server each time.
+ *
+ * Return value: a X atom for GDK's default display.
+ **/
+Atom
+gdk_x11_get_xatom_by_name (const gchar *atom_name)
+{
+ return gdk_x11_get_xatom_by_name_for_display (gdk_display_get_default (),
+ atom_name);
+}
+
+/**
+ * gdk_x11_get_xatom_name_for_display:
+ * @display: the #GdkDisplay where @xatom is defined
+ * @xatom: an X atom
+ *
+ * Returns the name of an X atom for its display. This
+ * function is meant mainly for debugging, so for convenience, unlike
+ * XAtomName() and gdk_atom_name(), the result doesn't need to
+ * be freed.
+ *
+ * Return value: name of the X atom; this string is owned by GDK,
+ * so it shouldn't be modifed or freed.
+ *
+ * Since: 2.2
+ **/
+const gchar *
+gdk_x11_get_xatom_name_for_display (GdkDisplay *display,
+ Atom xatom)
+{
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
+ return get_atom_name (gdk_x11_xatom_to_atom_for_display (display, xatom));
+}
+
+/**
+ * gdk_x11_get_xatom_name:
+ * @xatom: an X atom for GDK's default display
+ *
+ * Returns the name of an X atom for GDK's default display. This
+ * function is meant mainly for debugging, so for convenience, unlike
+ * <function>XAtomName()</function> and gdk_atom_name(), the result
+ * doesn't need to be freed. Also, this function will never return %NULL,
+ * even if @xatom is invalid.
+ *
+ * Return value: name of the X atom; this string is owned by GTK+,
+ * so it shouldn't be modifed or freed.
+ **/
+const gchar *
+gdk_x11_get_xatom_name (Atom xatom)
+{
+ return get_atom_name (gdk_x11_xatom_to_atom (xatom));
+}
+
+gboolean
+_gdk_x11_window_get_property (GdkWindow *window,
+ GdkAtom property,
+ GdkAtom type,
+ gulong offset,
+ gulong length,
+ gint pdelete,
+ GdkAtom *actual_property_type,
+ gint *actual_format_type,
+ gint *actual_length,
+ guchar **data)
+{
+ GdkDisplay *display;
Atom ret_prop_type;
gint ret_format;
gulong ret_nitems;
gulong ret_bytes_after;
+ gulong get_length;
gulong ret_length;
guchar *ret_data;
+ Atom xproperty;
+ Atom xtype;
+ int res;
- g_return_val_if_fail (window != NULL, FALSE);
- g_return_val_if_fail (!GDK_IS_WINDOW (window), FALSE);
+ g_return_val_if_fail (!window || GDK_WINDOW_IS_X11 (window), FALSE);
- if (window)
+ if (!window)
{
- if (GDK_DRAWABLE_DESTROYED (window))
- return FALSE;
-
- xdisplay = GDK_DRAWABLE_XDISPLAY (window);
- xwindow = GDK_DRAWABLE_XID (window);
+ GdkScreen *screen = gdk_screen_get_default ();
+ window = gdk_screen_get_root_window (screen);
+
+ GDK_NOTE (MULTIHEAD, g_message ("gdk_property_get(): window is NULL\n"));
}
+ else if (!GDK_WINDOW_IS_X11 (window))
+ return FALSE;
+
+ if (GDK_WINDOW_DESTROYED (window))
+ return FALSE;
+
+ display = gdk_window_get_display (window);
+ xproperty = gdk_x11_atom_to_xatom_for_display (display, property);
+ if (type == GDK_NONE)
+ xtype = AnyPropertyType;
else
+ xtype = gdk_x11_atom_to_xatom_for_display (display, type);
+
+ ret_data = NULL;
+
+ /*
+ * Round up length to next 4 byte value. Some code is in the (bad?)
+ * habit of passing G_MAXLONG as the length argument, causing an
+ * overflow to negative on the add. In this case, we clamp the
+ * value to G_MAXLONG.
+ */
+ get_length = length + 3;
+ if (get_length > G_MAXLONG)
+ get_length = G_MAXLONG;
+
+ /* To fail, either the user passed 0 or G_MAXULONG */
+ get_length = get_length / 4;
+ if (get_length == 0)
{
- xdisplay = gdk_display;
- xwindow = gdk_root_window;
+ g_warning ("gdk_propery-get(): invalid length 0");
+ return FALSE;
}
- ret_data = NULL;
- XGetWindowProperty (xdisplay, xwindow, property,
- offset, (length + 3) / 4, pdelete,
- type, &ret_prop_type, &ret_format,
- &ret_nitems, &ret_bytes_after,
- &ret_data);
+ res = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
+ GDK_WINDOW_XID (window), xproperty,
+ offset, get_length, pdelete,
+ xtype, &ret_prop_type, &ret_format,
+ &ret_nitems, &ret_bytes_after,
+ &ret_data);
- if ((ret_prop_type == None) && (ret_format == 0)) {
- return FALSE;
- }
+ if (res != Success || (ret_prop_type == None && ret_format == 0))
+ {
+ return FALSE;
+ }
if (actual_property_type)
- *actual_property_type = ret_prop_type;
+ *actual_property_type = gdk_x11_xatom_to_atom_for_display (display, ret_prop_type);
if (actual_format_type)
*actual_format_type = ret_format;
- if ((type != AnyPropertyType) && (ret_prop_type != type))
+ if ((xtype != AnyPropertyType) && (ret_prop_type != xtype))
{
- gchar *rn, *pn;
-
XFree (ret_data);
- rn = gdk_atom_name(ret_prop_type);
- pn = gdk_atom_name(type);
- g_warning("Couldn't match property type %s to %s\n", rn, pn);
- g_free(rn); g_free(pn);
+ g_warning ("Couldn't match property type %s to %s\n",
+ gdk_x11_get_xatom_name_for_display (display, ret_prop_type),
+ gdk_x11_get_xatom_name_for_display (display, xtype));
return FALSE;
}
if (data)
{
- switch (ret_format)
+ if (ret_prop_type == XA_ATOM ||
+ ret_prop_type == gdk_x11_get_xatom_by_name_for_display (display, "ATOM_PAIR"))
{
- case 8:
- ret_length = ret_nitems;
- break;
- case 16:
- ret_length = sizeof(short) * ret_nitems;
- break;
- case 32:
- ret_length = sizeof(long) * ret_nitems;
- break;
- default:
- g_warning ("unknown property return format: %d", ret_format);
- XFree (ret_data);
- return FALSE;
+ /*
+ * data is an array of X atom, we need to convert it
+ * to an array of GDK Atoms
+ */
+ gint i;
+ GdkAtom *ret_atoms = g_new (GdkAtom, ret_nitems);
+ Atom *xatoms = (Atom *)ret_data;
+
+ *data = (guchar *)ret_atoms;
+
+ for (i = 0; i < ret_nitems; i++)
+ ret_atoms[i] = gdk_x11_xatom_to_atom_for_display (display, xatoms[i]);
+
+ if (actual_length)
+ *actual_length = ret_nitems * sizeof (GdkAtom);
+ }
+ else
+ {
+ switch (ret_format)
+ {
+ case 8:
+ ret_length = ret_nitems;
+ break;
+ case 16:
+ ret_length = sizeof(short) * ret_nitems;
+ break;
+ case 32:
+ ret_length = sizeof(long) * ret_nitems;
+ break;
+ default:
+ g_warning ("unknown property return format: %d", ret_format);
+ XFree (ret_data);
+ return FALSE;
+ }
+
+ *data = g_new (guchar, ret_length);
+ memcpy (*data, ret_data, ret_length);
+ if (actual_length)
+ *actual_length = ret_length;
}
-
- *data = g_new (guchar, ret_length);
- memcpy (*data, ret_data, ret_length);
- if (actual_length)
- *actual_length = ret_length;
}
XFree (ret_data);
}
void
-gdk_property_change (GdkWindow *window,
- GdkAtom property,
- GdkAtom type,
- gint format,
- GdkPropMode mode,
- guchar *data,
- gint nelements)
-{
- Display *xdisplay;
+_gdk_x11_window_change_property (GdkWindow *window,
+ GdkAtom property,
+ GdkAtom type,
+ gint format,
+ GdkPropMode mode,
+ const guchar *data,
+ gint nelements)
+{
+ GdkDisplay *display;
Window xwindow;
+ Atom xproperty;
+ Atom xtype;
- g_return_if_fail (window != NULL);
- g_return_if_fail (!GDK_IS_WINDOW (window));
+ g_return_if_fail (!window || GDK_WINDOW_IS_X11 (window));
- if (window)
+ if (!window)
{
- if (GDK_DRAWABLE_DESTROYED (window))
- return;
-
- xdisplay = GDK_DRAWABLE_XDISPLAY (window);
- xwindow = GDK_DRAWABLE_XID (window);
- }
- else
- {
- xdisplay = gdk_display;
- xwindow = gdk_root_window;
+ GdkScreen *screen;
+
+ screen = gdk_screen_get_default ();
+ window = gdk_screen_get_root_window (screen);
+
+ GDK_NOTE (MULTIHEAD, g_message ("gdk_property_change(): window is NULL\n"));
}
+ else if (!GDK_WINDOW_IS_X11 (window))
+ return;
- XChangeProperty (xdisplay, xwindow, property, type,
- format, mode, data, nelements);
-}
+ if (GDK_WINDOW_DESTROYED (window))
+ return;
-void
-gdk_property_delete (GdkWindow *window,
- GdkAtom property)
-{
- Display *xdisplay;
- Window xwindow;
+ gdk_window_ensure_native (window);
- g_return_if_fail (window != NULL);
- g_return_if_fail (!GDK_IS_WINDOW (window));
+ display = gdk_window_get_display (window);
+ xproperty = gdk_x11_atom_to_xatom_for_display (display, property);
+ xtype = gdk_x11_atom_to_xatom_for_display (display, type);
+ xwindow = GDK_WINDOW_XID (window);
- if (window)
+ if (xtype == XA_ATOM ||
+ xtype == gdk_x11_get_xatom_by_name_for_display (display, "ATOM_PAIR"))
{
- if (GDK_DRAWABLE_DESTROYED (window))
- return;
-
- xdisplay = GDK_DRAWABLE_XDISPLAY (window);
- xwindow = GDK_DRAWABLE_XID (window);
+ /*
+ * data is an array of GdkAtom, we need to convert it
+ * to an array of X Atoms
+ */
+ gint i;
+ GdkAtom *atoms = (GdkAtom*) data;
+ Atom *xatoms;
+
+ xatoms = g_new (Atom, nelements);
+ for (i = 0; i < nelements; i++)
+ xatoms[i] = gdk_x11_atom_to_xatom_for_display (display, atoms[i]);
+
+ XChangeProperty (GDK_DISPLAY_XDISPLAY (display), xwindow,
+ xproperty, xtype,
+ format, mode, (guchar *)xatoms, nelements);
+ g_free (xatoms);
}
else
+ XChangeProperty (GDK_DISPLAY_XDISPLAY (display), xwindow, xproperty,
+ xtype, format, mode, (guchar *)data, nelements);
+}
+
+void
+_gdk_x11_window_delete_property (GdkWindow *window,
+ GdkAtom property)
+{
+ g_return_if_fail (!window || GDK_WINDOW_IS_X11 (window));
+
+ if (!window)
{
- xdisplay = gdk_display;
- xwindow = gdk_root_window;
+ GdkScreen *screen = gdk_screen_get_default ();
+ window = gdk_screen_get_root_window (screen);
+
+ GDK_NOTE (MULTIHEAD,
+ g_message ("gdk_property_delete(): window is NULL\n"));
}
+ else if (!GDK_WINDOW_IS_X11 (window))
+ return;
+
+ if (GDK_WINDOW_DESTROYED (window))
+ return;
- XDeleteProperty (xdisplay, xwindow, property);
+ XDeleteProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
+ gdk_x11_atom_to_xatom_for_display (GDK_WINDOW_DISPLAY (window),
+ property));
}
projects / ~andy / gtk / blobdiff