+Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
+ Start implementing display/screen closing scheme; keep a
+ flag for whether displays and screens are closed,
+ call g_object_run_dispose(). Remove public gdk_screen_close().
+
+ * gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
+ dispose() methods; move appropriate parts of the finalize
+ there.
+
+ * gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
+ gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
+ gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
+ gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
+ Start of making everything correctly ignore operations
+ when a display has been closed.
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
+ Handle decorations == NULL.
+
+ * gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
+ Remove unnecessary hash table creation.
+
+ * gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
+ Fix up gdk_device_get_history - handle events, n_events == NULL,
+ etc.
+
+ * gdk/x11/gdkproperty-x11.c (gdk_property_get):
+ Handle failure better.
+
+ * gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
+ Handle failure better, handle data == NULL, move docs
+ here, remove an excess round trip by asking for
+ all selection data at once.
+
+ * gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
+ gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
+ gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
+ gdk_display_set_sm_client_id() to display-independent part of GDK.
+
+ * gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
+ into the right place.
+
2002-07-31 jacob berkman <jacob@ximian.com>
* gtk/queryimmodules.c (print_escaped): escape_string() only takes
+Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
+ Start implementing display/screen closing scheme; keep a
+ flag for whether displays and screens are closed,
+ call g_object_run_dispose(). Remove public gdk_screen_close().
+
+ * gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
+ dispose() methods; move appropriate parts of the finalize
+ there.
+
+ * gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
+ gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
+ gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
+ gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
+ Start of making everything correctly ignore operations
+ when a display has been closed.
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
+ Handle decorations == NULL.
+
+ * gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
+ Remove unnecessary hash table creation.
+
+ * gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
+ Fix up gdk_device_get_history - handle events, n_events == NULL,
+ etc.
+
+ * gdk/x11/gdkproperty-x11.c (gdk_property_get):
+ Handle failure better.
+
+ * gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
+ Handle failure better, handle data == NULL, move docs
+ here, remove an excess round trip by asking for
+ all selection data at once.
+
+ * gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
+ gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
+ gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
+ gdk_display_set_sm_client_id() to display-independent part of GDK.
+
+ * gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
+ into the right place.
+
2002-07-31 jacob berkman <jacob@ximian.com>
* gtk/queryimmodules.c (print_escaped): escape_string() only takes
+Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
+ Start implementing display/screen closing scheme; keep a
+ flag for whether displays and screens are closed,
+ call g_object_run_dispose(). Remove public gdk_screen_close().
+
+ * gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
+ dispose() methods; move appropriate parts of the finalize
+ there.
+
+ * gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
+ gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
+ gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
+ gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
+ Start of making everything correctly ignore operations
+ when a display has been closed.
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
+ Handle decorations == NULL.
+
+ * gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
+ Remove unnecessary hash table creation.
+
+ * gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
+ Fix up gdk_device_get_history - handle events, n_events == NULL,
+ etc.
+
+ * gdk/x11/gdkproperty-x11.c (gdk_property_get):
+ Handle failure better.
+
+ * gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
+ Handle failure better, handle data == NULL, move docs
+ here, remove an excess round trip by asking for
+ all selection data at once.
+
+ * gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
+ gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
+ gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
+ gdk_display_set_sm_client_id() to display-independent part of GDK.
+
+ * gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
+ into the right place.
+
2002-07-31 jacob berkman <jacob@ximian.com>
* gtk/queryimmodules.c (print_escaped): escape_string() only takes
+Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
+ Start implementing display/screen closing scheme; keep a
+ flag for whether displays and screens are closed,
+ call g_object_run_dispose(). Remove public gdk_screen_close().
+
+ * gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
+ dispose() methods; move appropriate parts of the finalize
+ there.
+
+ * gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
+ gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
+ gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
+ gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
+ Start of making everything correctly ignore operations
+ when a display has been closed.
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
+ Handle decorations == NULL.
+
+ * gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
+ Remove unnecessary hash table creation.
+
+ * gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
+ Fix up gdk_device_get_history - handle events, n_events == NULL,
+ etc.
+
+ * gdk/x11/gdkproperty-x11.c (gdk_property_get):
+ Handle failure better.
+
+ * gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
+ Handle failure better, handle data == NULL, move docs
+ here, remove an excess round trip by asking for
+ all selection data at once.
+
+ * gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
+ gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
+ gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
+ gdk_display_set_sm_client_id() to display-independent part of GDK.
+
+ * gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
+ into the right place.
+
2002-07-31 jacob berkman <jacob@ximian.com>
* gtk/queryimmodules.c (print_escaped): escape_string() only takes
+Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
+ Start implementing display/screen closing scheme; keep a
+ flag for whether displays and screens are closed,
+ call g_object_run_dispose(). Remove public gdk_screen_close().
+
+ * gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
+ dispose() methods; move appropriate parts of the finalize
+ there.
+
+ * gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
+ gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
+ gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
+ gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
+ Start of making everything correctly ignore operations
+ when a display has been closed.
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
+ Handle decorations == NULL.
+
+ * gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
+ Remove unnecessary hash table creation.
+
+ * gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
+ Fix up gdk_device_get_history - handle events, n_events == NULL,
+ etc.
+
+ * gdk/x11/gdkproperty-x11.c (gdk_property_get):
+ Handle failure better.
+
+ * gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
+ Handle failure better, handle data == NULL, move docs
+ here, remove an excess round trip by asking for
+ all selection data at once.
+
+ * gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
+ gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
+ gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
+ gdk_display_set_sm_client_id() to display-independent part of GDK.
+
+ * gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
+ into the right place.
+
2002-07-31 jacob berkman <jacob@ximian.com>
* gtk/queryimmodules.c (print_escaped): escape_string() only takes
+Thu Aug 1 11:26:03 2002 Owen Taylor <otaylor@redhat.com>
+
+ * gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch] gdkinternals.h:
+ Start implementing display/screen closing scheme; keep a
+ flag for whether displays and screens are closed,
+ call g_object_run_dispose(). Remove public gdk_screen_close().
+
+ * gdk/x11/gdkdisplay-x11.c gdk/x11/gdkscreen-x11.c: Add
+ dispose() methods; move appropriate parts of the finalize
+ there.
+
+ * gdk/x11/gdkcolor-x11.c gdk/x11/gdkimage-x11.c
+ gdk/x11/gdkmain-x11.c gdk/x11/gdkpango-x11.c
+ gdk/x11/gdkpixmap-x11.c gdk/x11/gdkproperty-x11.c
+ gdk/x11/gdkselection-x11.c gdk/x11/gdkwindow-x11.c:
+ Start of making everything correctly ignore operations
+ when a display has been closed.
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_decorations):
+ Handle decorations == NULL.
+
+ * gdk/x11/gdkcolor-x11.c (gdk_colormap_remove):
+ Remove unnecessary hash table creation.
+
+ * gdk/x11/gdkinput.c gdk/x11/gdkinput-x11.c gdk/win32/gdkinput.c
+ Fix up gdk_device_get_history - handle events, n_events == NULL,
+ etc.
+
+ * gdk/x11/gdkproperty-x11.c (gdk_property_get):
+ Handle failure better.
+
+ * gdk/x11/gdkselection-x11.c (gdk_selection_property_get):
+ Handle failure better, handle data == NULL, move docs
+ here, remove an excess round trip by asking for
+ all selection data at once.
+
+ * gdk/gdkselection.c gdk/win32/{x11,win32}/gdkselection-{x11,win32}.c
+ gdk/{x11,win32}/gdkmain-{x11,win32}.c gdk/gdkdisplay.c: Move
+ gdk_text_property_to_text_list(), gdk_string_to_compound_text(),
+ gdk_display_set_sm_client_id() to display-independent part of GDK.
+
+ * gdk/Makefile.am (gdk_c_sources): Sort gdkdisplay/screen.[ch]
+ into the right place.
+
2002-07-31 jacob berkman <jacob@ximian.com>
* gtk/queryimmodules.c (print_escaped): escape_string() only takes
<!-- ##### FUNCTION gdk_selection_property_get ##### -->
<para>
-Retrieves selection data that was stored by the selection
-data in response to a call to gdk_selection_convert().
</para>
-@requestor: the window on which the data is stored
-@data: location to store a pointer to the retrieved data.
- If the retrieval failed, %NULL we be stored here, otherwise, it
- will be non-%NULL and the returned data should be freed with g_free()
- when you are finished using it. The length of the
- allocated memory is one more than the the length
- of the returned data, and the final byte will always
- be zero, to ensure nul-termination of strings.
-@prop_type: location to store the type of the property.
-@prop_format: location to store the format of the property.
-@Returns: the length of the retrieved data.
+@requestor:
+@data:
+@prop_type:
+@prop_format:
+@Returns:
<!-- ##### FUNCTION gdk_selection_send_notify ##### -->
gdk.h \
gdkcolor.h \
gdkcursor.h \
+ gdkdisplay.h \
gdkdnd.h \
gdkdrawable.h \
gdkevents.h \
gdkproperty.h \
gdkregion.h \
gdkrgb.h \
+ gdkscreen.h \
gdkselection.h \
gdktypes.h \
gdkvisual.h \
gdkwindow.h \
- gdkdisplay.h \
- gdkscreen.h \
@STRIP_END@
gdk_headers = @STRIP_BEGIN@ \
gdk.c \
gdkcolor.c \
gdkcursor.c \
+ gdkdisplay.c \
gdkdraw.c \
gdkevents.c \
gdkfont.c \
gdkrectangle.c \
gdkregion-generic.c \
gdkregion-generic.h \
+ gdkscreen.c \
gdkselection.c \
gdkvisual.c \
gdkwindow.c \
- gdkdisplay.c \
- gdkscreen.c \
@STRIP_END@
#
static void gdk_display_class_init (GdkDisplayClass *class);
static void gdk_display_init (GdkDisplay *display);
+static void gdk_display_dispose (GObject *object);
static void gdk_display_finalize (GObject *object);
static GObjectClass *parent_class;
parent_class = g_type_class_peek_parent (class);
object_class->finalize = gdk_display_finalize;
+ object_class->dispose = gdk_display_dispose;
}
static void
display->double_click_time = 250;
}
+static void
+gdk_display_dispose (GObject *object)
+{
+ GdkDisplay *display = GDK_DISPLAY_OBJECT (object);
+}
+
static void
gdk_display_finalize (GObject *object)
{
* gdk_display_close:
* @display: a #GdkDisplay
*
- * Closes and cleanup the resources used by the @display
+ * Closes the connection windowing system for the given display,
+ * and cleans up associated resources.
*/
void
gdk_display_close (GdkDisplay *display)
{
g_return_if_fail (GDK_IS_DISPLAY (display));
- g_object_unref (G_OBJECT (display));
+
+ if (!display->closed)
+ {
+ display->closed = TRUE;
+
+ g_object_run_dispose (G_OBJECT (display));
+
+ g_object_unref (G_OBJECT (display));
+ }
}
/**
{
return display->core_pointer;
}
+
+/**
+ * gdk_set_sm_client_id:
+ * @sm_client_id: the client id assigned by the session manager when the
+ * connection was opened, or %NULL to remove the property.
+ *
+ * Sets the <literal>SM_CLIENT_ID</literal> property on the application's leader window so that
+ * the window manager can save the application's state using the X11R6 ICCCM
+ * session management protocol.
+ *
+ * See the X Session Management Library documentation for more information on
+ * session management and the Inter-Client Communication Conventions Manual
+ * (ICCCM) for information on the <literal>WM_CLIENT_LEADER</literal> property.
+ * (Both documents are part of the X Window System distribution.)
+ **/
+void
+gdk_set_sm_client_id (const gchar* sm_client_id)
+{
+ gdk_display_set_sm_client_id (gdk_display_get_default (), sm_client_id);
+}
+
GdkWindow *button_window[2]; /* The last 2 windows to receive button presses. */
guint button_number[2]; /* The last 2 buttons to be pressed. */
+ guint double_click_time; /* Maximum time between clicks in msecs */
GdkDevice *core_pointer; /* Core pointer device */
- guint double_click_time; /* Maximum time between clicks in msecs */
+ guint closed : 1; /* Whether this display has been closed */
};
struct _GdkDisplayClass
void _gdk_window_destroy (GdkWindow *window,
gboolean foreign_destroy);
void _gdk_window_clear_update_area (GdkWindow *window);
-
+
+void _gdk_screen_close (GdkScreen *screen);
/*****************************************
* Interfaces provided by windowing code *
return object_type;
}
-
-/**
- * gdk_screen_close:
- * @screen: a #GdkScreen
- *
- * Closes the @screen connection and cleanup its resources.
- * Note that this function is called automatically by gdk_display_close().
- **/
void
-gdk_screen_close (GdkScreen *screen)
+_gdk_screen_close (GdkScreen *screen)
{
g_return_if_fail (GDK_IS_SCREEN (screen));
-
- g_object_run_dispose (G_OBJECT (screen));
+
+ if (!screen->closed)
+ {
+ screen->closed = TRUE;
+ g_object_run_dispose (G_OBJECT (screen));
+ }
}
/**
struct _GdkScreen
{
GObject parent_instance;
+
+ guint closed : 1;
};
struct _GdkScreenClass
gint gdk_screen_get_height (GdkScreen *screen);
gint gdk_screen_get_width_mm (GdkScreen *screen);
gint gdk_screen_get_height_mm (GdkScreen *screen);
-void gdk_screen_close (GdkScreen *screen);
GList * gdk_screen_list_visuals (GdkScreen *screen);
GList * gdk_screen_get_toplevel_windows (GdkScreen *screen);
target, property, time);
}
+gint
+gdk_text_property_to_text_list (GdkAtom encoding,
+ gint format,
+ const guchar *text,
+ gint length,
+ gchar ***list)
+{
+ return gdk_text_property_to_text_list_for_display (gdk_display_get_default (),
+ encoding, format, text, length, list);
+}
+
/**
* gdk_text_property_to_utf8_list:
* @encoding: an atom representing the encoding of the text
encoding, format, text, length, list);
}
+gint
+gdk_string_to_compound_text (const gchar *str,
+ GdkAtom *encoding,
+ gint *format,
+ guchar **ctext,
+ gint *length)
+{
+ return gdk_string_to_compound_text_for_display (gdk_display_get_default (),
+ str, encoding, format,
+ ctext, length);
+}
+
/**
* gdk_utf8_to_compound_text:
* @str: a UTF-8 string
g_return_val_if_fail (events != NULL, FALSE);
g_return_val_if_fail (n_events != NULL, FALSE);
- *n_events = 0;
- *events = NULL;
+ if (n_events)
+ *n_events = 0;
+ if (events)
+ *events = NULL;
if (GDK_WINDOW_DESTROYED (window))
return FALSE;
}
void
-gdk_set_sm_client_id (const gchar* sm_client_id)
+gdk_display_set_sm_client_id (const gchar* sm_client_id)
{
g_warning("gdk_set_sm_client_id %s", sm_client_id ? sm_client_id : "NULL");
}
/* Simplistic implementations of text list and compound text functions */
gint
-gdk_text_property_to_text_list (GdkAtom encoding,
- gint format,
- const guchar *text,
- gint length,
- gchar ***list)
+gdk_text_property_to_text_list_for_display (GdkAtom encoding,
+ gint format,
+ const guchar *text,
+ gint length,
+ gchar ***list)
{
gchar *enc_name;
}
gint
-gdk_string_to_compound_text (const gchar *str,
- GdkAtom *encoding,
- gint *format,
- guchar **ctext,
- gint *length)
+gdk_string_to_compound_text_for_display (const gchar *str,
+ GdkAtom *encoding,
+ gint *format,
+ guchar **ctext,
+ gint *length)
{
GDK_NOTE (DND, g_print ("gdk_string_to_compound_text: %.20s\n", str));
gdk_colormap_remove (colormap);
- XFreeColormap (GDK_SCREEN_XDISPLAY (private->screen), private->xcolormap);
+ if (!private->screen->closed)
+ XFreeColormap (GDK_SCREEN_XDISPLAY (private->screen), private->xcolormap);
if (private->hash)
g_hash_table_destroy (private->hash);
nlookup++;
}
}
-
+
XQueryColors (GDK_SCREEN_XDISPLAY (private->screen),
private->xcolormap, xpalette, nlookup);
{
time_t current_time;
GdkColormapPrivateX11 *private = GDK_COLORMAP_PRIVATE_DATA (colormap);
-
+
g_return_if_fail (GDK_IS_COLORMAP (colormap));
+ if (private->screen->closed)
+ return;
+
current_time = time (NULL);
if (!force && ((current_time - private->last_sync_time) < MIN_SYNC_TIME))
return;
private = GDK_COLORMAP_PRIVATE_DATA (colormap);
+ if (private->screen->closed)
+ return;
+
xdisplay = GDK_SCREEN_XDISPLAY (private->screen);
palette = g_new (XColor, ncolors);
private = GDK_COLORMAP_PRIVATE_DATA (colormap);
+ if (private->screen->closed)
+ return FALSE;
+
return_val = XAllocColorCells (GDK_SCREEN_XDISPLAY (private->screen),
private->xcolormap,contiguous, planes,
nplanes, pixels, npixels);
}
}
- if (npixels)
+ if (npixels && !private->screen->closed)
XFreeColors (GDK_SCREEN_XDISPLAY (private->screen), private->xcolormap,
pixels, npixels, planes);
g_free (pixels);
}
}
- if (npixels)
+ if (npixels && !private->screen->closed)
XFreeColors (GDK_SCREEN_XDISPLAY (private->screen), private->xcolormap,
pixels, npixels, 0);
gint nremaining = 0;
XColor xcolor;
- g_return_val_if_fail (GDK_IS_COLORMAP (colormap), FALSE);
- g_return_val_if_fail (colors != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_COLORMAP (colormap), ncolors);
+ g_return_val_if_fail (colors != NULL, ncolors);
private = GDK_COLORMAP_PRIVATE_DATA (colormap);
+ if (private->screen->closed)
+ return ncolors;
+
for (i=0; i<ncolors; i++)
{
success[i] = FALSE;
* #GdkImage contains image data in hardware format, a #GdkPixbuf
* contains image data in a canonical 24-bit RGB format.)
*
- * This function is rarely useful, it's used for example to
+ * This function is rarely useful; it's used for example to
* implement the eyedropper feature in #GtkColorSelection.
*
**/
break;
case GDK_VISUAL_STATIC_COLOR:
xcolor.pixel = pixel;
- XQueryColor (GDK_SCREEN_XDISPLAY (private->screen), private->xcolormap, &xcolor);
- result->red = xcolor.red;
- result->green = xcolor.green;
- result->blue = xcolor.blue;
+ if (!private->screen->closed)
+ {
+ XQueryColor (GDK_SCREEN_XDISPLAY (private->screen), private->xcolormap, &xcolor);
+ result->red = xcolor.red;
+ result->green = xcolor.green;
+ result->blue = xcolor.blue;
+ }
+ else
+ result->red = result->green = result->blue = 0;
break;
case GDK_VISUAL_PSEUDO_COLOR:
g_return_if_fail (pixel < colormap->size);
xcolor.flags = DoRed | DoGreen | DoBlue;
private = GDK_COLORMAP_PRIVATE_DATA (colormap);
- XStoreColor (GDK_SCREEN_XDISPLAY (private->screen), private->xcolormap, &xcolor);
+ if (!private->screen->closed)
+ XStoreColor (GDK_SCREEN_XDISPLAY (private->screen), private->xcolormap, &xcolor);
return TRUE;
}
{
GdkColormapPrivateX11 *private;
- if (!colormap_hash)
- colormap_hash = g_hash_table_new ((GHashFunc) gdk_colormap_hash,
- (GEqualFunc) gdk_colormap_equal);
-
private = GDK_COLORMAP_PRIVATE_DATA (cmap);
g_hash_table_remove (colormap_hash, &private->xcolormap);
private = GDK_COLORMAP_PRIVATE_DATA (colormap);
- return private->xcolormap;
+ if (private->screen->closed)
+ return None;
+ else
+ return private->xcolormap;
}
/**
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
- xcursor = XCreateFontCursor (GDK_DISPLAY_XDISPLAY (display), cursor_type);
+ if (display->closed)
+ xcursor = None;
+ else
+ xcursor = XCreateFontCursor (GDK_DISPLAY_XDISPLAY (display), cursor_type);
+
private = g_new (GdkCursorPrivate, 1);
private->display = display;
private->xcursor = xcursor;
xbg.blue = bg->blue;
xbg.green = bg->green;
- xcursor = XCreatePixmapCursor (GDK_DISPLAY_XDISPLAY (display),
- source_pixmap, mask_pixmap, &xfg, &xbg, x, y);
+ if (display->closed)
+ xcursor = None;
+ else
+ xcursor = XCreatePixmapCursor (GDK_DISPLAY_XDISPLAY (display),
+ source_pixmap, mask_pixmap, &xfg, &xbg, x, y);
private = g_new (GdkCursorPrivate, 1);
private->display = display;
private->xcursor = xcursor;
g_return_if_fail (cursor->ref_count == 0);
private = (GdkCursorPrivate *) cursor;
- XFreeCursor (GDK_DISPLAY_XDISPLAY (private->display), private->xcursor);
+ if (!private->display->closed && private->xcursor)
+ XFreeCursor (GDK_DISPLAY_XDISPLAY (private->display), private->xcursor);
g_free (private);
}
#endif
static void gdk_display_x11_class_init (GdkDisplayX11Class *class);
+static void gdk_display_x11_dispose (GObject *object);
static void gdk_display_x11_finalize (GObject *object);
static void gdk_internal_connection_watch (Display *display,
static void
gdk_display_x11_class_init (GdkDisplayX11Class * class)
{
- G_OBJECT_CLASS (class)->finalize = gdk_display_x11_finalize;
+ GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+ object_class->dispose = gdk_display_x11_dispose;
+ object_class->finalize = gdk_display_x11_finalize;
parent_class = g_type_class_peek_parent (class);
}
XUngrabServer (display_x11->xdisplay);
}
+static void
+gdk_display_x11_dispose (GObject *object)
+{
+ GdkDisplayX11 *display_x11;
+ gint i;
+
+ display_x11 = GDK_DISPLAY_X11 (object);;
+
+ for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
+ _gdk_screen_close (display_x11->screens[i]);
+
+ XCloseDisplay (display_x11->xdisplay);
+ display_x11->xdisplay = NULL;
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
static void
gdk_display_x11_finalize (GObject *object)
{
for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
g_object_unref (G_OBJECT (display_x11->screens[i]));
g_free (display_x11->screens);
- XCloseDisplay (display_x11->xdisplay);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
{
return GDK_DISPLAY_X11 (display)->xdisplay;
}
-
-
}
}
+/**
+ * gdk_image_new_bitmap:
+ * @visual: the #GdkVisual to use for the image.
+ * @data: the pixel data.
+ * @w: the width of the image in pixels.
+ * @h: the height of the image in pixels.
+ *
+ * Creates a new #GdkImage with a depth of 1 from the given data.
+ * <warning><para>THIS FUNCTION IS INCREDIBLY BROKEN. The passed-in data must
+ * be allocated by malloc() (NOT g_malloc()) and will be freed when the
+ * image is freed.</para></warning>
+ *
+ * Return value: a new #GdkImage.
+ **/
GdkImage *
gdk_image_new_bitmap(GdkVisual *visual, gpointer data, gint w, gint h)
-/*
- * Desc: create a new bitmap image
- */
{
Visual *xvisual;
GdkImage *image;
+ GdkDisplay *display;
GdkImagePrivateX11 *private;
+
image = g_object_new (gdk_image_get_type (), NULL);
private = PRIVATE_DATA (image);
private->screen = gdk_visual_get_screen (visual);
+ display = GDK_SCREEN_DISPLAY (private->screen);
+
image->type = GDK_IMAGE_NORMAL;
image->visual = visual;
image->width = w;
image->height = h;
image->depth = 1;
image->bits_per_pixel = 1;
- xvisual = ((GdkVisualPrivate*) visual)->xvisual;
- private->ximage = XCreateImage (GDK_SCREEN_XDISPLAY (private->screen),
- xvisual, 1, XYBitmap,
- 0, 0, w ,h, 8, 0);
+ if (display->closed)
+ private->ximage = NULL;
+ else
+ {
+ xvisual = ((GdkVisualPrivate*) visual)->xvisual;
+ private->ximage = XCreateImage (GDK_SCREEN_XDISPLAY (private->screen),
+ xvisual, 1, XYBitmap,
+ 0, 0, w ,h, 8, 0);
+ }
+
private->ximage->data = data;
private->ximage->bitmap_bit_order = MSBFirst;
private->ximage->byte_order = MSBFirst;
return(image);
} /* gdk_image_new_bitmap() */
-static int
-gdk_image_check_xshm(Display *display)
/*
* Desc: query the server for support for the MIT_SHM extension
* Return: 0 = not available
* 1 = shared XImage support available
* 2 = shared Pixmap support available also
*/
+static int
+gdk_image_check_xshm(Display *display)
{
#ifdef USE_SHM
int major, minor, ignore;
GdkImagePrivateX11 *private = PRIVATE_DATA (image);
GdkDisplay *display = GDK_SCREEN_DISPLAY (private->screen);
+ if (display->closed)
+ return None;
+
#ifdef USE_SHM
/* Future: do we need one of these per-screen per-image? ShmPixmaps
* are the same for every screen, but can they be shared? Not a concern
impl = GDK_DRAWABLE_IMPL_X11 (drawable);
display = gdk_drawable_get_display (drawable);
xdisplay = gdk_x11_display_get_xdisplay (display);
-
+
+ if (display->closed)
+ return NULL;
have_grab = FALSE;
private = PRIVATE_DATA (image);
- pixel = XGetPixel (private->ximage, x, y);
+ if (!private->screen->closed)
+ pixel = XGetPixel (private->ximage, x, y);
+ else
+ pixel = 0;
return pixel;
}
private = PRIVATE_DATA (image);
- pixel = XPutPixel (private->ximage, x, y, pixel);
+ if (!private->screen->closed)
+ pixel = XPutPixel (private->ximage, x, y, pixel);
}
static void
switch (image->type)
{
case GDK_IMAGE_NORMAL:
- XDestroyImage (private->ximage);
+ if (!private->screen->closed)
+ XDestroyImage (private->ximage);
break;
case GDK_IMAGE_SHARED:
#ifdef USE_SHM
- gdk_display_sync (GDK_SCREEN_DISPLAY (private->screen));
+ if (!private->screen->closed)
+ {
+ gdk_display_sync (GDK_SCREEN_DISPLAY (private->screen));
- if (private->shm_pixmap)
- XFreePixmap (GDK_SCREEN_XDISPLAY (private->screen), private->shm_pixmap);
+ if (private->shm_pixmap)
+ XFreePixmap (GDK_SCREEN_XDISPLAY (private->screen), private->shm_pixmap);
- image_list = g_list_remove (image_list, image);
- XShmDetach (GDK_SCREEN_XDISPLAY (private->screen), private->x_shm_info);
- XDestroyImage (private->ximage);
+ XShmDetach (GDK_SCREEN_XDISPLAY (private->screen), private->x_shm_info);
+ XDestroyImage (private->ximage);
+ }
+ image_list = g_list_remove (image_list, image);
+
x_shm_info = private->x_shm_info;
shmdt (x_shm_info->shmaddr);
private = PRIVATE_DATA (image);
- return private->ximage;
+ if (private->screen->closed)
+ return NULL;
+ else
+ return private->ximage;
}
gint
{
XPixmapFormatValues *formats;
gint count, i;
-
+
formats = XListPixmapFormats (GDK_DISPLAY_XDISPLAY (display), &count);
for (i = 0; i < count; i++)
return TRUE;
}
else
- {
- *events = NULL;
- *n_events = 0;
-
- return FALSE;
- }
+ return FALSE;
}
void
void
_gdk_input_init(GdkDisplay *display)
{
- _gdk_init_input_core ();
+ _gdk_init_input_core (display);
GDK_DISPLAY_X11 (display)->input_ignore_core = FALSE;
gdk_input_common_init (display, FALSE);
}
}
}
+/**
+ * gdk_device_get_history:
+ * @device: a #GdkDevice
+ * @window: the window with respect to which which the event coordinates will be reported
+ * @start: starting timestamp for range of events to return
+ * @stop: ending timestamp for the range of events to return
+ * @events: location to store a newly-allocated array of #GdkTimeCoord, or %NULL
+ * @n_events: location to store the length of @events, or %NULL
+ *
+ * Obtains the motion history for a device; given a starting and
+ * ending timestamp, return all events in the motion history for
+ * the device in the given range of time. Some windowing systems
+ * do not support motion history, in which case, %FALSE will
+ * be returned. (This is not distinguishable from the case where
+ * motion history is supported and no events were found.)
+ *
+ * Return value: %TRUE if the windowing system supports motion history and
+ * at least one event was found.
+ **/
gboolean
gdk_device_get_history (GdkDevice *device,
GdkWindow *window,
GdkTimeCoord ***events,
gint *n_events)
{
- GdkTimeCoord **coords;
+ GdkTimeCoord **coords = NULL;
+ gboolean result = FALSE;
+ int tmp_n_events = 0;
int i;
- g_return_val_if_fail (window != NULL, FALSE);
g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
- g_return_val_if_fail (events != NULL, FALSE);
- g_return_val_if_fail (n_events != NULL, FALSE);
-
- *n_events = 0;
- *events = NULL;
if (GDK_WINDOW_DESTROYED (window))
- return FALSE;
-
- if (GDK_IS_CORE (device))
+ /* Nothing */ ;
+ else if (GDK_IS_CORE (device))
{
XTimeCoord *xcoords;
xcoords = XGetMotionEvents (GDK_DRAWABLE_XDISPLAY (window),
GDK_DRAWABLE_XID (window),
- start, stop, n_events);
+ start, stop, &tmp_n_events);
if (xcoords)
{
- coords = _gdk_device_allocate_history (device, *n_events);
- for (i=0; i<*n_events; i++)
+ coords = _gdk_device_allocate_history (device, tmp_n_events);
+ for (i=0; i<tmp_n_events; i++)
{
coords[i]->time = xcoords[i].time;
coords[i]->axes[0] = xcoords[i].x;
XFree (xcoords);
- *events = coords;
- return TRUE;
+ result = TRUE;
}
else
- return FALSE;
+ result = FALSE;
}
else
- return _gdk_device_get_history (device, window, start, stop, events, n_events);
+ result = _gdk_device_get_history (device, window, start, stop, &coords, &tmp_n_events);
+
+ if (n_events)
+ *n_events = tmp_n_events;
+ if (events)
+ *events = coords;
+ else if (coords)
+ gdk_device_free_history (coords, tmp_n_events);
+
+ return result;
}
GdkTimeCoord **
display_x11->keyboard_xgrab_window = NULL;
}
-/**
- * gdk_set_sm_client_id:
- * @sm_client_id: the client id assigned by the session manager when the
- * connection was opened, or %NULL to remove the property.
- *
- * Sets the <literal>SM_CLIENT_ID</literal> property on the application's leader window so that
- * the window manager can save the application's state using the X11R6 ICCCM
- * session management protocol.
- *
- * See the X Session Management Library documentation for more information on
- * session management and the Inter-Client Communication Conventions Manual
- * (ICCCM) for information on the <literal>WM_CLIENT_LEADER</literal> property.
- * (Both documents are part of the X Window System distribution.)
- **/
-void
-gdk_set_sm_client_id (const gchar* sm_client_id)
-{
- gdk_display_set_sm_client_id (gdk_display_get_default (),sm_client_id);
-}
-
/**
* gdk_display_set_sm_client_id:
* @display: a #GdkDisplay
{
GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
+ if (display->closed)
+ return;
+
if (sm_client_id && strcmp (sm_client_id, ""))
{
XChangeProperty (display_x11->xdisplay, display_x11->leader_window,
{
gboolean result;
+ if (display->closed)
+ return FALSE;
+
gdk_error_trap_push ();
result = XSendEvent (GDK_DISPLAY_XDISPLAY (display), window,
propagate, event_mask, event_send);
* Gets the default GTK+ screen number.
*
* Return value: returns the screen number specified by
- * the --display command line option on the DISPLAY environment
- * variable gdk_init() calls XOpenDisplay().
+ * the --display command line option or the DISPLAY environment
+ * variable when gdk_init() calls XOpenDisplay().
**/
gint
gdk_x11_get_default_screen (void)
GdkDisplayX11 *display_x11;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+
+ if (screen->closed)
+ return NULL;
display_x11 = GDK_DISPLAY_X11 (GDK_SCREEN_DISPLAY (screen));
{
GdkPixmapImplX11 *impl = GDK_PIXMAP_IMPL_X11 (object);
GdkPixmap *wrapper = GDK_PIXMAP (GDK_DRAWABLE_IMPL_X11 (impl)->wrapper);
+ GdkDisplay *display = GDK_PIXMAP_DISPLAY (wrapper);
+ if (!display->closed)
+ {
#ifdef HAVE_XFT
- {
- GdkDrawableImplX11 *draw_impl = GDK_DRAWABLE_IMPL_X11 (impl);
-
- if (draw_impl->picture)
- XRenderFreePicture (GDK_PIXMAP_XDISPLAY (wrapper), draw_impl->picture);
- }
+ {
+ GdkDrawableImplX11 *draw_impl = GDK_DRAWABLE_IMPL_X11 (impl);
+
+ if (draw_impl->picture)
+ XRenderFreePicture (GDK_DISPLAY_XDISPLAY (display), draw_impl->picture);
+ }
#endif /* HAVE_XFT */
- if (!impl->is_foreign)
- XFreePixmap (GDK_PIXMAP_XDISPLAY (wrapper), GDK_PIXMAP_XID (wrapper));
-
- _gdk_xid_table_remove (GDK_PIXMAP_DISPLAY (wrapper), GDK_PIXMAP_XID (wrapper));
+ if (!impl->is_foreign)
+ XFreePixmap (GDK_DISPLAY_XDISPLAY (display), GDK_PIXMAP_XID (wrapper));
+ }
+
+ _gdk_xid_table_remove (display, GDK_PIXMAP_XID (wrapper));
G_OBJECT_CLASS (parent_class)->finalize (object);
}
"CAP_HEIGHT",
"WM_CLASS",
"WM_TRANSIENT_FOR",
- /* Below here, these our our additions. Increment N_CUSTOM_PREDEFINED
+ /* Below here, these are our additions. Increment N_CUSTOM_PREDEFINED
* if you add any.
*/
"CLIPBOARD" /* = 69 */
Atom xatom = None;
g_return_val_if_fail (GDK_IS_DISPLAY (display), None);
+
+ if (display->closed)
+ return None;
display_x11 = GDK_DISPLAY_X11 (display);
GdkDisplayX11 *display_x11;
GdkAtom virtual_atom = GDK_NONE;
- g_return_val_if_fail (GDK_IS_DISPLAY (display), virtual_atom);
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), GDK_NONE);
+
+ if (display->closed)
+ return GDK_NONE;
display_x11 = GDK_DISPLAY_X11 (display);
guchar *ret_data;
Atom xproperty;
Atom xtype;
+ int res;
g_return_val_if_fail (!window || GDK_IS_WINDOW (window), FALSE);
GDK_NOTE (MULTIHEAD, g_message ("gdk_property_get(): window is NULL\n"));
}
+ if (GDK_WINDOW_DESTROYED (window))
+ return FALSE;
+
display = gdk_drawable_get_display (window);
xproperty = gdk_x11_atom_to_xatom_for_display (display, property);
xtype = gdk_x11_atom_to_xatom_for_display (display, type);
ret_data = NULL;
- XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
- GDK_WINDOW_XWINDOW (window), xproperty,
- offset, (length + 3) / 4, pdelete,
- xtype, &ret_prop_type, &ret_format,
- &ret_nitems, &ret_bytes_after,
- &ret_data);
-
- if ((ret_prop_type == None) && (ret_format == 0))
+ res = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
+ GDK_WINDOW_XWINDOW (window), xproperty,
+ offset, (length + 3) / 4, pdelete,
+ xtype, &ret_prop_type, &ret_format,
+ &ret_nitems, &ret_bytes_after,
+ &ret_data);
+
+ if (res != Success || (ret_prop_type == None && ret_format == 0))
{
return FALSE;
}
}
+ if (GDK_WINDOW_DESTROYED (window))
+ return;
+
display = gdk_drawable_get_display (window);
xproperty = gdk_x11_atom_to_xatom_for_display (display, property);
#endif
static void gdk_screen_x11_class_init (GdkScreenX11Class *klass);
+static void gdk_screen_x11_dispose (GObject *object);
static void gdk_screen_x11_finalize (GObject *object);
static void init_xinerama_support (GdkScreen *screen);
}
void
-gdk_screen_x11_class_init (GdkScreenX11Class * klass)
+gdk_screen_x11_class_init (GdkScreenX11Class *klass)
{
- G_OBJECT_CLASS (klass)->finalize = gdk_screen_x11_finalize;
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->dispose = gdk_screen_x11_dispose;
+ object_class->finalize = gdk_screen_x11_finalize;
+
parent_class = g_type_class_peek_parent (klass);
}
GDK_SCREEN_X11 (screen)->default_colormap = colormap;
}
+static void
+gdk_screen_x11_dispose (GObject *object)
+{
+ GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (object);
+
+ screen_x11->root_window = NULL;
+
+ screen_x11->xdisplay = NULL;
+ screen_x11->xscreen = NULL;
+ screen_x11->screen_num = -1;
+ screen_x11->xroot_window = None;
+ screen_x11->wmspec_check_window = None;
+
+ G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
static void
gdk_screen_x11_finalize (GObject *object)
{
g_hash_table_destroy (screen_x11->visual_hash);
/* X settings */
g_free (screen_x11->xsettings_client);
+
+ g_free (screen_x11->monitors);
+
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GType _gdk_screen_x11_get_type (void);
GdkScreen * _gdk_x11_screen_new (GdkDisplay *display,
gint screen_number);
+
G_END_DECLS
#endif /* __GDK_SCREEN_X11_H__ */
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
+ if (display->closed)
+ return FALSE;
+
if (owner)
{
if (GDK_WINDOW_DESTROYED (owner))
Window xwindow;
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+ if (display->closed)
+ return NULL;
+
xwindow = XGetSelectionOwner (GDK_DISPLAY_XDISPLAY (display),
gdk_x11_atom_to_xatom_for_display (display,
selection));
GDK_WINDOW_XID (requestor), time);
}
+/**
+ * gdk_selection_property_get:
+ * @requestor: the window on which the data is stored
+ * @data: location to store a pointer to the retrieved data.
+ If the retrieval failed, %NULL we be stored here, otherwise, it
+ will be non-%NULL and the returned data should be freed with g_free()
+ when you are finished using it. The length of the
+ allocated memory is one more than the the length
+ of the returned data, and the final byte will always
+ be zero, to ensure nul-termination of strings.
+ * @prop_type: location to store the type of the property.
+ * @prop_format: location to store the format of the property.
+ *
+ * Retrieves selection data that was stored by the selection
+ * data in response to a call to gdk_selection_convert(). This function
+ * will not be used by applications, who should use the #GtkClipboard
+ * API instead.
+ *
+ * Return value: the length of the retrieved data.
+ **/
gint
gdk_selection_property_get (GdkWindow *requestor,
guchar **data,
display = GDK_WINDOW_DISPLAY (requestor);
- /* If retrieved chunks are typically small, (and the ICCCM says the
- should be) it would be a win to try first with a buffer of
- moderate length, to avoid two round trips to the server */
-
if (GDK_WINDOW_DESTROYED (requestor))
- return 0;
+ goto err;
t = NULL;
- XGetWindowProperty (GDK_WINDOW_XDISPLAY (requestor),
- GDK_WINDOW_XID (requestor),
- gdk_x11_atom_to_xatom_for_display (display, _gdk_selection_property),
- 0, 0, False,
- AnyPropertyType, &prop_type,
- &prop_format, &nitems, &nbytes, &t);
- if (ret_type)
- *ret_type = gdk_x11_xatom_to_atom_for_display (display, prop_type);
- if (ret_format)
- *ret_format = prop_format;
-
- if (prop_type == None)
- {
- *data = NULL;
- return 0;
- }
-
- if (t)
- {
- XFree (t);
- t = NULL;
- }
-
- /* Add on an extra byte to handle null termination. X guarantees
- that t will be 1 longer than nbytes and null terminated */
- length = nbytes + 1;
/* We can't delete the selection here, because it might be the INCR
protocol, in which case the client has to make sure they'll be
notified of PropertyChange events _before_ the property is deleted.
Otherwise there's no guarantee we'll win the race ... */
- XGetWindowProperty (GDK_DRAWABLE_XDISPLAY (requestor),
- GDK_DRAWABLE_XID (requestor),
- gdk_x11_atom_to_xatom_for_display (display, _gdk_selection_property),
- 0, (nbytes + 3) / 4, False,
- AnyPropertyType, &prop_type, &prop_format,
- &nitems, &nbytes, &t);
-
+ if (XGetWindowProperty (GDK_DRAWABLE_XDISPLAY (requestor),
+ GDK_DRAWABLE_XID (requestor),
+ gdk_x11_atom_to_xatom_for_display (display, _gdk_selection_property),
+ 0, 0x1FFFFFFF /* MAXINT32 / 4 */, False,
+ AnyPropertyType, &prop_type, &prop_format,
+ &nitems, &nbytes, &t) != Success)
+ goto err;
+
if (prop_type != None)
{
- *data = g_new (guchar, length);
+ if (ret_type)
+ *ret_type = gdk_x11_xatom_to_atom_for_display (display, prop_type);
+ if (ret_format)
+ *ret_format = prop_format;
- if (prop_type == XA_ATOM ||
- prop_type == gdk_x11_get_xatom_by_name_for_display (display, "ATOM_PAIR"))
- {
- Atom* atoms = (Atom*) t;
- GdkAtom* atoms_dest;
- gint num_atom, i;
-
- num_atom = (length - 1) / sizeof (Atom);
- length = sizeof (GdkAtom) * num_atom + 1;
- *data = g_malloc (length);
- (*data)[length - 1] = '\0';
- atoms_dest = (GdkAtom *)(*data);
-
- for (i=0; i < num_atom; i++)
- atoms_dest[i] = gdk_x11_xatom_to_atom_for_display (display, atoms[i]);
- }
- else
+ /* Add on an extra byte to handle null termination. X guarantees
+ that t will be 1 longer than nbytes and null terminated */
+ length = nbytes + 1;
+
+ if (data)
{
- *data = g_memdup (t, length);
+ *data = g_new (guchar, length);
+
+ if (prop_type == XA_ATOM ||
+ prop_type == gdk_x11_get_xatom_by_name_for_display (display, "ATOM_PAIR"))
+ {
+ Atom* atoms = (Atom*) t;
+ GdkAtom* atoms_dest;
+ gint num_atom, i;
+
+ num_atom = (length - 1) / sizeof (Atom);
+ length = sizeof (GdkAtom) * num_atom + 1;
+ *data = g_malloc (length);
+ (*data)[length - 1] = '\0';
+ atoms_dest = (GdkAtom *)(*data);
+
+ for (i=0; i < num_atom; i++)
+ atoms_dest[i] = gdk_x11_xatom_to_atom_for_display (display, atoms[i]);
+ }
+ else
+ {
+ *data = g_memdup (t, length);
+ }
}
if (t)
XFree (t);
- return length-1;
- }
- else
- {
- *data = NULL;
- return 0;
+
+ return length - 1;
}
+
+ err:
+ if (ret_type)
+ *ret_type = GDK_NONE;
+ if (ret_format)
+ *ret_format = 0;
+ if (data)
+ *data = NULL;
+
+ return 0;
}
/**
gchar **local_list;
g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
+ if (list)
+ *list = NULL;
+
+ if (display->closed)
+ return 0;
+
property.value = (guchar *)text;
property.encoding = gdk_x11_atom_to_xatom_for_display (display, encoding);
property.format = format;
property.nitems = length;
res = XmbTextPropertyToTextList (GDK_DISPLAY_XDISPLAY (display), &property,
&local_list, &count);
-
- if (res == XNoMemory || res == XLocaleNotSupported ||
- res == XConverterNotFound)
- {
- if (list)
- *list = NULL;
-
- return 0;
- }
+ if (res == XNoMemory || res == XLocaleNotSupported || res == XConverterNotFound)
+ return 0;
else
{
if (list)
}
}
-gint
-gdk_text_property_to_text_list (GdkAtom encoding,
- gint format,
- const guchar *text,
- gint length,
- gchar ***list)
-{
- return gdk_text_property_to_text_list_for_display (gdk_display_get_default (),
- encoding, format, text, length, list);
-}
-
void
gdk_free_text_list (gchar **list)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
- res = XmbTextListToTextProperty (GDK_DISPLAY_XDISPLAY (display),
- (char **)&str, 1, XCompoundTextStyle,
- &property);
+ if (display->closed)
+ res = XLocaleNotSupported;
+ else
+ res = XmbTextListToTextProperty (GDK_DISPLAY_XDISPLAY (display),
+ (char **)&str, 1, XCompoundTextStyle,
+ &property);
if (res != Success)
{
property.encoding = None;
return res;
}
-gint
-gdk_string_to_compound_text (const gchar *str,
- GdkAtom *encoding,
- gint *format,
- guchar **ctext,
- gint *length)
-{
- return gdk_string_to_compound_text_for_display (gdk_display_get_default (),
- str, encoding, format,
- ctext, length);
-}
-
/* The specifications for COMPOUND_TEXT and STRING specify that C0 and
* C1 are not allowed except for \n and \t, however the X conversions
* routines for COMPOUND_TEXT only enforce this in one direction,
impl = GDK_WINDOW_IMPL_X11 (drawable);
draw_impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+ if (GDK_WINDOW_DESTROYED (draw_impl->wrapper))
+ return;
+
/* chain up */
GDK_DRAWABLE_CLASS (parent_class)->set_colormap (drawable, cmap);
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
-
- toplevel = gdk_window_get_toplevel (window);
- if (GDK_WINDOW_DESTROYED (toplevel))
+
+ if (GDK_WINDOW_DESTROYED (window))
return;
+ toplevel = gdk_window_get_toplevel (window);
old_windows = NULL;
if (!XGetWMColormapWindows (GDK_WINDOW_XDISPLAY (toplevel),
* Returns: TRUE if the window has decorations set, FALSE otherwise.
**/
gboolean
-gdk_window_get_decorations(GdkWindow *window,
+gdk_window_get_decorations(GdkWindow *window,
GdkWMDecoration *decorations)
{
MotifWmHints *hints;
gboolean result = FALSE;
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
+
hints = gdk_window_get_mwm_hints (window);
if (hints)
{
if (hints->flags & MWM_HINTS_DECORATIONS)
{
- *decorations = hints->decorations;
+ if (decorations)
+ *decorations = hints->decorations;
result = TRUE;
}
projects / ~andy / gtk / commitdiff