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