gdkdisplay.c 74.5 KB
Newer Older
Cody Russell's avatar
Cody Russell committed
1
/* GDK - The GIMP Drawing Kit
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * gdkdisplay.c
 * 
 * Copyright 2001 Sun Microsystems Inc. 
 *
 * Erwann Chenede <erwann.chenede@sun.com>
 *
 * 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
Javier Jardón's avatar
Javier Jardón committed
19
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
20 21
 */

22
#include "config.h"
23

24
#include "gdkdisplay.h"
25
#include "gdkdisplayprivate.h"
26

27 28
#include "gdk-private.h"

29
#include "gdkdeviceprivate.h"
30
#include "gdkdisplaymanagerprivate.h"
31
#include "gdkevents.h"
32
#include "gdkwindowimpl.h"
33
#include "gdkinternals.h"
34
#include "gdkmarshalers.h"
35
#include "gdkscreen.h"
36
#include "gdkmonitorprivate.h"
37

38
#include <math.h>
39
#include <glib.h>
40

41 42
/* for the use of round() */
#include "fallback-c89.c"
43 44 45

/**
 * SECTION:gdkdisplay
46
 * @Short_description: Controls a set of GdkScreens and their associated input devices
47 48 49
 * @Title: GdkDisplay
 *
 * #GdkDisplay objects purpose are two fold:
50 51 52 53
 *
 * - To manage and provide information about input devices (pointers and keyboards)
 *
 * - To manage and provide information about the available #GdkScreens
54
 *
55
 * GdkDisplay objects are the GDK representation of an X Display,
56
 * which can be described as a workstation consisting of
57
 * a keyboard, a pointing device (such as a mouse) and one or more
58
 * screens.
59 60 61 62 63 64 65 66
 * It is used to open and keep track of various GdkScreen objects
 * currently instantiated by the application. It is also used to
 * access the keyboard(s) and mouse pointer(s) of the display.
 *
 * Most of the input device handling has been factored out into
 * the separate #GdkDeviceManager object. Every display has a
 * device manager, which you can obtain using
 * gdk_display_get_device_manager().
67 68 69
 */


70
enum {
71
  OPENED,
72
  CLOSED,
73 74
  SEAT_ADDED,
  SEAT_REMOVED,
75 76
  MONITOR_ADDED,
  MONITOR_REMOVED,
77 78 79
  LAST_SIGNAL
};

80 81
static void gdk_display_dispose     (GObject         *object);
static void gdk_display_finalize    (GObject         *object);
Matthias Clasen's avatar
Matthias Clasen committed
82 83
static void gdk_display_put_event_nocopy (GdkDisplay *display,
                                          GdkEvent   *event);
84

85

86
static GdkAppLaunchContext *gdk_display_real_get_app_launch_context (GdkDisplay *display);
87

88 89
static guint signals[LAST_SIGNAL] = { 0 };

Matthias Clasen's avatar
Matthias Clasen committed
90
G_DEFINE_TYPE (GdkDisplay, gdk_display, G_TYPE_OBJECT)
91

92 93 94 95 96
static void
gdk_display_real_make_default (GdkDisplay *display)
{
}

97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
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_real_opened (GdkDisplay *display)
{
  GdkDeviceManager *device_manager;

114
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
115
  device_manager = gdk_display_get_device_manager (display);
116
  G_GNUC_END_IGNORE_DEPRECATIONS;
117 118 119

  g_signal_connect (device_manager, "device-removed",
                    G_CALLBACK (device_removed_cb), display);
120 121

  _gdk_display_manager_add_display (gdk_display_manager_get (), display);
122 123
}

124 125 126 127 128 129 130 131 132 133 134 135 136
static void
gdk_display_real_event_data_copy (GdkDisplay     *display,
                                  const GdkEvent *src,
                                  GdkEvent       *dst)
{
}

static void
gdk_display_real_event_data_free (GdkDisplay     *display,
                                  GdkEvent       *dst)
{
}

137 138 139 140 141 142 143 144 145
static GdkSeat *
gdk_display_real_get_default_seat (GdkDisplay *display)
{
  if (!display->seats)
    return NULL;

  return display->seats->data;
}

146 147 148 149
static void
gdk_display_class_init (GdkDisplayClass *class)
{
  GObjectClass *object_class = G_OBJECT_CLASS (class);
150

151
  object_class->finalize = gdk_display_finalize;
152
  object_class->dispose = gdk_display_dispose;
153

154
  class->get_app_launch_context = gdk_display_real_get_app_launch_context;
155
  class->window_type = GDK_TYPE_WINDOW;
156

157
  class->opened = gdk_display_real_opened;
158
  class->make_default = gdk_display_real_make_default;
159 160
  class->event_data_copy = gdk_display_real_event_data_copy;
  class->event_data_free = gdk_display_real_event_data_free;
161
  class->get_default_seat = gdk_display_real_get_default_seat;
162

163
  /**
Matthias Clasen's avatar
Matthias Clasen committed
164
   * GdkDisplay::opened:
165 166
   * @display: the object on which the signal is emitted
   *
Matthias Clasen's avatar
Matthias Clasen committed
167 168
   * The ::opened signal is emitted when the connection to the windowing
   * system for @display is opened.
169 170 171 172 173
   */
  signals[OPENED] =
    g_signal_new (g_intern_static_string ("opened"),
		  G_OBJECT_CLASS_TYPE (object_class),
                  G_SIGNAL_RUN_LAST,
174 175
		  G_STRUCT_OFFSET (GdkDisplayClass, opened),
                  NULL, NULL,
176 177 178
                  g_cclosure_marshal_VOID__VOID,
                  G_TYPE_NONE, 0);

179 180 181 182 183 184 185 186 187 188
  /**
   * 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
   */   
189
  signals[CLOSED] =
190
    g_signal_new (g_intern_static_string ("closed"),
191 192 193 194
		  G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  G_STRUCT_OFFSET (GdkDisplayClass, closed),
		  NULL, NULL,
Matthias Clasen's avatar
Matthias Clasen committed
195
		  _gdk_marshal_VOID__BOOLEAN,
196 197 198
		  G_TYPE_NONE,
		  1,
		  G_TYPE_BOOLEAN);
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220

  /**
   * GdkDisplay::seat-added:
   * @display: the object on which the signal is emitted
   * @seat: the seat that was just added
   *
   * The ::seat-added signal is emitted whenever a new seat is made
   * known to the windowing system.
   *
   * Since: 3.20
   */
  signals[SEAT_ADDED] =
    g_signal_new (g_intern_static_string ("seat-added"),
		  G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  0, NULL, NULL,
                  g_cclosure_marshal_VOID__OBJECT,
		  G_TYPE_NONE, 1, GDK_TYPE_SEAT);

  /**
   * GdkDisplay::seat-removed:
   * @display: the object on which the signal is emitted
Matthias Clasen's avatar
Matthias Clasen committed
221
   * @seat: the seat that was just removed
222 223 224 225 226 227 228 229 230 231 232 233 234
   *
   * The ::seat-removed signal is emitted whenever a seat is removed
   * by the windowing system.
   *
   * Since: 3.20
   */
  signals[SEAT_REMOVED] =
    g_signal_new (g_intern_static_string ("seat-removed"),
		  G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  0, NULL, NULL,
                  g_cclosure_marshal_VOID__OBJECT,
		  G_TYPE_NONE, 1, GDK_TYPE_SEAT);
235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270

  /**
   * GdkDisplay::monitor-added:
   * @display: the objedct on which the signal is emitted
   * @monitor: the monitor that was just added
   *
   * The ::monitor-added signal is emitted whenever a monitor is
   * added.
   *
   * Since: 3.22
   */
  signals[MONITOR_ADDED] =
    g_signal_new (g_intern_static_string ("monitor-added"),
		  G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  0, NULL, NULL,
                  g_cclosure_marshal_VOID__OBJECT,
		  G_TYPE_NONE, 1, GDK_TYPE_MONITOR);

  /**
   * GdkDisplay::monitor-removed:
   * @display: the object on which the signal is emitted
   * @monitor: the monitor that was just removed
   *
   * The ::monitor-removed signal is emitted whenever a monitor is
   * removed.
   *
   * Since: 3.22
   */
  signals[MONITOR_REMOVED] =
    g_signal_new (g_intern_static_string ("monitor-removed"),
		  G_OBJECT_CLASS_TYPE (object_class),
		  G_SIGNAL_RUN_LAST,
		  0, NULL, NULL,
                  g_cclosure_marshal_VOID__OBJECT,
		  G_TYPE_NONE, 1, GDK_TYPE_MONITOR);
271 272
}

273 274 275
static void
free_pointer_info (GdkPointerWindowInfo *info)
{
276 277
  if (info->toplevel_under_pointer)
    g_object_unref (info->toplevel_under_pointer);
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
  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;

296
  g_list_free_full (list, (GDestroyNotify) free_device_grab);
297 298 299 300

  return TRUE;
}

301 302 303 304
static void
gdk_display_init (GdkDisplay *display)
{
  display->double_click_time = 250;
305
  display->double_click_distance = 5;
306

307
  display->touch_implicit_grabs = g_array_new (FALSE, FALSE, sizeof (GdkTouchGrabInfo));
308 309 310 311 312 313 314 315 316
  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);
317 318

  display->rendering_mode = _gdk_rendering_mode;
319 320
}

321 322 323
static void
gdk_display_dispose (GObject *object)
{
324
  GdkDisplay *display = GDK_DISPLAY (object);
325 326
  GdkDeviceManager *device_manager;

327
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
328
  device_manager = gdk_display_get_device_manager (GDK_DISPLAY (object));
329
  G_GNUC_END_IGNORE_DEPRECATIONS;
330

331 332
  _gdk_display_manager_remove_display (gdk_display_manager_get (), display);

333
  g_list_free_full (display->queued_events, (GDestroyNotify) gdk_event_free);
334 335 336
  display->queued_events = NULL;
  display->queued_tail = NULL;

337 338
  g_list_foreach (display->input_devices, (GFunc) g_object_run_dispose, NULL);

339
  if (device_manager)
340 341 342 343 344 345 346
    {
      /* 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));
    }
347

Matthias Clasen's avatar
Matthias Clasen committed
348
  G_OBJECT_CLASS (gdk_display_parent_class)->dispose (object);
349 350
}

351 352 353
static void
gdk_display_finalize (GObject *object)
{
354
  GdkDisplay *display = GDK_DISPLAY (object);
355 356 357 358 359 360

  g_hash_table_foreach_remove (display->device_grabs,
                               free_device_grabs_foreach,
                               NULL);
  g_hash_table_destroy (display->device_grabs);

361 362
  g_array_free (display->touch_implicit_grabs, TRUE);

363
  g_hash_table_destroy (display->motion_hint_info);
364 365 366
  g_hash_table_destroy (display->pointers_info);
  g_hash_table_destroy (display->multiple_click_info);

367
  g_list_free_full (display->input_devices, g_object_unref);
368
  g_list_free_full (display->seats, g_object_unref);
369

370 371 372
  if (display->device_manager)
    g_object_unref (display->device_manager);

Matthias Clasen's avatar
Matthias Clasen committed
373
  G_OBJECT_CLASS (gdk_display_parent_class)->finalize (object);
374 375 376 377 378 379
}

/**
 * gdk_display_close:
 * @display: a #GdkDisplay
 *
380
 * Closes the connection to the windowing system for the given display,
381
 * and cleans up associated resources.
382 383
 *
 * Since: 2.2
384 385 386 387 388
 */
void
gdk_display_close (GdkDisplay *display)
{
  g_return_if_fail (GDK_IS_DISPLAY (display));
389 390 391 392

  if (!display->closed)
    {
      display->closed = TRUE;
393 394
      
      g_signal_emit (display, signals[CLOSED], 0, FALSE);
395 396
      g_object_run_dispose (G_OBJECT (display));
      
397
      g_object_unref (display);
398
    }
399 400
}

John Stowers's avatar
John Stowers committed
401 402 403 404
/**
 * gdk_display_is_closed:
 * @display: a #GdkDisplay
 *
405 406 407
 * Finds out if the display has been closed.
 *
 * Returns: %TRUE if the display is closed.
John Stowers's avatar
John Stowers committed
408 409 410 411 412 413 414 415 416 417 418
 *
 * Since: 2.22
 */
gboolean
gdk_display_is_closed  (GdkDisplay  *display)
{
  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);

  return display->closed;
}

419 420 421 422 423 424 425
/**
 * gdk_display_get_event:
 * @display: a #GdkDisplay
 * 
 * Gets the next #GdkEvent to be processed for @display, fetching events from the
 * windowing system if necessary.
 * 
426 427 428
 * Returns: (nullable): the next #GdkEvent to be processed, or %NULL
 * if no events are pending. The returned #GdkEvent should be freed
 * with gdk_event_free().
429 430
 *
 * Since: 2.2
431 432 433 434 435
 **/
GdkEvent*
gdk_display_get_event (GdkDisplay *display)
{
  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
436

437 438
  if (display->event_pause_count == 0)
    GDK_DISPLAY_GET_CLASS (display)->queue_events (display);
439 440

  return _gdk_event_unqueue (display);
441 442 443 444
}

/**
 * gdk_display_peek_event:
Alexander Larsson's avatar
Alexander Larsson committed
445
 * @display: a #GdkDisplay 
446
 * 
447
 * Gets a copy of the first #GdkEvent in the @display’s event queue, without
448 449 450 451
 * 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.)
 * 
452 453 454
 * Returns: (nullable): 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().
455 456
 *
 * Since: 2.2
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472
 **/
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;
}

Matthias Clasen's avatar
Matthias Clasen committed
473 474 475 476 477 478 479 480 481
static void
gdk_display_put_event_nocopy (GdkDisplay *display,
                              GdkEvent   *event)
{
  _gdk_event_queue_append (display, event);
  /* If the main loop is blocking in a different thread, wake it up */
  g_main_context_wakeup (NULL);
}

482 483 484 485 486 487 488
/**
 * 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.
489 490
 *
 * Since: 2.2
491 492
 **/
void
493 494
gdk_display_put_event (GdkDisplay     *display,
		       const GdkEvent *event)
495 496 497 498
{
  g_return_if_fail (GDK_IS_DISPLAY (display));
  g_return_if_fail (event != NULL);

Matthias Clasen's avatar
Matthias Clasen committed
499
  gdk_display_put_event_nocopy (display, gdk_event_copy (event));
500
}
501

502 503 504 505 506 507 508 509 510
/**
 * gdk_display_pointer_ungrab:
 * @display: a #GdkDisplay.
 * @time_: a timestap (e.g. %GDK_CURRENT_TIME).
 *
 * Release any pointer grab.
 *
 * Since: 2.2
 *
511
 * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
512 513 514 515 516 517
 *             instead.
 */
void
gdk_display_pointer_ungrab (GdkDisplay *display,
			    guint32     time_)
{
518
  GList *seats, *s;
519 520 521 522
  GdkDevice *device;

  g_return_if_fail (GDK_IS_DISPLAY (display));

523
  seats = gdk_display_list_seats (display);
524

525
  for (s = seats; s; s = s->next)
526
    {
527 528
      device = gdk_seat_get_pointer (s->data);
      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
529
      gdk_device_ungrab (device, time_);
530
      G_GNUC_END_IGNORE_DEPRECATIONS;
531 532
    }

533
  g_list_free (seats);
534 535 536 537 538 539 540 541 542 543 544
}

/**
 * gdk_display_keyboard_ungrab:
 * @display: a #GdkDisplay.
 * @time_: a timestap (e.g #GDK_CURRENT_TIME).
 *
 * Release any keyboard grab
 *
 * Since: 2.2
 *
545
 * Deprecated: 3.0: Use gdk_device_ungrab(), together with gdk_device_grab()
546 547 548 549 550 551
 *             instead.
 */
void
gdk_display_keyboard_ungrab (GdkDisplay *display,
			     guint32     time)
{
552
  GList *seats, *s;
553 554 555 556
  GdkDevice *device;

  g_return_if_fail (GDK_IS_DISPLAY (display));

557
  seats = gdk_display_list_seats (display);
558

559
  for (s = seats; s; s = s->next)
560
    {
561 562
      device = gdk_seat_get_keyboard (s->data);
      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
563
      gdk_device_ungrab (device, time);
564
      G_GNUC_END_IGNORE_DEPRECATIONS;
565 566
    }

567
  g_list_free (seats);
568 569
}

570 571 572
/**
 * gdk_beep:
 * 
573
 * Emits a short beep on the default display.
574 575 576 577
 **/
void
gdk_beep (void)
{
Owen Taylor's avatar
Owen Taylor committed
578
  gdk_display_beep (gdk_display_get_default ());
579 580
}

581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
/**
 * gdk_flush:
 *
 * Flushes the output buffers of all display connections and waits
 * until all requests have been processed.
 * This is rarely needed by applications.
 */
void
gdk_flush (void)
{
  GSList *list, *l;

  list = gdk_display_manager_list_displays (gdk_display_manager_get ());
  for (l = list; l; l = l->next)
    {
      GdkDisplay *display = l->data;

      GDK_DISPLAY_GET_CLASS (display)->sync (display);
    }

  g_slist_free (list);
}

604
void
605 606
_gdk_display_enable_motion_hints (GdkDisplay *display,
                                  GdkDevice  *device)
607
{
608 609 610 611 612 613 614 615 616 617 618 619
  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)
620
    {
621
      serial = _gdk_display_get_next_serial (display);
622 623
      /* We might not actually generate the next request, so
	 make sure this triggers always, this may cause it to
624
	 trigger slightly too early, but this is just a hint
625 626 627
	 anyway. */
      if (serial > 0)
	serial--;
628 629
      if (serial < *device_serial)
	*device_serial = serial;
630 631 632
    }
}

633 634 635
/**
 * gdk_display_get_pointer:
 * @display: a #GdkDisplay
636
 * @screen: (out) (allow-none) (transfer none): location to store the screen that the
637
 *          cursor is on, or %NULL.
638 639 640
 * @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
641
 *
642 643
 * Gets the current location of the pointer and the current modifier
 * mask for a given display.
644 645
 *
 * Since: 2.2
646
 *
647
 * Deprecated: 3.0: Use gdk_device_get_position() instead.
648 649 650 651 652 653 654 655
 **/
void
gdk_display_get_pointer (GdkDisplay      *display,
			 GdkScreen      **screen,
			 gint            *x,
			 gint            *y,
			 GdkModifierType *mask)
{
656
  GdkScreen *default_screen;
657
  GdkSeat *default_seat;
658
  GdkWindow *root;
659
  gdouble tmp_x, tmp_y;
660 661
  GdkModifierType tmp_mask;

662 663
  g_return_if_fail (GDK_IS_DISPLAY (display));

664 665 666 667
  if (gdk_display_is_closed (display))
    return;

  default_screen = gdk_display_get_default_screen (display);
668
  default_seat = gdk_display_get_default_seat (display);
669 670 671 672

  /* We call _gdk_device_query_state() here manually instead of
   * gdk_device_get_position() because we care about the modifier mask */

673
  _gdk_device_query_state (gdk_seat_get_pointer (default_seat),
674 675 676 677 678
                           gdk_screen_get_root_window (default_screen),
                           &root, NULL,
                           &tmp_x, &tmp_y,
                           NULL, NULL,
                           &tmp_mask);
679 680

  if (screen)
681
    *screen = gdk_window_get_screen (root);
682
  if (x)
683
    *x = round (tmp_x);
684
  if (y)
685
    *y = round (tmp_y);
686 687
  if (mask)
    *mask = tmp_mask;
688 689 690 691 692
}

/**
 * gdk_display_get_window_at_pointer:
 * @display: a #GdkDisplay
693
 * @win_x: (out) (allow-none): return location for x coordinate of the pointer location relative
694
 *    to the window origin, or %NULL
695
 * @win_y: (out) (allow-none): return location for y coordinate of the pointer location relative
696
 &    to the window origin, or %NULL
697
 *
698
 * Obtains the window underneath the mouse pointer, returning the location
699
 * of the pointer in that window in @win_x, @win_y for @screen. Returns %NULL
700 701
 * if the window under the mouse pointer is not known to GDK (for example, 
 * belongs to another application).
702
 *
703 704
 * Returns: (nullable) (transfer none): the window under the mouse
 *   pointer, or %NULL
705 706
 *
 * Since: 2.2
707
 *
708
 * Deprecated: 3.0: Use gdk_device_get_window_at_position() instead.
709 710 711 712 713 714
 **/
GdkWindow *
gdk_display_get_window_at_pointer (GdkDisplay *display,
				   gint       *win_x,
				   gint       *win_y)
{
715 716
  GdkDevice *pointer;

717
  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
Kristian Rietveld's avatar
Kristian Rietveld committed
718

719 720 721
  pointer = gdk_seat_get_pointer (gdk_display_get_default_seat (display));

  return gdk_device_get_window_at_position (pointer, win_x, win_y);
722
}
723

724
static void
Matthias Clasen's avatar
Matthias Clasen committed
725 726 727 728 729
generate_grab_broken_event (GdkDisplay *display,
                            GdkWindow  *window,
                            GdkDevice  *device,
			    gboolean    implicit,
			    GdkWindow  *grab_window)
730 731 732 733 734
{
  g_return_if_fail (window != NULL);

  if (!GDK_WINDOW_DESTROYED (window))
    {
735 736 737 738 739 740 741 742
      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);
743
      event->grab_broken.keyboard = (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) ? TRUE : FALSE;
744

Matthias Clasen's avatar
Matthias Clasen committed
745
      gdk_display_put_event_nocopy (display, event);
746 747 748
    }
}

749 750 751
GdkDeviceGrabInfo *
_gdk_display_get_last_device_grab (GdkDisplay *display,
                                   GdkDevice  *device)
752 753 754
{
  GList *l;

755
  l = g_hash_table_lookup (display->device_grabs, device);
756

757 758 759 760 761
  if (l)
    {
      l = g_list_last (l);
      return l->data;
    }
762

763 764
  return NULL;
}
765

766 767 768 769 770 771 772 773 774 775 776
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)
777
{
778 779
  GdkDeviceGrabInfo *info, *other_info;
  GList *grabs, *l;
780

781
  info = g_new0 (GdkDeviceGrabInfo, 1);
782 783 784 785 786 787 788 789 790

  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;
791 792 793
  info->ownership = grab_ownership;

  grabs = g_hash_table_lookup (display->device_grabs, device);
794 795 796 797

  /* 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 */
798
  for (l = grabs; l != NULL; l = l->next)
799
    {
800
      other_info = l->data;
801

802 803 804
      if (info->serial_start < other_info->serial_start)
	break;
    }
805 806

  grabs = g_list_insert_before (grabs, l, info);
807 808 809 810 811 812

  /* Make sure the new grab end before next grab */
  if (l)
    {
      other_info = l->data;
      info->serial_end = other_info->serial_start;
813
    }
814

815
  /* Find any previous grab and update its end time */
816
  l = g_list_find (grabs, info);
817 818
  l = l->prev;
  if (l)
819
    {
820 821 822 823
      other_info = l->data;
      other_info->serial_end = serial_start;
    }

824
  g_hash_table_insert (display->device_grabs, device, grabs);
825

826
  return info;
827 828
}

829 830 831 832 833
static void
_gdk_display_break_touch_grabs (GdkDisplay *display,
                                GdkDevice  *device,
                                GdkWindow  *new_grab_window)
{
834
  guint i;
835

836
  for (i = 0; i < display->touch_implicit_grabs->len; i++)
837 838 839 840 841 842
    {
      GdkTouchGrabInfo *info;

      info = &g_array_index (display->touch_implicit_grabs,
                             GdkTouchGrabInfo, i);

843
      if (info->device == device && info->window != new_grab_window)
Matthias Clasen's avatar
Matthias Clasen committed
844
        generate_grab_broken_event (display, GDK_WINDOW (info->window),
845
                                    device, TRUE, new_grab_window);
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895
    }
}

void
_gdk_display_add_touch_grab (GdkDisplay       *display,
                             GdkDevice        *device,
                             GdkEventSequence *sequence,
                             GdkWindow        *window,
                             GdkWindow        *native_window,
                             GdkEventMask      event_mask,
                             unsigned long     serial,
                             guint32           time)
{
  GdkTouchGrabInfo info;

  info.device = device;
  info.sequence = sequence;
  info.window = g_object_ref (window);
  info.native_window = g_object_ref (native_window);
  info.serial = serial;
  info.event_mask = event_mask;
  info.time = time;

  g_array_append_val (display->touch_implicit_grabs, info);
}

gboolean
_gdk_display_end_touch_grab (GdkDisplay       *display,
                             GdkDevice        *device,
                             GdkEventSequence *sequence)
{
  guint i;

  for (i = 0; i < display->touch_implicit_grabs->len; i++)
    {
      GdkTouchGrabInfo *info;

      info = &g_array_index (display->touch_implicit_grabs,
                             GdkTouchGrabInfo, i);

      if (info->device == device && info->sequence == sequence)
        {
          g_array_remove_index_fast (display->touch_implicit_grabs, i);
          return TRUE;
        }
    }

  return FALSE;
}

896
/* _gdk_synthesize_crossing_events only works inside one toplevel.
897 898 899
   This function splits things into two calls if needed, converting the
   coordinates to the right toplevel */
static void
900 901
synthesize_crossing_events (GdkDisplay      *display,
                            GdkDevice       *device,
902
                            GdkDevice       *source_device,
903 904 905 906 907
			    GdkWindow       *src_window,
			    GdkWindow       *dest_window,
			    GdkCrossingMode  crossing_mode,
			    guint32          time,
			    gulong           serial)
908 909 910
{
  GdkWindow *src_toplevel, *dest_toplevel;
  GdkModifierType state;
911
  double x, y;
912

913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
  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 */
929 930 931
      gdk_window_get_device_position_double (dest_toplevel,
                                             device,
                                             &x, &y, &state);
932
      _gdk_synthesize_crossing_events (display,
933 934
				       src_window,
				       dest_window,
935
                                       device, source_device,
936 937 938 939 940
				       crossing_mode,
				       x, y, state,
				       time,
				       NULL,
				       serial, FALSE);
941 942 943
    }
  else if (dest_toplevel == NULL)
    {
944 945 946
      gdk_window_get_device_position_double (src_toplevel,
                                             device,
                                             &x, &y, &state);
947
      _gdk_synthesize_crossing_events (display,
948 949
                                       src_window,
                                       NULL,
950
                                       device, source_device,
951 952 953 954 955
                                       crossing_mode,
                                       x, y, state,
                                       time,
                                       NULL,
                                       serial, FALSE);
956 957 958 959
    }
  else
    {
      /* Different toplevels */
960 961 962
      gdk_window_get_device_position_double (src_toplevel,
                                             device,
                                             &x, &y, &state);
963
      _gdk_synthesize_crossing_events (display,
964 965
				       src_window,
				       NULL,
966
                                       device, source_device,
967 968 969 970 971
				       crossing_mode,
				       x, y, state,
				       time,
				       NULL,
				       serial, FALSE);
972 973 974
      gdk_window_get_device_position_double (dest_toplevel,
                                             device,
                                             &x, &y, &state);
975
      _gdk_synthesize_crossing_events (display,
976 977
				       NULL,
				       dest_window,
978
                                       device, source_device,
979 980 981 982 983
				       crossing_mode,
				       x, y, state,
				       time,
				       NULL,
				       serial, FALSE);
984 985
    }
}
986

987
static GdkWindow *
988 989 990 991
get_current_toplevel (GdkDisplay      *display,
                      GdkDevice       *device,
                      int             *x_out,
                      int             *y_out,
992 993 994
		      GdkModifierType *state_out)
{
  GdkWindow *pointer_window;
995
  gdouble x, y;
996 997
  GdkModifierType state;

998
  pointer_window = _gdk_device_window_at_position (device, &x, &y, &state, TRUE);
999

1000 1001 1002 1003 1004 1005
  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;

1006 1007
  *x_out = round (x);
  *y_out = round (y);
1008
  *state_out = state;
1009

1010
  return pointer_window;
1011 1012
}

1013
static void
1014 1015
switch_to_pointer_grab (GdkDisplay        *display,
                        GdkDevice         *device,
1016
                        GdkDevice         *source_device,
1017 1018 1019 1020
			GdkDeviceGrabInfo *grab,
			GdkDeviceGrabInfo *last_grab,
			guint32            time,
			gulong             serial)
1021
{
1022
  GdkWindow *src_window, *pointer_window, *new_toplevel;
1023
  GdkPointerWindowInfo *info;
1024 1025
  GList *old_grabs;
  GdkModifierType state;
1026
  int x = 0, y = 0;
1027 1028

  /* Temporarily unset pointer to make sure we send the crossing events below */
1029 1030 1031 1032
  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);

1033 1034 1035
  if (grab)
    {
      /* New grab is in effect */
1036

1037 1038 1039
      /* 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
1040
       *           doesn't have button mask so a parent gets the event...
1041 1042
       */
      if (!grab->implicit)
1043
	{
1044 1045 1046 1047
	  /* 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;
1048
	  else
1049 1050
	    src_window = info->window_under_pointer;

1051
	  if (src_window != grab->window)
1052
            synthesize_crossing_events (display, device, source_device,
1053 1054
                                        src_window, grab->window,
                                        GDK_CROSSING_GRAB, time, serial);
1055

1056 1057
	  /* !owner_event Grabbing a window that we're not inside, current status is
	     now NULL (i.e. outside grabbed window) */
1058 1059
	  if (!grab->owner_events && info->window_under_pointer != grab->window)
	    _gdk_display_set_window_under_pointer (display, device, NULL);
1060
	}
1061

1062 1063
      grab->activated = TRUE;
    }
1064 1065

  if (last_grab)
1066
    {
1067 1068 1069 1070 1071 1072 1073 1074
      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.
	   */
1075 1076 1077
	  if (info->toplevel_under_pointer)
	    g_object_unref (info->toplevel_under_pointer);
	  info->toplevel_under_pointer = NULL;
1078

1079 1080 1081 1082 1083 1084 1085 1086
          /* Ungrabbed slave devices don't have a position by
           * itself, rather depend on its master pointer, so
           * it doesn't make sense to track any position for
           * these after the grab
           */
          if (grab || gdk_device_get_device_type (device) != GDK_DEVICE_TYPE_SLAVE)
            new_toplevel = get_current_toplevel (display, device, &x, &y, &state);

1087 1088 1089
	  if (new_toplevel)
	    {
	      /* w is now toplevel and x,y in toplevel coords */
1090 1091 1092 1093
	      info->toplevel_under_pointer = g_object_ref (new_toplevel);
	      info->toplevel_x = x;
	      info->toplevel_y = y;
	      info->state = state;
1094 1095 1096 1097
	    }
	}

      if (grab == NULL) /* Ungrabbed, send events */
1098
	{
1099 1100 1101 1102 1103
          /* If the source device is a touch device, do not
           * propagate any enter event yet, until one is
           * synthesized when needed.
           */
          if (source_device &&
1104
              (gdk_device_get_source (source_device) == GDK_SOURCE_TOUCHSCREEN))
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
            info->need_touch_press_enter = TRUE;

          pointer_window = NULL;

          if (new_toplevel &&
              !info->need_touch_press_enter)
            {
              /* Find (possibly virtual) child window */
              pointer_window =
                _gdk_window_find_descendant_at (new_toplevel,
                                                x, y,
                                                NULL, NULL);
            }
1118

1119 1120
	  if (!info->need_touch_press_enter &&
	      pointer_window != last_grab->window)
1121
            synthesize_crossing_events (display, device, source_device,
1122 1123 1124
                                        last_grab->window, pointer_window,
                                        GDK_CROSSING_UNGRAB, time, serial);

1125
	  /* We're now ungrabbed, update the window_under_pointer */
1126
	  _gdk_display_set_window_under_pointer (display, device, pointer_window);
1127
	}
1128 1129
    }

1130
  g_hash_table_insert (display->device_grabs, device, old_grabs);
1131 1132
}

1133 1134 1135 1136 1137 1138 1139 1140
void
_gdk_display_update_last_event (GdkDisplay     *display,
                                const GdkEvent *event)
{
  if (gdk_event_get_time (event) != GDK_CURRENT_TIME)
    display->last_event_time = gdk_event_get_time (event);
}

1141
void
1142 1143
_gdk_display_device_grab_update (GdkDisplay *display,
                                 GdkDevice  *device,
1144
                                 GdkDevice  *source_device,
1145
                                 gulong      current_serial)
1146
{
1147 1148
  GdkDeviceGrabInfo *current_grab, *next_grab;
  GList *grabs;
1149
  guint32 time;
1150

1151
  time = display->last_event_time;
1152
  grabs = g_hash_table_lookup (display->device_grabs, device);
1153

1154
  while (grabs != NULL)
1155
    {
1156
      current_grab = grabs->data;
1157

1158 1159
      if (current_grab->serial_start > current_serial)
	return; /* Hasn't started yet */
1160

1161
      if (current_grab->serial_end > current_serial)
1162 1163 1164
	{
	  /* This one hasn't ended yet.
	     its the currently active one or scheduled to be active */
1165

1166
	  if (!current_grab->activated)
1167
            {
1168
              if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
1169
                switch_to_pointer_grab (display, device, source_device, current_grab, NULL, time, current_serial);
1170 1171
            }

1172 1173 1174 1175
	  break;
	}

      next_grab = NULL;
1176
      if (grabs->next)
1177
	{
1178
	  /* This is the next active grab */
1179 1180
	  next_grab = grabs->next->data;

1181 1182
	  if (next_grab->serial_start > current_serial)
	    next_grab = NULL; /* Actually its not yet active */
1183 1184
	}

1185 1186 1187
      if (next_grab)
        _gdk_display_break_touch_grabs (display, device, next_grab->window);

1188
      if ((next_grab == NULL && current_grab->implicit_ungrab) ||
1189
          (next_grab != NULL && current_grab->window != next_grab->window))
Matthias Clasen's avatar
Matthias Clasen committed
1190
        generate_grab_broken_event (display, GDK_WINDOW (current_grab->window),
1191
                                    device,
1192 1193
                                    current_grab->implicit,
                                    next_grab? next_grab->window : NULL);
1194

1195
      /* Remove old grab */
1196 1197 1198
      grabs = g_list_delete_link (grabs, grabs);
      g_hash_table_insert (display->device_grabs, device, grabs);

1199
      if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
1200
        switch_to_pointer_grab (display, device, source_device,
1201 1202 1203 1204
                                next_grab, current_grab,
                                time, current_serial);

      free_device_grab (current_grab);
1205
    }
1206 1207 1208
}

static GList *
1209 1210
grab_list_find (GList  *grabs,
                gulong  serial)
1211
{
1212
  GdkDeviceGrabInfo *grab;
1213

1214
  while (grabs)
1215
    {
1216
      grab = grabs->data;
1217

1218
      if (serial >= grab->serial_start && serial < grab->serial_end)
1219 1220 1221
	return grabs;

      grabs = grabs->next;
1222
    }
1223

1224 1225 1226
  return NULL;
}

1227 1228 1229 1230 1231 1232
static GList *
find_device_grab (GdkDisplay *display,
                   GdkDevice  *device,
                   gulong      serial)
{
  GList *l;
1233

1234 1235 1236
  l = g_hash_table_lookup (display->device_grabs, device);
  return grab_list_find (l, serial);
}
1237

1238 1239 1240 1241
GdkDeviceGrabInfo *
_gdk_display_has_device_grab (GdkDisplay *display,
                              GdkDevice  *device,
                              gulong      serial)
1242 1243 1244
{
  GList *l;

1245
  l = find_device_grab (display, device, serial);
1246 1247
  if (l)
    return l->data;
1248

1249 1250 1251
  return NULL;
}

1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278
GdkTouchGrabInfo *
_gdk_display_has_touch_grab (GdkDisplay       *display,
                             GdkDevice        *device,
                             GdkEventSequence *sequence,
                             gulong            serial)
{
  guint i;

  for (i = 0; i < display->touch_implicit_grabs->len; i++)
    {
      GdkTouchGrabInfo *info;

      info = &g_array_index (display->touch_implicit_grabs,
                             GdkTouchGrabInfo, i);

      if (info->device == device && info->sequence == sequence)
        {
          if (serial >= info->serial)
            return info;
          else
            return NULL;
        }
    }

  return NULL;
}

1279 1280 1281
/* 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 */
1282
gboolean
1283 1284 1285 1286 1287
_gdk_display_end_device_grab (GdkDisplay *display,
                              GdkDevice  *device,
                              gulong      serial,
                              GdkWindow  *if_child,
                              gboolean    implicit)
1288
{
1289
  GdkDeviceGrabInfo *grab;
1290 1291
  GList *l;

1292 1293
  l = find_device_grab (display, device, serial);

1294 1295 1296 1297 1298 1299
  if (l == NULL)
    return FALSE;

  grab = l->data;
  if (grab &&
      (if_child == NULL ||
1300
       _gdk_window_event_parent_of (if_child, grab->window)))
1301 1302 1303 1304 1305 1306 1307
    {
      grab->serial_end = serial;
      grab->implicit_ungrab = implicit;
      return l->next == NULL;
    }
  
  return FALSE;
1308 1309
}

1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
/* 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;
1323
  device_is_keyboard = (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD);
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338

  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 */
1339 1340
      if ((device_is_keyboard && gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD) ||
          (!device_is_keyboard && gdk_device_get_source (dev) == GDK_SOURCE_KEYBOARD))
1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362
        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;
1363 1364
}

1365 1366 1367
GdkPointerWindowInfo *
_gdk_display_get_pointer_info (GdkDisplay *display,
                               GdkDevice  *device)
1368
{
1369 1370
  GdkPointerWindowInfo *info;

1371 1372 1373
  if (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
    device = gdk_device_get_associated_device (device);

1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
  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;
1386 1387
}

1388 1389 1390 1391
void
_gdk_display_pointer_info_foreach (GdkDisplay                   *display,
                                   GdkDisplayPointerInfoForeach  func,
                                   gpointer                      user_data)
1392
{
1393 1394
  GHashTableIter iter;
  gpointer key, value;
1395

1396 1397 1398
  g_hash_table_iter_init (&iter, display->pointers_info);

  while (g_hash_table_iter_next (&iter, &key, &value))
1399
    {
1400 1401
      GdkPointerWindowInfo *info = value;
      GdkDevice *device = key;
1402

1403
      (func) (display, device, info, user_data);
1404 1405
    }
}
1406

1407 1408
/*< private >
 * gdk_device_grab_info:
1409 1410
 * @display: the display for which to get the grab information
 * @device: device to get the grab information from
1411 1412
 * @grab_window: (out) (transfer none): location to store current grab window
 * @owner_events: (out): location to store boolean indicating whether
1413 1414 1415 1416
 *   the @owner_events flag to gdk_keyboard_grab() or
 *   gdk_pointer_grab() was %TRUE.
 *
 * Determines information about the current keyboard grab.
1417
 * This is not public API and must not be used by applications.
1418
 *
1419
 * Returns: %TRUE if this application currently has the
1420
 *  keyboard grabbed.
1421
 */
1422
gboolean
1423 1424 1425 1426
gdk_device_grab_info (GdkDisplay  *display,
                      GdkDevice   *device,
                      GdkWindow  **grab_window,
                      gboolean    *owner_events)
1427
{
1428 1429
  GdkDeviceGrabInfo *info;

1430
  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
1431 1432 1433
  g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);

  info = _gdk_display_get_last_device_grab (display, device);
1434