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