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 "gdk.h"
  28 #include "gdkinternals.h"
  29
  30 typedef struct _GdkIOClosure GdkIOClosure;
  31 typedef struct _GdkEventPrivate GdkEventPrivate;
  32
  33 typedef enum
  34 {
  35   /* Following flag is set for events on the event queue during
  36    * translation and cleared afterwards.
  37    */
  38   GDK_EVENT_PENDING = 1 << 0
  39 } GdkEventFlags;
  40
  41 struct _GdkIOClosure
  42 {
  43   GdkInputFunction function;
  44   GdkInputCondition condition;
  45   GdkDestroyNotify notify;
  46   gpointer data;
  47 };
  48
  49 struct _GdkEventPrivate
  50 {
  51   GdkEvent event;
  52   guint    flags;
  53 };
  54
  55 /*
  56  * Private function declarations
  57  */
  58
  59 GdkFilterReturn gdk_wm_protocols_filter (GdkXEvent *xev,
  60                                          GdkEvent  *event,
  61                                          gpointer   data);
  62
  63 /* Private variable declarations
  64  */
  65
  66 static guint32 button_click_time[2] = { 0, 0}; /* The last 2 button click times. Used
  67                                                 * to determine if the latest button click
  68                                                 * is part of a double or triple click.
  69                                                 */
  70 static GdkWindow *button_window[2] = { NULL, NULL}; /* The last 2 windows to receive button presses.
  71                                                      *  Also used to determine if the latest button
  72                                                      *  click is part of a double or triple click.
  73                                              */
  74 static guint button_number[2] = { -1, -1 }; /* The last 2 buttons to be pressed.
  75                                              */
  76 GdkEventFunc   gdk_event_func = NULL;    /* Callback for events */
  77 gpointer       gdk_event_data = NULL;
  78 GDestroyNotify gdk_event_notify = NULL;
  79
  80 GPollFD event_poll_fd;
  81
  82 static guint double_click_time = 250;
  83 #define TRIPLE_CLICK_TIME      (2*double_click_time)
  84 #define DOUBLE_CLICK_DIST      5
  85 #define TRIPLE_CLICK_DIST      5
  86
  87 /*********************************************
  88  * Functions for maintaining the event queue *
  89  *********************************************/
  90
  91 /*************************************************************
  92  * gdk_event_queue_find_first:
  93  *     Find the first event on the queue that is not still
  94  *     being filled in.
  95  *   arguments:
  96  *
  97  *   results:
  98  *     Pointer to the list node for that event, or NULL
  99  *************************************************************/
 100
 101 GList*
 102 gdk_event_queue_find_first (void)
 103 {
 104   GList *tmp_list = gdk_queued_events;
 105
 106   while (tmp_list)
 107     {
 108       GdkEventPrivate *event = tmp_list->data;
 109       if (!(event->flags & GDK_EVENT_PENDING))
 110         return tmp_list;
 111
 112       tmp_list = g_list_next (tmp_list);
 113     }
 114
 115   return NULL;
 116 }
 117
 118 /*************************************************************
 119  * gdk_event_queue_remove_link:
 120  *     Remove a specified list node from the event queue.
 121  *   arguments:
 122  *     node: Node to remove.
 123  *   results:
 124  *************************************************************/
 125
 126 void
 127 gdk_event_queue_remove_link (GList *node)
 128 {
 129   if (node->prev)
 130     node->prev->next = node->next;
 131   else
 132     gdk_queued_events = node->next;
 133
 134   if (node->next)
 135     node->next->prev = node->prev;
 136   else
 137     gdk_queued_tail = node->prev;
 138 }
 139
 140 /*************************************************************
 141  * gdk_event_queue_append:
 142  *     Append an event onto the tail of the event queue.
 143  *   arguments:
 144  *     event: Event to append.
 145  *   results:
 146  *************************************************************/
 147
 148 void
 149 gdk_event_queue_append (GdkEvent *event)
 150 {
 151   gdk_queued_tail = g_list_append (gdk_queued_tail, event);
 152
 153   if (!gdk_queued_events)
 154     gdk_queued_events = gdk_queued_tail;
 155   else
 156     gdk_queued_tail = gdk_queued_tail->next;
 157 }
 158
 159 /*************************************************************
 160  * gdk_event_handler_set:
 161  *
 162  *   arguments:
 163  *     func: Callback function to be called for each event.
 164  *     data: Data supplied to the function
 165  *     notify: function called when function is no longer needed
 166  *
 167  *   results:
 168  *************************************************************/
 169
 170 void
 171 gdk_event_handler_set (GdkEventFunc   func,
 172                        gpointer       data,
 173                        GDestroyNotify notify)
 174 {
 175   if (gdk_event_notify)
 176     (*gdk_event_notify) (gdk_event_data);
 177
 178   gdk_event_func = func;
 179   gdk_event_data = data;
 180   gdk_event_notify = notify;
 181 }
 182
 183 /*
 184  *--------------------------------------------------------------
 185  * gdk_event_get
 186  *
 187  *   Gets the next event.
 188  *
 189  * Arguments:
 190  *
 191  * Results:
 192  *   If an event is waiting that we care about, returns
 193  *   a pointer to that event, to be freed with gdk_event_free.
 194  *   Otherwise, returns NULL.
 195  *
 196  * Side effects:
 197  *
 198  *--------------------------------------------------------------
 199  */
 200
 201 GdkEvent*
 202 gdk_event_get (void)
 203 {
 204   gdk_events_queue ();
 205
 206   return gdk_event_unqueue ();
 207 }
 208
 209 /*
 210  *--------------------------------------------------------------
 211  * gdk_event_peek
 212  *
 213  *   Gets the next event.
 214  *
 215  * Arguments:
 216  *
 217  * Results:
 218  *   If an event is waiting that we care about, returns
 219  *   a copy of that event, but does not remove it from
 220  *   the queue. The pointer is to be freed with gdk_event_free.
 221  *   Otherwise, returns NULL.
 222  *
 223  * Side effects:
 224  *
 225  *--------------------------------------------------------------
 226  */
 227
 228 GdkEvent*
 229 gdk_event_peek (void)
 230 {
 231   GList *tmp_list;
 232
 233   tmp_list = gdk_event_queue_find_first ();
 234
 235   if (tmp_list)
 236     return gdk_event_copy (tmp_list->data);
 237   else
 238     return NULL;
 239 }
 240
 241 void
 242 gdk_event_put (GdkEvent *event)
 243 {
 244   GdkEvent *new_event;
 245
 246   g_return_if_fail (event != NULL);
 247
 248   new_event = gdk_event_copy (event);
 249
 250   gdk_event_queue_append (new_event);
 251 }
 252
 253 /*
 254  *--------------------------------------------------------------
 255  * gdk_event_copy
 256  *
 257  *   Copy a event structure into new storage.
 258  *
 259  * Arguments:
 260  *   "event" is the event struct to copy.
 261  *
 262  * Results:
 263  *   A new event structure.  Free it with gdk_event_free.
 264  *
 265  * Side effects:
 266  *   The reference count of the window in the event is increased.
 267  *
 268  *--------------------------------------------------------------
 269  */
 270
 271 static GMemChunk *event_chunk = NULL;
 272
 273 GdkEvent*
 274 gdk_event_new (void)
 275 {
 276   GdkEventPrivate *new_event;
 277
 278   if (event_chunk == NULL)
 279     event_chunk = g_mem_chunk_new ("events",
 280                                    sizeof (GdkEventPrivate),
 281                                    4096,
 282                                    G_ALLOC_AND_FREE);
 283
 284   new_event = g_chunk_new (GdkEventPrivate, event_chunk);
 285   new_event->flags = 0;
 286
 287   return (GdkEvent*) new_event;
 288 }
 289
 290 GdkEvent*
 291 gdk_event_copy (GdkEvent *event)
 292 {
 293   GdkEvent *new_event;
 294
 295   g_return_val_if_fail (event != NULL, NULL);
 296
 297   new_event = gdk_event_new ();
 298
 299   *new_event = *event;
 300   if (new_event->any.window)
 301     gdk_window_ref (new_event->any.window);
 302
 303   switch (event->any.type)
 304     {
 305     case GDK_KEY_PRESS:
 306     case GDK_KEY_RELEASE:
 307       new_event->key.string = g_strdup (event->key.string);
 308       break;
 309
 310     case GDK_ENTER_NOTIFY:
 311     case GDK_LEAVE_NOTIFY:
 312       if (event->crossing.subwindow != NULL)
 313         gdk_window_ref (event->crossing.subwindow);
 314       break;
 315
 316     case GDK_DRAG_ENTER:
 317     case GDK_DRAG_LEAVE:
 318     case GDK_DRAG_MOTION:
 319     case GDK_DRAG_STATUS:
 320     case GDK_DROP_START:
 321     case GDK_DROP_FINISHED:
 322       gdk_drag_context_ref (event->dnd.context);
 323       break;
 324
 325     case GDK_EXPOSE:
 326       if (event->expose.region)
 327         new_event->expose.region = gdk_region_copy (event->expose.region);
 328       break;
 329
 330     case GDK_SETTING:
 331       new_event->setting.name = g_strdup (new_event->setting.name);
 332       break;
 333
 334     default:
 335       break;
 336     }
 337
 338   return new_event;
 339 }
 340
 341 /*
 342  *--------------------------------------------------------------
 343  * gdk_event_free
 344  *
 345  *   Free a event structure obtained from gdk_event_copy.  Do not use
 346  *   with other event structures.
 347  *
 348  * Arguments:
 349  *   "event" is the event struct to free.
 350  *
 351  * Results:
 352  *
 353  * Side effects:
 354  *   The reference count of the window in the event is decreased and
 355  *   might be freed, too.
 356  *
 357  *-------------------------------------------------------------- */
 358
 359 void
 360 gdk_event_free (GdkEvent *event)
 361 {
 362   g_return_if_fail (event != NULL);
 363
 364   g_assert (event_chunk != NULL); /* paranoid */
 365
 366   if (event->any.window)
 367     gdk_window_unref (event->any.window);
 368
 369   switch (event->any.type)
 370     {
 371     case GDK_KEY_PRESS:
 372     case GDK_KEY_RELEASE:
 373       g_free (event->key.string);
 374       break;
 375
 376     case GDK_ENTER_NOTIFY:
 377     case GDK_LEAVE_NOTIFY:
 378       if (event->crossing.subwindow != NULL)
 379         gdk_window_unref (event->crossing.subwindow);
 380       break;
 381
 382     case GDK_DRAG_ENTER:
 383     case GDK_DRAG_LEAVE:
 384     case GDK_DRAG_MOTION:
 385     case GDK_DRAG_STATUS:
 386     case GDK_DROP_START:
 387     case GDK_DROP_FINISHED:
 388       gdk_drag_context_unref (event->dnd.context);
 389       break;
 390
 391     case GDK_BUTTON_PRESS:
 392     case GDK_BUTTON_RELEASE:
 393       if (event->button.axes)
 394         g_free (event->button.axes);
 395       break;
 396
 397     case GDK_EXPOSE:
 398       if (event->expose.region)
 399         gdk_region_destroy (event->expose.region);
 400       break;
 401
 402     case GDK_MOTION_NOTIFY:
 403       if (event->motion.axes)
 404         g_free (event->motion.axes);
 405       break;
 406
 407     case GDK_SETTING:
 408       g_free (event->setting.name);
 409       break;
 410
 411     default:
 412       break;
 413     }
 414
 415   g_mem_chunk_free (event_chunk, event);
 416 }
 417
 418 /**
 419  * gdk_event_get_time:
 420  * @event: a #GdkEvent
 421  *
 422  * Returns the time stamp from @event, if there is one; otherwise
 423  * returns #GDK_CURRENT_TIME. If @event is %NULL, returns #GDK_CURRENT_TIME.
 424  *
 425  * Return value: time stamp field from @event
 426  **/
 427 guint32
 428 gdk_event_get_time (GdkEvent *event)
 429 {
 430   if (event)
 431     switch (event->type)
 432       {
 433       case GDK_MOTION_NOTIFY:
 434         return event->motion.time;
 435       case GDK_BUTTON_PRESS:
 436       case GDK_2BUTTON_PRESS:
 437       case GDK_3BUTTON_PRESS:
 438       case GDK_BUTTON_RELEASE:
 439         return event->button.time;
 440       case GDK_SCROLL:
 441         return event->scroll.time;
 442       case GDK_KEY_PRESS:
 443       case GDK_KEY_RELEASE:
 444         return event->key.time;
 445       case GDK_ENTER_NOTIFY:
 446       case GDK_LEAVE_NOTIFY:
 447         return event->crossing.time;
 448       case GDK_PROPERTY_NOTIFY:
 449         return event->property.time;
 450       case GDK_SELECTION_CLEAR:
 451       case GDK_SELECTION_REQUEST:
 452       case GDK_SELECTION_NOTIFY:
 453         return event->selection.time;
 454       case GDK_PROXIMITY_IN:
 455       case GDK_PROXIMITY_OUT:
 456         return event->proximity.time;
 457       case GDK_DRAG_ENTER:
 458       case GDK_DRAG_LEAVE:
 459       case GDK_DRAG_MOTION:
 460       case GDK_DRAG_STATUS:
 461       case GDK_DROP_START:
 462       case GDK_DROP_FINISHED:
 463         return event->dnd.time;
 464       case GDK_CLIENT_EVENT:
 465       case GDK_VISIBILITY_NOTIFY:
 466       case GDK_NO_EXPOSE:
 467       case GDK_CONFIGURE:
 468       case GDK_FOCUS_CHANGE:
 469       case GDK_NOTHING:
 470       case GDK_DELETE:
 471       case GDK_DESTROY:
 472       case GDK_EXPOSE:
 473       case GDK_MAP:
 474       case GDK_UNMAP:
 475       case GDK_WINDOW_STATE:
 476       case GDK_SETTING:
 477         /* return current time */
 478         break;
 479       }
 480
 481   return GDK_CURRENT_TIME;
 482 }
 483
 484 /**
 485  * gdk_event_get_state:
 486  * @event: a #GdkEvent or NULL
 487  * @state: return location for state
 488  *
 489  * If the event contains a "state" field, puts that field in @state. Otherwise
 490  * stores an empty state (0). Returns %TRUE if there was a state field
 491  * in the event. @event may be %NULL, in which case it's treated
 492  * as if the event had no state field.
 493  *
 494  * Return value: %TRUE if there was a state field in the event
 495  **/
 496 gboolean
 497 gdk_event_get_state (GdkEvent        *event,
 498                      GdkModifierType *state)
 499 {
 500   g_return_val_if_fail (state != NULL, FALSE);
 501
 502   if (event)
 503     switch (event->type)
 504       {
 505       case GDK_MOTION_NOTIFY:
 506         *state = event->motion.state;
 507         return TRUE;
 508       case GDK_BUTTON_PRESS:
 509       case GDK_2BUTTON_PRESS:
 510       case GDK_3BUTTON_PRESS:
 511       case GDK_BUTTON_RELEASE:
 512         *state =  event->button.state;
 513         return TRUE;
 514       case GDK_SCROLL:
 515         *state =  event->scroll.state;
 516         return TRUE;
 517       case GDK_KEY_PRESS:
 518       case GDK_KEY_RELEASE:
 519         *state =  event->key.state;
 520         return TRUE;
 521       case GDK_ENTER_NOTIFY:
 522       case GDK_LEAVE_NOTIFY:
 523         *state =  event->crossing.state;
 524         return TRUE;
 525       case GDK_PROPERTY_NOTIFY:
 526         *state =  event->property.state;
 527         return TRUE;
 528       case GDK_VISIBILITY_NOTIFY:
 529         *state =  event->visibility.state;
 530         return TRUE;
 531       case GDK_CLIENT_EVENT:
 532       case GDK_NO_EXPOSE:
 533       case GDK_CONFIGURE:
 534       case GDK_FOCUS_CHANGE:
 535       case GDK_SELECTION_CLEAR:
 536       case GDK_SELECTION_REQUEST:
 537       case GDK_SELECTION_NOTIFY:
 538       case GDK_PROXIMITY_IN:
 539       case GDK_PROXIMITY_OUT:
 540       case GDK_DRAG_ENTER:
 541       case GDK_DRAG_LEAVE:
 542       case GDK_DRAG_MOTION:
 543       case GDK_DRAG_STATUS:
 544       case GDK_DROP_START:
 545       case GDK_DROP_FINISHED:
 546       case GDK_NOTHING:
 547       case GDK_DELETE:
 548       case GDK_DESTROY:
 549       case GDK_EXPOSE:
 550       case GDK_MAP:
 551       case GDK_UNMAP:
 552       case GDK_WINDOW_STATE:
 553       case GDK_SETTING:
 554         /* no state field */
 555         break;
 556       }
 557
 558   *state = 0;
 559   return FALSE;
 560 }
 561
 562 /**
 563  * gdk_event_get_coords:
 564  * @event: a #GdkEvent
 565  * @x_root: location to put event window x coordinate
 566  * @y_root: location to put event window y coordinate
 567  *
 568  * Extract the event window relative x/y coordinates from an event.
 569  *
 570  * Return value: %TRUE if the event delivered event window coordinates
 571  **/
 572 gboolean
 573 gdk_event_get_coords (GdkEvent *event,
 574                       gdouble  *x_win,
 575                       gdouble  *y_win)
 576 {
 577   gdouble x = 0, y = 0;
 578   gboolean fetched = TRUE;
 579
 580   g_return_val_if_fail (event != NULL, FALSE);
 581
 582   switch (event->type)
 583     {
 584     case GDK_CONFIGURE:
 585       x = event->configure.x;
 586       y = event->configure.y;
 587       break;
 588     case GDK_ENTER_NOTIFY:
 589     case GDK_LEAVE_NOTIFY:
 590       x = event->crossing.x;
 591       y = event->crossing.y;
 592       break;
 593     case GDK_SCROLL:
 594       x = event->scroll.x;
 595       y = event->scroll.y;
 596       break;
 597     case GDK_BUTTON_PRESS:
 598     case GDK_2BUTTON_PRESS:
 599     case GDK_3BUTTON_PRESS:
 600     case GDK_BUTTON_RELEASE:
 601       x = event->button.x;
 602       y = event->button.y;
 603       break;
 604     case GDK_MOTION_NOTIFY:
 605       x = event->motion.x;
 606       y = event->motion.y;
 607       break;
 608     default:
 609       fetched = FALSE;
 610       break;
 611     }
 612
 613   if (x_win)
 614     *x_win = x;
 615   if (y_win)
 616     *y_win = x;
 617
 618   return fetched;
 619 }
 620
 621 /**
 622  * gdk_event_get_root_coords:
 623  * @event: a #GdkEvent
 624  * @x_root: location to put root window x coordinate
 625  * @y_root: location to put root window y coordinate
 626  *
 627  * Extract the root window relative x/y coordinates from an event.
 628  *
 629  * Return value: %TRUE if the event delivered root window coordinates
 630  **/
 631 gboolean
 632 gdk_event_get_root_coords (GdkEvent *event,
 633                            gdouble  *x_root,
 634                            gdouble  *y_root)
 635 {
 636   gdouble x = 0, y = 0;
 637   gboolean fetched = TRUE;
 638
 639   g_return_val_if_fail (event != NULL, FALSE);
 640
 641   switch (event->type)
 642     {
 643     case GDK_MOTION_NOTIFY:
 644       x = event->motion.x_root;
 645       y = event->motion.y_root;
 646       break;
 647     case GDK_BUTTON_PRESS:
 648     case GDK_2BUTTON_PRESS:
 649     case GDK_3BUTTON_PRESS:
 650     case GDK_BUTTON_RELEASE:
 651       x = event->button.x_root;
 652       y = event->button.y_root;
 653       break;
 654     case GDK_ENTER_NOTIFY:
 655     case GDK_LEAVE_NOTIFY:
 656       x = event->crossing.x_root;
 657       y = event->crossing.y_root;
 658       break;
 659     case GDK_DRAG_ENTER:
 660     case GDK_DRAG_LEAVE:
 661     case GDK_DRAG_MOTION:
 662     case GDK_DRAG_STATUS:
 663     case GDK_DROP_START:
 664     case GDK_DROP_FINISHED:
 665       x = event->dnd.x_root;
 666       y = event->dnd.y_root;
 667       break;
 668     default:
 669       fetched = FALSE;
 670       break;
 671     }
 672
 673   if (x_root)
 674     *x_root = x;
 675   if (y_root)
 676     *y_root = x;
 677
 678   return fetched;
 679 }
 680
 681 /**
 682  * gdk_event_get_axis:
 683  * @event: a #GdkEvent
 684  * @axis_use: the axis use to look for
 685  * @value: location to store the value found
 686  *
 687  * Extract the axis value for a particular axis use from
 688  * an event structure.
 689  *
 690  * Return value: %TRUE if the specified axis was found, otherwise %FALSE
 691  **/
 692 gboolean
 693 gdk_event_get_axis (GdkEvent   *event,
 694                     GdkAxisUse  axis_use,
 695                     gdouble    *value)
 696 {
 697   gdouble *axes;
 698   GdkDevice *device;
 699
 700   g_return_val_if_fail (event != NULL, FALSE);
 701
 702   if (axis_use == GDK_AXIS_X || axis_use == GDK_AXIS_Y)
 703     {
 704       gdouble x, y;
 705
 706       switch (event->type)
 707         {
 708         case GDK_MOTION_NOTIFY:
 709           x = event->motion.x;
 710           y = event->motion.y;
 711           break;
 712         case GDK_SCROLL:
 713           x = event->scroll.x;
 714           y = event->scroll.y;
 715           break;
 716         case GDK_BUTTON_PRESS:
 717         case GDK_BUTTON_RELEASE:
 718           x = event->button.x;
 719           y = event->button.y;
 720           break;
 721         case GDK_ENTER_NOTIFY:
 722         case GDK_LEAVE_NOTIFY:
 723           x = event->crossing.x;
 724           y = event->crossing.y;
 725           break;
 726
 727         default:
 728           return FALSE;
 729         }
 730
 731       if (axis_use == GDK_AXIS_X && value)
 732         *value = x;
 733       if (axis_use == GDK_AXIS_Y && value)
 734         *value = y;
 735
 736       return TRUE;
 737     }
 738   else if (event->type == GDK_BUTTON_PRESS ||
 739            event->type == GDK_BUTTON_RELEASE)
 740     {
 741       device = event->button.device;
 742       axes = event->button.axes;
 743     }
 744   else if (event->type == GDK_MOTION_NOTIFY)
 745     {
 746       device = event->motion.device;
 747       axes = event->motion.axes;
 748     }
 749   else
 750     return FALSE;
 751
 752   return gdk_device_get_axis (device, axes, axis_use, value);
 753 }
 754
 755 /*
 756  *--------------------------------------------------------------
 757  * gdk_set_show_events
 758  *
 759  *   Turns on/off the showing of events.
 760  *
 761  * Arguments:
 762  *   "show_events" is a boolean describing whether or
 763  *   not to show the events gdk receives.
 764  *
 765  * Results:
 766  *
 767  * Side effects:
 768  *   When "show_events" is TRUE, calls to "gdk_event_get"
 769  *   will output debugging informatin regarding the event
 770  *   received to stdout.
 771  *
 772  *--------------------------------------------------------------
 773  */
 774
 775 void
 776 gdk_set_show_events (gboolean show_events)
 777 {
 778   if (show_events)
 779     gdk_debug_flags |= GDK_DEBUG_EVENTS;
 780   else
 781     gdk_debug_flags &= ~GDK_DEBUG_EVENTS;
 782 }
 783
 784 gboolean
 785 gdk_get_show_events (void)
 786 {
 787   return (gdk_debug_flags & GDK_DEBUG_EVENTS) != 0;
 788 }
 789
 790 static void
 791 gdk_io_destroy (gpointer data)
 792 {
 793   GdkIOClosure *closure = data;
 794
 795   if (closure->notify)
 796     closure->notify (closure->data);
 797
 798   g_free (closure);
 799 }
 800
 801 /* What do we do with G_IO_NVAL?
 802  */
 803 #define READ_CONDITION (G_IO_IN | G_IO_HUP | G_IO_ERR)
 804 #define WRITE_CONDITION (G_IO_OUT | G_IO_ERR)
 805 #define EXCEPTION_CONDITION (G_IO_PRI)
 806
 807 static gboolean
 808 gdk_io_invoke (GIOChannel   *source,
 809                GIOCondition  condition,
 810                gpointer      data)
 811 {
 812   GdkIOClosure *closure = data;
 813   GdkInputCondition gdk_cond = 0;
 814
 815   if (condition & READ_CONDITION)
 816     gdk_cond |= GDK_INPUT_READ;
 817   if (condition & WRITE_CONDITION)
 818     gdk_cond |= GDK_INPUT_WRITE;
 819   if (condition & EXCEPTION_CONDITION)
 820     gdk_cond |= GDK_INPUT_EXCEPTION;
 821
 822   if (closure->condition & gdk_cond)
 823     closure->function (closure->data, g_io_channel_unix_get_fd (source), gdk_cond);
 824
 825   return TRUE;
 826 }
 827
 828 gint
 829 gdk_input_add_full (gint              source,
 830                     GdkInputCondition condition,
 831                     GdkInputFunction  function,
 832                     gpointer          data,
 833                     GdkDestroyNotify  destroy)
 834 {
 835   guint result;
 836   GdkIOClosure *closure = g_new (GdkIOClosure, 1);
 837   GIOChannel *channel;
 838   GIOCondition cond = 0;
 839
 840   closure->function = function;
 841   closure->condition = condition;
 842   closure->notify = destroy;
 843   closure->data = data;
 844
 845   if (condition & GDK_INPUT_READ)
 846     cond |= READ_CONDITION;
 847   if (condition & GDK_INPUT_WRITE)
 848     cond |= WRITE_CONDITION;
 849   if (condition & GDK_INPUT_EXCEPTION)
 850     cond |= EXCEPTION_CONDITION;
 851
 852   channel = g_io_channel_unix_new (source);
 853   result = g_io_add_watch_full (channel, G_PRIORITY_DEFAULT, cond,
 854                                 gdk_io_invoke,
 855                                 closure, gdk_io_destroy);
 856   g_io_channel_unref (channel);
 857
 858   return result;
 859 }
 860
 861 gint
 862 gdk_input_add (gint              source,
 863                GdkInputCondition condition,
 864                GdkInputFunction  function,
 865                gpointer          data)
 866 {
 867   return gdk_input_add_full (source, condition, function, data, NULL);
 868 }
 869
 870 void
 871 gdk_input_remove (gint tag)
 872 {
 873   g_source_remove (tag);
 874 }
 875
 876 GdkEvent*
 877 gdk_event_unqueue (void)
 878 {
 879   GdkEvent *event = NULL;
 880   GList *tmp_list;
 881
 882   tmp_list = gdk_event_queue_find_first ();
 883
 884   if (tmp_list)
 885     {
 886       event = tmp_list->data;
 887       gdk_event_queue_remove_link (tmp_list);
 888       g_list_free_1 (tmp_list);
 889     }
 890
 891   return event;
 892 }
 893
 894 void
 895 gdk_synthesize_click (GdkEvent *event,
 896                       gint      nclicks)
 897 {
 898   GdkEvent temp_event;
 899
 900   g_return_if_fail (event != NULL);
 901
 902   temp_event = *event;
 903   temp_event.type = (nclicks == 2) ? GDK_2BUTTON_PRESS : GDK_3BUTTON_PRESS;
 904
 905   gdk_event_put (&temp_event);
 906 }
 907
 908 void
 909 gdk_event_button_generate (GdkEvent *event)
 910 {
 911   if ((event->button.time < (button_click_time[1] + TRIPLE_CLICK_TIME)) &&
 912       (event->button.window == button_window[1]) &&
 913       (event->button.button == button_number[1]))
 914     {
 915       gdk_synthesize_click (event, 3);
 916
 917       button_click_time[1] = 0;
 918       button_click_time[0] = 0;
 919       button_window[1] = NULL;
 920       button_window[0] = 0;
 921       button_number[1] = -1;
 922       button_number[0] = -1;
 923     }
 924   else if ((event->button.time < (button_click_time[0] + double_click_time)) &&
 925            (event->button.window == button_window[0]) &&
 926            (event->button.button == button_number[0]))
 927     {
 928       gdk_synthesize_click (event, 2);
 929
 930       button_click_time[1] = button_click_time[0];
 931       button_click_time[0] = event->button.time;
 932       button_window[1] = button_window[0];
 933       button_window[0] = event->button.window;
 934       button_number[1] = button_number[0];
 935       button_number[0] = event->button.button;
 936     }
 937   else
 938     {
 939       button_click_time[1] = 0;
 940       button_click_time[0] = event->button.time;
 941       button_window[1] = NULL;
 942       button_window[0] = event->button.window;
 943       button_number[1] = -1;
 944       button_number[0] = event->button.button;
 945     }
 946 }
 947
 948
 949 void
 950 gdk_synthesize_window_state (GdkWindow     *window,
 951                              GdkWindowState unset_flags,
 952                              GdkWindowState set_flags)
 953 {
 954   GdkEventWindowState temp_event;
 955   GdkWindowState old;
 956
 957   g_return_if_fail (window != NULL);
 958
 959   temp_event.window = window;
 960   temp_event.type = GDK_WINDOW_STATE;
 961   temp_event.send_event = FALSE;
 962
 963   old = ((GdkWindowObject*) temp_event.window)->state;
 964
 965   temp_event.changed_mask = (unset_flags | set_flags) ^ old;
 966   temp_event.new_window_state = old;
 967   temp_event.new_window_state |= set_flags;
 968   temp_event.new_window_state &= ~unset_flags;
 969
 970   if (temp_event.new_window_state == old)
 971     return; /* No actual work to do, nothing changed. */
 972
 973   /* Actually update the field in GdkWindow, this is sort of an odd
 974    * place to do it, but seems like the safest since it ensures we expose no
 975    * inconsistent state to the user.
 976    */
 977
 978   ((GdkWindowObject*) window)->state = temp_event.new_window_state;
 979
 980   /* We only really send the event to toplevels, since
 981    * all the window states don't apply to non-toplevels.
 982    * Non-toplevels do use the GDK_WINDOW_STATE_WITHDRAWN flag
 983    * internally so we needed to update window->state.
 984    */
 985   switch (((GdkWindowObject*) window)->window_type)
 986     {
 987     case GDK_WINDOW_TOPLEVEL:
 988     case GDK_WINDOW_DIALOG:
 989     case GDK_WINDOW_TEMP: /* ? */
 990       gdk_event_put ((GdkEvent*) &temp_event);
 991       break;
 992
 993     case GDK_WINDOW_FOREIGN:
 994     case GDK_WINDOW_ROOT:
 995     case GDK_WINDOW_CHILD:
 996       break;
 997     }
 998 }
 999
1000 void
1001 gdk_set_double_click_time (guint msec)
1002 {
1003   double_click_time = msec;
1004 }
1005
1006 GType
1007 gdk_event_get_type (void)
1008 {
1009   static GType our_type = 0;
1010
1011   if (our_type == 0)
1012     our_type = g_boxed_type_register_static ("GdkEvent",
1013                                              NULL,
1014                                              (GBoxedCopyFunc)gdk_event_copy,
1015                                              (GBoxedFreeFunc)gdk_event_free,
1016                                              FALSE);
1017   return our_type;
1018 }
1019
1020 /* These functions are defined here to avoid a new C file, as GdkDevice is
1021  * platform specific. (similar to how gdk_visual_get_type() is in gdkcolor.c)
1022  */
1023 GdkDevice *
1024 gdk_device_ref (GdkDevice *device)
1025 {
1026   return device;
1027 }
1028
1029 void
1030 gdk_device_unref (GdkDevice *device)
1031 {
1032   return;
1033 }
1034
1035 GType
1036 gdk_device_get_type (void)
1037 {
1038   static GType our_type = 0;
1039
1040   if (our_type == 0)
1041     our_type = g_boxed_type_register_static ("GdkDevice",
1042                                              NULL,
1043                                              (GBoxedCopyFunc)gdk_device_ref,
1044                                              (GBoxedFreeFunc)gdk_device_unref,
1045                                              TRUE);
1046   return our_type;
1047 }