/* GDK - The GIMP Drawing Kit * gdkdisplay.c * * Copyright 2001 Sun Microsystems Inc. * * Erwann Chenede * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #include "config.h" #include #include #include "gdk.h" /* gdk_event_send_client_message() */ #include "gdkdisplay.h" #include "gdkwindowimpl.h" #include "gdkinternals.h" #include "gdkmarshalers.h" #include "gdkscreen.h" #include "gdkalias.h" enum { CLOSED, LAST_SIGNAL }; static void gdk_display_dispose (GObject *object); static void gdk_display_finalize (GObject *object); static void singlehead_get_pointer (GdkDisplay *display, GdkScreen **screen, gint *x, gint *y, GdkModifierType *mask); static GdkWindow* singlehead_window_get_pointer (GdkDisplay *display, GdkWindow *window, gint *x, gint *y, GdkModifierType *mask); static GdkWindow* singlehead_window_at_pointer (GdkDisplay *display, gint *win_x, gint *win_y); static GdkWindow* singlehead_default_window_get_pointer (GdkWindow *window, gint *x, gint *y, GdkModifierType *mask); static GdkWindow* singlehead_default_window_at_pointer (GdkScreen *screen, gint *win_x, gint *win_y); static GdkWindow *gdk_window_real_window_get_pointer (GdkDisplay *display, GdkWindow *window, gint *x, gint *y, GdkModifierType *mask); static GdkWindow *gdk_display_real_get_window_at_pointer (GdkDisplay *display, gint *win_x, gint *win_y); static guint signals[LAST_SIGNAL] = { 0 }; static char *gdk_sm_client_id; static const GdkDisplayPointerHooks default_pointer_hooks = { _gdk_windowing_get_pointer, gdk_window_real_window_get_pointer, gdk_display_real_get_window_at_pointer }; static const GdkDisplayPointerHooks singlehead_pointer_hooks = { singlehead_get_pointer, singlehead_window_get_pointer, singlehead_window_at_pointer }; static const GdkPointerHooks singlehead_default_pointer_hooks = { singlehead_default_window_get_pointer, singlehead_default_window_at_pointer }; static const GdkPointerHooks *singlehead_current_pointer_hooks = &singlehead_default_pointer_hooks; G_DEFINE_TYPE (GdkDisplay, gdk_display, G_TYPE_OBJECT) static void gdk_display_class_init (GdkDisplayClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->finalize = gdk_display_finalize; object_class->dispose = gdk_display_dispose; /** * GdkDisplay::closed: * @display: the object on which the signal is emitted * @is_error: %TRUE if the display was closed due to an error * * The ::closed signal is emitted when the connection to the windowing * system for @display is closed. * * Since: 2.2 */ signals[CLOSED] = g_signal_new (g_intern_static_string ("closed"), G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GdkDisplayClass, closed), NULL, NULL, gdk_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN); } static void gdk_display_init (GdkDisplay *display) { _gdk_displays = g_slist_prepend (_gdk_displays, display); display->button_click_time[0] = display->button_click_time[1] = 0; display->button_window[0] = display->button_window[1] = NULL; display->button_number[0] = display->button_number[1] = -1; display->button_x[0] = display->button_x[1] = 0; display->button_y[0] = display->button_y[1] = 0; display->double_click_time = 250; display->double_click_distance = 5; display->pointer_hooks = &default_pointer_hooks; } static void gdk_display_dispose (GObject *object) { GdkDisplay *display = GDK_DISPLAY_OBJECT (object); g_list_foreach (display->queued_events, (GFunc)gdk_event_free, NULL); g_list_free (display->queued_events); display->queued_events = NULL; display->queued_tail = NULL; _gdk_displays = g_slist_remove (_gdk_displays, object); if (gdk_display_get_default() == display) { if (_gdk_displays) gdk_display_manager_set_default_display (gdk_display_manager_get(), _gdk_displays->data); else gdk_display_manager_set_default_display (gdk_display_manager_get(), NULL); } G_OBJECT_CLASS (gdk_display_parent_class)->dispose (object); } static void gdk_display_finalize (GObject *object) { G_OBJECT_CLASS (gdk_display_parent_class)->finalize (object); } /** * gdk_display_close: * @display: a #GdkDisplay * * Closes the connection to the windowing system for the given display, * and cleans up associated resources. * * Since: 2.2 */ void gdk_display_close (GdkDisplay *display) { g_return_if_fail (GDK_IS_DISPLAY (display)); if (!display->closed) { display->closed = TRUE; g_signal_emit (display, signals[CLOSED], 0, FALSE); g_object_run_dispose (G_OBJECT (display)); g_object_unref (display); } } /** * gdk_display_get_event: * @display: a #GdkDisplay * * Gets the next #GdkEvent to be processed for @display, fetching events from the * windowing system if necessary. * * Return value: the next #GdkEvent to be processed, or %NULL if no events * are pending. The returned #GdkEvent should be freed with gdk_event_free(). * * Since: 2.2 **/ GdkEvent* gdk_display_get_event (GdkDisplay *display) { g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); _gdk_events_queue (display); return _gdk_event_unqueue (display); } /** * gdk_display_peek_event: * @display: a #GdkDisplay * * Gets a copy of the first #GdkEvent in the @display's event queue, without * removing the event from the queue. (Note that this function will * not get more events from the windowing system. It only checks the events * that have already been moved to the GDK event queue.) * * Return value: a copy of the first #GdkEvent on the event queue, or %NULL * if no events are in the queue. The returned #GdkEvent should be freed with * gdk_event_free(). * * Since: 2.2 **/ GdkEvent* gdk_display_peek_event (GdkDisplay *display) { GList *tmp_list; g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); tmp_list = _gdk_event_queue_find_first (display); if (tmp_list) return gdk_event_copy (tmp_list->data); else return NULL; } /** * gdk_display_put_event: * @display: a #GdkDisplay * @event: a #GdkEvent. * * Appends a copy of the given event onto the front of the event * queue for @display. * * Since: 2.2 **/ void gdk_display_put_event (GdkDisplay *display, const GdkEvent *event) { g_return_if_fail (GDK_IS_DISPLAY (display)); g_return_if_fail (event != NULL); _gdk_event_queue_append (display, gdk_event_copy (event)); /* If the main loop is blocking in a different thread, wake it up */ g_main_context_wakeup (NULL); } /** * gdk_pointer_ungrab: * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no * timestamp is available. * * Ungrabs the pointer on the default display, if it is grabbed by this * application. **/ void gdk_pointer_ungrab (guint32 time) { gdk_display_pointer_ungrab (gdk_display_get_default (), time); } /** * gdk_pointer_is_grabbed: * * Returns %TRUE if the pointer on the default display is currently * grabbed by this application. * * Note that this does not take the inmplicit pointer grab on button * presses into account. * Return value: %TRUE if the pointer is currently grabbed by this application.* **/ gboolean gdk_pointer_is_grabbed (void) { return gdk_display_pointer_is_grabbed (gdk_display_get_default ()); } /** * gdk_keyboard_ungrab: * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no * timestamp is available. * * Ungrabs the keyboard on the default display, if it is grabbed by this * application. **/ void gdk_keyboard_ungrab (guint32 time) { gdk_display_keyboard_ungrab (gdk_display_get_default (), time); } /** * gdk_beep: * * Emits a short beep on the default display. **/ void gdk_beep (void) { gdk_display_beep (gdk_display_get_default ()); } /** * gdk_event_send_client_message: * @event: the #GdkEvent to send, which should be a #GdkEventClient. * @winid: the window to send the X ClientMessage event to. * * Sends an X ClientMessage event to a given window (which must be * on the default #GdkDisplay.) * This could be used for communicating between different applications, * though the amount of data is limited to 20 bytes. * * Return value: non-zero on success. **/ gboolean gdk_event_send_client_message (GdkEvent *event, GdkNativeWindow winid) { g_return_val_if_fail (event != NULL, FALSE); return gdk_event_send_client_message_for_display (gdk_display_get_default (), event, winid); } /** * gdk_event_send_clientmessage_toall: * @event: the #GdkEvent to send, which should be a #GdkEventClient. * * Sends an X ClientMessage event to all toplevel windows on the default * #GdkScreen. * * Toplevel windows are determined by checking for the WM_STATE property, as * described in the Inter-Client Communication Conventions Manual (ICCCM). * If no windows are found with the WM_STATE property set, the message is sent * to all children of the root window. **/ void gdk_event_send_clientmessage_toall (GdkEvent *event) { g_return_if_fail (event != NULL); gdk_screen_broadcast_client_message (gdk_screen_get_default (), event); } /** * gdk_device_get_core_pointer: * * Returns the core pointer device for the default display. * * Return value: the core pointer device; this is owned by the * display and should not be freed. **/ GdkDevice * gdk_device_get_core_pointer (void) { return gdk_display_get_core_pointer (gdk_display_get_default ()); } /** * gdk_display_get_core_pointer: * @display: a #GdkDisplay * * Returns the core pointer device for the given display * * Return value: the core pointer device; this is owned by the * display and should not be freed. * * Since: 2.2 **/ GdkDevice * gdk_display_get_core_pointer (GdkDisplay *display) { return display->core_pointer; } /** * gdk_set_sm_client_id: * @sm_client_id: the client id assigned by the session manager when the * connection was opened, or %NULL to remove the property. * * Sets the SM_CLIENT_ID property on the application's leader window so that * the window manager can save the application's state using the X11R6 ICCCM * session management protocol. * * See the X Session Management Library documentation for more information on * session management and the Inter-Client Communication Conventions Manual * (ICCCM) for information on the WM_CLIENT_LEADER property. * (Both documents are part of the X Window System distribution.) **/ void gdk_set_sm_client_id (const gchar* sm_client_id) { GSList *displays, *tmp_list; g_free (gdk_sm_client_id); gdk_sm_client_id = g_strdup (sm_client_id); displays = gdk_display_manager_list_displays (gdk_display_manager_get ()); for (tmp_list = displays; tmp_list; tmp_list = tmp_list->next) _gdk_windowing_display_set_sm_client_id (tmp_list->data, sm_client_id); g_slist_free (displays); } /** * _gdk_get_sm_client_id: * * Gets the client ID set with gdk_set_sm_client_id(), if any. * * Return value: Session ID, or %NULL if gdk_set_sm_client_id() * has never been called. **/ const char * _gdk_get_sm_client_id (void) { return gdk_sm_client_id; } void _gdk_display_enable_motion_hints (GdkDisplay *display) { gulong next_serial; if (display->pointer_info.motion_hint_serial != 0) { next_serial = _gdk_windowing_window_get_next_serial (display); if (next_serial < display->pointer_info.motion_hint_serial) display->pointer_info.motion_hint_serial = next_serial; } } /** * gdk_display_get_pointer: * @display: a #GdkDisplay * @screen: location to store the screen that the * cursor is on, or %NULL. * @x: location to store root window X coordinate of pointer, or %NULL. * @y: location to store root window Y coordinate of pointer, or %NULL. * @mask: location to store current modifier mask, or %NULL * * Gets the current location of the pointer and the current modifier * mask for a given display. * * Since: 2.2 **/ void gdk_display_get_pointer (GdkDisplay *display, GdkScreen **screen, gint *x, gint *y, GdkModifierType *mask) { GdkScreen *tmp_screen; gint tmp_x, tmp_y; GdkModifierType tmp_mask; g_return_if_fail (GDK_IS_DISPLAY (display)); display->pointer_hooks->get_pointer (display, &tmp_screen, &tmp_x, &tmp_y, &tmp_mask); if (screen) *screen = tmp_screen; if (x) *x = tmp_x; if (y) *y = tmp_y; if (mask) *mask = tmp_mask; } static GdkWindow * gdk_display_real_get_window_at_pointer (GdkDisplay *display, gint *win_x, gint *win_y) { GdkWindow *window; gint x, y; window = _gdk_windowing_window_at_pointer (display, &x, &y, NULL); /* This might need corrections, as the native window returned may contain client side children */ if (window) { double xx, yy; window = _gdk_window_find_descendant_at (window, x, y, &xx, &yy); x = floor (xx + 0.5); y = floor (yy + 0.5); } *win_x = x; *win_y = y; return window; } static GdkWindow * gdk_window_real_window_get_pointer (GdkDisplay *display, GdkWindow *window, gint *x, gint *y, GdkModifierType *mask) { GdkWindowObject *private; GdkWindow *pointer_window; gint tmpx, tmpy; GdkModifierType tmp_mask; private = (GdkWindowObject *) window; pointer_window = _gdk_windowing_window_get_pointer (display, window, &tmpx, &tmpy, mask); /* We got the coords on the impl, conver to the window */ tmpx -= private->abs_x; tmpy -= private->abs_y; if (x) *x = tmpx; if (y) *y = tmpy; /* We need to recalculate the true child window with the pointer in it due to possible client side child windows */ if (pointer_window != NULL) { /* First get the pointer coords relative to pointer_window */ _gdk_windowing_window_get_pointer (display, pointer_window, &tmpx, &tmpy, &tmp_mask); /* Then convert that to a client side window */ pointer_window = _gdk_window_find_descendant_at (pointer_window, tmpx, tmpy, NULL, NULL); } return pointer_window; } /** * gdk_display_get_window_at_pointer: * @display: a #GdkDisplay * @win_x: return location for x coordinate of the pointer location relative * to the window origin, or %NULL * @win_y: return location for y coordinate of the pointer location relative & to the window origin, or %NULL * * Obtains the window underneath the mouse pointer, returning the location * of the pointer in that window in @win_x, @win_y for @screen. Returns %NULL * if the window under the mouse pointer is not known to GDK (for example, * belongs to another application). * * Returns: the window under the mouse pointer, or %NULL * * Since: 2.2 **/ GdkWindow * gdk_display_get_window_at_pointer (GdkDisplay *display, gint *win_x, gint *win_y) { gint tmp_x, tmp_y; GdkWindow *window; g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); window = display->pointer_hooks->window_at_pointer (display, &tmp_x, &tmp_y); if (win_x) *win_x = tmp_x; if (win_y) *win_y = tmp_y; return window; } /** * gdk_display_set_pointer_hooks: * @display: a #GdkDisplay * @new_hooks: a table of pointers to functions for getting * quantities related to the current pointer position, * or %NULL to restore the default table. * * This function allows for hooking into the operation * of getting the current location of the pointer on a particular * display. This is only useful for such low-level tools as an * event recorder. Applications should never have any * reason to use this facility. * * Return value: the previous pointer hook table * * Since: 2.2 **/ GdkDisplayPointerHooks * gdk_display_set_pointer_hooks (GdkDisplay *display, const GdkDisplayPointerHooks *new_hooks) { const GdkDisplayPointerHooks *result; g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); result = display->pointer_hooks; if (new_hooks) display->pointer_hooks = new_hooks; else display->pointer_hooks = &default_pointer_hooks; return (GdkDisplayPointerHooks *)result; } static void singlehead_get_pointer (GdkDisplay *display, GdkScreen **screen, gint *x, gint *y, GdkModifierType *mask) { GdkScreen *default_screen = gdk_display_get_default_screen (display); GdkWindow *root_window = gdk_screen_get_root_window (default_screen); *screen = default_screen; singlehead_current_pointer_hooks->get_pointer (root_window, x, y, mask); } static GdkWindow* singlehead_window_get_pointer (GdkDisplay *display, GdkWindow *window, gint *x, gint *y, GdkModifierType *mask) { return singlehead_current_pointer_hooks->get_pointer (window, x, y, mask); } static GdkWindow* singlehead_window_at_pointer (GdkDisplay *display, gint *win_x, gint *win_y) { GdkScreen *default_screen = gdk_display_get_default_screen (display); return singlehead_current_pointer_hooks->window_at_pointer (default_screen, win_x, win_y); } static GdkWindow* singlehead_default_window_get_pointer (GdkWindow *window, gint *x, gint *y, GdkModifierType *mask) { return gdk_window_real_window_get_pointer (gdk_drawable_get_display (window), window, x, y, mask); } static GdkWindow* singlehead_default_window_at_pointer (GdkScreen *screen, gint *win_x, gint *win_y) { return gdk_display_real_get_window_at_pointer (gdk_screen_get_display (screen), win_x, win_y); } /** * gdk_set_pointer_hooks: * @new_hooks: a table of pointers to functions for getting * quantities related to the current pointer position, * or %NULL to restore the default table. * * This function allows for hooking into the operation * of getting the current location of the pointer. This * is only useful for such low-level tools as an * event recorder. Applications should never have any * reason to use this facility. * * This function is not multihead safe. For multihead operation, * see gdk_display_set_pointer_hooks(). * * Return value: the previous pointer hook table **/ GdkPointerHooks * gdk_set_pointer_hooks (const GdkPointerHooks *new_hooks) { const GdkPointerHooks *result = singlehead_current_pointer_hooks; if (new_hooks) singlehead_current_pointer_hooks = new_hooks; else singlehead_current_pointer_hooks = &singlehead_default_pointer_hooks; gdk_display_set_pointer_hooks (gdk_display_get_default (), &singlehead_pointer_hooks); return (GdkPointerHooks *)result; } static void generate_grab_broken_event (GdkWindow *window, gboolean keyboard, gboolean implicit, GdkWindow *grab_window) { g_return_if_fail (window != NULL); if (!GDK_WINDOW_DESTROYED (window)) { GdkEvent event; event.type = GDK_GRAB_BROKEN; event.grab_broken.window = window; event.grab_broken.send_event = 0; event.grab_broken.keyboard = keyboard; event.grab_broken.implicit = implicit; event.grab_broken.grab_window = grab_window; gdk_event_put (&event); } } /* Get the pointer grab in effects for events we just sent */ GdkPointerGrabInfo * _gdk_display_get_active_pointer_grab (GdkDisplay *display) { GdkPointerGrabInfo *info; if (display->pointer_grabs == NULL) return NULL; info = display->pointer_grabs->data; if (info->activated) return info; return NULL; } GdkPointerGrabInfo * _gdk_display_get_last_pointer_grab (GdkDisplay *display) { GList *l; l = display->pointer_grabs; if (l == NULL) return NULL; while (l->next != NULL) l = l->next; return (GdkPointerGrabInfo *)l->data; } GdkPointerGrabInfo * _gdk_display_add_pointer_grab (GdkDisplay *display, GdkWindow *window, GdkWindow *native_window, gboolean owner_events, GdkEventMask event_mask, unsigned long serial_start, guint32 time, gboolean implicit) { GdkPointerGrabInfo *info, *other_info; GList *l; info = g_new0 (GdkPointerGrabInfo, 1); info->window = g_object_ref (window); info->native_window = g_object_ref (native_window); info->serial_start = serial_start; info->serial_end = G_MAXULONG; info->owner_events = owner_events; info->event_mask = event_mask; info->time = time; info->implicit = implicit; /* Find the first grab that has a larger start time (if any) and insert * before that. I.E we insert after already existing grabs with same * start time */ for (l = display->pointer_grabs; l != NULL; l = l->next) { other_info = l->data; if (info->serial_start < other_info->serial_start) break; } display->pointer_grabs = g_list_insert_before (display->pointer_grabs, l, info); /* Make sure the new grab end before next grab */ if (l) { other_info = l->data; info->serial_end = other_info->serial_start; } /* Find any previous grab and update its end time */ l = g_list_find (display->pointer_grabs, info); l = l->prev; if (l) { other_info = l->data; other_info->serial_end = serial_start; } return info; } static void free_pointer_grab (GdkPointerGrabInfo *info) { g_object_unref (info->window); g_object_unref (info->native_window); g_free (info); } /* _gdk_syntesize_crossing_events only works inside one toplevel. This function splits things into two calls if needed, converting the coordinates to the right toplevel */ static void synthesize_crossing_events (GdkDisplay *display, GdkWindow *src_window, GdkWindow *dest_window, GdkCrossingMode crossing_mode, guint32 time, gulong serial) { GdkWindow *src_toplevel, *dest_toplevel; GdkModifierType state; int x, y; if (src_window) src_toplevel = gdk_window_get_toplevel (src_window); else src_toplevel = NULL; if (dest_window) dest_toplevel = gdk_window_get_toplevel (dest_window); else dest_toplevel = NULL; if (src_toplevel == NULL && dest_toplevel == NULL) return; if (src_toplevel == NULL || src_toplevel == dest_toplevel) { /* Same toplevels */ _gdk_windowing_window_get_pointer (display, dest_toplevel, &x, &y, &state); _gdk_syntesize_crossing_events (display, src_window, dest_window, crossing_mode, x, y, state, time, NULL, serial); } else if (dest_toplevel == NULL) { _gdk_windowing_window_get_pointer (display, src_toplevel, &x, &y, &state); _gdk_syntesize_crossing_events (display, src_window, NULL, crossing_mode, x, y, state, time, NULL, serial); } else { /* Different toplevels */ _gdk_windowing_window_get_pointer (display, src_toplevel, &x, &y, &state); _gdk_syntesize_crossing_events (display, src_window, NULL, crossing_mode, x, y, state, time, NULL, serial); _gdk_windowing_window_get_pointer (display, dest_toplevel, &x, &y, &state); _gdk_syntesize_crossing_events (display, NULL, dest_window, crossing_mode, x, y, state, time, NULL, serial); } } static void switch_to_pointer_grab (GdkDisplay *display, GdkPointerGrabInfo *grab, GdkPointerGrabInfo *last_grab, guint32 time, gulong serial) { GdkWindow *src_window, *pointer_window; GdkWindowObject *w; GList *old_grabs; GdkModifierType state; int x, y; /* Temporarily unset pointer to make sure we send the crossing events below */ old_grabs = display->pointer_grabs; display->pointer_grabs = NULL; if (grab) { /* New grab is in effect */ /* We need to generate crossing events for the grab. * However, there are never any crossing events for implicit grabs * TODO: ... Actually, this could happen if the pointer window * doesn't have button mask so a parent gets the event... */ if (!grab->implicit) { /* We send GRAB crossing events from the window under the pointer to the grab window. Except if there is an old grab then we start from that */ if (last_grab) src_window = last_grab->window; else src_window = display->pointer_info.window_under_pointer; if (src_window != grab->window) { synthesize_crossing_events (display, src_window, grab->window, GDK_CROSSING_GRAB, time, serial); } /* !owner_event Grabbing a window that we're not inside, current status is now NULL (i.e. outside grabbed window) */ if (!grab->owner_events && display->pointer_info.window_under_pointer != grab->window) _gdk_display_set_window_under_pointer (display, NULL); } grab->activated = TRUE; } else if (last_grab) { pointer_window = _gdk_windowing_window_at_pointer (display, &x, &y, &state); if (pointer_window != NULL && (GDK_WINDOW_DESTROYED (pointer_window) || GDK_WINDOW_TYPE (pointer_window) == GDK_WINDOW_ROOT || GDK_WINDOW_TYPE (pointer_window) == GDK_WINDOW_FOREIGN)) pointer_window = NULL; /* We force checked what window we're in, so we need to * update the toplevel_under_pointer info, as that won't get told of * this change. */ if (display->pointer_info.toplevel_under_pointer) g_object_unref (display->pointer_info.toplevel_under_pointer); display->pointer_info.toplevel_under_pointer = NULL; if (pointer_window) { /* Convert to toplevel */ w = (GdkWindowObject *)pointer_window; while (/*w->parent != NULL && */ w->parent->window_type != GDK_WINDOW_ROOT) { x += w->x; y += w->y; w = w->parent; } /* w is now toplevel and x,y in toplevel coords */ display->pointer_info.toplevel_under_pointer = g_object_ref (w); /* Find (possibly virtual) child window */ pointer_window = _gdk_window_find_descendant_at ((GdkWindow *)w, x, y, NULL, NULL); } if (pointer_window != last_grab->window) synthesize_crossing_events (display, last_grab->window, pointer_window, GDK_CROSSING_UNGRAB, time, serial); /* We're now ungrabbed, update the window_under_pointer */ _gdk_display_set_window_under_pointer (display, pointer_window); if (last_grab->implicit_ungrab) generate_grab_broken_event (last_grab->window, FALSE, TRUE, NULL); } display->pointer_grabs = old_grabs; } void _gdk_display_pointer_grab_update (GdkDisplay *display, gulong current_serial) { GdkPointerGrabInfo *current_grab, *next_grab; guint32 time; time = display->last_event_time; while (display->pointer_grabs != NULL) { current_grab = display->pointer_grabs->data; if (current_grab->serial_start > current_serial) return; /* Hasn't started yet */ if (current_grab->serial_end > current_serial || (current_grab->serial_end == current_serial && current_grab->grab_one_pointer_release_event)) { /* This one hasn't ended yet. its the currently active one or scheduled to be active */ if (!current_grab->activated) switch_to_pointer_grab (display, current_grab, NULL, time, current_serial); break; } next_grab = NULL; if (display->pointer_grabs->next) { /* This is the next active grab */ next_grab = display->pointer_grabs->next->data; if (next_grab->serial_start > current_serial) next_grab = NULL; /* Actually its not yet active */ } if (next_grab == NULL || current_grab->window != next_grab->window) generate_grab_broken_event (GDK_WINDOW (current_grab->window), FALSE, current_grab->implicit, next_grab? next_grab->window : NULL); /* Remove old grab */ display->pointer_grabs = g_list_delete_link (display->pointer_grabs, display->pointer_grabs); switch_to_pointer_grab (display, next_grab, current_grab, time, current_serial); free_pointer_grab (current_grab); } } static gboolean is_parent_of (GdkWindow *parent, GdkWindow *child) { GdkWindow *w; w = child; while (w != NULL) { if (w == parent) return TRUE; w = gdk_window_get_parent (w); } return FALSE; } static GList * find_pointer_grab (GdkDisplay *display, gulong serial) { GdkPointerGrabInfo *grab; GList *l; for (l = display->pointer_grabs; l != NULL; l = l->next) { grab = l->data; if (serial >= grab->serial_start && serial < grab->serial_end) return l; } return NULL; } GdkPointerGrabInfo * _gdk_display_has_pointer_grab (GdkDisplay *display, gulong serial) { GList *l; l = find_pointer_grab (display, serial); if (l) return l->data; return NULL; } /* Returns true if last grab was ended */ gboolean _gdk_display_end_pointer_grab (GdkDisplay *display, gulong serial, GdkWindow *if_child, gboolean implicit) { GdkPointerGrabInfo *grab; GList *l; l = find_pointer_grab (display, serial); if (l == NULL) return FALSE; grab = l->data; if (grab && (if_child == NULL || is_parent_of (grab->window, if_child))) { grab->serial_end = serial; grab->implicit_ungrab = implicit; return l->next == NULL; } return FALSE; } void _gdk_display_set_has_keyboard_grab (GdkDisplay *display, GdkWindow *window, GdkWindow *native_window, gboolean owner_events, unsigned long serial, guint32 time) { if (display->keyboard_grab.window != NULL && display->keyboard_grab.window != window) generate_grab_broken_event (display->keyboard_grab.window, TRUE, FALSE, window); display->keyboard_grab.window = window; display->keyboard_grab.native_window = native_window; display->keyboard_grab.owner_events = owner_events; display->keyboard_grab.serial = serial; display->keyboard_grab.time = time; } void _gdk_display_unset_has_keyboard_grab (GdkDisplay *display, gboolean implicit) { if (implicit) generate_grab_broken_event (display->keyboard_grab.window, TRUE, FALSE, NULL); display->keyboard_grab.window = NULL; } /** * gdk_keyboard_grab_info_libgtk_only: * @display: the display for which to get the grab information * @grab_window: location to store current grab window * @owner_events: location to store boolean indicating whether * the @owner_events flag to gdk_keyboard_grab() was %TRUE. * * Determines information about the current keyboard grab. * This is not public API and must not be used by applications. * * Return value: %TRUE if this application currently has the * keyboard grabbed. **/ gboolean gdk_keyboard_grab_info_libgtk_only (GdkDisplay *display, GdkWindow **grab_window, gboolean *owner_events) { g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE); if (display->keyboard_grab.window) { if (grab_window) *grab_window = display->keyboard_grab.window; if (owner_events) *owner_events = display->keyboard_grab.owner_events; return TRUE; } else return FALSE; } /** * gdk_pointer_grab_info_libgtk_only: * @display: the #GdkDisplay for which to get the grab information * @grab_window: location to store current grab window * @owner_events: location to store boolean indicating whether * the @owner_events flag to gdk_pointer_grab() was %TRUE. * * Determines information about the current pointer grab. * This is not public API and must not be used by applications. * * Return value: %TRUE if this application currently has the * pointer grabbed. **/ gboolean gdk_pointer_grab_info_libgtk_only (GdkDisplay *display, GdkWindow **grab_window, gboolean *owner_events) { GdkPointerGrabInfo *info; g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE); info = _gdk_display_get_active_pointer_grab (display); if (info) { if (grab_window) *grab_window = info->window; if (owner_events) *owner_events = info->owner_events; return TRUE; } else return FALSE; } /** * gdk_display_pointer_is_grabbed: * @display: a #GdkDisplay * * Test if the pointer is grabbed. * * Returns: %TRUE if an active X pointer grab is in effect * * Since: 2.2 */ gboolean gdk_display_pointer_is_grabbed (GdkDisplay *display) { GdkPointerGrabInfo *info; g_return_val_if_fail (GDK_IS_DISPLAY (display), TRUE); info = _gdk_display_get_active_pointer_grab (display); return (info && !info->implicit); } #define __GDK_DISPLAY_C__ #include "gdkaliasdef.c"