Pileus Git - ~andy/gtk/blob - gdk/gdkevents.c

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "config.h"
  28
  29 #include "gdkinternals.h"
  30
  31 #include <string.h>
  32 #include <math.h>
  33
  34 typedef struct _GdkIOClosure GdkIOClosure;
  35
  36 struct _GdkIOClosure
  37 {
  38   GDestroyNotify notify;
  39   gpointer data;
  40 };
  41
  42 /* Private variable declarations
  43  */
  44
  45 GdkEventFunc   _gdk_event_func = NULL;    /* Callback for events */
  46 gpointer       _gdk_event_data = NULL;
  47 GDestroyNotify _gdk_event_notify = NULL;
  48
  49 /*********************************************
  50  * Functions for maintaining the event queue *
  51  *********************************************/
  52
  53 /**
  54  * _gdk_event_queue_find_first:
  55  * @display: a #GdkDisplay
  56  *
  57  * Find the first event on the queue that is not still
  58  * being filled in.
  59  *
  60  * Return value: Pointer to the list node for that event, or NULL.
  61  **/
  62 GList*
  63 _gdk_event_queue_find_first (GdkDisplay *display)
  64 {
  65   GList *tmp_list = display->queued_events;
  66
  67   while (tmp_list)
  68     {
  69       GdkEventPrivate *event = tmp_list->data;
  70       if (!(event->flags & GDK_EVENT_PENDING))
  71         return tmp_list;
  72
  73       tmp_list = g_list_next (tmp_list);
  74     }
  75
  76   return NULL;
  77 }
  78
  79 /**
  80  * _gdk_event_queue_prepend:
  81  * @display: a #GdkDisplay
  82  * @event: Event to prepend.
  83  *
  84  * Prepends an event before the head of the event queue.
  85  *
  86  * Returns: the newly prepended list node.
  87  **/
  88 GList*
  89 _gdk_event_queue_prepend (GdkDisplay *display,
  90                           GdkEvent   *event)
  91 {
  92   display->queued_events = g_list_prepend (display->queued_events, event);
  93   if (!display->queued_tail)
  94     display->queued_tail = display->queued_events;
  95   return display->queued_events;
  96 }
  97
  98 /**
  99  * _gdk_event_queue_append:
 100  * @display: a #GdkDisplay
 101  * @event: Event to append.
 102  *
 103  * Appends an event onto the tail of the event queue.
 104  *
 105  * Returns: the newly appended list node.
 106  **/
 107 GList *
 108 _gdk_event_queue_append (GdkDisplay *display,
 109                          GdkEvent   *event)
 110 {
 111   display->queued_tail = g_list_append (display->queued_tail, event);
 112
 113   if (!display->queued_events)
 114     display->queued_events = display->queued_tail;
 115   else
 116     display->queued_tail = display->queued_tail->next;
 117
 118   return display->queued_tail;
 119 }
 120
 121 /**
 122  * _gdk_event_queue_insert_after:
 123  * @display: a #GdkDisplay
 124  * @sibling: Append after this event.
 125  * @event: Event to append.
 126  *
 127  * Appends an event after the specified event, or if it isn't in
 128  * the queue, onto the tail of the event queue.
 129  *
 130  * Returns: the newly appended list node.
 131  *
 132  * Since: 2.16
 133  */
 134 GList*
 135 _gdk_event_queue_insert_after (GdkDisplay *display,
 136                                GdkEvent   *sibling,
 137                                GdkEvent   *event)
 138 {
 139   GList *prev = g_list_find (display->queued_events, sibling);
 140   if (prev && prev->next)
 141     {
 142       display->queued_events = g_list_insert_before (display->queued_events, prev->next, event);
 143       return prev->next;
 144     }
 145   else
 146     return _gdk_event_queue_append (display, event);
 147 }
 148
 149 /**
 150  * _gdk_event_queue_insert_after:
 151  * @display: a #GdkDisplay
 152  * @sibling: Append after this event.
 153  * @event: Event to append.
 154  *
 155  * Appends an event before the specified event, or if it isn't in
 156  * the queue, onto the tail of the event queue.
 157  *
 158  * Returns: the newly appended list node.
 159  *
 160  * Since: 2.16
 161  */
 162 GList*
 163 _gdk_event_queue_insert_before (GdkDisplay *display,
 164                                 GdkEvent   *sibling,
 165                                 GdkEvent   *event)
 166 {
 167   GList *next = g_list_find (display->queued_events, sibling);
 168   if (next)
 169     {
 170       display->queued_events = g_list_insert_before (display->queued_events, next, event);
 171       return next->prev;
 172     }
 173   else
 174     return _gdk_event_queue_append (display, event);
 175 }
 176
 177
 178 /**
 179  * _gdk_event_queue_remove_link:
 180  * @display: a #GdkDisplay
 181  * @node: node to remove
 182  *
 183  * Removes a specified list node from the event queue.
 184  **/
 185 void
 186 _gdk_event_queue_remove_link (GdkDisplay *display,
 187                               GList      *node)
 188 {
 189   if (node->prev)
 190     node->prev->next = node->next;
 191   else
 192     display->queued_events = node->next;
 193
 194   if (node->next)
 195     node->next->prev = node->prev;
 196   else
 197     display->queued_tail = node->prev;
 198 }
 199
 200 /**
 201  * _gdk_event_unqueue:
 202  * @display: a #GdkDisplay
 203  *
 204  * Removes and returns the first event from the event
 205  * queue that is not still being filled in.
 206  *
 207  * Return value: the event, or %NULL. Ownership is transferred
 208  * to the caller.
 209  **/
 210 GdkEvent*
 211 _gdk_event_unqueue (GdkDisplay *display)
 212 {
 213   GdkEvent *event = NULL;
 214   GList *tmp_list;
 215
 216   tmp_list = _gdk_event_queue_find_first (display);
 217
 218   if (tmp_list)
 219     {
 220       event = tmp_list->data;
 221       _gdk_event_queue_remove_link (display, tmp_list);
 222       g_list_free_1 (tmp_list);
 223     }
 224
 225   return event;
 226 }
 227
 228 /**
 229  * gdk_event_handler_set:
 230  * @func: the function to call to handle events from GDK.
 231  * @data: user data to pass to the function.
 232  * @notify: the function to call when the handler function is removed, i.e. when
 233  *          gdk_event_handler_set() is called with another event handler.
 234  *
 235  * Sets the function to call to handle all events from GDK.
 236  *
 237  * Note that GTK+ uses this to install its own event handler, so it is
 238  * usually not useful for GTK+ applications. (Although an application
 239  * can call this function then call gtk_main_do_event() to pass
 240  * events to GTK+.)
 241  **/
 242 void
 243 gdk_event_handler_set (GdkEventFunc   func,
 244                        gpointer       data,
 245                        GDestroyNotify notify)
 246 {
 247   if (_gdk_event_notify)
 248     (*_gdk_event_notify) (_gdk_event_data);
 249
 250   _gdk_event_func = func;
 251   _gdk_event_data = data;
 252   _gdk_event_notify = notify;
 253 }
 254
 255 /**
 256  * gdk_event_get:
 257  *
 258  * Checks all open displays for a #GdkEvent to process,to be processed
 259  * on, fetching events from the windowing system if necessary.
 260  * See gdk_display_get_event().
 261  *
 262  * Return value: the next #GdkEvent to be processed, or %NULL if no events
 263  * are pending. The returned #GdkEvent should be freed with gdk_event_free().
 264  **/
 265 GdkEvent*
 266 gdk_event_get (void)
 267 {
 268   GSList *tmp_list;
 269
 270   for (tmp_list = _gdk_displays; tmp_list; tmp_list = tmp_list->next)
 271     {
 272       GdkEvent *event = gdk_display_get_event (tmp_list->data);
 273       if (event)
 274         return event;
 275     }
 276
 277   return NULL;
 278 }
 279
 280 /**
 281  * gdk_event_peek:
 282  *
 283  * If there is an event waiting in the event queue of some open
 284  * display, returns a copy of it. See gdk_display_peek_event().
 285  *
 286  * Return value: a copy of the first #GdkEvent on some event queue, or %NULL if no
 287  * events are in any queues. The returned #GdkEvent should be freed with
 288  * gdk_event_free().
 289  **/
 290 GdkEvent*
 291 gdk_event_peek (void)
 292 {
 293   GSList *tmp_list;
 294
 295   for (tmp_list = _gdk_displays; tmp_list; tmp_list = tmp_list->next)
 296     {
 297       GdkEvent *event = gdk_display_peek_event (tmp_list->data);
 298       if (event)
 299         return event;
 300     }
 301
 302   return NULL;
 303 }
 304
 305 /**
 306  * gdk_event_put:
 307  * @event: a #GdkEvent.
 308  *
 309  * Appends a copy of the given event onto the front of the event
 310  * queue for event->any.window's display, or the default event
 311  * queue if event->any.window is %NULL. See gdk_display_put_event().
 312  **/
 313 void
 314 gdk_event_put (const GdkEvent *event)
 315 {
 316   GdkDisplay *display;
 317
 318   g_return_if_fail (event != NULL);
 319
 320   if (event->any.window)
 321     display = gdk_window_get_display (event->any.window);
 322   else
 323     {
 324       GDK_NOTE (MULTIHEAD,
 325                 g_message ("Falling back to default display for gdk_event_put()"));
 326       display = gdk_display_get_default ();
 327     }
 328
 329   gdk_display_put_event (display, event);
 330 }
 331
 332 static GHashTable *event_hash = NULL;
 333
 334 /**
 335  * gdk_event_new:
 336  * @type: a #GdkEventType
 337  *
 338  * Creates a new event of the given type. All fields are set to 0.
 339  *
 340  * Return value: a newly-allocated #GdkEvent. The returned #GdkEvent
 341  * should be freed with gdk_event_free().
 342  *
 343  * Since: 2.2
 344  **/
 345 GdkEvent*
 346 gdk_event_new (GdkEventType type)
 347 {
 348   GdkEventPrivate *new_private;
 349   GdkEvent *new_event;
 350
 351   if (!event_hash)
 352     event_hash = g_hash_table_new (g_direct_hash, NULL);
 353
 354   new_private = g_slice_new0 (GdkEventPrivate);
 355
 356   new_private->flags = 0;
 357   new_private->screen = NULL;
 358
 359   g_hash_table_insert (event_hash, new_private, GUINT_TO_POINTER (1));
 360
 361   new_event = (GdkEvent *) new_private;
 362
 363   new_event->any.type = type;
 364
 365   /*
 366    * Bytewise 0 initialization is reasonable for most of the
 367    * current event types. Explicitely initialize double fields
 368    * since I trust bytewise 0 == 0. less than for integers
 369    * or pointers.
 370    */
 371   switch (type)
 372     {
 373     case GDK_MOTION_NOTIFY:
 374       new_event->motion.x = 0.;
 375       new_event->motion.y = 0.;
 376       new_event->motion.x_root = 0.;
 377       new_event->motion.y_root = 0.;
 378       break;
 379     case GDK_BUTTON_PRESS:
 380     case GDK_2BUTTON_PRESS:
 381     case GDK_3BUTTON_PRESS:
 382     case GDK_BUTTON_RELEASE:
 383       new_event->button.x = 0.;
 384       new_event->button.y = 0.;
 385       new_event->button.x_root = 0.;
 386       new_event->button.y_root = 0.;
 387       break;
 388     case GDK_SCROLL:
 389       new_event->scroll.x = 0.;
 390       new_event->scroll.y = 0.;
 391       new_event->scroll.x_root = 0.;
 392       new_event->scroll.y_root = 0.;
 393       break;
 394     case GDK_ENTER_NOTIFY:
 395     case GDK_LEAVE_NOTIFY:
 396       new_event->crossing.x = 0.;
 397       new_event->crossing.y = 0.;
 398       new_event->crossing.x_root = 0.;
 399       new_event->crossing.y_root = 0.;
 400       break;
 401     default:
 402       break;
 403     }
 404
 405   return new_event;
 406 }
 407
 408 static gboolean
 409 gdk_event_is_allocated (const GdkEvent *event)
 410 {
 411   if (event_hash)
 412     return g_hash_table_lookup (event_hash, event) != NULL;
 413
 414   return FALSE;
 415 }
 416
 417 /**
 418  * gdk_event_copy:
 419  * @event: a #GdkEvent
 420  *
 421  * Copies a #GdkEvent, copying or incrementing the reference count of the
 422  * resources associated with it (e.g. #GdkWindow's and strings).
 423  *
 424  * Return value: a copy of @event. The returned #GdkEvent should be freed with
 425  * gdk_event_free().
 426  **/
 427 GdkEvent*
 428 gdk_event_copy (const GdkEvent *event)
 429 {
 430   GdkEventPrivate *new_private;
 431   GdkEvent *new_event;
 432
 433   g_return_val_if_fail (event != NULL, NULL);
 434
 435   new_event = gdk_event_new (GDK_NOTHING);
 436   new_private = (GdkEventPrivate *)new_event;
 437
 438   *new_event = *event;
 439   if (new_event->any.window)
 440     g_object_ref (new_event->any.window);
 441
 442   if (gdk_event_is_allocated (event))
 443     {
 444       GdkEventPrivate *private = (GdkEventPrivate *)event;
 445
 446       new_private->screen = private->screen;
 447       new_private->device = private->device;
 448     }
 449
 450   switch (event->any.type)
 451     {
 452     case GDK_KEY_PRESS:
 453     case GDK_KEY_RELEASE:
 454       new_event->key.string = g_strdup (event->key.string);
 455       break;
 456
 457     case GDK_ENTER_NOTIFY:
 458     case GDK_LEAVE_NOTIFY:
 459       if (event->crossing.subwindow != NULL)
 460         g_object_ref (event->crossing.subwindow);
 461       break;
 462
 463     case GDK_DRAG_ENTER:
 464     case GDK_DRAG_LEAVE:
 465     case GDK_DRAG_MOTION:
 466     case GDK_DRAG_STATUS:
 467     case GDK_DROP_START:
 468     case GDK_DROP_FINISHED:
 469       g_object_ref (event->dnd.context);
 470       break;
 471
 472     case GDK_EXPOSE:
 473     case GDK_DAMAGE:
 474       if (event->expose.region)
 475         new_event->expose.region = cairo_region_copy (event->expose.region);
 476       break;
 477
 478     case GDK_SETTING:
 479       new_event->setting.name = g_strdup (new_event->setting.name);
 480       break;
 481
 482     case GDK_BUTTON_PRESS:
 483     case GDK_BUTTON_RELEASE:
 484       if (event->button.axes)
 485         new_event->button.axes = g_memdup (event->button.axes,
 486                                              sizeof (gdouble) * event->button.device->num_axes);
 487       break;
 488
 489     case GDK_MOTION_NOTIFY:
 490       if (event->motion.axes)
 491         new_event->motion.axes = g_memdup (event->motion.axes,
 492                                            sizeof (gdouble) * event->motion.device->num_axes);
 493
 494       break;
 495
 496     default:
 497       break;
 498     }
 499
 500   if (gdk_event_is_allocated (event))
 501     _gdk_windowing_event_data_copy (event, new_event);
 502
 503   return new_event;
 504 }
 505
 506 /**
 507  * gdk_event_free:
 508  * @event:  a #GdkEvent.
 509  *
 510  * Frees a #GdkEvent, freeing or decrementing any resources associated with it.
 511  * Note that this function should only be called with events returned from
 512  * functions such as gdk_event_peek(), gdk_event_get(), gdk_event_copy()
 513  * and gdk_event_new().
 514  **/
 515 void
 516 gdk_event_free (GdkEvent *event)
 517 {
 518   g_return_if_fail (event != NULL);
 519
 520   if (event->any.window)
 521     g_object_unref (event->any.window);
 522
 523   switch (event->any.type)
 524     {
 525     case GDK_KEY_PRESS:
 526     case GDK_KEY_RELEASE:
 527       g_free (event->key.string);
 528       break;
 529
 530     case GDK_ENTER_NOTIFY:
 531     case GDK_LEAVE_NOTIFY:
 532       if (event->crossing.subwindow != NULL)
 533         g_object_unref (event->crossing.subwindow);
 534       break;
 535
 536     case GDK_DRAG_ENTER:
 537     case GDK_DRAG_LEAVE:
 538     case GDK_DRAG_MOTION:
 539     case GDK_DRAG_STATUS:
 540     case GDK_DROP_START:
 541     case GDK_DROP_FINISHED:
 542       if (event->dnd.context != NULL)
 543         g_object_unref (event->dnd.context);
 544       break;
 545
 546     case GDK_BUTTON_PRESS:
 547     case GDK_BUTTON_RELEASE:
 548       g_free (event->button.axes);
 549       break;
 550
 551     case GDK_EXPOSE:
 552     case GDK_DAMAGE:
 553       if (event->expose.region)
 554         cairo_region_destroy (event->expose.region);
 555       break;
 556
 557     case GDK_MOTION_NOTIFY:
 558       g_free (event->motion.axes);
 559       break;
 560
 561     case GDK_SETTING:
 562       g_free (event->setting.name);
 563       break;
 564
 565     default:
 566       break;
 567     }
 568
 569   _gdk_windowing_event_data_free (event);
 570
 571   g_hash_table_remove (event_hash, event);
 572   g_slice_free (GdkEventPrivate, (GdkEventPrivate*) event);
 573 }
 574
 575 /**
 576  * gdk_event_get_time:
 577  * @event: a #GdkEvent
 578  *
 579  * Returns the time stamp from @event, if there is one; otherwise
 580  * returns #GDK_CURRENT_TIME. If @event is %NULL, returns #GDK_CURRENT_TIME.
 581  *
 582  * Return value: time stamp field from @event
 583  **/
 584 guint32
 585 gdk_event_get_time (const GdkEvent *event)
 586 {
 587   if (event)
 588     switch (event->type)
 589       {
 590       case GDK_MOTION_NOTIFY:
 591         return event->motion.time;
 592       case GDK_BUTTON_PRESS:
 593       case GDK_2BUTTON_PRESS:
 594       case GDK_3BUTTON_PRESS:
 595       case GDK_BUTTON_RELEASE:
 596         return event->button.time;
 597       case GDK_SCROLL:
 598         return event->scroll.time;
 599       case GDK_KEY_PRESS:
 600       case GDK_KEY_RELEASE:
 601         return event->key.time;
 602       case GDK_ENTER_NOTIFY:
 603       case GDK_LEAVE_NOTIFY:
 604         return event->crossing.time;
 605       case GDK_PROPERTY_NOTIFY:
 606         return event->property.time;
 607       case GDK_SELECTION_CLEAR:
 608       case GDK_SELECTION_REQUEST:
 609       case GDK_SELECTION_NOTIFY:
 610         return event->selection.time;
 611       case GDK_PROXIMITY_IN:
 612       case GDK_PROXIMITY_OUT:
 613         return event->proximity.time;
 614       case GDK_DRAG_ENTER:
 615       case GDK_DRAG_LEAVE:
 616       case GDK_DRAG_MOTION:
 617       case GDK_DRAG_STATUS:
 618       case GDK_DROP_START:
 619       case GDK_DROP_FINISHED:
 620         return event->dnd.time;
 621       case GDK_CLIENT_EVENT:
 622       case GDK_VISIBILITY_NOTIFY:
 623       case GDK_NO_EXPOSE:
 624       case GDK_CONFIGURE:
 625       case GDK_FOCUS_CHANGE:
 626       case GDK_NOTHING:
 627       case GDK_DAMAGE:
 628       case GDK_DELETE:
 629       case GDK_DESTROY:
 630       case GDK_EXPOSE:
 631       case GDK_MAP:
 632       case GDK_UNMAP:
 633       case GDK_WINDOW_STATE:
 634       case GDK_SETTING:
 635       case GDK_OWNER_CHANGE:
 636       case GDK_GRAB_BROKEN:
 637       case GDK_EVENT_LAST:
 638         /* return current time */
 639         break;
 640       }
 641
 642   return GDK_CURRENT_TIME;
 643 }
 644
 645 /**
 646  * gdk_event_get_state:
 647  * @event: a #GdkEvent or NULL
 648  * @state: (out): return location for state
 649  *
 650  * If the event contains a "state" field, puts that field in @state. Otherwise
 651  * stores an empty state (0). Returns %TRUE if there was a state field
 652  * in the event. @event may be %NULL, in which case it's treated
 653  * as if the event had no state field.
 654  *
 655  * Return value: %TRUE if there was a state field in the event
 656  **/
 657 gboolean
 658 gdk_event_get_state (const GdkEvent        *event,
 659                      GdkModifierType       *state)
 660 {
 661   g_return_val_if_fail (state != NULL, FALSE);
 662
 663   if (event)
 664     switch (event->type)
 665       {
 666       case GDK_MOTION_NOTIFY:
 667         *state = event->motion.state;
 668         return TRUE;
 669       case GDK_BUTTON_PRESS:
 670       case GDK_2BUTTON_PRESS:
 671       case GDK_3BUTTON_PRESS:
 672       case GDK_BUTTON_RELEASE:
 673         *state =  event->button.state;
 674         return TRUE;
 675       case GDK_SCROLL:
 676         *state =  event->scroll.state;
 677         return TRUE;
 678       case GDK_KEY_PRESS:
 679       case GDK_KEY_RELEASE:
 680         *state =  event->key.state;
 681         return TRUE;
 682       case GDK_ENTER_NOTIFY:
 683       case GDK_LEAVE_NOTIFY:
 684         *state =  event->crossing.state;
 685         return TRUE;
 686       case GDK_PROPERTY_NOTIFY:
 687         *state =  event->property.state;
 688         return TRUE;
 689       case GDK_VISIBILITY_NOTIFY:
 690       case GDK_CLIENT_EVENT:
 691       case GDK_NO_EXPOSE:
 692       case GDK_CONFIGURE:
 693       case GDK_FOCUS_CHANGE:
 694       case GDK_SELECTION_CLEAR:
 695       case GDK_SELECTION_REQUEST:
 696       case GDK_SELECTION_NOTIFY:
 697       case GDK_PROXIMITY_IN:
 698       case GDK_PROXIMITY_OUT:
 699       case GDK_DAMAGE:
 700       case GDK_DRAG_ENTER:
 701       case GDK_DRAG_LEAVE:
 702       case GDK_DRAG_MOTION:
 703       case GDK_DRAG_STATUS:
 704       case GDK_DROP_START:
 705       case GDK_DROP_FINISHED:
 706       case GDK_NOTHING:
 707       case GDK_DELETE:
 708       case GDK_DESTROY:
 709       case GDK_EXPOSE:
 710       case GDK_MAP:
 711       case GDK_UNMAP:
 712       case GDK_WINDOW_STATE:
 713       case GDK_SETTING:
 714       case GDK_OWNER_CHANGE:
 715       case GDK_GRAB_BROKEN:
 716       case GDK_EVENT_LAST:
 717         /* no state field */
 718         break;
 719       }
 720
 721   *state = 0;
 722   return FALSE;
 723 }
 724
 725 /**
 726  * gdk_event_get_coords:
 727  * @event: a #GdkEvent
 728  * @x_win: (out): location to put event window x coordinate
 729  * @y_win: (out): location to put event window y coordinate
 730  *
 731  * Extract the event window relative x/y coordinates from an event.
 732  *
 733  * Return value: %TRUE if the event delivered event window coordinates
 734  **/
 735 gboolean
 736 gdk_event_get_coords (const GdkEvent *event,
 737                       gdouble        *x_win,
 738                       gdouble        *y_win)
 739 {
 740   gdouble x = 0, y = 0;
 741   gboolean fetched = TRUE;
 742
 743   g_return_val_if_fail (event != NULL, FALSE);
 744
 745   switch (event->type)
 746     {
 747     case GDK_CONFIGURE:
 748       x = event->configure.x;
 749       y = event->configure.y;
 750       break;
 751     case GDK_ENTER_NOTIFY:
 752     case GDK_LEAVE_NOTIFY:
 753       x = event->crossing.x;
 754       y = event->crossing.y;
 755       break;
 756     case GDK_SCROLL:
 757       x = event->scroll.x;
 758       y = event->scroll.y;
 759       break;
 760     case GDK_BUTTON_PRESS:
 761     case GDK_2BUTTON_PRESS:
 762     case GDK_3BUTTON_PRESS:
 763     case GDK_BUTTON_RELEASE:
 764       x = event->button.x;
 765       y = event->button.y;
 766       break;
 767     case GDK_MOTION_NOTIFY:
 768       x = event->motion.x;
 769       y = event->motion.y;
 770       break;
 771     default:
 772       fetched = FALSE;
 773       break;
 774     }
 775
 776   if (x_win)
 777     *x_win = x;
 778   if (y_win)
 779     *y_win = y;
 780
 781   return fetched;
 782 }
 783
 784 /**
 785  * gdk_event_get_root_coords:
 786  * @event: a #GdkEvent
 787  * @x_root: (out): location to put root window x coordinate
 788  * @y_root: (out): location to put root window y coordinate
 789  *
 790  * Extract the root window relative x/y coordinates from an event.
 791  *
 792  * Return value: %TRUE if the event delivered root window coordinates
 793  **/
 794 gboolean
 795 gdk_event_get_root_coords (const GdkEvent *event,
 796                            gdouble        *x_root,
 797                            gdouble        *y_root)
 798 {
 799   gdouble x = 0, y = 0;
 800   gboolean fetched = TRUE;
 801
 802   g_return_val_if_fail (event != NULL, FALSE);
 803
 804   switch (event->type)
 805     {
 806     case GDK_MOTION_NOTIFY:
 807       x = event->motion.x_root;
 808       y = event->motion.y_root;
 809       break;
 810     case GDK_SCROLL:
 811       x = event->scroll.x_root;
 812       y = event->scroll.y_root;
 813       break;
 814     case GDK_BUTTON_PRESS:
 815     case GDK_2BUTTON_PRESS:
 816     case GDK_3BUTTON_PRESS:
 817     case GDK_BUTTON_RELEASE:
 818       x = event->button.x_root;
 819       y = event->button.y_root;
 820       break;
 821     case GDK_ENTER_NOTIFY:
 822     case GDK_LEAVE_NOTIFY:
 823       x = event->crossing.x_root;
 824       y = event->crossing.y_root;
 825       break;
 826     case GDK_DRAG_ENTER:
 827     case GDK_DRAG_LEAVE:
 828     case GDK_DRAG_MOTION:
 829     case GDK_DRAG_STATUS:
 830     case GDK_DROP_START:
 831     case GDK_DROP_FINISHED:
 832       x = event->dnd.x_root;
 833       y = event->dnd.y_root;
 834       break;
 835     default:
 836       fetched = FALSE;
 837       break;
 838     }
 839
 840   if (x_root)
 841     *x_root = x;
 842   if (y_root)
 843     *y_root = y;
 844
 845   return fetched;
 846 }
 847
 848 /**
 849  * gdk_event_get_axis:
 850  * @event: a #GdkEvent
 851  * @axis_use: (out): the axis use to look for
 852  * @value: (out): location to store the value found
 853  *
 854  * Extract the axis value for a particular axis use from
 855  * an event structure.
 856  *
 857  * Return value: %TRUE if the specified axis was found, otherwise %FALSE
 858  **/
 859 gboolean
 860 gdk_event_get_axis (const GdkEvent *event,
 861                     GdkAxisUse      axis_use,
 862                     gdouble        *value)
 863 {
 864   gdouble *axes;
 865   GdkDevice *device;
 866
 867   g_return_val_if_fail (event != NULL, FALSE);
 868
 869   if (axis_use == GDK_AXIS_X || axis_use == GDK_AXIS_Y)
 870     {
 871       gdouble x, y;
 872
 873       switch (event->type)
 874         {
 875         case GDK_MOTION_NOTIFY:
 876           x = event->motion.x;
 877           y = event->motion.y;
 878           break;
 879         case GDK_SCROLL:
 880           x = event->scroll.x;
 881           y = event->scroll.y;
 882           break;
 883         case GDK_BUTTON_PRESS:
 884         case GDK_BUTTON_RELEASE:
 885           x = event->button.x;
 886           y = event->button.y;
 887           break;
 888         case GDK_ENTER_NOTIFY:
 889         case GDK_LEAVE_NOTIFY:
 890           x = event->crossing.x;
 891           y = event->crossing.y;
 892           break;
 893
 894         default:
 895           return FALSE;
 896         }
 897
 898       if (axis_use == GDK_AXIS_X && value)
 899         *value = x;
 900       if (axis_use == GDK_AXIS_Y && value)
 901         *value = y;
 902
 903       return TRUE;
 904     }
 905   else if (event->type == GDK_BUTTON_PRESS ||
 906            event->type == GDK_BUTTON_RELEASE)
 907     {
 908       device = event->button.device;
 909       axes = event->button.axes;
 910     }
 911   else if (event->type == GDK_MOTION_NOTIFY)
 912     {
 913       device = event->motion.device;
 914       axes = event->motion.axes;
 915     }
 916   else
 917     return FALSE;
 918
 919   return gdk_device_get_axis (device, axes, axis_use, value);
 920 }
 921
 922 /**
 923  * gdk_event_set_device:
 924  * @event: a #GdkEvent
 925  * @device: a #GdkDevice
 926  *
 927  * Sets the device for @event to @device. The event must
 928  * have been allocated by GTK+, for instance, by
 929  * gdk_event_copy().
 930  *
 931  * Since: 3.0
 932  **/
 933 void
 934 gdk_event_set_device (GdkEvent  *event,
 935                       GdkDevice *device)
 936 {
 937   GdkEventPrivate *private;
 938
 939   g_return_if_fail (gdk_event_is_allocated (event));
 940
 941   private = (GdkEventPrivate *) event;
 942
 943   private->device = device;
 944
 945   switch (event->type)
 946     {
 947     case GDK_MOTION_NOTIFY:
 948       event->motion.device = device;
 949       break;
 950     case GDK_BUTTON_PRESS:
 951     case GDK_2BUTTON_PRESS:
 952     case GDK_3BUTTON_PRESS:
 953     case GDK_BUTTON_RELEASE:
 954       event->button.device = device;
 955       break;
 956     case GDK_SCROLL:
 957       event->scroll.device = device;
 958       break;
 959     case GDK_PROXIMITY_IN:
 960     case GDK_PROXIMITY_OUT:
 961       event->proximity.device = device;
 962       break;
 963     default:
 964       break;
 965     }
 966 }
 967
 968 /**
 969  * gdk_event_get_device:
 970  * @event: a #GdkEvent.
 971  *
 972  * If the event contains a "device" field, this function will return
 973  * it, else it will return %NULL.
 974  *
 975  * Returns: (transfer none): a #GdkDevice, or %NULL.
 976  *
 977  * Since: 3.0
 978  **/
 979 GdkDevice *
 980 gdk_event_get_device (const GdkEvent *event)
 981 {
 982   g_return_val_if_fail (event != NULL, NULL);
 983
 984   if (gdk_event_is_allocated (event))
 985     {
 986       GdkEventPrivate *private = (GdkEventPrivate *) event;
 987
 988       if (private->device)
 989         return private->device;
 990     }
 991
 992   switch (event->type)
 993     {
 994     case GDK_MOTION_NOTIFY:
 995       return event->motion.device;
 996     case GDK_BUTTON_PRESS:
 997     case GDK_2BUTTON_PRESS:
 998     case GDK_3BUTTON_PRESS:
 999     case GDK_BUTTON_RELEASE:
1000       return event->button.device;
1001     case GDK_SCROLL:
1002       return event->scroll.device;
1003     case GDK_PROXIMITY_IN:
1004     case GDK_PROXIMITY_OUT:
1005       return event->proximity.device;
1006     default:
1007       break;
1008     }
1009
1010   /* Fallback if event has no device set */
1011   switch (event->type)
1012     {
1013     case GDK_MOTION_NOTIFY:
1014     case GDK_BUTTON_PRESS:
1015     case GDK_2BUTTON_PRESS:
1016     case GDK_3BUTTON_PRESS:
1017     case GDK_BUTTON_RELEASE:
1018     case GDK_ENTER_NOTIFY:
1019     case GDK_LEAVE_NOTIFY:
1020     case GDK_FOCUS_CHANGE:
1021     case GDK_PROXIMITY_IN:
1022     case GDK_PROXIMITY_OUT:
1023     case GDK_DRAG_ENTER:
1024     case GDK_DRAG_LEAVE:
1025     case GDK_DRAG_MOTION:
1026     case GDK_DRAG_STATUS:
1027     case GDK_DROP_START:
1028     case GDK_DROP_FINISHED:
1029     case GDK_SCROLL:
1030     case GDK_GRAB_BROKEN:
1031     case GDK_KEY_PRESS:
1032     case GDK_KEY_RELEASE:
1033       {
1034         GdkDisplay *display;
1035         GdkDevice *core_pointer;
1036         GdkDeviceManager *device_manager;
1037
1038         g_warning ("Event with type %d not holding a GdkDevice. "
1039                    "It is most likely synthesized outside Gdk/GTK+\n",
1040                    event->type);
1041
1042         display = gdk_window_get_display (event->any.window);
1043         device_manager = gdk_display_get_device_manager (display);
1044         core_pointer = gdk_display_get_core_pointer (display);
1045
1046         if (event->type == GDK_KEY_PRESS ||
1047             event->type == GDK_KEY_RELEASE)
1048           return gdk_device_get_associated_device (core_pointer);
1049         else
1050           return core_pointer;
1051       }
1052       break;
1053     default:
1054       return NULL;
1055     }
1056 }
1057
1058 /**
1059  * gdk_event_request_motions:
1060  * @event: a valid #GdkEvent
1061  *
1062  * Request more motion notifies if @event is a motion notify hint event.
1063  * This function should be used instead of gdk_window_get_pointer() to
1064  * request further motion notifies, because it also works for extension
1065  * events where motion notifies are provided for devices other than the
1066  * core pointer. Coordinate extraction, processing and requesting more
1067  * motion events from a %GDK_MOTION_NOTIFY event usually works like this:
1068  *
1069  * |[
1070  * {
1071  *   /&ast; motion_event handler &ast;/
1072  *   x = motion_event->x;
1073  *   y = motion_event->y;
1074  *   /&ast; handle (x,y) motion &ast;/
1075  *   gdk_event_request_motions (motion_event); /&ast; handles is_hint events &ast;/
1076  * }
1077  * ]|
1078  *
1079  * Since: 2.12
1080  **/
1081 void
1082 gdk_event_request_motions (const GdkEventMotion *event)
1083 {
1084   GdkDisplay *display;
1085
1086   g_return_if_fail (event != NULL);
1087
1088   if (event->type == GDK_MOTION_NOTIFY && event->is_hint)
1089     {
1090       gdk_device_get_state (event->device, event->window, NULL, NULL);
1091
1092       display = gdk_window_get_display (event->window);
1093       _gdk_display_enable_motion_hints (display, event->device);
1094     }
1095 }
1096
1097 static gboolean
1098 gdk_events_get_axis_distances (GdkEvent *event1,
1099                                GdkEvent *event2,
1100                                gdouble  *x_distance,
1101                                gdouble  *y_distance,
1102                                gdouble  *distance)
1103 {
1104   gdouble x1, x2, y1, y2;
1105   gdouble xd, yd;
1106
1107   if (!gdk_event_get_coords (event1, &x1, &y1) ||
1108       !gdk_event_get_coords (event2, &x2, &y2))
1109     return FALSE;
1110
1111   xd = x2 - x1;
1112   yd = y2 - y1;
1113
1114   if (x_distance)
1115     *x_distance = xd;
1116
1117   if (y_distance)
1118     *y_distance = yd;
1119
1120   if (distance)
1121     *distance = sqrt ((xd * xd) + (yd * yd));
1122
1123   return TRUE;
1124 }
1125
1126 /**
1127  * gdk_events_get_distance:
1128  * @event1: first #GdkEvent
1129  * @event2: second #GdkEvent
1130  * @distance: return location for the distance
1131  *
1132  * If both events have X/Y information, the distance between both coordinates
1133  * (as in a straight line going from @event1 to @event2) will be returned.
1134  *
1135  * Returns: %TRUE if the distance could be calculated.
1136  *
1137  * Since: 3.0
1138  **/
1139 gboolean
1140 gdk_events_get_distance (GdkEvent *event1,
1141                          GdkEvent *event2,
1142                          gdouble  *distance)
1143 {
1144   return gdk_events_get_axis_distances (event1, event2,
1145                                         NULL, NULL,
1146                                         distance);
1147 }
1148
1149 /**
1150  * gdk_events_get_angle:
1151  * @event1: first #GdkEvent
1152  * @event2: second #GdkEvent
1153  * @angle: return location for the relative angle between both events
1154  *
1155  * If both events contain X/Y information, this function will return %TRUE
1156  * and return in @angle the relative angle from @event1 to @event2. The rotation
1157  * direction for positive angles is from the positive X axis towards the positive
1158  * Y axis.
1159  *
1160  * Returns: %TRUE if the angle could be calculated.
1161  *
1162  * Since: 3.0
1163  **/
1164 gboolean
1165 gdk_events_get_angle (GdkEvent *event1,
1166                       GdkEvent *event2,
1167                       gdouble  *angle)
1168 {
1169   gdouble x_distance, y_distance, distance;
1170
1171   if (!gdk_events_get_axis_distances (event1, event2,
1172                                       &x_distance, &y_distance,
1173                                       &distance))
1174     return FALSE;
1175
1176   if (angle)
1177     {
1178       *angle = atan2 (x_distance, y_distance);
1179
1180       /* Invert angle */
1181       *angle = (2 * G_PI) - *angle;
1182
1183       /* Shift it 90° */
1184       *angle += G_PI / 2;
1185
1186       /* And constraint it to 0°-360° */
1187       *angle = fmod (*angle, 2 * G_PI);
1188     }
1189
1190   return TRUE;
1191 }
1192
1193 /**
1194  * gdk_events_get_center:
1195  * @event1: first #GdkEvent
1196  * @event2: second #GdkEvent
1197  * @x: (out): return location for the X coordinate of the center
1198  * @y: (out): return location for the Y coordinate of the center
1199  *
1200  * If both events contain X/Y information, the center of both coordinates
1201  * will be returned in @x and @y.
1202  *
1203  * Returns: %TRUE if the center could be calculated.
1204  *
1205  * Since: 3.0
1206  **/
1207 gboolean
1208 gdk_events_get_center (GdkEvent *event1,
1209                        GdkEvent *event2,
1210                        gdouble  *x,
1211                        gdouble  *y)
1212 {
1213   gdouble x1, x2, y1, y2;
1214
1215   if (!gdk_event_get_coords (event1, &x1, &y1) ||
1216       !gdk_event_get_coords (event2, &x2, &y2))
1217     return FALSE;
1218
1219   if (x)
1220     *x = (x2 + x1) / 2;
1221
1222   if (y)
1223     *y = (y2 + y1) / 2;
1224
1225   return TRUE;
1226 }
1227
1228 /**
1229  * gdk_event_set_screen:
1230  * @event: a #GdkEvent
1231  * @screen: a #GdkScreen
1232  *
1233  * Sets the screen for @event to @screen. The event must
1234  * have been allocated by GTK+, for instance, by
1235  * gdk_event_copy().
1236  *
1237  * Since: 2.2
1238  **/
1239 void
1240 gdk_event_set_screen (GdkEvent  *event,
1241                       GdkScreen *screen)
1242 {
1243   GdkEventPrivate *private;
1244
1245   g_return_if_fail (gdk_event_is_allocated (event));
1246
1247   private = (GdkEventPrivate *)event;
1248
1249   private->screen = screen;
1250 }
1251
1252 /**
1253  * gdk_event_get_screen:
1254  * @event: a #GdkEvent
1255  *
1256  * Returns the screen for the event. The screen is
1257  * typically the screen for <literal>event->any.window</literal>, but
1258  * for events such as mouse events, it is the screen
1259  * where the pointer was when the event occurs -
1260  * that is, the screen which has the root window
1261  * to which <literal>event->motion.x_root</literal> and
1262  * <literal>event->motion.y_root</literal> are relative.
1263  *
1264  * Return value: the screen for the event
1265  *
1266  * Since: 2.2
1267  **/
1268 GdkScreen *
1269 gdk_event_get_screen (const GdkEvent *event)
1270 {
1271   if (gdk_event_is_allocated (event))
1272     {
1273       GdkEventPrivate *private = (GdkEventPrivate *)event;
1274
1275       if (private->screen)
1276         return private->screen;
1277     }
1278
1279   if (event->any.window)
1280     return gdk_window_get_screen (event->any.window);
1281
1282   return NULL;
1283 }
1284
1285 /**
1286  * gdk_set_show_events:
1287  * @show_events:  %TRUE to output event debugging information.
1288  *
1289  * Sets whether a trace of received events is output.
1290  * Note that GTK+ must be compiled with debugging (that is,
1291  * configured using the <option>--enable-debug</option> option)
1292  * to use this option.
1293  **/
1294 void
1295 gdk_set_show_events (gboolean show_events)
1296 {
1297   if (show_events)
1298     _gdk_debug_flags |= GDK_DEBUG_EVENTS;
1299   else
1300     _gdk_debug_flags &= ~GDK_DEBUG_EVENTS;
1301 }
1302
1303 /**
1304  * gdk_get_show_events:
1305  *
1306  * Gets whether event debugging output is enabled.
1307  *
1308  * Return value: %TRUE if event debugging output is enabled.
1309  **/
1310 gboolean
1311 gdk_get_show_events (void)
1312 {
1313   return (_gdk_debug_flags & GDK_DEBUG_EVENTS) != 0;
1314 }
1315
1316 /* What do we do with G_IO_NVAL?
1317  */
1318 #define READ_CONDITION (G_IO_IN | G_IO_HUP | G_IO_ERR)
1319 #define WRITE_CONDITION (G_IO_OUT | G_IO_ERR)
1320 #define EXCEPTION_CONDITION (G_IO_PRI)
1321
1322 static void
1323 gdk_synthesize_click (GdkDisplay *display,
1324                       GdkEvent   *event,
1325                       gint        nclicks)
1326 {
1327   GdkEvent temp_event;
1328   GdkEvent *event_copy;
1329   GList *link;
1330
1331   g_return_if_fail (event != NULL);
1332
1333   temp_event = *event;
1334   temp_event.type = (nclicks == 2) ? GDK_2BUTTON_PRESS : GDK_3BUTTON_PRESS;
1335
1336   event_copy = gdk_event_copy (&temp_event);
1337   link = _gdk_event_queue_append (display, event_copy);
1338 }
1339
1340 void
1341 _gdk_event_button_generate (GdkDisplay *display,
1342                             GdkEvent   *event)
1343 {
1344   GdkMultipleClickInfo *info;
1345
1346   info = g_hash_table_lookup (display->multiple_click_info, event->button.device);
1347
1348   if (G_UNLIKELY (!info))
1349     {
1350       info = g_new0 (GdkMultipleClickInfo, 1);
1351       info->button_number[0] = info->button_number[1] = -1;
1352
1353       g_hash_table_insert (display->multiple_click_info,
1354                            event->button.device, info);
1355     }
1356
1357   if ((event->button.time < (info->button_click_time[1] + 2 * display->double_click_time)) &&
1358       (event->button.window == info->button_window[1]) &&
1359       (event->button.button == info->button_number[1]) &&
1360       (ABS (event->button.x - info->button_x[1]) <= display->double_click_distance) &&
1361       (ABS (event->button.y - info->button_y[1]) <= display->double_click_distance))
1362     {
1363       gdk_synthesize_click (display, event, 3);
1364
1365       info->button_click_time[1] = 0;
1366       info->button_click_time[0] = 0;
1367       info->button_window[1] = NULL;
1368       info->button_window[0] = NULL;
1369       info->button_number[1] = -1;
1370       info->button_number[0] = -1;
1371       info->button_x[0] = info->button_x[1] = 0;
1372       info->button_y[0] = info->button_y[1] = 0;
1373     }
1374   else if ((event->button.time < (info->button_click_time[0] + display->double_click_time)) &&
1375            (event->button.window == info->button_window[0]) &&
1376            (event->button.button == info->button_number[0]) &&
1377            (ABS (event->button.x - info->button_x[0]) <= display->double_click_distance) &&
1378            (ABS (event->button.y - info->button_y[0]) <= display->double_click_distance))
1379     {
1380       gdk_synthesize_click (display, event, 2);
1381
1382       info->button_click_time[1] = info->button_click_time[0];
1383       info->button_click_time[0] = event->button.time;
1384       info->button_window[1] = info->button_window[0];
1385       info->button_window[0] = event->button.window;
1386       info->button_number[1] = info->button_number[0];
1387       info->button_number[0] = event->button.button;
1388       info->button_x[1] = info->button_x[0];
1389       info->button_x[0] = event->button.x;
1390       info->button_y[1] = info->button_y[0];
1391       info->button_y[0] = event->button.y;
1392     }
1393   else
1394     {
1395       info->button_click_time[1] = 0;
1396       info->button_click_time[0] = event->button.time;
1397       info->button_window[1] = NULL;
1398       info->button_window[0] = event->button.window;
1399       info->button_number[1] = -1;
1400       info->button_number[0] = event->button.button;
1401       info->button_x[1] = 0;
1402       info->button_x[0] = event->button.x;
1403       info->button_y[1] = 0;
1404       info->button_y[0] = event->button.y;
1405     }
1406 }
1407
1408 void
1409 gdk_synthesize_window_state (GdkWindow     *window,
1410                              GdkWindowState unset_flags,
1411                              GdkWindowState set_flags)
1412 {
1413   GdkEvent temp_event;
1414   GdkWindowState old;
1415
1416   g_return_if_fail (window != NULL);
1417
1418   temp_event.window_state.window = window;
1419   temp_event.window_state.type = GDK_WINDOW_STATE;
1420   temp_event.window_state.send_event = FALSE;
1421
1422   old = ((GdkWindowObject*) temp_event.window_state.window)->state;
1423
1424   temp_event.window_state.new_window_state = old;
1425   temp_event.window_state.new_window_state |= set_flags;
1426   temp_event.window_state.new_window_state &= ~unset_flags;
1427   temp_event.window_state.changed_mask = temp_event.window_state.new_window_state ^ old;
1428
1429   if (temp_event.window_state.new_window_state == old)
1430     return; /* No actual work to do, nothing changed. */
1431
1432   /* Actually update the field in GdkWindow, this is sort of an odd
1433    * place to do it, but seems like the safest since it ensures we expose no
1434    * inconsistent state to the user.
1435    */
1436
1437   ((GdkWindowObject*) window)->state = temp_event.window_state.new_window_state;
1438
1439   if (temp_event.window_state.changed_mask & GDK_WINDOW_STATE_WITHDRAWN)
1440     _gdk_window_update_viewable (window);
1441
1442   /* We only really send the event to toplevels, since
1443    * all the window states don't apply to non-toplevels.
1444    * Non-toplevels do use the GDK_WINDOW_STATE_WITHDRAWN flag
1445    * internally so we needed to update window->state.
1446    */
1447   switch (((GdkWindowObject*) window)->window_type)
1448     {
1449     case GDK_WINDOW_TOPLEVEL:
1450     case GDK_WINDOW_TEMP: /* ? */
1451       gdk_display_put_event (gdk_window_get_display (window), &temp_event);
1452       break;
1453
1454     case GDK_WINDOW_FOREIGN:
1455     case GDK_WINDOW_ROOT:
1456     case GDK_WINDOW_CHILD:
1457       break;
1458     }
1459 }
1460
1461 /**
1462  * gdk_display_set_double_click_time:
1463  * @display: a #GdkDisplay
1464  * @msec: double click time in milliseconds (thousandths of a second)
1465  *
1466  * Sets the double click time (two clicks within this time interval
1467  * count as a double click and result in a #GDK_2BUTTON_PRESS event).
1468  * Applications should <emphasis>not</emphasis> set this, it is a global
1469  * user-configured setting.
1470  *
1471  * Since: 2.2
1472  **/
1473 void
1474 gdk_display_set_double_click_time (GdkDisplay *display,
1475                                    guint       msec)
1476 {
1477   display->double_click_time = msec;
1478 }
1479
1480 /**
1481  * gdk_set_double_click_time:
1482  * @msec: double click time in milliseconds (thousandths of a second)
1483  *
1484  * Set the double click time for the default display. See
1485  * gdk_display_set_double_click_time().
1486  * See also gdk_display_set_double_click_distance().
1487  * Applications should <emphasis>not</emphasis> set this, it is a
1488  * global user-configured setting.
1489  **/
1490 void
1491 gdk_set_double_click_time (guint msec)
1492 {
1493   gdk_display_set_double_click_time (gdk_display_get_default (), msec);
1494 }
1495
1496 /**
1497  * gdk_display_set_double_click_distance:
1498  * @display: a #GdkDisplay
1499  * @distance: distance in pixels
1500  *
1501  * Sets the double click distance (two clicks within this distance
1502  * count as a double click and result in a #GDK_2BUTTON_PRESS event).
1503  * See also gdk_display_set_double_click_time().
1504  * Applications should <emphasis>not</emphasis> set this, it is a global
1505  * user-configured setting.
1506  *
1507  * Since: 2.4
1508  **/
1509 void
1510 gdk_display_set_double_click_distance (GdkDisplay *display,
1511                                        guint       distance)
1512 {
1513   display->double_click_distance = distance;
1514 }
1515
1516 G_DEFINE_BOXED_TYPE (GdkEvent, gdk_event,
1517                      gdk_event_copy,
1518                      gdk_event_free)
1519
1520 /**
1521  * gdk_setting_get:
1522  * @name: the name of the setting.
1523  * @value: location to store the value of the setting.
1524  *
1525  * Obtains a desktop-wide setting, such as the double-click time,
1526  * for the default screen. See gdk_screen_get_setting().
1527  *
1528  * Returns: %TRUE if the setting existed and a value was stored
1529  *   in @value, %FALSE otherwise.
1530  **/
1531 gboolean
1532 gdk_setting_get (const gchar *name,
1533                  GValue      *value)
1534 {
1535   return gdk_screen_get_setting (gdk_screen_get_default (), name, value);
1536 }