1 /* GDK - The GIMP Drawing Kit
4 * Copyright 2001 Sun Microsystems Inc.
6 * Erwann Chenede <erwann.chenede@sun.com>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the
20 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 * Boston, MA 02111-1307, USA.
26 #include "gdkdisplay.h"
27 #include "gdkdisplayprivate.h"
29 #include "gdkdeviceprivate.h"
30 #include "gdkevents.h"
31 #include "gdkwindowimpl.h"
32 #include "gdkinternals.h"
33 #include "gdkmarshalers.h"
34 #include "gdkscreen.h"
41 * @Short_description: Controls the keyboard/mouse pointer grabs and a set of <type>GdkScreen</type>s
44 * #GdkDisplay objects purpose are two fold:
47 * To grab/ungrab keyboard focus and mouse pointer
50 * To manage and provide information about the #GdkScreen(s)
51 * available for this #GdkDisplay
55 * #GdkDisplay objects are the GDK representation of the X Display which can be
56 * described as <emphasis>a workstation consisting of a keyboard a pointing
57 * device (such as a mouse) and one or more screens</emphasis>.
58 * It is used to open and keep track of various #GdkScreen objects currently
59 * instanciated by the application. It is also used to grab and release the keyboard
60 * and the mouse pointer.
70 static void gdk_display_dispose (GObject *object);
71 static void gdk_display_finalize (GObject *object);
74 static GdkAppLaunchContext *gdk_display_real_get_app_launch_context (GdkDisplay *display);
76 static guint signals[LAST_SIGNAL] = { 0 };
78 G_DEFINE_TYPE (GdkDisplay, gdk_display, G_TYPE_OBJECT)
81 gdk_display_class_init (GdkDisplayClass *class)
83 GObjectClass *object_class = G_OBJECT_CLASS (class);
85 object_class->finalize = gdk_display_finalize;
86 object_class->dispose = gdk_display_dispose;
88 class->get_app_launch_context = gdk_display_real_get_app_launch_context;
89 class->window_type = GDK_TYPE_WINDOW;
93 * @display: the object on which the signal is emitted
95 * The ::opened signal is emitted when the connection to the windowing
96 * system for @display is opened.
99 g_signal_new (g_intern_static_string ("opened"),
100 G_OBJECT_CLASS_TYPE (object_class),
103 g_cclosure_marshal_VOID__VOID,
107 * GdkDisplay::closed:
108 * @display: the object on which the signal is emitted
109 * @is_error: %TRUE if the display was closed due to an error
111 * The ::closed signal is emitted when the connection to the windowing
112 * system for @display is closed.
117 g_signal_new (g_intern_static_string ("closed"),
118 G_OBJECT_CLASS_TYPE (object_class),
120 G_STRUCT_OFFSET (GdkDisplayClass, closed),
122 _gdk_marshal_VOID__BOOLEAN,
129 free_pointer_info (GdkPointerWindowInfo *info)
131 g_object_unref (info->toplevel_under_pointer);
132 g_slice_free (GdkPointerWindowInfo, info);
136 free_device_grab (GdkDeviceGrabInfo *info)
138 g_object_unref (info->window);
139 g_object_unref (info->native_window);
144 free_device_grabs_foreach (gpointer key,
150 g_list_foreach (list, (GFunc) free_device_grab, NULL);
157 device_removed_cb (GdkDeviceManager *device_manager,
161 g_hash_table_remove (display->multiple_click_info, device);
162 g_hash_table_remove (display->device_grabs, device);
163 g_hash_table_remove (display->pointers_info, device);
165 /* FIXME: change core pointer and remove from device list */
169 gdk_display_opened (GdkDisplay *display)
171 GdkDeviceManager *device_manager;
173 device_manager = gdk_display_get_device_manager (display);
175 g_signal_connect (device_manager, "device-removed",
176 G_CALLBACK (device_removed_cb), display);
180 gdk_display_init (GdkDisplay *display)
182 display->double_click_time = 250;
183 display->double_click_distance = 5;
185 display->device_grabs = g_hash_table_new (NULL, NULL);
186 display->motion_hint_info = g_hash_table_new_full (NULL, NULL, NULL,
187 (GDestroyNotify) g_free);
189 display->pointers_info = g_hash_table_new_full (NULL, NULL, NULL,
190 (GDestroyNotify) free_pointer_info);
192 display->multiple_click_info = g_hash_table_new_full (NULL, NULL, NULL,
193 (GDestroyNotify) g_free);
195 g_signal_connect (display, "opened",
196 G_CALLBACK (gdk_display_opened), NULL);
200 gdk_display_dispose (GObject *object)
202 GdkDisplay *display = GDK_DISPLAY (object);
203 GdkDeviceManager *device_manager;
205 device_manager = gdk_display_get_device_manager (GDK_DISPLAY (object));
207 g_list_foreach (display->queued_events, (GFunc)gdk_event_free, NULL);
208 g_list_free (display->queued_events);
209 display->queued_events = NULL;
210 display->queued_tail = NULL;
214 /* this is to make it drop devices which may require using the X
215 * display and therefore can't be cleaned up in finalize.
216 * It will also disconnect device_removed_cb
218 g_object_run_dispose (G_OBJECT (display->device_manager));
221 G_OBJECT_CLASS (gdk_display_parent_class)->dispose (object);
225 gdk_display_finalize (GObject *object)
227 GdkDisplay *display = GDK_DISPLAY (object);
229 g_hash_table_foreach_remove (display->device_grabs,
230 free_device_grabs_foreach,
232 g_hash_table_destroy (display->device_grabs);
234 g_hash_table_destroy (display->pointers_info);
235 g_hash_table_destroy (display->multiple_click_info);
237 if (display->device_manager)
238 g_object_unref (display->device_manager);
240 G_OBJECT_CLASS (gdk_display_parent_class)->finalize (object);
245 * @display: a #GdkDisplay
247 * Closes the connection to the windowing system for the given display,
248 * and cleans up associated resources.
253 gdk_display_close (GdkDisplay *display)
255 g_return_if_fail (GDK_IS_DISPLAY (display));
257 if (!display->closed)
259 display->closed = TRUE;
261 g_signal_emit (display, signals[CLOSED], 0, FALSE);
262 g_object_run_dispose (G_OBJECT (display));
264 g_object_unref (display);
269 * gdk_display_is_closed:
270 * @display: a #GdkDisplay
272 * Finds out if the display has been closed.
274 * Returns: %TRUE if the display is closed.
279 gdk_display_is_closed (GdkDisplay *display)
281 g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
283 return display->closed;
287 * gdk_display_get_event:
288 * @display: a #GdkDisplay
290 * Gets the next #GdkEvent to be processed for @display, fetching events from the
291 * windowing system if necessary.
293 * Return value: the next #GdkEvent to be processed, or %NULL if no events
294 * are pending. The returned #GdkEvent should be freed with gdk_event_free().
299 gdk_display_get_event (GdkDisplay *display)
301 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
303 GDK_DISPLAY_GET_CLASS (display)->queue_events (display);
304 return _gdk_event_unqueue (display);
308 * gdk_display_peek_event:
309 * @display: a #GdkDisplay
311 * Gets a copy of the first #GdkEvent in the @display's event queue, without
312 * removing the event from the queue. (Note that this function will
313 * not get more events from the windowing system. It only checks the events
314 * that have already been moved to the GDK event queue.)
316 * Return value: a copy of the first #GdkEvent on the event queue, or %NULL
317 * if no events are in the queue. The returned #GdkEvent should be freed with
323 gdk_display_peek_event (GdkDisplay *display)
327 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
329 tmp_list = _gdk_event_queue_find_first (display);
332 return gdk_event_copy (tmp_list->data);
338 * gdk_display_put_event:
339 * @display: a #GdkDisplay
340 * @event: a #GdkEvent.
342 * Appends a copy of the given event onto the front of the event
343 * queue for @display.
348 gdk_display_put_event (GdkDisplay *display,
349 const GdkEvent *event)
351 g_return_if_fail (GDK_IS_DISPLAY (display));
352 g_return_if_fail (event != NULL);
354 _gdk_event_queue_append (display, gdk_event_copy (event));
355 /* If the main loop is blocking in a different thread, wake it up */
356 g_main_context_wakeup (NULL);
360 * gdk_display_pointer_ungrab:
361 * @display: a #GdkDisplay.
362 * @time_: a timestap (e.g. %GDK_CURRENT_TIME).
364 * Release any pointer grab.
368 * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
372 gdk_display_pointer_ungrab (GdkDisplay *display,
375 GdkDeviceManager *device_manager;
376 GList *devices, *dev;
379 g_return_if_fail (GDK_IS_DISPLAY (display));
381 device_manager = gdk_display_get_device_manager (display);
382 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
384 /* FIXME: Should this be generic to all backends? */
385 /* FIXME: What happens with extended devices? */
386 for (dev = devices; dev; dev = dev->next)
390 if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
393 gdk_device_ungrab (device, time_);
396 g_list_free (devices);
400 * gdk_pointer_ungrab:
401 * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no
402 * timestamp is available.
404 * Ungrabs the pointer on the default display, if it is grabbed by this
407 * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
411 gdk_pointer_ungrab (guint32 time)
413 gdk_display_pointer_ungrab (gdk_display_get_default (), time);
417 * gdk_pointer_is_grabbed:
419 * Returns %TRUE if the pointer on the default display is currently
420 * grabbed by this application.
422 * Note that this does not take the inmplicit pointer grab on button
423 * presses into account.
425 * Return value: %TRUE if the pointer is currently grabbed by this application.
427 * Deprecated: 3.0: Use gdk_display_device_is_grabbed() instead.
430 gdk_pointer_is_grabbed (void)
432 return gdk_display_pointer_is_grabbed (gdk_display_get_default ());
436 * gdk_display_keyboard_ungrab:
437 * @display: a #GdkDisplay.
438 * @time_: a timestap (e.g #GDK_CURRENT_TIME).
440 * Release any keyboard grab
444 * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
448 gdk_display_keyboard_ungrab (GdkDisplay *display,
451 GdkDeviceManager *device_manager;
452 GList *devices, *dev;
455 g_return_if_fail (GDK_IS_DISPLAY (display));
457 device_manager = gdk_display_get_device_manager (display);
458 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
460 /* FIXME: Should this be generic to all backends? */
461 /* FIXME: What happens with extended devices? */
462 for (dev = devices; dev; dev = dev->next)
466 if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
469 gdk_device_ungrab (device, time);
472 g_list_free (devices);
476 * gdk_keyboard_ungrab:
477 * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no
478 * timestamp is available.
480 * Ungrabs the keyboard on the default display, if it is grabbed by this
483 * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
487 gdk_keyboard_ungrab (guint32 time)
489 gdk_display_keyboard_ungrab (gdk_display_get_default (), time);
495 * Emits a short beep on the default display.
500 gdk_display_beep (gdk_display_get_default ());
506 * Flushes the output buffers of all display connections and waits
507 * until all requests have been processed.
508 * This is rarely needed by applications.
515 list = gdk_display_manager_list_displays (gdk_display_manager_get ());
516 for (l = list; l; l = l->next)
518 GdkDisplay *display = l->data;
520 GDK_DISPLAY_GET_CLASS (display)->sync (display);
527 _gdk_display_enable_motion_hints (GdkDisplay *display,
530 gulong *device_serial, serial;
532 device_serial = g_hash_table_lookup (display->motion_hint_info, device);
536 device_serial = g_new0 (gulong, 1);
537 *device_serial = G_MAXULONG;
538 g_hash_table_insert (display->motion_hint_info, device, device_serial);
541 if (*device_serial != 0)
543 serial = _gdk_display_get_next_serial (display);
544 /* We might not actually generate the next request, so
545 make sure this triggers always, this may cause it to
546 trigger slightly too early, but this is just a hint
550 if (serial < *device_serial)
551 *device_serial = serial;
556 * gdk_display_get_pointer:
557 * @display: a #GdkDisplay
558 * @screen: (out) (allow-none): location to store the screen that the
559 * cursor is on, or %NULL.
560 * @x: (out) (allow-none): location to store root window X coordinate of pointer, or %NULL.
561 * @y: (out) (allow-none): location to store root window Y coordinate of pointer, or %NULL.
562 * @mask: (out) (allow-none): location to store current modifier mask, or %NULL
564 * Gets the current location of the pointer and the current modifier
565 * mask for a given display.
569 * Deprecated: 3.0: Use gdk_device_get_position() instead.
572 gdk_display_get_pointer (GdkDisplay *display,
576 GdkModifierType *mask)
578 GdkScreen *default_screen;
581 GdkModifierType tmp_mask;
583 g_return_if_fail (GDK_IS_DISPLAY (display));
585 if (gdk_display_is_closed (display))
588 default_screen = gdk_display_get_default_screen (display);
590 /* We call _gdk_device_query_state() here manually instead of
591 * gdk_device_get_position() because we care about the modifier mask */
593 _gdk_device_query_state (display->core_pointer,
594 gdk_screen_get_root_window (default_screen),
601 *screen = gdk_window_get_screen (root);
611 * gdk_display_get_window_at_pointer:
612 * @display: a #GdkDisplay
613 * @win_x: (out) (allow-none): return location for x coordinate of the pointer location relative
614 * to the window origin, or %NULL
615 * @win_y: (out) (allow-none): return location for y coordinate of the pointer location relative
616 & to the window origin, or %NULL
618 * Obtains the window underneath the mouse pointer, returning the location
619 * of the pointer in that window in @win_x, @win_y for @screen. Returns %NULL
620 * if the window under the mouse pointer is not known to GDK (for example,
621 * belongs to another application).
623 * Returns: (transfer none): the window under the mouse pointer, or %NULL
627 * Deprecated: 3.0: Use gdk_device_get_window_at_position() instead.
630 gdk_display_get_window_at_pointer (GdkDisplay *display,
634 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
636 return gdk_device_get_window_at_position (display->core_pointer, win_x, win_y);
640 generate_grab_broken_event (GdkWindow *window,
643 GdkWindow *grab_window)
645 g_return_if_fail (window != NULL);
647 if (!GDK_WINDOW_DESTROYED (window))
651 event = gdk_event_new (GDK_GRAB_BROKEN);
652 event->grab_broken.window = g_object_ref (window);
653 event->grab_broken.send_event = FALSE;
654 event->grab_broken.implicit = implicit;
655 event->grab_broken.grab_window = grab_window;
656 gdk_event_set_device (event, device);
657 event->grab_broken.keyboard = (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) ? TRUE : FALSE;
659 gdk_event_put (event);
660 gdk_event_free (event);
665 _gdk_display_get_last_device_grab (GdkDisplay *display,
670 l = g_hash_table_lookup (display->device_grabs, device);
682 _gdk_display_add_device_grab (GdkDisplay *display,
685 GdkWindow *native_window,
686 GdkGrabOwnership grab_ownership,
687 gboolean owner_events,
688 GdkEventMask event_mask,
689 unsigned long serial_start,
693 GdkDeviceGrabInfo *info, *other_info;
696 info = g_new0 (GdkDeviceGrabInfo, 1);
698 info->window = g_object_ref (window);
699 info->native_window = g_object_ref (native_window);
700 info->serial_start = serial_start;
701 info->serial_end = G_MAXULONG;
702 info->owner_events = owner_events;
703 info->event_mask = event_mask;
705 info->implicit = implicit;
706 info->ownership = grab_ownership;
708 grabs = g_hash_table_lookup (display->device_grabs, device);
710 /* Find the first grab that has a larger start time (if any) and insert
711 * before that. I.E we insert after already existing grabs with same
713 for (l = grabs; l != NULL; l = l->next)
715 other_info = l->data;
717 if (info->serial_start < other_info->serial_start)
721 grabs = g_list_insert_before (grabs, l, info);
723 /* Make sure the new grab end before next grab */
726 other_info = l->data;
727 info->serial_end = other_info->serial_start;
730 /* Find any previous grab and update its end time */
731 l = g_list_find (grabs, info);
735 other_info = l->data;
736 other_info->serial_end = serial_start;
739 g_hash_table_insert (display->device_grabs, device, grabs);
744 /* _gdk_synthesize_crossing_events only works inside one toplevel.
745 This function splits things into two calls if needed, converting the
746 coordinates to the right toplevel */
748 synthesize_crossing_events (GdkDisplay *display,
750 GdkDevice *source_device,
751 GdkWindow *src_window,
752 GdkWindow *dest_window,
753 GdkCrossingMode crossing_mode,
757 GdkWindow *src_toplevel, *dest_toplevel;
758 GdkModifierType state;
761 /* We use the native crossing events if all native */
762 if (_gdk_native_windows)
766 src_toplevel = gdk_window_get_toplevel (src_window);
770 dest_toplevel = gdk_window_get_toplevel (dest_window);
772 dest_toplevel = NULL;
774 if (src_toplevel == NULL && dest_toplevel == NULL)
777 if (src_toplevel == NULL ||
778 src_toplevel == dest_toplevel)
781 gdk_window_get_pointer (dest_toplevel,
783 _gdk_synthesize_crossing_events (display,
786 device, source_device,
793 else if (dest_toplevel == NULL)
795 gdk_window_get_pointer (src_toplevel,
797 _gdk_synthesize_crossing_events (display,
800 device, source_device,
809 /* Different toplevels */
810 gdk_window_get_pointer (src_toplevel,
812 _gdk_synthesize_crossing_events (display,
815 device, source_device,
821 gdk_window_get_pointer (dest_toplevel,
823 _gdk_synthesize_crossing_events (display,
826 device, source_device,
836 get_current_toplevel (GdkDisplay *display,
840 GdkModifierType *state_out)
842 GdkWindow *pointer_window;
844 GdkModifierType state;
846 pointer_window = _gdk_device_window_at_position (device, &x, &y, &state, TRUE);
848 if (pointer_window != NULL &&
849 (GDK_WINDOW_DESTROYED (pointer_window) ||
850 GDK_WINDOW_TYPE (pointer_window) == GDK_WINDOW_ROOT ||
851 GDK_WINDOW_TYPE (pointer_window) == GDK_WINDOW_FOREIGN))
852 pointer_window = NULL;
858 return pointer_window;
862 switch_to_pointer_grab (GdkDisplay *display,
864 GdkDevice *source_device,
865 GdkDeviceGrabInfo *grab,
866 GdkDeviceGrabInfo *last_grab,
870 GdkWindow *src_window, *pointer_window, *new_toplevel;
871 GdkPointerWindowInfo *info;
873 GdkModifierType state;
876 /* Temporarily unset pointer to make sure we send the crossing events below */
877 old_grabs = g_hash_table_lookup (display->device_grabs, device);
878 g_hash_table_steal (display->device_grabs, device);
879 info = _gdk_display_get_pointer_info (display, device);
883 /* New grab is in effect */
885 /* We need to generate crossing events for the grab.
886 * However, there are never any crossing events for implicit grabs
887 * TODO: ... Actually, this could happen if the pointer window
888 * doesn't have button mask so a parent gets the event...
892 /* We send GRAB crossing events from the window under the pointer to the
893 grab window. Except if there is an old grab then we start from that */
895 src_window = last_grab->window;
897 src_window = info->window_under_pointer;
899 if (src_window != grab->window)
900 synthesize_crossing_events (display, device, source_device,
901 src_window, grab->window,
902 GDK_CROSSING_GRAB, time, serial);
904 /* !owner_event Grabbing a window that we're not inside, current status is
905 now NULL (i.e. outside grabbed window) */
906 if (!grab->owner_events && info->window_under_pointer != grab->window)
907 _gdk_display_set_window_under_pointer (display, device, NULL);
910 grab->activated = TRUE;
917 if (grab == NULL /* ungrab */ ||
918 (!last_grab->owner_events && grab->owner_events) /* switched to owner_events */ )
920 /* We force check what window we're in, and update the toplevel_under_pointer info,
921 * as that won't get told of this change with toplevel enter events.
923 if (info->toplevel_under_pointer)
924 g_object_unref (info->toplevel_under_pointer);
925 info->toplevel_under_pointer = NULL;
927 /* Ungrabbed slave devices don't have a position by
928 * itself, rather depend on its master pointer, so
929 * it doesn't make sense to track any position for
930 * these after the grab
932 if (grab || gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_SLAVE)
933 new_toplevel = get_current_toplevel (display, device, &x, &y, &state);
937 /* w is now toplevel and x,y in toplevel coords */
938 info->toplevel_under_pointer = g_object_ref (new_toplevel);
939 info->toplevel_x = x;
940 info->toplevel_y = y;
945 if (grab == NULL) /* Ungrabbed, send events */
947 pointer_window = NULL;
950 /* Find (possibly virtual) child window */
952 _gdk_window_find_descendant_at (new_toplevel,
957 if (pointer_window != last_grab->window)
958 synthesize_crossing_events (display, device, source_device,
959 last_grab->window, pointer_window,
960 GDK_CROSSING_UNGRAB, time, serial);
962 /* We're now ungrabbed, update the window_under_pointer */
963 _gdk_display_set_window_under_pointer (display, device, pointer_window);
967 g_hash_table_insert (display->device_grabs, device, old_grabs);
971 _gdk_display_device_grab_update (GdkDisplay *display,
973 GdkDevice *source_device,
974 gulong current_serial)
976 GdkDeviceGrabInfo *current_grab, *next_grab;
980 time = display->last_event_time;
981 grabs = g_hash_table_lookup (display->device_grabs, device);
983 while (grabs != NULL)
985 current_grab = grabs->data;
987 if (current_grab->serial_start > current_serial)
988 return; /* Hasn't started yet */
990 if (current_grab->serial_end > current_serial)
992 /* This one hasn't ended yet.
993 its the currently active one or scheduled to be active */
995 if (!current_grab->activated)
997 if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
998 switch_to_pointer_grab (display, device, source_device, current_grab, NULL, time, current_serial);
1007 /* This is the next active grab */
1008 next_grab = grabs->next->data;
1010 if (next_grab->serial_start > current_serial)
1011 next_grab = NULL; /* Actually its not yet active */
1014 if ((next_grab == NULL && current_grab->implicit_ungrab) ||
1015 (next_grab != NULL && current_grab->window != next_grab->window))
1016 generate_grab_broken_event (GDK_WINDOW (current_grab->window),
1018 current_grab->implicit,
1019 next_grab? next_grab->window : NULL);
1021 /* Remove old grab */
1022 grabs = g_list_delete_link (grabs, grabs);
1023 g_hash_table_insert (display->device_grabs, device, grabs);
1025 if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
1026 switch_to_pointer_grab (display, device, source_device,
1027 next_grab, current_grab,
1028 time, current_serial);
1030 free_device_grab (current_grab);
1035 grab_list_find (GList *grabs,
1038 GdkDeviceGrabInfo *grab;
1044 if (serial >= grab->serial_start && serial < grab->serial_end)
1047 grabs = grabs->next;
1054 find_device_grab (GdkDisplay *display,
1060 l = g_hash_table_lookup (display->device_grabs, device);
1061 return grab_list_find (l, serial);
1065 _gdk_display_has_device_grab (GdkDisplay *display,
1071 l = find_device_grab (display, device, serial);
1078 /* Returns true if last grab was ended
1079 * If if_child is non-NULL, end the grab only if the grabbed
1080 * window is the same as if_child or a descendant of it */
1082 _gdk_display_end_device_grab (GdkDisplay *display,
1085 GdkWindow *if_child,
1088 GdkDeviceGrabInfo *grab;
1091 l = find_device_grab (display, device, serial);
1098 (if_child == NULL ||
1099 _gdk_window_event_parent_of (if_child, grab->window)))
1101 grab->serial_end = serial;
1102 grab->implicit_ungrab = implicit;
1103 return l->next == NULL;
1109 /* Returns TRUE if device events are not blocked by any grab */
1111 _gdk_display_check_grab_ownership (GdkDisplay *display,
1115 GHashTableIter iter;
1116 gpointer key, value;
1117 GdkGrabOwnership higher_ownership, device_ownership;
1118 gboolean device_is_keyboard;
1120 g_hash_table_iter_init (&iter, display->device_grabs);
1121 higher_ownership = device_ownership = GDK_OWNERSHIP_NONE;
1122 device_is_keyboard = (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD);
1124 while (g_hash_table_iter_next (&iter, &key, &value))
1126 GdkDeviceGrabInfo *grab;
1132 grabs = grab_list_find (grabs, serial);
1137 /* Discard device if it's not of the same type */
1138 if ((device_is_keyboard && gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD) ||
1139 (!device_is_keyboard && gdk_device_get_source (dev) == GDK_SOURCE_KEYBOARD))
1145 device_ownership = grab->ownership;
1148 if (grab->ownership > higher_ownership)
1149 higher_ownership = grab->ownership;
1153 if (higher_ownership > device_ownership)
1155 /* There's a higher priority ownership
1156 * going on for other device(s)
1164 GdkPointerWindowInfo *
1165 _gdk_display_get_pointer_info (GdkDisplay *display,
1168 GdkPointerWindowInfo *info;
1170 if (G_UNLIKELY (!device))
1173 info = g_hash_table_lookup (display->pointers_info, device);
1175 if (G_UNLIKELY (!info))
1177 info = g_slice_new0 (GdkPointerWindowInfo);
1178 g_hash_table_insert (display->pointers_info, device, info);
1185 _gdk_display_pointer_info_foreach (GdkDisplay *display,
1186 GdkDisplayPointerInfoForeach func,
1189 GHashTableIter iter;
1190 gpointer key, value;
1192 g_hash_table_iter_init (&iter, display->pointers_info);
1194 while (g_hash_table_iter_next (&iter, &key, &value))
1196 GdkPointerWindowInfo *info = value;
1197 GdkDevice *device = key;
1199 (func) (display, device, info, user_data);
1204 * gdk_device_grab_info_libgtk_only:
1205 * @display: the display for which to get the grab information
1206 * @device: device to get the grab information from
1207 * @grab_window: (out) (transfer none): location to store current grab window
1208 * @owner_events: (out): location to store boolean indicating whether
1209 * the @owner_events flag to gdk_keyboard_grab() or
1210 * gdk_pointer_grab() was %TRUE.
1212 * Determines information about the current keyboard grab.
1213 * This is not public API and must not be used by applications.
1215 * Return value: %TRUE if this application currently has the
1219 gdk_device_grab_info_libgtk_only (GdkDisplay *display,
1221 GdkWindow **grab_window,
1222 gboolean *owner_events)
1224 GdkDeviceGrabInfo *info;
1226 g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
1227 g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
1229 info = _gdk_display_get_last_device_grab (display, device);
1234 *grab_window = info->window;
1236 *owner_events = info->owner_events;
1245 * gdk_display_pointer_is_grabbed:
1246 * @display: a #GdkDisplay
1248 * Test if the pointer is grabbed.
1250 * Returns: %TRUE if an active X pointer grab is in effect
1254 * Deprecated: 3.0: Use gdk_display_device_is_grabbed() instead.
1257 gdk_display_pointer_is_grabbed (GdkDisplay *display)
1259 GdkDeviceManager *device_manager;
1260 GList *devices, *dev;
1263 g_return_val_if_fail (GDK_IS_DISPLAY (display), TRUE);
1265 device_manager = gdk_display_get_device_manager (display);
1266 devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
1268 for (dev = devices; dev; dev = dev->next)
1272 if (gdk_device_get_source (device) == GDK_SOURCE_MOUSE &&
1273 gdk_display_device_is_grabbed (display, device))
1281 * gdk_display_device_is_grabbed:
1282 * @display: a #GdkDisplay
1283 * @device: a #GdkDevice
1285 * Returns %TRUE if there is an ongoing grab on @device for @display.
1287 * Returns: %TRUE if there is a grab in effect for @device.
1290 gdk_display_device_is_grabbed (GdkDisplay *display,
1293 GdkDeviceGrabInfo *info;
1295 g_return_val_if_fail (GDK_IS_DISPLAY (display), TRUE);
1296 g_return_val_if_fail (GDK_IS_DEVICE (device), TRUE);
1298 /* What we're interested in is the steady state (ie last grab),
1299 because we're interested e.g. if we grabbed so that we
1300 can ungrab, even if our grab is not active just yet. */
1301 info = _gdk_display_get_last_device_grab (display, device);
1303 return (info && !info->implicit);
1307 * gdk_display_get_device_manager:
1308 * @display: a #GdkDisplay.
1310 * Returns the #GdkDeviceManager associated to @display.
1312 * Returns: (transfer none): A #GdkDeviceManager, or %NULL. This memory is
1313 * owned by GDK and must not be freed or unreferenced.
1318 gdk_display_get_device_manager (GdkDisplay *display)
1320 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
1322 return display->device_manager;
1326 * gdk_display_get_name:
1327 * @display: a #GdkDisplay
1329 * Gets the name of the display.
1331 * Returns: a string representing the display name. This string is owned
1332 * by GDK and should not be modified or freed.
1336 G_CONST_RETURN gchar *
1337 gdk_display_get_name (GdkDisplay *display)
1339 return GDK_DISPLAY_GET_CLASS(display)->get_name (display);
1343 gdk_get_display (void)
1345 return g_strdup (gdk_display_get_name (gdk_display_get_default ()));
1349 * gdk_display_get_n_screens:
1350 * @display: a #GdkDisplay
1352 * Gets the number of screen managed by the @display.
1354 * Returns: number of screens.
1359 gdk_display_get_n_screens (GdkDisplay *display)
1361 return GDK_DISPLAY_GET_CLASS(display)->get_n_screens (display);
1365 * gdk_display_get_screen:
1366 * @display: a #GdkDisplay
1367 * @screen_num: the screen number
1369 * Returns a screen object for one of the screens of the display.
1371 * Returns: (transfer none): the #GdkScreen object
1376 gdk_display_get_screen (GdkDisplay *display,
1379 return GDK_DISPLAY_GET_CLASS(display)->get_screen (display, screen_num);
1383 * gdk_display_get_default_screen:
1384 * @display: a #GdkDisplay
1386 * Get the default #GdkScreen for @display.
1388 * Returns: (transfer none): the default #GdkScreen object for @display
1393 gdk_display_get_default_screen (GdkDisplay *display)
1395 return GDK_DISPLAY_GET_CLASS(display)->get_default_screen (display);
1400 * @display: a #GdkDisplay
1402 * Emits a short beep on @display
1407 gdk_display_beep (GdkDisplay *display)
1409 GDK_DISPLAY_GET_CLASS(display)->beep (display);
1414 * @display: a #GdkDisplay
1416 * Flushes any requests queued for the windowing system and waits until all
1417 * requests have been handled. This is often used for making sure that the
1418 * display is synchronized with the current state of the program. Calling
1419 * gdk_display_sync() before gdk_error_trap_pop() makes sure that any errors
1420 * generated from earlier requests are handled before the error trap is
1423 * This is most useful for X11. On windowing systems where requests are
1424 * handled synchronously, this function will do nothing.
1429 gdk_display_sync (GdkDisplay *display)
1431 GDK_DISPLAY_GET_CLASS(display)->sync (display);
1435 * gdk_display_flush:
1436 * @display: a #GdkDisplay
1438 * Flushes any requests queued for the windowing system; this happens automatically
1439 * when the main loop blocks waiting for new events, but if your application
1440 * is drawing without returning control to the main loop, you may need
1441 * to call this function explicitely. A common case where this function
1442 * needs to be called is when an application is executing drawing commands
1443 * from a thread other than the thread where the main loop is running.
1445 * This is most useful for X11. On windowing systems where requests are
1446 * handled synchronously, this function will do nothing.
1451 gdk_display_flush (GdkDisplay *display)
1453 GDK_DISPLAY_GET_CLASS(display)->flush (display);
1457 * gdk_display_get_default_group:
1458 * @display: a #GdkDisplay
1460 * Returns the default group leader window for all toplevel windows
1461 * on @display. This window is implicitly created by GDK.
1462 * See gdk_window_set_group().
1464 * Return value: (transfer none): The default group leader window
1470 gdk_display_get_default_group (GdkDisplay *display)
1472 return GDK_DISPLAY_GET_CLASS(display)->get_default_group (display);
1476 * gdk_display_supports_selection_notification:
1477 * @display: a #GdkDisplay
1479 * Returns whether #GdkEventOwnerChange events will be
1480 * sent when the owner of a selection changes.
1482 * Return value: whether #GdkEventOwnerChange events will
1488 gdk_display_supports_selection_notification (GdkDisplay *display)
1490 return GDK_DISPLAY_GET_CLASS(display)->supports_selection_notification (display);
1494 * gdk_display_request_selection_notification:
1495 * @display: a #GdkDisplay
1496 * @selection: the #GdkAtom naming the selection for which
1497 * ownership change notification is requested
1499 * Request #GdkEventOwnerChange events for ownership changes
1500 * of the selection named by the given atom.
1502 * Return value: whether #GdkEventOwnerChange events will
1508 gdk_display_request_selection_notification (GdkDisplay *display,
1512 return GDK_DISPLAY_GET_CLASS(display)->request_selection_notification (display, selection);
1516 * gdk_display_supports_clipboard_persistence
1517 * @display: a #GdkDisplay
1519 * Returns whether the speicifed display supports clipboard
1520 * persistance; i.e. if it's possible to store the clipboard data after an
1521 * application has quit. On X11 this checks if a clipboard daemon is
1524 * Returns: %TRUE if the display supports clipboard persistance.
1529 gdk_display_supports_clipboard_persistence (GdkDisplay *display)
1531 return GDK_DISPLAY_GET_CLASS(display)->supports_clipboard_persistence (display);
1535 * gdk_display_store_clipboard
1536 * @display: a #GdkDisplay
1537 * @clipboard_window: a #GdkWindow belonging to the clipboard owner
1538 * @time_: a timestamp
1539 * @targets: (array length=n_targets): an array of targets
1540 * that should be saved, or %NULL
1541 * if all available targets should be saved.
1542 * @n_targets: length of the @targets array
1544 * Issues a request to the clipboard manager to store the
1545 * clipboard data. On X11, this is a special program that works
1546 * according to the freedesktop clipboard specification, available at
1547 * <ulink url="http://www.freedesktop.org/Standards/clipboard-manager-spec">
1548 * http://www.freedesktop.org/Standards/clipboard-manager-spec</ulink>.
1553 gdk_display_store_clipboard (GdkDisplay *display,
1554 GdkWindow *clipboard_window,
1556 const GdkAtom *targets,
1559 GDK_DISPLAY_GET_CLASS(display)->store_clipboard (display, clipboard_window, time_, targets, n_targets);
1563 * gdk_display_supports_shapes:
1564 * @display: a #GdkDisplay
1566 * Returns %TRUE if gdk_window_shape_combine_mask() can
1567 * be used to create shaped windows on @display.
1569 * Returns: %TRUE if shaped windows are supported
1574 gdk_display_supports_shapes (GdkDisplay *display)
1576 return GDK_DISPLAY_GET_CLASS(display)->supports_shapes (display);
1580 * gdk_display_supports_input_shapes:
1581 * @display: a #GdkDisplay
1583 * Returns %TRUE if gdk_window_input_shape_combine_mask() can
1584 * be used to modify the input shape of windows on @display.
1586 * Returns: %TRUE if windows with modified input shape are supported
1591 gdk_display_supports_input_shapes (GdkDisplay *display)
1593 return GDK_DISPLAY_GET_CLASS(display)->supports_input_shapes (display);
1597 * gdk_display_supports_composite:
1598 * @display: a #GdkDisplay
1600 * Returns %TRUE if gdk_window_set_composited() can be used
1601 * to redirect drawing on the window using compositing.
1603 * Currently this only works on X11 with XComposite and
1604 * XDamage extensions available.
1606 * Returns: %TRUE if windows may be composited.
1611 gdk_display_supports_composite (GdkDisplay *display)
1613 return GDK_DISPLAY_GET_CLASS(display)->supports_composite (display);
1617 * gdk_display_list_devices:
1618 * @display: a #GdkDisplay
1620 * Returns the list of available input devices attached to @display.
1621 * The list is statically allocated and should not be freed.
1623 * Return value: (transfer none) (element-type GdkDevice):
1624 * a list of #GdkDevice
1628 * Deprecated: 3.0: Use gdk_device_manager_list_devices() instead.
1631 gdk_display_list_devices (GdkDisplay *display)
1633 return GDK_DISPLAY_GET_CLASS(display)->list_devices (display);
1636 static GdkAppLaunchContext *
1637 gdk_display_real_get_app_launch_context (GdkDisplay *display)
1639 GdkAppLaunchContext *ctx;
1641 ctx = g_object_new (GDK_TYPE_APP_LAUNCH_CONTEXT,
1649 * gdk_display_get_app_launch_context:
1650 * @display: a #GdkDisplay
1652 * Returns a #GdkAppLaunchContext suitable for launching
1653 * applications on the given display.
1655 * Returns: (transfer full): a new #GdkAppLaunchContext for @display.
1656 * Free with g_object_unref() when done
1660 GdkAppLaunchContext *
1661 gdk_display_get_app_launch_context (GdkDisplay *display)
1663 return GDK_DISPLAY_GET_CLASS(display)->get_app_launch_context (display);
1668 * @display_name: the name of the display to open
1672 * Return value: (transfer none): a #GdkDisplay, or %NULL
1673 * if the display could not be opened
1678 gdk_display_open (const gchar *display_name)
1680 return gdk_display_manager_open_display (gdk_display_manager_get (), display_name);
1684 * gdk_display_has_pending:
1685 * @display: a #GdkDisplay
1687 * Returns whether the display has events that are waiting
1690 * Returns: %TRUE if there are events ready to be processed.
1695 gdk_display_has_pending (GdkDisplay *display)
1697 return GDK_DISPLAY_GET_CLASS (display)->has_pending (display);
1701 * gdk_display_supports_cursor_alpha:
1702 * @display: a #GdkDisplay
1704 * Returns %TRUE if cursors can use an 8bit alpha channel
1705 * on @display. Otherwise, cursors are restricted to bilevel
1706 * alpha (i.e. a mask).
1708 * Returns: whether cursors can have alpha channels.
1713 gdk_display_supports_cursor_alpha (GdkDisplay *display)
1715 g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
1717 return GDK_DISPLAY_GET_CLASS (display)->supports_cursor_alpha (display);
1721 * gdk_display_supports_cursor_color:
1722 * @display: a #GdkDisplay
1724 * Returns %TRUE if multicolored cursors are supported
1725 * on @display. Otherwise, cursors have only a forground
1726 * and a background color.
1728 * Returns: whether cursors can have multiple colors.
1733 gdk_display_supports_cursor_color (GdkDisplay *display)
1735 g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
1737 return GDK_DISPLAY_GET_CLASS (display)->supports_cursor_color (display);
1741 * gdk_display_get_default_cursor_size:
1742 * @display: a #GdkDisplay
1744 * Returns the default size to use for cursors on @display.
1746 * Returns: the default cursor size.
1751 gdk_display_get_default_cursor_size (GdkDisplay *display)
1753 guint width, height;
1755 g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
1757 GDK_DISPLAY_GET_CLASS (display)->get_default_cursor_size (display,
1761 return MIN (width, height);
1765 * gdk_display_get_maximal_cursor_size:
1766 * @display: a #GdkDisplay
1767 * @width: (out): the return location for the maximal cursor width
1768 * @height: (out): the return location for the maximal cursor height
1770 * Gets the maximal size to use for cursors on @display.
1775 gdk_display_get_maximal_cursor_size (GdkDisplay *display,
1779 g_return_if_fail (GDK_IS_DISPLAY (display));
1781 GDK_DISPLAY_GET_CLASS (display)->get_maximal_cursor_size (display,
1787 * gdk_display_warp_pointer:
1788 * @display: a #GdkDisplay
1789 * @screen: the screen of @display to warp the pointer to
1790 * @x: the x coordinate of the destination
1791 * @y: the y coordinate of the destination
1793 * Warps the pointer of @display to the point @x,@y on
1794 * the screen @screen, unless the pointer is confined
1795 * to a window by a grab, in which case it will be moved
1796 * as far as allowed by the grab. Warping the pointer
1797 * creates events as if the user had moved the mouse
1798 * instantaneously to the destination.
1800 * Note that the pointer should normally be under the
1801 * control of the user. This function was added to cover
1802 * some rare use cases like keyboard navigation support
1803 * for the color picker in the #GtkColorSelectionDialog.
1807 * Deprecated: 3.0: Use gdk_device_warp() instead.
1810 gdk_display_warp_pointer (GdkDisplay *display,
1815 gdk_device_warp (display->core_pointer,
1821 _gdk_display_get_next_serial (GdkDisplay *display)
1823 return GDK_DISPLAY_GET_CLASS (display)->get_next_serial (display);
1828 * gdk_notify_startup_complete:
1830 * Indicates to the GUI environment that the application has finished
1831 * loading. If the applications opens windows, this function is
1832 * normally called after opening the application's initial set of
1835 * GTK+ will call this function automatically after opening the first
1836 * #GtkWindow unless gtk_window_set_auto_startup_notification() is called
1837 * to disable that feature.
1842 gdk_notify_startup_complete (void)
1844 gdk_notify_startup_complete_with_id (NULL);
1848 * gdk_notify_startup_complete_with_id:
1849 * @startup_id: a startup-notification identifier, for which
1850 * notification process should be completed
1852 * Indicates to the GUI environment that the application has
1853 * finished loading, using a given identifier.
1855 * GTK+ will call this function automatically for #GtkWindow
1856 * with custom startup-notification identifier unless
1857 * gtk_window_set_auto_startup_notification() is called to
1858 * disable that feature.
1863 gdk_notify_startup_complete_with_id (const gchar* startup_id)
1865 GdkDisplay *display;
1867 display = gdk_display_get_default ();
1869 gdk_display_notify_startup_complete (display, startup_id);
1873 * gdk_display_notify_startup_complete:
1874 * @display: a #GdkDisplay
1875 * @startup_id: a startup-notification identifier, for which
1876 * notification process should be completed
1878 * Indicates to the GUI environment that the application has
1879 * finished loading, using a given identifier.
1881 * GTK+ will call this function automatically for #GtkWindow
1882 * with custom startup-notification identifier unless
1883 * gtk_window_set_auto_startup_notification() is called to
1884 * disable that feature.
1889 gdk_display_notify_startup_complete (GdkDisplay *display,
1890 const gchar *startup_id)
1892 GDK_DISPLAY_GET_CLASS (display)->notify_startup_complete (display, startup_id);
1896 _gdk_display_event_data_copy (GdkDisplay *display,
1897 const GdkEvent *event,
1898 GdkEvent *new_event)
1900 GDK_DISPLAY_GET_CLASS (display)->event_data_copy (display, event, new_event);
1904 _gdk_display_event_data_free (GdkDisplay *display,
1907 GDK_DISPLAY_GET_CLASS (display)->event_data_free (display, event);
1911 _gdk_display_create_window_impl (GdkDisplay *display,
1913 GdkWindow *real_parent,
1915 GdkEventMask event_mask,
1916 GdkWindowAttr *attributes,
1917 gint attributes_mask)
1919 GDK_DISPLAY_GET_CLASS (display)->create_window_impl (display,
1929 _gdk_display_create_window (GdkDisplay *display)
1931 return g_object_new (GDK_DISPLAY_GET_CLASS (display)->window_type, NULL);
1935 * gdk_keymap_get_for_display:
1936 * @display: the #GdkDisplay.
1938 * Returns the #GdkKeymap attached to @display.
1940 * Return value: (transfer none): the #GdkKeymap attached to @display.
1945 gdk_keymap_get_for_display (GdkDisplay *display)
1947 return GDK_DISPLAY_GET_CLASS (display)->get_keymap (display);
1950 typedef struct _GdkGlobalErrorTrap GdkGlobalErrorTrap;
1952 struct _GdkGlobalErrorTrap
1957 static GQueue gdk_error_traps = G_QUEUE_INIT;
1960 * gdk_error_trap_push:
1962 * This function allows X errors to be trapped instead of the normal
1963 * behavior of exiting the application. It should only be used if it
1964 * is not possible to avoid the X error in any other way. Errors are
1965 * ignored on all #GdkDisplay currently known to the
1966 * #GdkDisplayManager. If you don't care which error happens and just
1967 * want to ignore everything, pop with gdk_error_trap_pop_ignored().
1968 * If you need the error code, use gdk_error_trap_pop() which may have
1969 * to block and wait for the error to arrive from the X server.
1971 * This API exists on all platforms but only does anything on X.
1973 * You can use gdk_x11_display_error_trap_push() to ignore errors
1974 * on only a single display.
1977 * <title>Trapping an X error</title>
1979 * gdk_error_trap_push (<!-- -->);
1981 * // ... Call the X function which may cause an error here ...
1984 * if (gdk_error_trap_pop (<!-- -->))
1986 * // ... Handle the error here ...
1992 gdk_error_trap_push (void)
1994 GdkDisplayManager *manager;
1995 GdkDisplayClass *class;
1996 GdkGlobalErrorTrap *trap;
1999 manager = gdk_display_manager_get ();
2000 class = GDK_DISPLAY_GET_CLASS (gdk_display_manager_get_default_display (manager));
2002 if (class->push_error_trap == NULL)
2005 trap = g_slice_new (GdkGlobalErrorTrap);
2006 trap->displays = gdk_display_manager_list_displays (manager);
2008 g_slist_foreach (trap->displays, (GFunc) g_object_ref, NULL);
2009 for (l = trap->displays; l != NULL; l = l->next)
2011 class->push_error_trap (l->data);
2014 g_queue_push_head (&gdk_error_traps, trap);
2018 gdk_error_trap_pop_internal (gboolean need_code)
2020 GdkDisplayManager *manager;
2021 GdkDisplayClass *class;
2022 GdkGlobalErrorTrap *trap;
2026 manager = gdk_display_manager_get ();
2027 class = GDK_DISPLAY_GET_CLASS (gdk_display_manager_get_default_display (manager));
2029 if (class->pop_error_trap == NULL)
2032 trap = g_queue_pop_head (&gdk_error_traps);
2034 g_return_val_if_fail (trap != NULL, 0);
2037 for (l = trap->displays; l != NULL; l = l->next)
2041 code = class->pop_error_trap (l->data, !need_code);
2043 /* we use the error on the last display listed, why not. */
2048 g_slist_free_full (trap->displays, g_object_unref);
2049 g_slice_free (GdkGlobalErrorTrap, trap);
2055 * gdk_error_trap_pop_ignored:
2057 * Removes an error trap pushed with gdk_error_trap_push(), but
2058 * without bothering to wait and see whether an error occurred. If an
2059 * error arrives later asynchronously that was triggered while the
2060 * trap was pushed, that error will be ignored.
2065 gdk_error_trap_pop_ignored (void)
2067 gdk_error_trap_pop_internal (FALSE);
2071 * gdk_error_trap_pop:
2073 * Removes an error trap pushed with gdk_error_trap_push().
2074 * May block until an error has been definitively received
2075 * or not received from the X server. gdk_error_trap_pop_ignored()
2076 * is preferred if you don't need to know whether an error
2077 * occurred, because it never has to block. If you don't
2078 * need the return value of gdk_error_trap_pop(), use
2079 * gdk_error_trap_pop_ignored().
2081 * Prior to GDK 3.0, this function would not automatically
2082 * sync for you, so you had to gdk_flush() if your last
2083 * call to Xlib was not a blocking round trip.
2085 * Return value: X error code or 0 on success
2088 gdk_error_trap_pop (void)
2090 return gdk_error_trap_pop_internal (TRUE);