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.
33 #include "gdkdisplay.h"
34 #include "gdkdisplay-x11.h"
35 #include "gdkscreen.h"
36 #include "gdkscreen-x11.h"
37 #include "gdkinternals.h"
38 #include "gdkinputprivate.h"
39 #include "xsettings-client.h"
41 #include <X11/Xatom.h>
44 #include <X11/XKBlib.h>
48 #include <X11/extensions/Xfixes.h>
51 static void gdk_display_x11_class_init (GdkDisplayX11Class *class);
52 static void gdk_display_x11_dispose (GObject *object);
53 static void gdk_display_x11_finalize (GObject *object);
56 static void gdk_internal_connection_watch (Display *display,
60 XPointer *watch_data);
61 #endif /* HAVE_X11R6 */
63 static gpointer parent_class = NULL;
65 /* Note that we never *directly* use WM_LOCALE_NAME, WM_PROTOCOLS,
66 * but including them here has the side-effect of getting them
67 * into the internal Xlib cache
69 static const char *const precache_atoms[] = {
83 "_NET_WM_STATE_STICKY",
84 "_NET_WM_STATE_MAXIMIZED_VERT",
85 "_NET_WM_STATE_MAXIMIZED_HORZ",
86 "_NET_WM_STATE_FULLSCREEN",
87 "_NET_WM_SYNC_REQUEST",
88 "_NET_WM_SYNC_REQUEST_COUNTER",
89 "_NET_WM_WINDOW_TYPE",
90 "_NET_WM_WINDOW_TYPE_NORMAL",
95 _gdk_display_x11_get_type (void)
97 static GType object_type = 0;
101 static const GTypeInfo object_info =
103 sizeof (GdkDisplayX11Class),
104 (GBaseInitFunc) NULL,
105 (GBaseFinalizeFunc) NULL,
106 (GClassInitFunc) gdk_display_x11_class_init,
107 NULL, /* class_finalize */
108 NULL, /* class_data */
109 sizeof (GdkDisplayX11),
111 (GInstanceInitFunc) NULL,
114 object_type = g_type_register_static (GDK_TYPE_DISPLAY,
123 gdk_display_x11_class_init (GdkDisplayX11Class * class)
125 GObjectClass *object_class = G_OBJECT_CLASS (class);
127 object_class->dispose = gdk_display_x11_dispose;
128 object_class->finalize = gdk_display_x11_finalize;
130 parent_class = g_type_class_peek_parent (class);
136 * @display_name: the name of the display to open
137 * @returns: a #GdkDisplay, or %NULL if the display
138 * could not be opened.
145 gdk_display_open (const gchar *display_name)
149 GdkDisplayX11 *display_x11;
153 const char *sm_client_id;
155 XClassHint *class_hint;
162 xdisplay = XOpenDisplay (display_name);
166 display = g_object_new (GDK_TYPE_DISPLAY_X11, NULL);
167 display_x11 = GDK_DISPLAY_X11 (display);
169 display_x11->use_xshm = TRUE;
170 display_x11->xdisplay = xdisplay;
173 /* Set up handlers for Xlib internal connections */
174 XAddConnectionWatch (xdisplay, gdk_internal_connection_watch, NULL);
175 #endif /* HAVE_X11R6 */
177 /* initialize the display's screens */
178 display_x11->screens = g_new (GdkScreen *, ScreenCount (display_x11->xdisplay));
179 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
180 display_x11->screens[i] = _gdk_x11_screen_new (display, i);
182 /* We need to initialize events after we have the screen
183 * structures in places
185 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
186 _gdk_x11_events_init_screen (display_x11->screens[i]);
188 /*set the default screen */
189 display_x11->default_screen = display_x11->screens[DefaultScreen (display_x11->xdisplay)];
191 attr.window_type = GDK_WINDOW_TOPLEVEL;
192 attr.wclass = GDK_INPUT_OUTPUT;
199 display_x11->leader_gdk_window = gdk_window_new (GDK_SCREEN_X11 (display_x11->default_screen)->root_window,
200 &attr, GDK_WA_X | GDK_WA_Y);
201 (_gdk_x11_window_get_toplevel (display_x11->leader_gdk_window))->is_leader = TRUE;
203 display_x11->leader_window = GDK_WINDOW_XID (display_x11->leader_gdk_window);
205 display_x11->leader_window_title_set = FALSE;
207 display_x11->have_render = GDK_UNKNOWN;
210 if (XFixesQueryExtension (display_x11->xdisplay,
211 &display_x11->xfixes_event_base,
214 display_x11->have_xfixes = TRUE;
216 gdk_x11_register_standard_event_type (display,
217 display_x11->xfixes_event_base,
222 display_x11->have_xfixes = FALSE;
224 if (_gdk_synchronize)
225 XSynchronize (display_x11->xdisplay, True);
227 _gdk_x11_precache_atoms (display, precache_atoms, G_N_ELEMENTS (precache_atoms));
229 class_hint = XAllocClassHint();
230 class_hint->res_name = g_get_prgname ();
232 class_hint->res_class = (char *)gdk_get_program_class ();
234 /* XmbSetWMProperties sets the RESOURCE_NAME environment variable
235 * from argv[0], so we just synthesize an argument array here.
238 argv[0] = g_get_prgname ();
240 XmbSetWMProperties (display_x11->xdisplay,
241 display_x11->leader_window,
242 NULL, NULL, argv, argc, NULL, NULL,
246 sm_client_id = _gdk_get_sm_client_id ();
248 _gdk_windowing_display_set_sm_client_id (display, sm_client_id);
251 XChangeProperty (display_x11->xdisplay,
252 display_x11->leader_window,
253 gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_PID"),
254 XA_CARDINAL, 32, PropModeReplace, (guchar *) & pid, 1);
256 /* We don't yet know a valid time. */
257 display_x11->user_time = 0;
261 gint xkb_major = XkbMajorVersion;
262 gint xkb_minor = XkbMinorVersion;
263 if (XkbLibraryVersion (&xkb_major, &xkb_minor))
265 xkb_major = XkbMajorVersion;
266 xkb_minor = XkbMinorVersion;
268 if (XkbQueryExtension (display_x11->xdisplay,
269 NULL, &display_x11->xkb_event_type, NULL,
270 &xkb_major, &xkb_minor))
272 Bool detectable_autorepeat_supported;
274 display_x11->use_xkb = TRUE;
276 XkbSelectEvents (display_x11->xdisplay,
278 XkbNewKeyboardNotifyMask | XkbMapNotifyMask | XkbStateNotifyMask,
279 XkbNewKeyboardNotifyMask | XkbMapNotifyMask | XkbStateNotifyMask);
281 XkbSetDetectableAutoRepeat (display_x11->xdisplay,
283 &detectable_autorepeat_supported);
285 GDK_NOTE (MISC, g_message ("Detectable autorepeat %s.",
286 detectable_autorepeat_supported ?
287 "supported" : "not supported"));
289 display_x11->have_xkb_autorepeat = detectable_autorepeat_supported;
295 display_x11->use_sync = FALSE;
299 int error_base, event_base;
301 if (XSyncQueryExtension (display_x11->xdisplay,
302 &event_base, &error_base) &&
303 XSyncInitialize (display_x11->xdisplay,
305 display_x11->use_sync = TRUE;
309 _gdk_windowing_image_init (display);
310 _gdk_events_init (display);
311 _gdk_input_init (display);
312 _gdk_dnd_init (display);
314 g_signal_emit_by_name (gdk_display_manager_get(),
315 "display_opened", display);
322 * XLib internal connection handling
324 typedef struct _GdkInternalConnection GdkInternalConnection;
326 struct _GdkInternalConnection
334 process_internal_connection (GIOChannel *gioc,
338 GdkInternalConnection *connection = (GdkInternalConnection *)data;
340 GDK_THREADS_ENTER ();
342 XProcessInternalConnection ((Display*)connection->display, connection->fd);
344 GDK_THREADS_LEAVE ();
349 static GdkInternalConnection *
350 gdk_add_connection_handler (Display *display,
353 GIOChannel *io_channel;
354 GdkInternalConnection *connection;
356 connection = g_new (GdkInternalConnection, 1);
359 connection->display = display;
361 io_channel = g_io_channel_unix_new (fd);
363 connection->source = g_io_create_watch (io_channel, G_IO_IN);
364 g_source_set_callback (connection->source,
365 (GSourceFunc)process_internal_connection, connection, NULL);
366 g_source_attach (connection->source, NULL);
368 g_io_channel_unref (io_channel);
374 gdk_remove_connection_handler (GdkInternalConnection *connection)
376 g_source_destroy (connection->source);
381 gdk_internal_connection_watch (Display *display,
385 XPointer *watch_data)
388 *watch_data = (XPointer)gdk_add_connection_handler (display, fd);
390 gdk_remove_connection_handler ((GdkInternalConnection *)*watch_data);
392 #endif /* HAVE_X11R6 */
395 * gdk_display_get_name:
396 * @display: a #GdkDisplay
398 * Gets the name of the display.
400 * Returns: a string representing the display name. This string is owned
401 * by GDK and should not be modified or freed.
405 G_CONST_RETURN gchar *
406 gdk_display_get_name (GdkDisplay * display)
408 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
410 return (gchar *) DisplayString (GDK_DISPLAY_X11 (display)->xdisplay);
414 * gdk_display_get_n_screens:
415 * @display: a #GdkDisplay
417 * Gets the number of screen managed by the @display.
419 * Returns: number of screens.
424 gdk_display_get_n_screens (GdkDisplay * display)
426 g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
428 return ScreenCount (GDK_DISPLAY_X11 (display)->xdisplay);
432 * gdk_display_get_screen:
433 * @display: a #GdkDisplay
434 * @screen_num: the screen number
436 * Returns a screen object for one of the screens of the display.
438 * Returns: the #GdkScreen object
443 gdk_display_get_screen (GdkDisplay * display, gint screen_num)
445 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
446 g_return_val_if_fail (ScreenCount (GDK_DISPLAY_X11 (display)->xdisplay) > screen_num, NULL);
448 return GDK_DISPLAY_X11 (display)->screens[screen_num];
452 * gdk_display_get_default_screen:
453 * @display: a #GdkDisplay
455 * Get the default #GdkScreen for @display.
457 * Returns: the default #GdkScreen object for @display
462 gdk_display_get_default_screen (GdkDisplay * display)
464 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
466 return GDK_DISPLAY_X11 (display)->default_screen;
470 _gdk_x11_display_is_root_window (GdkDisplay *display,
473 GdkDisplayX11 *display_x11;
476 g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
478 display_x11 = GDK_DISPLAY_X11 (display);
480 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
482 if (GDK_SCREEN_XROOTWIN (display_x11->screens[i]) == xroot_window)
489 * gdk_display_pointer_ungrab:
490 * @display: a #GdkDisplay.
491 * @time_: a timestap (e.g. GDK_CURRENT_TIME).
493 * Release any pointer grab.
498 gdk_display_pointer_ungrab (GdkDisplay *display,
503 g_return_if_fail (GDK_IS_DISPLAY (display));
505 xdisplay = GDK_DISPLAY_XDISPLAY (display);
507 _gdk_input_ungrab_pointer (display, time);
508 XUngrabPointer (xdisplay, time);
511 GDK_DISPLAY_X11 (display)->pointer_xgrab_window = NULL;
515 * gdk_display_pointer_is_grabbed:
516 * @display: a #GdkDisplay
518 * Test if the pointer is grabbed.
520 * Returns: %TRUE if an active X pointer grab is in effect
525 gdk_display_pointer_is_grabbed (GdkDisplay * display)
527 g_return_val_if_fail (GDK_IS_DISPLAY (display), TRUE);
529 return (GDK_DISPLAY_X11 (display)->pointer_xgrab_window != NULL);
533 * gdk_display_keyboard_ungrab:
534 * @display: a #GdkDisplay.
535 * @time_: a timestap (e.g #GDK_CURRENT_TIME).
537 * Release any keyboard grab
542 gdk_display_keyboard_ungrab (GdkDisplay *display,
547 g_return_if_fail (GDK_IS_DISPLAY (display));
549 xdisplay = GDK_DISPLAY_XDISPLAY (display);
551 XUngrabKeyboard (xdisplay, time);
554 GDK_DISPLAY_X11 (display)->keyboard_xgrab_window = NULL;
559 * @display: a #GdkDisplay
561 * Emits a short beep on @display
566 gdk_display_beep (GdkDisplay * display)
568 g_return_if_fail (GDK_IS_DISPLAY (display));
570 XBell (GDK_DISPLAY_XDISPLAY (display), 0);
575 * @display: a #GdkDisplay
577 * Flushes any requests queued for the windowing system and waits until all
578 * requests have been handled. This is often used for making sure that the
579 * display is synchronized with the current state of the program. Calling
580 * gdk_display_sync() before gdk_error_trap_pop() makes sure that any errors
581 * generated from earlier requests are handled before the error trap is
584 * This is most useful for X11. On windowing systems where requests are
585 * handled synchronously, this function will do nothing.
590 gdk_display_sync (GdkDisplay * display)
592 g_return_if_fail (GDK_IS_DISPLAY (display));
594 XSync (GDK_DISPLAY_XDISPLAY (display), False);
599 * @display: a #GdkDisplay
601 * Flushes any requests queued for the windowing system; this happens automatically
602 * when the main loop blocks waiting for new events, but if your application
603 * is drawing without returning control to the main loop, you may need
604 * to call this function explicitely. A common case where this function
605 * needs to be called is when an application is executing drawing commands
606 * from a thread other than the thread where the main loop is running.
608 * This is most useful for X11. On windowing systems where requests are
609 * handled synchronously, this function will do nothing.
614 gdk_display_flush (GdkDisplay *display)
616 g_return_if_fail (GDK_IS_DISPLAY (display));
618 if (!display->closed)
619 XFlush (GDK_DISPLAY_XDISPLAY (display));
623 * gdk_display_get_default_group:
624 * @display: a #GdkDisplay
626 * Returns the default group leader window for all toplevel windows
627 * on @display. This window is implicitly created by GDK.
628 * See gdk_window_set_group().
630 * Return value: The default group leader window for @display
634 GdkWindow *gdk_display_get_default_group (GdkDisplay *display)
636 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
638 return GDK_DISPLAY_X11 (display)->leader_gdk_window;
642 * gdk_x11_display_grab:
643 * @display: a #GdkDisplay
645 * Call XGrabServer() on @display.
646 * To ungrab the display again, use gdk_x11_display_ungrab().
648 * gdk_x11_display_grab()/gdk_x11_display_ungrab() calls can be nested.
653 gdk_x11_display_grab (GdkDisplay * display)
655 GdkDisplayX11 *display_x11;
657 g_return_if_fail (GDK_IS_DISPLAY (display));
659 display_x11 = GDK_DISPLAY_X11 (display);
661 if (display_x11->grab_count == 0)
662 XGrabServer (display_x11->xdisplay);
663 display_x11->grab_count++;
667 * gdk_x11_display_ungrab:
668 * @display: a #GdkDisplay
670 * Ungrab @display after it has been grabbed with
671 * gdk_x11_display_grab().
676 gdk_x11_display_ungrab (GdkDisplay * display)
678 GdkDisplayX11 *display_x11;
680 g_return_if_fail (GDK_IS_DISPLAY (display));
682 display_x11 = GDK_DISPLAY_X11 (display);;
683 g_return_if_fail (display_x11->grab_count > 0);
685 display_x11->grab_count--;
686 if (display_x11->grab_count == 0)
688 XUngrabServer (display_x11->xdisplay);
689 XFlush (display_x11->xdisplay);
694 gdk_display_x11_dispose (GObject *object)
696 GdkDisplayX11 *display_x11;
699 display_x11 = GDK_DISPLAY_X11 (object);
701 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
702 _gdk_screen_close (display_x11->screens[i]);
704 g_source_destroy (display_x11->event_source);
706 XCloseDisplay (display_x11->xdisplay);
707 display_x11->xdisplay = NULL;
709 G_OBJECT_CLASS (parent_class)->dispose (object);
713 gdk_display_x11_finalize (GObject *object)
715 GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (object);
718 /* FIXME need to write GdkKeymap finalize fct
719 g_object_unref (display_x11->keymap);
722 if (display_x11->motif_target_lists)
724 for (i = 0; i < display_x11->motif_n_target_lists; i++)
725 g_list_free (display_x11->motif_target_lists[i]);
726 g_free (display_x11->motif_target_lists);
730 g_hash_table_destroy (display_x11->atom_from_virtual);
731 g_hash_table_destroy (display_x11->atom_to_virtual);
733 XDestroyWindow (display_x11->xdisplay, display_x11->leader_window);
734 /* list of filters for client messages */
735 g_list_free (display_x11->client_filters);
736 /* List of event window extraction functions */
737 g_slist_foreach (display_x11->event_types, (GFunc)g_free, NULL);
738 g_slist_free (display_x11->event_types);
740 g_hash_table_destroy (display_x11->xid_ht);
741 /* input GdkDevice list */
742 /* FIXME need to write finalize fct */
743 for (tmp = display_x11->input_devices; tmp; tmp = tmp->next)
744 g_object_unref (tmp->data);
745 g_list_free (display_x11->input_devices);
746 /* input GdkWindow list */
747 for (tmp = display_x11->input_windows; tmp; tmp = tmp->next)
748 g_object_unref (tmp->data);
749 g_list_free (display_x11->input_windows);
750 /* Free all GdkScreens */
751 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
752 g_object_unref (display_x11->screens[i]);
753 g_free (display_x11->screens);
754 g_free (display_x11->startup_notification_id);
756 G_OBJECT_CLASS (parent_class)->finalize (object);
760 * gdk_x11_lookup_xdisplay:
761 * @xdisplay: a pointer to an X Display
763 * Find the #GdkDisplay corresponding to @display, if any exists.
765 * Return value: the #GdkDisplay, if found, otherwise %NULL.
770 gdk_x11_lookup_xdisplay (Display *xdisplay)
774 for (tmp_list = _gdk_displays; tmp_list; tmp_list = tmp_list->next)
776 if (GDK_DISPLAY_XDISPLAY (tmp_list->data) == xdisplay)
777 return tmp_list->data;
784 * _gdk_x11_display_screen_for_xrootwin:
785 * @display: a #Display
786 * @xrootwin: window ID for one of of the screen's of the display.
788 * Given the root window ID of one of the screen's of a #GdkDisplay,
791 * Return value: the #GdkScreen corresponding to @xrootwin, or %NULL.
794 _gdk_x11_display_screen_for_xrootwin (GdkDisplay *display,
799 n_screens = gdk_display_get_n_screens (display);
800 for (i = 0; i < n_screens; i++)
802 GdkScreen *screen = gdk_display_get_screen (display, i);
803 if (GDK_SCREEN_XROOTWIN (screen) == xrootwin)
811 * gdk_x11_display_get_xdisplay:
812 * @display: a #GdkDisplay
813 * @returns: an X display.
815 * Returns the X display of a #GdkDisplay.
820 gdk_x11_display_get_xdisplay (GdkDisplay *display)
822 return GDK_DISPLAY_X11 (display)->xdisplay;
826 _gdk_windowing_set_default_display (GdkDisplay *display)
828 GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
829 const gchar *startup_id;
832 gdk_display = GDK_DISPLAY_XDISPLAY (display);
836 g_free (display_x11->startup_notification_id);
837 display_x11->startup_notification_id = NULL;
839 startup_id = g_getenv ("DESKTOP_STARTUP_ID");
840 if (startup_id && *startup_id != '\0')
842 if (!g_utf8_validate (startup_id, -1, NULL))
843 g_warning ("DESKTOP_STARTUP_ID contains invalid UTF-8");
845 display_x11->startup_notification_id = g_strdup (startup_id);
847 /* Clear the environment variable so it won't be inherited by
848 * child processes and confuse things.
850 g_unsetenv ("DESKTOP_STARTUP_ID");
852 /* Set the startup id on the leader window so it
853 * applies to all windows we create on this display
855 XChangeProperty (display_x11->xdisplay,
856 display_x11->leader_window,
857 gdk_x11_get_xatom_by_name_for_display (display, "_NET_STARTUP_ID"),
858 gdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING"), 8,
860 startup_id, strlen (startup_id));
865 escape_for_xmessage (const char *str)
870 retval = g_string_new (NULL);
880 g_string_append_c (retval, '\\');
884 g_string_append_c (retval, *p);
888 return g_string_free (retval, FALSE);
892 broadcast_xmessage (GdkDisplay *display,
893 const char *message_type,
894 const char *message_type_begin,
897 Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
898 GdkScreen *screen = gdk_display_get_default_screen (display);
899 GdkWindow *root_window = gdk_screen_get_root_window (screen);
900 Window xroot_window = GDK_WINDOW_XID (root_window);
903 Atom type_atom_begin;
907 XSetWindowAttributes attrs;
909 attrs.override_redirect = True;
910 attrs.event_mask = PropertyChangeMask | StructureNotifyMask;
913 XCreateWindow (xdisplay,
920 CWOverrideRedirect | CWEventMask,
924 type_atom = gdk_x11_get_xatom_by_name_for_display (display,
926 type_atom_begin = gdk_x11_get_xatom_by_name_for_display (display,
936 xevent.xclient.type = ClientMessage;
937 xevent.xclient.message_type = type_atom_begin;
938 xevent.xclient.display =xdisplay;
939 xevent.xclient.window = xwindow;
940 xevent.xclient.format = 8;
943 src_end = message + strlen (message) + 1; /* +1 to include nul byte */
945 while (src != src_end)
947 dest = &xevent.xclient.data.b[0];
948 dest_end = dest + 20;
950 while (dest != dest_end &&
958 while (dest != dest_end)
964 XSendEvent (xdisplay,
970 xevent.xclient.message_type = type_atom;
974 XDestroyWindow (xdisplay, xwindow);
979 * gdk_notify_startup_complete:
981 * Indicates to the GUI environment that the application has finished
982 * loading. If the applications opens windows, this function is
983 * normally called after opening the application's initial set of
986 * GTK+ will call this function automatically after opening the first
987 * #GtkWindow unless gtk_window_set_auto_startup_notification() is called
988 * to disable that feature.
993 gdk_notify_startup_complete (void)
996 GdkDisplayX11 *display_x11;
1000 display = gdk_display_get_default ();
1004 display_x11 = GDK_DISPLAY_X11 (display);
1006 if (display_x11->startup_notification_id == NULL)
1009 escaped_id = escape_for_xmessage (display_x11->startup_notification_id);
1010 message = g_strdup_printf ("remove: ID=%s", escaped_id);
1011 g_free (escaped_id);
1013 broadcast_xmessage (display,
1014 "_NET_STARTUP_INFO",
1015 "_NET_STARTUP_INFO_BEGIN",
1023 * gdk_display_supports_selection_notification:
1024 * @display: a #GdkDisplay
1026 * Returns whether #GdkEventOwnerChange events will be
1027 * sent when the owner of a selection changes.
1029 * Return value: whether #GdkEventOwnerChange events will
1035 gdk_display_supports_selection_notification (GdkDisplay *display)
1037 GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
1039 return display_x11->have_xfixes;
1043 * gdk_display_request_selection_notification:
1044 * @display: a #GdkDisplay
1045 * @selection: the #GdkAtom naming the selection for which
1046 * ownership change notification is requested
1048 * Request #GdkEventOwnerChange events for ownership changes
1049 * of the selection named by the given atom.
1051 * Return value: whether #GdkEventOwnerChange events will
1056 gboolean gdk_display_request_selection_notification (GdkDisplay *display,
1061 GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
1064 if (display_x11->have_xfixes)
1066 atom = gdk_x11_atom_to_xatom_for_display (display,
1068 XFixesSelectSelectionInput (display_x11->xdisplay,
1069 display_x11->leader_window,
1071 XFixesSetSelectionOwnerNotifyMask |
1072 XFixesSelectionWindowDestroyNotifyMask |
1073 XFixesSelectionClientCloseNotifyMask);