* Boston, MA 02111-1307, USA.
*/
-#include <glib.h>
-#include "gdk.h" /* gdk_event_send_client_message() */
+#include "config.h"
+
#include "gdkdisplay.h"
+
+#include "gdkevents.h"
+#include "gdkwindowimpl.h"
#include "gdkinternals.h"
#include "gdkmarshalers.h"
#include "gdkscreen.h"
+#include <glib.h>
+#include <math.h>
+
+
+/**
+ * SECTION:gdkdisplay
+ * @Short_description: Controls the keyboard/mouse pointer grabs and a set of <type>GdkScreen</type>s
+ * @Title: GdkDisplay
+ *
+ * #GdkDisplay objects purpose are two fold:
+ * <itemizedlist>
+ * <listitem><para>
+ * To grab/ungrab keyboard focus and mouse pointer
+ * </para></listitem>
+ * <listitem><para>
+ * To manage and provide information about the #GdkScreen(s)
+ * available for this #GdkDisplay
+ * </para></listitem>
+ * </itemizedlist>
+ *
+ * #GdkDisplay objects are the GDK representation of the X Display which can be
+ * described as <emphasis>a workstation consisting of a keyboard a pointing
+ * device (such as a mouse) and one or more screens</emphasis>.
+ * It is used to open and keep track of various #GdkScreen objects currently
+ * instanciated by the application. It is also used to grab and release the keyboard
+ * and the mouse pointer.
+ */
+
+
enum {
+ OPENED,
CLOSED,
LAST_SIGNAL
};
-static void gdk_display_class_init (GdkDisplayClass *class);
-static void gdk_display_init (GdkDisplay *display);
-static void gdk_display_dispose (GObject *object);
-static void gdk_display_finalize (GObject *object);
+static void gdk_display_dispose (GObject *object);
+static void gdk_display_finalize (GObject *object);
+
+static void multihead_get_device_state (GdkDisplay *display,
+ GdkDevice *device,
+ GdkScreen **screen,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask);
+static GdkWindow * multihead_window_get_device_position (GdkDisplay *display,
+ GdkDevice *device,
+ GdkWindow *window,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask);
+static GdkWindow * multihead_window_at_device_position (GdkDisplay *display,
+ GdkDevice *device,
+ gint *win_x,
+ gint *win_y);
+
+static void multihead_default_get_pointer (GdkDisplay *display,
+ GdkScreen **screen,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask);
+static GdkWindow * multihead_default_window_get_pointer (GdkDisplay *display,
+ GdkWindow *window,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask);
+static GdkWindow * multihead_default_window_at_pointer (GdkDisplay *display,
+ gint *win_x,
+ gint *win_y);
+
+
+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_device_position (GdkDisplay *display,
+ GdkDevice *device,
+ GdkWindow *window,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask);
+static GdkWindow *gdk_display_real_get_window_at_device_position (GdkDisplay *display,
+ GdkDevice *device,
+ gint *win_x,
+ gint *win_y);
static guint signals[LAST_SIGNAL] = { 0 };
-static GObjectClass *parent_class;
static char *gdk_sm_client_id;
-GType
-gdk_display_get_type (void)
-{
+static const GdkDisplayDeviceHooks default_device_hooks = {
+ _gdk_windowing_get_device_state,
+ gdk_window_real_window_get_device_position,
+ gdk_display_real_get_window_at_device_position
+};
- static GType object_type = 0;
+static const GdkDisplayDeviceHooks multihead_pointer_hooks = {
+ multihead_get_device_state,
+ multihead_window_get_device_position,
+ multihead_window_at_device_position
+};
- if (!object_type)
- {
- static const GTypeInfo object_info = {
- sizeof (GdkDisplayClass),
- (GBaseInitFunc) NULL,
- (GBaseFinalizeFunc) NULL,
- (GClassInitFunc) gdk_display_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GdkDisplay),
- 0, /* n_preallocs */
- (GInstanceInitFunc) gdk_display_init
- };
- object_type = g_type_register_static (G_TYPE_OBJECT,
- "GdkDisplay", &object_info, 0);
- }
+static const GdkDisplayPointerHooks multihead_default_pointer_hooks = {
+ multihead_default_get_pointer,
+ multihead_default_window_get_pointer,
+ multihead_default_window_at_pointer
+};
- return object_type;
-}
+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;
+static const GdkDisplayPointerHooks *multihead_current_pointer_hooks = &multihead_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);
-
- parent_class = g_type_class_peek_parent (class);
object_class->finalize = gdk_display_finalize;
object_class->dispose = gdk_display_dispose;
+ /**
+ * GdkDisplay::opened:
+ * @display: the object on which the signal is emitted
+ *
+ * The ::opened signal is emitted when the connection to the windowing
+ * system for @display is opened.
+ */
+ signals[OPENED] =
+ g_signal_new (g_intern_static_string ("opened"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ 0, NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ /**
+ * 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 ("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,
+ _gdk_marshal_VOID__BOOLEAN,
G_TYPE_NONE,
1,
G_TYPE_BOOLEAN);
}
+static void
+free_pointer_info (GdkPointerWindowInfo *info)
+{
+ g_object_unref (info->toplevel_under_pointer);
+ g_slice_free (GdkPointerWindowInfo, info);
+}
+
+static void
+free_device_grab (GdkDeviceGrabInfo *info)
+{
+ g_object_unref (info->window);
+ g_object_unref (info->native_window);
+ g_free (info);
+}
+
+static gboolean
+free_device_grabs_foreach (gpointer key,
+ gpointer value,
+ gpointer user_data)
+{
+ GList *list = value;
+
+ g_list_foreach (list, (GFunc) free_device_grab, NULL);
+ g_list_free (list);
+
+ return TRUE;
+}
+
+static void
+device_removed_cb (GdkDeviceManager *device_manager,
+ GdkDevice *device,
+ GdkDisplay *display)
+{
+ g_hash_table_remove (display->multiple_click_info, device);
+ g_hash_table_remove (display->device_grabs, device);
+ g_hash_table_remove (display->pointers_info, device);
+
+ /* FIXME: change core pointer and remove from device list */
+}
+
+static void
+gdk_display_opened (GdkDisplay *display)
+{
+ GdkDeviceManager *device_manager;
+
+ device_manager = gdk_display_get_device_manager (display);
+
+ g_signal_connect (device_manager, "device-removed",
+ G_CALLBACK (device_removed_cb), display);
+}
+
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->double_click_time = 250;
+ display->double_click_distance = 5;
+
+ display->device_hooks = &default_device_hooks;
+
+ display->device_grabs = g_hash_table_new (NULL, NULL);
+ display->motion_hint_info = g_hash_table_new_full (NULL, NULL, NULL,
+ (GDestroyNotify) g_free);
+
+ display->pointers_info = g_hash_table_new_full (NULL, NULL, NULL,
+ (GDestroyNotify) free_pointer_info);
+
+ display->multiple_click_info = g_hash_table_new_full (NULL, NULL, NULL,
+ (GDestroyNotify) g_free);
+
+ g_signal_connect (display, "opened",
+ G_CALLBACK (gdk_display_opened), NULL);
}
static void
gdk_display_dispose (GObject *object)
{
GdkDisplay *display = GDK_DISPLAY_OBJECT (object);
+ GdkDeviceManager *device_manager;
+
+ device_manager = gdk_display_get_device_manager (GDK_DISPLAY_OBJECT (object));
g_list_foreach (display->queued_events, (GFunc)gdk_event_free, NULL);
g_list_free (display->queued_events);
_gdk_displays = g_slist_remove (_gdk_displays, object);
- if (gdk_display_get_default() == display)
- gdk_display_manager_set_default_display (gdk_display_manager_get(), NULL);
+ 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);
+ }
+
+ if (device_manager)
+ {
+ /* this is to make it drop devices which may require using the X
+ * display and therefore can't be cleaned up in finalize.
+ * It will also disconnect device_removed_cb
+ */
+ g_object_run_dispose (G_OBJECT (display->device_manager));
+ }
+
+ G_OBJECT_CLASS (gdk_display_parent_class)->dispose (object);
}
static void
gdk_display_finalize (GObject *object)
{
- parent_class->finalize (object);
+ GdkDisplay *display = GDK_DISPLAY_OBJECT (object);
+
+ g_hash_table_foreach_remove (display->device_grabs,
+ free_device_grabs_foreach,
+ NULL);
+ g_hash_table_destroy (display->device_grabs);
+
+ g_hash_table_destroy (display->pointers_info);
+ g_hash_table_destroy (display->multiple_click_info);
+
+ if (display->device_manager)
+ g_object_unref (display->device_manager);
+
+ G_OBJECT_CLASS (gdk_display_parent_class)->finalize (object);
}
/**
* gdk_display_close:
* @display: a #GdkDisplay
*
- * Closes the connection windowing system for the given display,
+ * 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)
}
}
+/**
+ * gdk_display_is_closed:
+ * @display: a #GdkDisplay
+ *
+ * Finds out if the display has been closed.
+ *
+ * Returns: %TRUE if the display is closed.
+ *
+ * Since: 2.22
+ */
+gboolean
+gdk_display_is_closed (GdkDisplay *display)
+{
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
+
+ return display->closed;
+}
+
/**
* gdk_display_get_event:
* @display: a #GdkDisplay
*
* 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)
* 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
+ * 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)
*
* 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,
- GdkEvent *event)
+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_display_pointer_ungrab:
+ * @display: a #GdkDisplay.
+ * @time_: a timestap (e.g. %GDK_CURRENT_TIME).
+ *
+ * Release any pointer grab.
+ *
+ * Since: 2.2
+ *
+ * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
+ * instead.
+ */
+void
+gdk_display_pointer_ungrab (GdkDisplay *display,
+ guint32 time_)
+{
+ GdkDeviceManager *device_manager;
+ GList *devices, *dev;
+ GdkDevice *device;
+
+ g_return_if_fail (GDK_IS_DISPLAY (display));
+
+ device_manager = gdk_display_get_device_manager (display);
+ devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
+
+ /* FIXME: Should this be generic to all backends? */
+ /* FIXME: What happens with extended devices? */
+ for (dev = devices; dev; dev = dev->next)
+ {
+ device = dev->data;
+
+ if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
+ continue;
+
+ gdk_device_ungrab (device, time_);
+ }
+
+ g_list_free (devices);
}
/**
* gdk_pointer_ungrab:
- * @time: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no timestamp is
- * available.
+ * @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.
*
- * Ungrabs the pointer, if it is grabbed by this application.
+ * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
+ * instead.
**/
void
gdk_pointer_ungrab (guint32 time)
/**
* gdk_pointer_is_grabbed:
*
- * Returns %TRUE if the pointer is currently grabbed by this application.
+ * 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.*
+ *
+ * Return value: %TRUE if the pointer is currently grabbed by this application.
+ *
+ * Deprecated: 3.0: Use gdk_display_device_is_grabbed() instead.
**/
gboolean
gdk_pointer_is_grabbed (void)
return gdk_display_pointer_is_grabbed (gdk_display_get_default ());
}
+/**
+ * gdk_display_keyboard_ungrab:
+ * @display: a #GdkDisplay.
+ * @time_: a timestap (e.g #GDK_CURRENT_TIME).
+ *
+ * Release any keyboard grab
+ *
+ * Since: 2.2
+ *
+ * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
+ * instead.
+ */
+void
+gdk_display_keyboard_ungrab (GdkDisplay *display,
+ guint32 time)
+{
+ GdkDeviceManager *device_manager;
+ GList *devices, *dev;
+ GdkDevice *device;
+
+ g_return_if_fail (GDK_IS_DISPLAY (display));
+
+ device_manager = gdk_display_get_device_manager (display);
+ devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
+
+ /* FIXME: Should this be generic to all backends? */
+ /* FIXME: What happens with extended devices? */
+ for (dev = devices; dev; dev = dev->next)
+ {
+ device = dev->data;
+
+ if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
+ continue;
+
+ gdk_device_ungrab (device, time);
+ }
+
+ g_list_free (devices);
+}
+
/**
* gdk_keyboard_ungrab:
- * @time: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no
+ * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no
* timestamp is available.
*
- * Ungrabs the keyboard, if it is grabbed by this application.
+ * Ungrabs the keyboard on the default display, if it is grabbed by this
+ * application.
+ *
+ * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
+ * instead.
**/
void
gdk_keyboard_ungrab (guint32 time)
/**
* gdk_beep:
*
- * Emits a short beep.
+ * Emits a short beep on the default display.
**/
void
gdk_beep (void)
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.
- **/
-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
{
return gdk_sm_client_id;
}
+
+void
+_gdk_display_enable_motion_hints (GdkDisplay *display,
+ GdkDevice *device)
+{
+ gulong *device_serial, serial;
+
+ device_serial = g_hash_table_lookup (display->motion_hint_info, device);
+
+ if (!device_serial)
+ {
+ device_serial = g_new0 (gulong, 1);
+ *device_serial = G_MAXULONG;
+ g_hash_table_insert (display->motion_hint_info, device, device_serial);
+ }
+
+ if (*device_serial != 0)
+ {
+ serial = _gdk_windowing_window_get_next_serial (display);
+ /* We might not actually generate the next request, so
+ make sure this triggers always, this may cause it to
+ trigger slightly too early, but this is just a hint
+ anyway. */
+ if (serial > 0)
+ serial--;
+ if (serial < *device_serial)
+ *device_serial = serial;
+ }
+}
+
+/**
+ * gdk_display_get_device_state:
+ * @display: a #GdkDisplay.
+ * @device: device to query status to.
+ * @screen: (out) (transfer none) (allow-none): location to store the #GdkScreen
+ * the @device is on, or %NULL.
+ * @x: (out) (allow-none): location to store root window X coordinate of @device, or %NULL.
+ * @y: (out) (allow-none): location to store root window Y coordinate of @device, or %NULL.
+ * @mask: (out) (allow-none): location to store current modifier mask for @device, or %NULL.
+ *
+ * Gets the current location and state of @device for a given display.
+ *
+ * Since: 3.0
+ **/
+void
+gdk_display_get_device_state (GdkDisplay *display,
+ GdkDevice *device,
+ 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));
+ g_return_if_fail (GDK_IS_DEVICE (device));
+
+ display->device_hooks->get_device_state (display, device, &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;
+}
+
+/**
+ * gdk_display_get_window_at_device_position:
+ * @display: a #GdkDisplay.
+ * @device: #GdkDevice to query info to.
+ * @win_x: (out) (allow-none): return location for the X coordinate of the device location,
+ * relative to the window origin, or %NULL.
+ * @win_y: (out) (allow-none): return location for the Y coordinate of the device location,
+ * relative to the window origin, or %NULL.
+ *
+ * Obtains the window underneath @device, returning the location of the device in @win_x and @win_y. Returns
+ * %NULL if the window tree under @device is not known to GDK (for example, belongs to another application).
+ *
+ * Returns: (transfer none): the #GdkWindow under the device position, or %NULL.
+ *
+ * Since: 3.0
+ **/
+GdkWindow *
+gdk_display_get_window_at_device_position (GdkDisplay *display,
+ GdkDevice *device,
+ gint *win_x,
+ gint *win_y)
+{
+ gint tmp_x, tmp_y;
+ GdkWindow *window;
+
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+ g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
+
+ window = display->device_hooks->window_at_device_position (display, device, &tmp_x, &tmp_y);
+
+ if (win_x)
+ *win_x = tmp_x;
+ if (win_y)
+ *win_y = tmp_y;
+
+ return window;
+}
+
+/**
+ * gdk_display_set_device_hooks:
+ * @display: a #GdkDisplay.
+ * @new_hooks: (allow-none): a table of pointers to functions for getting quantities related
+ * to all devices position, or %NULL to restore the default table.
+ *
+ * This function allows for hooking into the operation of getting the current location of any
+ * #GdkDevice on a particular #GdkDisplay. This is only useful for such low-level tools as
+ * an event recorder. Applications should never have any reason to use this facility.
+ *
+ * Returns: (transfer none): The previous device hook table.
+ *
+ * Since: 3.0
+ **/
+GdkDisplayDeviceHooks *
+gdk_display_set_device_hooks (GdkDisplay *display,
+ const GdkDisplayDeviceHooks *new_hooks)
+{
+ const GdkDisplayDeviceHooks *result;
+
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+ result = display->device_hooks;
+
+ if (new_hooks)
+ display->device_hooks = new_hooks;
+ else
+ display->device_hooks = &default_device_hooks;
+
+ return (GdkDisplayDeviceHooks *) result;
+}
+
+/**
+ * gdk_display_get_pointer:
+ * @display: a #GdkDisplay
+ * @screen: (allow-none): location to store the screen that the
+ * cursor is on, or %NULL.
+ * @x: (out) (allow-none): location to store root window X coordinate of pointer, or %NULL.
+ * @y: (out) (allow-none): location to store root window Y coordinate of pointer, or %NULL.
+ * @mask: (out) (allow-none): 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
+ *
+ * Deprecated: 3.0: Use gdk_display_get_device_state() instead.
+ **/
+void
+gdk_display_get_pointer (GdkDisplay *display,
+ GdkScreen **screen,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask)
+{
+ g_return_if_fail (GDK_IS_DISPLAY (display));
+
+ gdk_display_get_device_state (display, display->core_pointer, screen, x, y, mask);
+}
+
+static GdkWindow *
+gdk_display_real_get_window_at_device_position (GdkDisplay *display,
+ GdkDevice *device,
+ gint *win_x,
+ gint *win_y)
+{
+ GdkWindow *window;
+ gint x, y;
+
+ window = _gdk_windowing_window_at_device_position (display, device, &x, &y, NULL, FALSE);
+
+ /* 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_device_position (GdkDisplay *display,
+ GdkDevice *device,
+ GdkWindow *window,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask)
+{
+ gint tmpx, tmpy;
+ GdkModifierType tmp_mask;
+ gboolean normal_child;
+
+ normal_child = GDK_WINDOW_IMPL_GET_CLASS (window->impl)->get_device_state (window,
+ device,
+ &tmpx, &tmpy,
+ &tmp_mask);
+ /* We got the coords on the impl, convert to the window */
+ tmpx -= window->abs_x;
+ tmpy -= window->abs_y;
+
+ if (x)
+ *x = tmpx;
+ if (y)
+ *y = tmpy;
+ if (mask)
+ *mask = tmp_mask;
+
+ if (normal_child)
+ return _gdk_window_find_child_at (window, tmpx, tmpy);
+ return NULL;
+}
+
+/**
+ * gdk_display_get_window_at_pointer:
+ * @display: a #GdkDisplay
+ * @win_x: (out) (allow-none): return location for x coordinate of the pointer location relative
+ * to the window origin, or %NULL
+ * @win_y: (out) (allow-none): 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: (transfer none): the window under the mouse pointer, or %NULL
+ *
+ * Since: 2.2
+ *
+ * Deprecated: 3.0: Use gdk_display_get_window_at_device_position() instead.
+ **/
+GdkWindow *
+gdk_display_get_window_at_pointer (GdkDisplay *display,
+ gint *win_x,
+ gint *win_y)
+{
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
+ return gdk_display_get_window_at_device_position (display, display->core_pointer, win_x, win_y);
+}
+
+static void
+multihead_get_device_state (GdkDisplay *display,
+ GdkDevice *device,
+ GdkScreen **screen,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask)
+{
+ multihead_current_pointer_hooks->get_pointer (display, screen, x, y, mask);
+}
+
+static GdkWindow *
+multihead_window_get_device_position (GdkDisplay *display,
+ GdkDevice *device,
+ GdkWindow *window,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask)
+{
+ return multihead_current_pointer_hooks->window_get_pointer (display, window, x, y, mask);
+}
+
+static GdkWindow *
+multihead_window_at_device_position (GdkDisplay *display,
+ GdkDevice *device,
+ gint *win_x,
+ gint *win_y)
+{
+ return multihead_current_pointer_hooks->window_at_pointer (display, win_x, win_y);
+}
+
+static void
+multihead_default_get_pointer (GdkDisplay *display,
+ GdkScreen **screen,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask)
+{
+ return _gdk_windowing_get_device_state (display,
+ display->core_pointer,
+ screen, x, y, mask);
+}
+
+static GdkWindow *
+multihead_default_window_get_pointer (GdkDisplay *display,
+ GdkWindow *window,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask)
+{
+ return gdk_window_real_window_get_device_position (display,
+ display->core_pointer,
+ window, x, y, mask);
+}
+
+static GdkWindow *
+multihead_default_window_at_pointer (GdkDisplay *display,
+ gint *win_x,
+ gint *win_y)
+{
+ return gdk_display_real_get_window_at_device_position (display,
+ display->core_pointer,
+ win_x, win_y);
+}
+
+/**
+ * gdk_display_set_pointer_hooks:
+ * @display: a #GdkDisplay
+ * @new_hooks: (allow-none): 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: (transfer none): the previous pointer hook table
+ *
+ * Since: 2.2
+ *
+ * Deprecated: 3.0: Use gdk_display_set_device_hooks() instead.
+ **/
+GdkDisplayPointerHooks *
+gdk_display_set_pointer_hooks (GdkDisplay *display,
+ const GdkDisplayPointerHooks *new_hooks)
+{
+ const GdkDisplayPointerHooks *result = multihead_current_pointer_hooks;
+
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
+ if (new_hooks)
+ multihead_current_pointer_hooks = new_hooks;
+ else
+ multihead_current_pointer_hooks = &multihead_default_pointer_hooks;
+
+ gdk_display_set_device_hooks (display, &multihead_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)
+{
+ GdkDisplay *display;
+
+ display = gdk_window_get_display (window);
+
+ return gdk_window_real_window_get_device_position (display,
+ display->core_pointer,
+ window, x, y, mask);
+}
+
+static GdkWindow*
+singlehead_default_window_at_pointer (GdkScreen *screen,
+ gint *win_x,
+ gint *win_y)
+{
+ GdkDisplay *display;
+
+ display = gdk_screen_get_display (screen);
+
+ return gdk_display_real_get_window_at_device_position (display,
+ display->core_pointer,
+ win_x, win_y);
+}
+
+/**
+ * gdk_set_pointer_hooks:
+ * @new_hooks: (allow-none): 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
+ *
+ * Deprecated: 3.0: Use gdk_display_set_device_hooks() instead.
+ **/
+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,
+ GdkDevice *device,
+ gboolean implicit,
+ GdkWindow *grab_window)
+{
+ g_return_if_fail (window != NULL);
+
+ if (!GDK_WINDOW_DESTROYED (window))
+ {
+ GdkEvent *event;
+
+ event = gdk_event_new (GDK_GRAB_BROKEN);
+ event->grab_broken.window = g_object_ref (window);
+ event->grab_broken.send_event = FALSE;
+ event->grab_broken.implicit = implicit;
+ event->grab_broken.grab_window = grab_window;
+ gdk_event_set_device (event, device);
+ event->grab_broken.keyboard = (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) ? TRUE : FALSE;
+
+ gdk_event_put (event);
+ gdk_event_free (event);
+ }
+}
+
+GdkDeviceGrabInfo *
+_gdk_display_get_last_device_grab (GdkDisplay *display,
+ GdkDevice *device)
+{
+ GList *l;
+
+ l = g_hash_table_lookup (display->device_grabs, device);
+
+ if (l)
+ {
+ l = g_list_last (l);
+ return l->data;
+ }
+
+ return NULL;
+}
+
+GdkDeviceGrabInfo *
+_gdk_display_add_device_grab (GdkDisplay *display,
+ GdkDevice *device,
+ GdkWindow *window,
+ GdkWindow *native_window,
+ GdkGrabOwnership grab_ownership,
+ gboolean owner_events,
+ GdkEventMask event_mask,
+ unsigned long serial_start,
+ guint32 time,
+ gboolean implicit)
+{
+ GdkDeviceGrabInfo *info, *other_info;
+ GList *grabs, *l;
+
+ info = g_new0 (GdkDeviceGrabInfo, 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;
+ info->ownership = grab_ownership;
+
+ grabs = g_hash_table_lookup (display->device_grabs, device);
+
+ /* 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 = grabs; l != NULL; l = l->next)
+ {
+ other_info = l->data;
+
+ if (info->serial_start < other_info->serial_start)
+ break;
+ }
+
+ grabs = g_list_insert_before (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 (grabs, info);
+ l = l->prev;
+ if (l)
+ {
+ other_info = l->data;
+ other_info->serial_end = serial_start;
+ }
+
+ g_hash_table_insert (display->device_grabs, device, grabs);
+
+ return info;
+}
+
+/* _gdk_synthesize_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,
+ GdkDevice *device,
+ GdkDevice *source_device,
+ GdkWindow *src_window,
+ GdkWindow *dest_window,
+ GdkCrossingMode crossing_mode,
+ guint32 time,
+ gulong serial)
+{
+ GdkWindow *src_toplevel, *dest_toplevel;
+ GdkModifierType state;
+ int x, y;
+
+ /* We use the native crossing events if all native */
+ if (_gdk_native_windows)
+ return;
+
+ 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_window_get_pointer (dest_toplevel,
+ &x, &y, &state);
+ _gdk_synthesize_crossing_events (display,
+ src_window,
+ dest_window,
+ device, source_device,
+ crossing_mode,
+ x, y, state,
+ time,
+ NULL,
+ serial, FALSE);
+ }
+ else if (dest_toplevel == NULL)
+ {
+ gdk_window_get_pointer (src_toplevel,
+ &x, &y, &state);
+ _gdk_synthesize_crossing_events (display,
+ src_window,
+ NULL,
+ device, source_device,
+ crossing_mode,
+ x, y, state,
+ time,
+ NULL,
+ serial, FALSE);
+ }
+ else
+ {
+ /* Different toplevels */
+ gdk_window_get_pointer (src_toplevel,
+ &x, &y, &state);
+ _gdk_synthesize_crossing_events (display,
+ src_window,
+ NULL,
+ device, source_device,
+ crossing_mode,
+ x, y, state,
+ time,
+ NULL,
+ serial, FALSE);
+ gdk_window_get_pointer (dest_toplevel,
+ &x, &y, &state);
+ _gdk_synthesize_crossing_events (display,
+ NULL,
+ dest_window,
+ device, source_device,
+ crossing_mode,
+ x, y, state,
+ time,
+ NULL,
+ serial, FALSE);
+ }
+}
+
+static GdkWindow *
+get_current_toplevel (GdkDisplay *display,
+ GdkDevice *device,
+ int *x_out,
+ int *y_out,
+ GdkModifierType *state_out)
+{
+ GdkWindow *pointer_window;
+ int x, y;
+ GdkModifierType state;
+
+ pointer_window = _gdk_windowing_window_at_device_position (display, device, &x, &y, &state, TRUE);
+
+ 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;
+
+ *x_out = x;
+ *y_out = y;
+ *state_out = state;
+ return pointer_window;
+}
+
+static void
+switch_to_pointer_grab (GdkDisplay *display,
+ GdkDevice *device,
+ GdkDevice *source_device,
+ GdkDeviceGrabInfo *grab,
+ GdkDeviceGrabInfo *last_grab,
+ guint32 time,
+ gulong serial)
+{
+ GdkWindow *src_window, *pointer_window, *new_toplevel;
+ GdkPointerWindowInfo *info;
+ GList *old_grabs;
+ GdkModifierType state;
+ int x, y;
+
+ /* Temporarily unset pointer to make sure we send the crossing events below */
+ old_grabs = g_hash_table_lookup (display->device_grabs, device);
+ g_hash_table_steal (display->device_grabs, device);
+ info = _gdk_display_get_pointer_info (display, device);
+
+ 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 = info->window_under_pointer;
+
+ if (src_window != grab->window)
+ synthesize_crossing_events (display, device, source_device,
+ 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 && info->window_under_pointer != grab->window)
+ _gdk_display_set_window_under_pointer (display, device, NULL);
+ }
+
+ grab->activated = TRUE;
+ }
+
+ if (last_grab)
+ {
+ new_toplevel = NULL;
+
+ if (grab == NULL /* ungrab */ ||
+ (!last_grab->owner_events && grab->owner_events) /* switched to owner_events */ )
+ {
+ /* We force check what window we're in, and update the toplevel_under_pointer info,
+ * as that won't get told of this change with toplevel enter events.
+ */
+ if (info->toplevel_under_pointer)
+ g_object_unref (info->toplevel_under_pointer);
+ info->toplevel_under_pointer = NULL;
+
+ new_toplevel = get_current_toplevel (display, device, &x, &y, &state);
+ if (new_toplevel)
+ {
+ /* w is now toplevel and x,y in toplevel coords */
+ info->toplevel_under_pointer = g_object_ref (new_toplevel);
+ info->toplevel_x = x;
+ info->toplevel_y = y;
+ info->state = state;
+ }
+ }
+
+ if (grab == NULL) /* Ungrabbed, send events */
+ {
+ pointer_window = NULL;
+ if (new_toplevel)
+ {
+ /* Find (possibly virtual) child window */
+ pointer_window =
+ _gdk_window_find_descendant_at (new_toplevel,
+ x, y,
+ NULL, NULL);
+ }
+
+ if (pointer_window != last_grab->window)
+ synthesize_crossing_events (display, device, source_device,
+ 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, device, pointer_window);
+ }
+ }
+
+ g_hash_table_insert (display->device_grabs, device, old_grabs);
+}
+
+void
+_gdk_display_device_grab_update (GdkDisplay *display,
+ GdkDevice *device,
+ GdkDevice *source_device,
+ gulong current_serial)
+{
+ GdkDeviceGrabInfo *current_grab, *next_grab;
+ GList *grabs;
+ guint32 time;
+
+ time = display->last_event_time;
+ grabs = g_hash_table_lookup (display->device_grabs, device);
+
+ while (grabs != NULL)
+ {
+ current_grab = grabs->data;
+
+ if (current_grab->serial_start > current_serial)
+ return; /* Hasn't started yet */
+
+ if (current_grab->serial_end > current_serial)
+ {
+ /* This one hasn't ended yet.
+ its the currently active one or scheduled to be active */
+
+ if (!current_grab->activated)
+ {
+ if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
+ switch_to_pointer_grab (display, device, source_device, current_grab, NULL, time, current_serial);
+ }
+
+ break;
+ }
+
+ next_grab = NULL;
+ if (grabs->next)
+ {
+ /* This is the next active grab */
+ next_grab = grabs->next->data;
+
+ if (next_grab->serial_start > current_serial)
+ next_grab = NULL; /* Actually its not yet active */
+ }
+
+ if ((next_grab == NULL && current_grab->implicit_ungrab) ||
+ (next_grab != NULL && current_grab->window != next_grab->window))
+ generate_grab_broken_event (GDK_WINDOW (current_grab->window),
+ device,
+ current_grab->implicit,
+ next_grab? next_grab->window : NULL);
+
+ /* Remove old grab */
+ grabs = g_list_delete_link (grabs, grabs);
+ g_hash_table_insert (display->device_grabs, device, grabs);
+
+ if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
+ switch_to_pointer_grab (display, device, source_device,
+ next_grab, current_grab,
+ time, current_serial);
+
+ free_device_grab (current_grab);
+ }
+}
+
+static GList *
+grab_list_find (GList *grabs,
+ gulong serial)
+{
+ GdkDeviceGrabInfo *grab;
+
+ while (grabs)
+ {
+ grab = grabs->data;
+
+ if (serial >= grab->serial_start && serial < grab->serial_end)
+ return grabs;
+
+ grabs = grabs->next;
+ }
+
+ return NULL;
+}
+
+static GList *
+find_device_grab (GdkDisplay *display,
+ GdkDevice *device,
+ gulong serial)
+{
+ GList *l;
+
+ l = g_hash_table_lookup (display->device_grabs, device);
+ return grab_list_find (l, serial);
+}
+
+GdkDeviceGrabInfo *
+_gdk_display_has_device_grab (GdkDisplay *display,
+ GdkDevice *device,
+ gulong serial)
+{
+ GList *l;
+
+ l = find_device_grab (display, device, serial);
+ if (l)
+ return l->data;
+
+ return NULL;
+}
+
+/* Returns true if last grab was ended
+ * If if_child is non-NULL, end the grab only if the grabbed
+ * window is the same as if_child or a descendant of it */
+gboolean
+_gdk_display_end_device_grab (GdkDisplay *display,
+ GdkDevice *device,
+ gulong serial,
+ GdkWindow *if_child,
+ gboolean implicit)
+{
+ GdkDeviceGrabInfo *grab;
+ GList *l;
+
+ l = find_device_grab (display, device, serial);
+
+ if (l == NULL)
+ return FALSE;
+
+ grab = l->data;
+ if (grab &&
+ (if_child == NULL ||
+ _gdk_window_event_parent_of (if_child, grab->window)))
+ {
+ grab->serial_end = serial;
+ grab->implicit_ungrab = implicit;
+ return l->next == NULL;
+ }
+
+ return FALSE;
+}
+
+/* Returns TRUE if device events are not blocked by any grab */
+gboolean
+_gdk_display_check_grab_ownership (GdkDisplay *display,
+ GdkDevice *device,
+ gulong serial)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ GdkGrabOwnership higher_ownership, device_ownership;
+ gboolean device_is_keyboard;
+
+ g_hash_table_iter_init (&iter, display->device_grabs);
+ higher_ownership = device_ownership = GDK_OWNERSHIP_NONE;
+ device_is_keyboard = (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD);
+
+ while (g_hash_table_iter_next (&iter, &key, &value))
+ {
+ GdkDeviceGrabInfo *grab;
+ GdkDevice *dev;
+ GList *grabs;
+
+ dev = key;
+ grabs = value;
+ grabs = grab_list_find (grabs, serial);
+
+ if (!grabs)
+ continue;
+
+ /* Discard device if it's not of the same type */
+ if ((device_is_keyboard && gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD) ||
+ (!device_is_keyboard && gdk_device_get_source (dev) == GDK_SOURCE_KEYBOARD))
+ continue;
+
+ grab = grabs->data;
+
+ if (dev == device)
+ device_ownership = grab->ownership;
+ else
+ {
+ if (grab->ownership > higher_ownership)
+ higher_ownership = grab->ownership;
+ }
+ }
+
+ if (higher_ownership > device_ownership)
+ {
+ /* There's a higher priority ownership
+ * going on for other device(s)
+ */
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+GdkPointerWindowInfo *
+_gdk_display_get_pointer_info (GdkDisplay *display,
+ GdkDevice *device)
+{
+ GdkPointerWindowInfo *info;
+
+ if (G_UNLIKELY (!device))
+ return NULL;
+
+ info = g_hash_table_lookup (display->pointers_info, device);
+
+ if (G_UNLIKELY (!info))
+ {
+ info = g_slice_new0 (GdkPointerWindowInfo);
+ g_hash_table_insert (display->pointers_info, device, info);
+ }
+
+ return info;
+}
+
+void
+_gdk_display_pointer_info_foreach (GdkDisplay *display,
+ GdkDisplayPointerInfoForeach func,
+ gpointer user_data)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ g_hash_table_iter_init (&iter, display->pointers_info);
+
+ while (g_hash_table_iter_next (&iter, &key, &value))
+ {
+ GdkPointerWindowInfo *info = value;
+ GdkDevice *device = key;
+
+ (func) (display, device, info, user_data);
+ }
+}
+
+/**
+ * gdk_device_grab_info_libgtk_only:
+ * @display: the display for which to get the grab information
+ * @device: device to get the grab information from
+ * @grab_window: (out) (transfer none): location to store current grab window
+ * @owner_events: (out): location to store boolean indicating whether
+ * the @owner_events flag to gdk_keyboard_grab() or
+ * gdk_pointer_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_device_grab_info_libgtk_only (GdkDisplay *display,
+ GdkDevice *device,
+ GdkWindow **grab_window,
+ gboolean *owner_events)
+{
+ GdkDeviceGrabInfo *info;
+
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
+ g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
+
+ info = _gdk_display_get_last_device_grab (display, device);
+
+ 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
+ *
+ * Deprecated: 3.0: Use gdk_display_device_is_grabbed() instead.
+ */
+gboolean
+gdk_display_pointer_is_grabbed (GdkDisplay *display)
+{
+ GdkDeviceManager *device_manager;
+ GList *devices, *dev;
+ GdkDevice *device;
+
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), TRUE);
+
+ device_manager = gdk_display_get_device_manager (display);
+ devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
+
+ for (dev = devices; dev; dev = dev->next)
+ {
+ device = dev->data;
+
+ if (gdk_device_get_source (device) == GDK_SOURCE_MOUSE &&
+ gdk_display_device_is_grabbed (display, device))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/**
+ * gdk_display_device_is_grabbed:
+ * @display: a #GdkDisplay
+ * @device: a #GdkDevice
+ *
+ * Returns %TRUE if there is an ongoing grab on @device for @display.
+ *
+ * Returns: %TRUE if there is a grab in effect for @device.
+ **/
+gboolean
+gdk_display_device_is_grabbed (GdkDisplay *display,
+ GdkDevice *device)
+{
+ GdkDeviceGrabInfo *info;
+
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), TRUE);
+ g_return_val_if_fail (GDK_IS_DEVICE (device), TRUE);
+
+ /* What we're interested in is the steady state (ie last grab),
+ because we're interested e.g. if we grabbed so that we
+ can ungrab, even if our grab is not active just yet. */
+ info = _gdk_display_get_last_device_grab (display, device);
+
+ return (info && !info->implicit);
+}
+
+/**
+ * gdk_display_get_device_manager:
+ * @display: a #GdkDisplay.
+ *
+ * Returns the #GdkDeviceManager associated to @display.
+ *
+ * Returns: (transfer none): A #GdkDeviceManager, or %NULL. This memory is
+ * owned by GDK and must not be freed or unreferenced.
+ *
+ * Since: 3.0
+ **/
+GdkDeviceManager *
+gdk_display_get_device_manager (GdkDisplay *display)
+{
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
+ return display->device_manager;
+}
projects / ~andy / gtk / blobdiff