1 /* GDK - The GIMP Drawing Kit
4 * Copyright 2001 Sun Microsystems Inc.
5 * Copyright (C) 2004 Nokia Corporation
7 * Erwann Chenede <erwann.chenede@sun.com>
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Library General Public
11 * License as published by the Free Software Foundation; either
12 * version 2 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Library General Public License for more details.
19 * You should have received a copy of the GNU Library General Public
20 * License along with this library; if not, write to the
21 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 * Boston, MA 02111-1307, USA.
34 #include "gdkdisplay.h"
35 #include "gdkdisplay-x11.h"
36 #include "gdkscreen.h"
37 #include "gdkscreen-x11.h"
38 #include "gdkinternals.h"
39 #include "gdkinputprivate.h"
40 #include "xsettings-client.h"
43 #include <X11/Xatom.h>
46 #include <X11/XKBlib.h>
50 #include <X11/extensions/Xfixes.h>
54 #include <X11/extensions/shape.h>
57 #ifdef HAVE_XCOMPOSITE
58 #include <X11/extensions/Xcomposite.h>
62 #include <X11/extensions/Xdamage.h>
66 #include <X11/extensions/Xrandr.h>
70 static void gdk_display_x11_dispose (GObject *object);
71 static void gdk_display_x11_finalize (GObject *object);
74 static void gdk_internal_connection_watch (Display *display,
78 XPointer *watch_data);
79 #endif /* HAVE_X11R6 */
81 /* Note that we never *directly* use WM_LOCALE_NAME, WM_PROTOCOLS,
82 * but including them here has the side-effect of getting them
83 * into the internal Xlib cache
85 static const char *const precache_atoms[] = {
100 "_NET_WM_STATE_STICKY",
101 "_NET_WM_STATE_MAXIMIZED_VERT",
102 "_NET_WM_STATE_MAXIMIZED_HORZ",
103 "_NET_WM_STATE_FULLSCREEN",
104 "_NET_WM_SYNC_REQUEST",
105 "_NET_WM_SYNC_REQUEST_COUNTER",
106 "_NET_WM_WINDOW_TYPE",
107 "_NET_WM_WINDOW_TYPE_NORMAL",
112 G_DEFINE_TYPE (GdkDisplayX11, _gdk_display_x11, GDK_TYPE_DISPLAY)
115 _gdk_display_x11_class_init (GdkDisplayX11Class * class)
117 GObjectClass *object_class = G_OBJECT_CLASS (class);
119 object_class->dispose = gdk_display_x11_dispose;
120 object_class->finalize = gdk_display_x11_finalize;
124 _gdk_display_x11_init (GdkDisplayX11 *display)
130 * @display_name: the name of the display to open
131 * @returns: a #GdkDisplay, or %NULL if the display
132 * could not be opened.
139 gdk_display_open (const gchar *display_name)
143 GdkDisplayX11 *display_x11;
147 const char *sm_client_id;
149 XClassHint *class_hint;
152 #if defined(HAVE_XFIXES) || defined(HAVE_SHAPE_EXT)
157 xdisplay = XOpenDisplay (display_name);
161 display = g_object_new (GDK_TYPE_DISPLAY_X11, NULL);
162 display_x11 = GDK_DISPLAY_X11 (display);
164 display_x11->use_xshm = TRUE;
165 display_x11->xdisplay = xdisplay;
168 /* Set up handlers for Xlib internal connections */
169 XAddConnectionWatch (xdisplay, gdk_internal_connection_watch, NULL);
170 #endif /* HAVE_X11R6 */
172 /* RandR must be initialized before we initialize the screens */
173 display_x11->have_randr12 = FALSE;
175 if (XRRQueryExtension (display_x11->xdisplay,
176 &display_x11->xrandr_event_base, &ignore))
180 XRRQueryVersion (display_x11->xdisplay, &major, &minor);
182 if ((major == 1 && minor >= 2) || major > 1)
183 display_x11->have_randr12 = TRUE;
187 /* initialize the display's screens */
188 display_x11->screens = g_new (GdkScreen *, ScreenCount (display_x11->xdisplay));
189 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
190 display_x11->screens[i] = _gdk_x11_screen_new (display, i);
192 /* We need to initialize events after we have the screen
193 * structures in places
195 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
196 _gdk_x11_events_init_screen (display_x11->screens[i]);
198 /*set the default screen */
199 display_x11->default_screen = display_x11->screens[DefaultScreen (display_x11->xdisplay)];
201 attr.window_type = GDK_WINDOW_TOPLEVEL;
202 attr.wclass = GDK_INPUT_OUTPUT;
209 _gdk_x11_precache_atoms (display, precache_atoms, G_N_ELEMENTS (precache_atoms));
211 display_x11->leader_gdk_window = gdk_window_new (GDK_SCREEN_X11 (display_x11->default_screen)->root_window,
212 &attr, GDK_WA_X | GDK_WA_Y);
213 (_gdk_x11_window_get_toplevel (display_x11->leader_gdk_window))->is_leader = TRUE;
215 display_x11->leader_window = GDK_WINDOW_XID (display_x11->leader_gdk_window);
217 display_x11->leader_window_title_set = FALSE;
219 display_x11->have_render = GDK_UNKNOWN;
222 if (XFixesQueryExtension (display_x11->xdisplay,
223 &display_x11->xfixes_event_base,
226 display_x11->have_xfixes = TRUE;
228 gdk_x11_register_standard_event_type (display,
229 display_x11->xfixes_event_base,
234 display_x11->have_xfixes = FALSE;
236 #ifdef HAVE_XCOMPOSITE
237 if (XCompositeQueryExtension (display_x11->xdisplay,
239 display_x11->have_xcomposite = TRUE;
242 display_x11->have_xcomposite = FALSE;
245 if (XDamageQueryExtension (display_x11->xdisplay,
246 &display_x11->xdamage_event_base,
249 display_x11->have_xdamage = TRUE;
251 gdk_x11_register_standard_event_type (display,
252 display_x11->xdamage_event_base,
253 XDamageNumberEvents);
257 display_x11->have_xdamage = FALSE;
259 display_x11->have_shapes = FALSE;
260 display_x11->have_input_shapes = FALSE;
261 #ifdef HAVE_SHAPE_EXT
262 if (XShapeQueryExtension (GDK_DISPLAY_XDISPLAY (display), &ignore, &ignore))
264 display_x11->have_shapes = TRUE;
266 if (XShapeQueryVersion (GDK_DISPLAY_XDISPLAY (display), &maj, &min))
267 display_x11->have_input_shapes = (maj == 1 && min >= 1);
272 display_x11->trusted_client = TRUE;
275 int rootx, rooty, winx, winy;
278 gdk_error_trap_push ();
279 XQueryPointer (display_x11->xdisplay,
280 GDK_SCREEN_X11 (display_x11->default_screen)->xroot_window,
281 &root, &child, &rootx, &rooty, &winx, &winy, &xmask);
283 if (G_UNLIKELY (gdk_error_trap_pop () == BadWindow))
285 g_warning ("Connection to display %s appears to be untrusted. Pointer and keyboard grabs and inter-client communication may not work as expected.", gdk_display_get_name (display));
286 display_x11->trusted_client = FALSE;
290 if (_gdk_synchronize)
291 XSynchronize (display_x11->xdisplay, True);
293 class_hint = XAllocClassHint();
294 class_hint->res_name = g_get_prgname ();
296 class_hint->res_class = (char *)gdk_get_program_class ();
298 /* XmbSetWMProperties sets the RESOURCE_NAME environment variable
299 * from argv[0], so we just synthesize an argument array here.
302 argv[0] = g_get_prgname ();
304 XmbSetWMProperties (display_x11->xdisplay,
305 display_x11->leader_window,
306 NULL, NULL, argv, argc, NULL, NULL,
310 sm_client_id = _gdk_get_sm_client_id ();
312 _gdk_windowing_display_set_sm_client_id (display, sm_client_id);
315 XChangeProperty (display_x11->xdisplay,
316 display_x11->leader_window,
317 gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_PID"),
318 XA_CARDINAL, 32, PropModeReplace, (guchar *) & pid, 1);
320 /* We don't yet know a valid time. */
321 display_x11->user_time = 0;
325 gint xkb_major = XkbMajorVersion;
326 gint xkb_minor = XkbMinorVersion;
327 if (XkbLibraryVersion (&xkb_major, &xkb_minor))
329 xkb_major = XkbMajorVersion;
330 xkb_minor = XkbMinorVersion;
332 if (XkbQueryExtension (display_x11->xdisplay,
333 NULL, &display_x11->xkb_event_type, NULL,
334 &xkb_major, &xkb_minor))
336 Bool detectable_autorepeat_supported;
338 display_x11->use_xkb = TRUE;
340 XkbSelectEvents (display_x11->xdisplay,
342 XkbNewKeyboardNotifyMask | XkbMapNotifyMask | XkbStateNotifyMask,
343 XkbNewKeyboardNotifyMask | XkbMapNotifyMask | XkbStateNotifyMask);
345 /* keep this in sync with _gdk_keymap_state_changed() */
346 XkbSelectEventDetails (display_x11->xdisplay,
347 XkbUseCoreKbd, XkbStateNotify,
348 XkbAllStateComponentsMask,
351 XkbSetDetectableAutoRepeat (display_x11->xdisplay,
353 &detectable_autorepeat_supported);
355 GDK_NOTE (MISC, g_message ("Detectable autorepeat %s.",
356 detectable_autorepeat_supported ?
357 "supported" : "not supported"));
359 display_x11->have_xkb_autorepeat = detectable_autorepeat_supported;
365 display_x11->use_sync = FALSE;
369 int error_base, event_base;
371 if (XSyncQueryExtension (display_x11->xdisplay,
372 &event_base, &error_base) &&
373 XSyncInitialize (display_x11->xdisplay,
375 display_x11->use_sync = TRUE;
379 _gdk_windowing_image_init (display);
380 _gdk_events_init (display);
381 _gdk_input_init (display);
382 _gdk_dnd_init (display);
384 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
385 gdk_display_request_selection_notification (display,
386 GDK_SCREEN_X11 (display_x11->screens[i])->cm_selection_atom);
388 g_signal_emit_by_name (gdk_display_manager_get(),
389 "display_opened", display);
396 * XLib internal connection handling
398 typedef struct _GdkInternalConnection GdkInternalConnection;
400 struct _GdkInternalConnection
408 process_internal_connection (GIOChannel *gioc,
412 GdkInternalConnection *connection = (GdkInternalConnection *)data;
414 GDK_THREADS_ENTER ();
416 XProcessInternalConnection ((Display*)connection->display, connection->fd);
418 GDK_THREADS_LEAVE ();
423 static GdkInternalConnection *
424 gdk_add_connection_handler (Display *display,
427 GIOChannel *io_channel;
428 GdkInternalConnection *connection;
430 connection = g_new (GdkInternalConnection, 1);
433 connection->display = display;
435 io_channel = g_io_channel_unix_new (fd);
437 connection->source = g_io_create_watch (io_channel, G_IO_IN);
438 g_source_set_callback (connection->source,
439 (GSourceFunc)process_internal_connection, connection, NULL);
440 g_source_attach (connection->source, NULL);
442 g_io_channel_unref (io_channel);
448 gdk_remove_connection_handler (GdkInternalConnection *connection)
450 g_source_destroy (connection->source);
455 gdk_internal_connection_watch (Display *display,
459 XPointer *watch_data)
462 *watch_data = (XPointer)gdk_add_connection_handler (display, fd);
464 gdk_remove_connection_handler ((GdkInternalConnection *)*watch_data);
466 #endif /* HAVE_X11R6 */
469 * gdk_display_get_name:
470 * @display: a #GdkDisplay
472 * Gets the name of the display.
474 * Returns: a string representing the display name. This string is owned
475 * by GDK and should not be modified or freed.
479 G_CONST_RETURN gchar *
480 gdk_display_get_name (GdkDisplay *display)
482 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
484 return (gchar *) DisplayString (GDK_DISPLAY_X11 (display)->xdisplay);
488 * gdk_display_get_n_screens:
489 * @display: a #GdkDisplay
491 * Gets the number of screen managed by the @display.
493 * Returns: number of screens.
498 gdk_display_get_n_screens (GdkDisplay *display)
500 g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
502 return ScreenCount (GDK_DISPLAY_X11 (display)->xdisplay);
506 * gdk_display_get_screen:
507 * @display: a #GdkDisplay
508 * @screen_num: the screen number
510 * Returns a screen object for one of the screens of the display.
512 * Returns: the #GdkScreen object
517 gdk_display_get_screen (GdkDisplay *display,
520 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
521 g_return_val_if_fail (ScreenCount (GDK_DISPLAY_X11 (display)->xdisplay) > screen_num, NULL);
523 return GDK_DISPLAY_X11 (display)->screens[screen_num];
527 * gdk_display_get_default_screen:
528 * @display: a #GdkDisplay
530 * Get the default #GdkScreen for @display.
532 * Returns: the default #GdkScreen object for @display
537 gdk_display_get_default_screen (GdkDisplay *display)
539 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
541 return GDK_DISPLAY_X11 (display)->default_screen;
545 _gdk_x11_display_is_root_window (GdkDisplay *display,
548 GdkDisplayX11 *display_x11;
551 g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
553 display_x11 = GDK_DISPLAY_X11 (display);
555 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
557 if (GDK_SCREEN_XROOTWIN (display_x11->screens[i]) == xroot_window)
563 #define XSERVER_TIME_IS_LATER(time1, time2) \
564 ( (( time1 > time2 ) && ( time1 - time2 < ((guint32)-1)/2 )) || \
565 (( time1 < time2 ) && ( time2 - time1 > ((guint32)-1)/2 )) \
569 * gdk_display_pointer_ungrab:
570 * @display: a #GdkDisplay.
571 * @time_: a timestap (e.g. %GDK_CURRENT_TIME).
573 * Release any pointer grab.
578 gdk_display_pointer_ungrab (GdkDisplay *display,
582 GdkDisplayX11 *display_x11;
584 g_return_if_fail (GDK_IS_DISPLAY (display));
586 display_x11 = GDK_DISPLAY_X11 (display);
587 xdisplay = GDK_DISPLAY_XDISPLAY (display);
589 _gdk_input_ungrab_pointer (display, time);
590 XUngrabPointer (xdisplay, time);
593 if (time == GDK_CURRENT_TIME ||
594 display_x11->pointer_xgrab_time == GDK_CURRENT_TIME ||
595 !XSERVER_TIME_IS_LATER (display_x11->pointer_xgrab_time, time))
596 display_x11->pointer_xgrab_window = NULL;
600 * gdk_display_pointer_is_grabbed:
601 * @display: a #GdkDisplay
603 * Test if the pointer is grabbed.
605 * Returns: %TRUE if an active X pointer grab is in effect
610 gdk_display_pointer_is_grabbed (GdkDisplay *display)
612 g_return_val_if_fail (GDK_IS_DISPLAY (display), TRUE);
614 return (GDK_DISPLAY_X11 (display)->pointer_xgrab_window != NULL &&
615 !GDK_DISPLAY_X11 (display)->pointer_xgrab_implicit);
619 * gdk_display_keyboard_ungrab:
620 * @display: a #GdkDisplay.
621 * @time_: a timestap (e.g #GDK_CURRENT_TIME).
623 * Release any keyboard grab
628 gdk_display_keyboard_ungrab (GdkDisplay *display,
632 GdkDisplayX11 *display_x11;
634 g_return_if_fail (GDK_IS_DISPLAY (display));
636 display_x11 = GDK_DISPLAY_X11 (display);
637 xdisplay = GDK_DISPLAY_XDISPLAY (display);
639 XUngrabKeyboard (xdisplay, time);
642 if (time == GDK_CURRENT_TIME ||
643 display_x11->keyboard_xgrab_time == GDK_CURRENT_TIME ||
644 !XSERVER_TIME_IS_LATER (display_x11->keyboard_xgrab_time, time))
645 display_x11->keyboard_xgrab_window = NULL;
650 * @display: a #GdkDisplay
652 * Emits a short beep on @display
657 gdk_display_beep (GdkDisplay *display)
659 g_return_if_fail (GDK_IS_DISPLAY (display));
661 XBell (GDK_DISPLAY_XDISPLAY (display), 0);
666 * @display: a #GdkDisplay
668 * Flushes any requests queued for the windowing system and waits until all
669 * requests have been handled. This is often used for making sure that the
670 * display is synchronized with the current state of the program. Calling
671 * gdk_display_sync() before gdk_error_trap_pop() makes sure that any errors
672 * generated from earlier requests are handled before the error trap is
675 * This is most useful for X11. On windowing systems where requests are
676 * handled synchronously, this function will do nothing.
681 gdk_display_sync (GdkDisplay *display)
683 g_return_if_fail (GDK_IS_DISPLAY (display));
685 XSync (GDK_DISPLAY_XDISPLAY (display), False);
690 * @display: a #GdkDisplay
692 * Flushes any requests queued for the windowing system; this happens automatically
693 * when the main loop blocks waiting for new events, but if your application
694 * is drawing without returning control to the main loop, you may need
695 * to call this function explicitely. A common case where this function
696 * needs to be called is when an application is executing drawing commands
697 * from a thread other than the thread where the main loop is running.
699 * This is most useful for X11. On windowing systems where requests are
700 * handled synchronously, this function will do nothing.
705 gdk_display_flush (GdkDisplay *display)
707 g_return_if_fail (GDK_IS_DISPLAY (display));
709 if (!display->closed)
710 XFlush (GDK_DISPLAY_XDISPLAY (display));
714 * gdk_display_get_default_group:
715 * @display: a #GdkDisplay
717 * Returns the default group leader window for all toplevel windows
718 * on @display. This window is implicitly created by GDK.
719 * See gdk_window_set_group().
721 * Return value: The default group leader window for @display
726 gdk_display_get_default_group (GdkDisplay *display)
728 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
730 return GDK_DISPLAY_X11 (display)->leader_gdk_window;
734 * gdk_x11_display_grab:
735 * @display: a #GdkDisplay
737 * Call XGrabServer() on @display.
738 * To ungrab the display again, use gdk_x11_display_ungrab().
740 * gdk_x11_display_grab()/gdk_x11_display_ungrab() calls can be nested.
745 gdk_x11_display_grab (GdkDisplay *display)
747 GdkDisplayX11 *display_x11;
749 g_return_if_fail (GDK_IS_DISPLAY (display));
751 display_x11 = GDK_DISPLAY_X11 (display);
753 if (display_x11->grab_count == 0)
754 XGrabServer (display_x11->xdisplay);
755 display_x11->grab_count++;
759 * gdk_x11_display_ungrab:
760 * @display: a #GdkDisplay
762 * Ungrab @display after it has been grabbed with
763 * gdk_x11_display_grab().
768 gdk_x11_display_ungrab (GdkDisplay *display)
770 GdkDisplayX11 *display_x11;
772 g_return_if_fail (GDK_IS_DISPLAY (display));
774 display_x11 = GDK_DISPLAY_X11 (display);;
775 g_return_if_fail (display_x11->grab_count > 0);
777 display_x11->grab_count--;
778 if (display_x11->grab_count == 0)
780 XUngrabServer (display_x11->xdisplay);
781 XFlush (display_x11->xdisplay);
786 gdk_display_x11_dispose (GObject *object)
788 GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (object);
791 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
792 _gdk_screen_close (display_x11->screens[i]);
794 _gdk_events_uninit (GDK_DISPLAY_OBJECT (object));
796 G_OBJECT_CLASS (_gdk_display_x11_parent_class)->dispose (object);
800 gdk_display_x11_finalize (GObject *object)
802 GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (object);
806 if (display_x11->keymap)
807 g_object_unref (display_x11->keymap);
810 if (display_x11->motif_target_lists)
812 for (i = 0; i < display_x11->motif_n_target_lists; i++)
813 g_list_free (display_x11->motif_target_lists[i]);
814 g_free (display_x11->motif_target_lists);
818 g_hash_table_destroy (display_x11->atom_from_virtual);
819 g_hash_table_destroy (display_x11->atom_to_virtual);
822 XDestroyWindow (display_x11->xdisplay, display_x11->leader_window);
824 /* list of filters for client messages */
825 g_list_foreach (display_x11->client_filters, (GFunc) g_free, NULL);
826 g_list_free (display_x11->client_filters);
828 /* List of event window extraction functions */
829 g_slist_foreach (display_x11->event_types, (GFunc)g_free, NULL);
830 g_slist_free (display_x11->event_types);
832 /* input GdkDevice list */
833 /* FIXME need to write finalize fct */
834 g_list_foreach (display_x11->input_devices, (GFunc) g_object_unref, NULL);
835 g_list_free (display_x11->input_devices);
837 /* input GdkWindow list */
838 g_list_foreach (display_x11->input_windows, (GFunc) g_free, NULL);
839 g_list_free (display_x11->input_windows);
841 /* Free all GdkScreens */
842 for (i = 0; i < ScreenCount (display_x11->xdisplay); i++)
843 g_object_unref (display_x11->screens[i]);
844 g_free (display_x11->screens);
846 g_free (display_x11->startup_notification_id);
849 g_hash_table_destroy (display_x11->xid_ht);
851 XCloseDisplay (display_x11->xdisplay);
853 G_OBJECT_CLASS (_gdk_display_x11_parent_class)->finalize (object);
857 * gdk_x11_lookup_xdisplay:
858 * @xdisplay: a pointer to an X Display
860 * Find the #GdkDisplay corresponding to @display, if any exists.
862 * Return value: the #GdkDisplay, if found, otherwise %NULL.
867 gdk_x11_lookup_xdisplay (Display *xdisplay)
871 for (tmp_list = _gdk_displays; tmp_list; tmp_list = tmp_list->next)
873 if (GDK_DISPLAY_XDISPLAY (tmp_list->data) == xdisplay)
874 return tmp_list->data;
881 * _gdk_x11_display_screen_for_xrootwin:
882 * @display: a #GdkDisplay
883 * @xrootwin: window ID for one of of the screen's of the display.
885 * Given the root window ID of one of the screen's of a #GdkDisplay,
888 * Return value: the #GdkScreen corresponding to @xrootwin, or %NULL.
891 _gdk_x11_display_screen_for_xrootwin (GdkDisplay *display,
896 for (i = 0; i < ScreenCount (GDK_DISPLAY_X11 (display)->xdisplay); i++)
898 GdkScreen *screen = gdk_display_get_screen (display, i);
899 if (GDK_SCREEN_XROOTWIN (screen) == xrootwin)
907 * gdk_x11_display_get_xdisplay:
908 * @display: a #GdkDisplay
909 * @returns: an X display.
911 * Returns the X display of a #GdkDisplay.
916 gdk_x11_display_get_xdisplay (GdkDisplay *display)
918 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
919 return GDK_DISPLAY_X11 (display)->xdisplay;
923 _gdk_windowing_set_default_display (GdkDisplay *display)
925 GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
926 const gchar *startup_id;
934 gdk_display = GDK_DISPLAY_XDISPLAY (display);
936 g_free (display_x11->startup_notification_id);
937 display_x11->startup_notification_id = NULL;
939 startup_id = g_getenv ("DESKTOP_STARTUP_ID");
940 if (startup_id && *startup_id != '\0')
944 if (!g_utf8_validate (startup_id, -1, NULL))
945 g_warning ("DESKTOP_STARTUP_ID contains invalid UTF-8");
947 display_x11->startup_notification_id = g_strdup (startup_id);
949 /* Find the launch time from the startup_id, if it's there. Newer spec
950 * states that the startup_id is of the form <unique>_TIME<timestamp>
952 time_str = g_strrstr (startup_id, "_TIME");
953 if (time_str != NULL)
959 /* Skip past the "_TIME" part */
962 retval = strtoul (time_str, &end, 0);
963 if (end != time_str && errno == 0)
964 display_x11->user_time = retval;
967 /* Clear the environment variable so it won't be inherited by
968 * child processes and confuse things.
970 g_unsetenv ("DESKTOP_STARTUP_ID");
972 /* Set the startup id on the leader window so it
973 * applies to all windows we create on this display
975 XChangeProperty (display_x11->xdisplay,
976 display_x11->leader_window,
977 gdk_x11_get_xatom_by_name_for_display (display, "_NET_STARTUP_ID"),
978 gdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING"), 8,
980 (guchar *)startup_id, strlen (startup_id));
985 broadcast_xmessage (GdkDisplay *display,
986 const char *message_type,
987 const char *message_type_begin,
990 Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
991 GdkScreen *screen = gdk_display_get_default_screen (display);
992 GdkWindow *root_window = gdk_screen_get_root_window (screen);
993 Window xroot_window = GDK_WINDOW_XID (root_window);
996 Atom type_atom_begin;
999 if (!G_LIKELY (GDK_DISPLAY_X11 (display)->trusted_client))
1003 XSetWindowAttributes attrs;
1005 attrs.override_redirect = True;
1006 attrs.event_mask = PropertyChangeMask | StructureNotifyMask;
1009 XCreateWindow (xdisplay,
1015 (Visual *)CopyFromParent,
1016 CWOverrideRedirect | CWEventMask,
1020 type_atom = gdk_x11_get_xatom_by_name_for_display (display,
1022 type_atom_begin = gdk_x11_get_xatom_by_name_for_display (display,
1023 message_type_begin);
1026 XClientMessageEvent xclient;
1028 const char *src_end;
1032 memset(&xclient, 0, sizeof (xclient));
1033 xclient.type = ClientMessage;
1034 xclient.message_type = type_atom_begin;
1035 xclient.display =xdisplay;
1036 xclient.window = xwindow;
1040 src_end = message + strlen (message) + 1; /* +1 to include nul byte */
1042 while (src != src_end)
1044 dest = &xclient.data.b[0];
1045 dest_end = dest + 20;
1047 while (dest != dest_end &&
1055 while (dest != dest_end)
1061 XSendEvent (xdisplay,
1065 (XEvent *)&xclient);
1067 xclient.message_type = type_atom;
1071 XDestroyWindow (xdisplay, xwindow);
1076 * gdk_x11_display_broadcast_startup_message:
1077 * @display: a #GdkDisplay
1078 * @message_type: startup notification message type ("new", "change",
1080 * @...: a list of key/value pairs (as strings), terminated by a
1081 * %NULL key. (A %NULL value for a key will cause that key to be
1082 * skipped in the output.)
1084 * Sends a startup notification message of type @message_type to
1087 * This is a convenience function for use by code that implements the
1088 * freedesktop startup notification specification. Applications should
1089 * not normally need to call it directly. See the <ulink
1090 * url="http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt">Startup
1091 * Notification Protocol specification</ulink> for
1092 * definitions of the message types and keys that can be used.
1097 gdk_x11_display_broadcast_startup_message (GdkDisplay *display,
1098 const char *message_type,
1103 const char *key, *value, *p;
1105 message = g_string_new (message_type);
1106 g_string_append_c (message, ':');
1108 va_start (ap, message_type);
1109 while ((key = va_arg (ap, const char *)))
1111 value = va_arg (ap, const char *);
1115 g_string_append_printf (message, " %s=\"", key);
1116 for (p = value; *p; p++)
1123 g_string_append_c (message, '\\');
1127 g_string_append_c (message, *p);
1129 g_string_append_c (message, '\"');
1133 broadcast_xmessage (display,
1134 "_NET_STARTUP_INFO",
1135 "_NET_STARTUP_INFO_BEGIN",
1138 g_string_free (message, TRUE);
1142 * gdk_notify_startup_complete:
1144 * Indicates to the GUI environment that the application has finished
1145 * loading. If the applications opens windows, this function is
1146 * normally called after opening the application's initial set of
1149 * GTK+ will call this function automatically after opening the first
1150 * #GtkWindow unless gtk_window_set_auto_startup_notification() is called
1151 * to disable that feature.
1156 gdk_notify_startup_complete (void)
1158 GdkDisplay *display;
1159 GdkDisplayX11 *display_x11;
1161 display = gdk_display_get_default ();
1165 display_x11 = GDK_DISPLAY_X11 (display);
1167 if (display_x11->startup_notification_id == NULL)
1170 gdk_notify_startup_complete_with_id (display_x11->startup_notification_id);
1174 * gdk_notify_startup_complete_with_id:
1175 * @startup_id: a startup-notification identifier, for which notification
1176 * process should be completed
1178 * Indicates to the GUI environment that the application has finished
1179 * loading, using a given identifier.
1181 * GTK+ will call this function automatically for #GtkWindow with custom
1182 * startup-notification identifier unless
1183 * gtk_window_set_auto_startup_notification() is called to disable
1189 gdk_notify_startup_complete_with_id (const gchar* startup_id)
1191 GdkDisplay *display;
1193 display = gdk_display_get_default ();
1197 gdk_x11_display_broadcast_startup_message (display, "remove",
1203 * gdk_display_supports_selection_notification:
1204 * @display: a #GdkDisplay
1206 * Returns whether #GdkEventOwnerChange events will be
1207 * sent when the owner of a selection changes.
1209 * Return value: whether #GdkEventOwnerChange events will
1215 gdk_display_supports_selection_notification (GdkDisplay *display)
1217 GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
1219 return display_x11->have_xfixes;
1223 * gdk_display_request_selection_notification:
1224 * @display: a #GdkDisplay
1225 * @selection: the #GdkAtom naming the selection for which
1226 * ownership change notification is requested
1228 * Request #GdkEventOwnerChange events for ownership changes
1229 * of the selection named by the given atom.
1231 * Return value: whether #GdkEventOwnerChange events will
1237 gdk_display_request_selection_notification (GdkDisplay *display,
1242 GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
1245 if (display_x11->have_xfixes)
1247 atom = gdk_x11_atom_to_xatom_for_display (display,
1249 XFixesSelectSelectionInput (display_x11->xdisplay,
1250 display_x11->leader_window,
1252 XFixesSetSelectionOwnerNotifyMask |
1253 XFixesSelectionWindowDestroyNotifyMask |
1254 XFixesSelectionClientCloseNotifyMask);
1263 * gdk_display_supports_clipboard_persistence
1264 * @display: a #GdkDisplay
1266 * Returns whether the speicifed display supports clipboard
1267 * persistance; i.e. if it's possible to store the clipboard data after an
1268 * application has quit. On X11 this checks if a clipboard daemon is
1271 * Returns: %TRUE if the display supports clipboard persistance.
1276 gdk_display_supports_clipboard_persistence (GdkDisplay *display)
1278 Atom clipboard_manager;
1280 /* It might make sense to cache this */
1281 clipboard_manager = gdk_x11_get_xatom_by_name_for_display (display, "CLIPBOARD_MANAGER");
1282 return XGetSelectionOwner (GDK_DISPLAY_X11 (display)->xdisplay, clipboard_manager) != None;
1286 * gdk_display_store_clipboard
1287 * @display: a #GdkDisplay
1288 * @clipboard_window: a #GdkWindow belonging to the clipboard owner
1289 * @time_: a timestamp
1290 * @targets: an array of targets that should be saved, or %NULL
1291 * if all available targets should be saved.
1292 * @n_targets: length of the @targets array
1294 * Issues a request to the clipboard manager to store the
1295 * clipboard data. On X11, this is a special program that works
1296 * according to the freedesktop clipboard specification, available at
1297 * <ulink url="http://www.freedesktop.org/Standards/clipboard-manager-spec">
1298 * http://www.freedesktop.org/Standards/clipboard-manager-spec</ulink>.
1303 gdk_display_store_clipboard (GdkDisplay *display,
1304 GdkWindow *clipboard_window,
1306 const GdkAtom *targets,
1309 GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
1310 Atom clipboard_manager, save_targets;
1312 clipboard_manager = gdk_x11_get_xatom_by_name_for_display (display, "CLIPBOARD_MANAGER");
1313 save_targets = gdk_x11_get_xatom_by_name_for_display (display, "SAVE_TARGETS");
1315 gdk_error_trap_push ();
1317 if (XGetSelectionOwner (display_x11->xdisplay, clipboard_manager) != None)
1319 Atom property_name = None;
1325 property_name = gdk_x11_atom_to_xatom_for_display (display, _gdk_selection_property);
1327 xatoms = g_new (Atom, n_targets);
1328 for (i = 0; i < n_targets; i++)
1329 xatoms[i] = gdk_x11_atom_to_xatom_for_display (display, targets[i]);
1331 XChangeProperty (display_x11->xdisplay, GDK_WINDOW_XID (clipboard_window),
1332 property_name, XA_ATOM,
1333 32, PropModeReplace, (guchar *)xatoms, n_targets);
1338 XConvertSelection (display_x11->xdisplay,
1339 clipboard_manager, save_targets, property_name,
1340 GDK_WINDOW_XID (clipboard_window), time_);
1343 gdk_error_trap_pop ();
1348 * gdk_x11_display_get_user_time:
1349 * @display: a #GdkDisplay
1351 * Returns the timestamp of the last user interaction on
1352 * @display. The timestamp is taken from events caused
1353 * by user interaction such as key presses or pointer
1354 * movements. See gdk_x11_window_set_user_time().
1356 * Returns: the timestamp of the last user interaction
1361 gdk_x11_display_get_user_time (GdkDisplay *display)
1363 return GDK_DISPLAY_X11 (display)->user_time;
1367 * gdk_display_supports_shapes:
1368 * @display: a #GdkDisplay
1370 * Returns %TRUE if gdk_window_shape_combine_mask() can
1371 * be used to create shaped windows on @display.
1373 * Returns: %TRUE if shaped windows are supported
1378 gdk_display_supports_shapes (GdkDisplay *display)
1380 return GDK_DISPLAY_X11 (display)->have_shapes;
1384 * gdk_display_supports_input_shapes:
1385 * @display: a #GdkDisplay
1387 * Returns %TRUE if gdk_window_input_shape_combine_mask() can
1388 * be used to modify the input shape of windows on @display.
1390 * Returns: %TRUE if windows with modified input shape are supported
1395 gdk_display_supports_input_shapes (GdkDisplay *display)
1397 return GDK_DISPLAY_X11 (display)->have_input_shapes;
1402 * gdk_x11_display_get_startup_notification_id:
1403 * @display: a #GdkDisplay
1405 * Gets the startup notification ID for a display.
1407 * Returns: the startup notification ID for @display
1411 G_CONST_RETURN gchar *
1412 gdk_x11_display_get_startup_notification_id (GdkDisplay *display)
1414 return GDK_DISPLAY_X11 (display)->startup_notification_id;
1418 * gdk_display_supports_composite:
1419 * @display: a #GdkDisplay
1421 * Returns %TRUE if gdk_window_set_composited() can be used
1422 * to redirect drawing on the window using compositing.
1424 * Currently this only works on X11 with XComposite and
1425 * XDamage extensions available.
1427 * Returns: %TRUE if windows may be composited.
1432 gdk_display_supports_composite (GdkDisplay *display)
1434 GdkDisplayX11 *x11_display = GDK_DISPLAY_X11 (display);
1436 return x11_display->have_xcomposite &&
1437 x11_display->have_xdamage &&
1438 x11_display->have_xfixes;
1442 #define __GDK_DISPLAY_X11_C__
1443 #include "gdkaliasdef.c"