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

   1 /* gdkevents-quartz.c
   2  *
   3  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   4  * Copyright (C) 1998-2002 Tor Lillqvist
   5  * Copyright (C) 2005-2008 Imendio AB
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include "config.h"
  24 #include <sys/types.h>
  25 #include <sys/sysctl.h>
  26 #include <pthread.h>
  27 #include <unistd.h>
  28
  29 #import <Cocoa/Cocoa.h>
  30 #include <Carbon/Carbon.h>
  31
  32 #include "gdkscreen.h"
  33 #include "gdkkeysyms.h"
  34 #include "gdkprivate-quartz.h"
  35 #include "gdkdevicemanager-core.h"
  36
  37 #define GRIP_WIDTH 15
  38 #define GRIP_HEIGHT 15
  39
  40 #define WINDOW_IS_TOPLEVEL(window)                   \
  41   (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&   \
  42    GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \
  43    GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
  44
  45 /* This is the window corresponding to the key window */
  46 static GdkWindow   *current_keyboard_window;
  47
  48 /* This is the event mask and button state from the last event */
  49 static GdkEventMask current_event_mask;
  50 static int          current_button_state;
  51
  52 static void append_event                        (GdkEvent  *event,
  53                                                  gboolean   windowing);
  54
  55 NSEvent *
  56 gdk_quartz_event_get_nsevent (GdkEvent *event)
  57 {
  58   /* FIXME: If the event here is unallocated, we crash. */
  59   return ((GdkEventPrivate *) event)->windowing_data;
  60 }
  61
  62 void
  63 _gdk_events_init (void)
  64 {
  65   _gdk_quartz_event_loop_init ();
  66
  67   current_keyboard_window = g_object_ref (_gdk_root);
  68 }
  69
  70 gboolean
  71 gdk_events_pending (void)
  72 {
  73   return (_gdk_event_queue_find_first (_gdk_display) ||
  74           (_gdk_quartz_event_loop_check_pending ()));
  75 }
  76
  77 static void
  78 break_all_grabs (guint32 time)
  79 {
  80   GList *list, *l;
  81   GdkDeviceManager *device_manager;
  82
  83   device_manager = gdk_display_get_device_manager (_gdk_display);
  84   list = gdk_device_manager_list_devices (device_manager,
  85                                           GDK_DEVICE_TYPE_MASTER);
  86   for (l = list; l; l = l->next)
  87     {
  88       GdkDeviceGrabInfo *grab;
  89
  90       grab = _gdk_display_get_last_device_grab (_gdk_display, l->data);
  91       if (grab)
  92         {
  93           grab->serial_end = 0;
  94           grab->implicit_ungrab = TRUE;
  95         }
  96
  97       _gdk_display_device_grab_update (_gdk_display, l->data, 0);
  98     }
  99
 100   g_list_free (list);
 101 }
 102
 103 static void
 104 fixup_event (GdkEvent *event)
 105 {
 106   if (event->any.window)
 107     g_object_ref (event->any.window);
 108   if (((event->any.type == GDK_ENTER_NOTIFY) ||
 109        (event->any.type == GDK_LEAVE_NOTIFY)) &&
 110       (event->crossing.subwindow != NULL))
 111     g_object_ref (event->crossing.subwindow);
 112   event->any.send_event = FALSE;
 113 }
 114
 115 static void
 116 append_event (GdkEvent *event,
 117               gboolean  windowing)
 118 {
 119   GList *node;
 120
 121   fixup_event (event);
 122   node = _gdk_event_queue_append (_gdk_display, event);
 123
 124   if (windowing)
 125     _gdk_windowing_got_event (_gdk_display, node, event, 0);
 126 }
 127
 128 static gint
 129 gdk_event_apply_filters (NSEvent *nsevent,
 130                          GdkEvent *event,
 131                          GList **filters)
 132 {
 133   GList *tmp_list;
 134   GdkFilterReturn result;
 135
 136   tmp_list = *filters;
 137
 138   while (tmp_list)
 139     {
 140       GdkEventFilter *filter = (GdkEventFilter*) tmp_list->data;
 141       GList *node;
 142
 143       if ((filter->flags & GDK_EVENT_FILTER_REMOVED) != 0)
 144         {
 145           tmp_list = tmp_list->next;
 146           continue;
 147         }
 148
 149       filter->ref_count++;
 150       result = filter->function (nsevent, event, filter->data);
 151
 152       /* get the next node after running the function since the
 153          function may add or remove a next node */
 154       node = tmp_list;
 155       tmp_list = tmp_list->next;
 156
 157       filter->ref_count--;
 158       if (filter->ref_count == 0)
 159         {
 160           *filters = g_list_remove_link (*filters, node);
 161           g_list_free_1 (node);
 162           g_free (filter);
 163         }
 164
 165       if (result !=  GDK_FILTER_CONTINUE)
 166         return result;
 167     }
 168
 169   return GDK_FILTER_CONTINUE;
 170 }
 171
 172 static guint32
 173 get_time_from_ns_event (NSEvent *event)
 174 {
 175   double time = [event timestamp];
 176
 177   return time * 1000.0;
 178 }
 179
 180 static int
 181 get_mouse_button_from_ns_event (NSEvent *event)
 182 {
 183   NSInteger button;
 184
 185   button = [event buttonNumber];
 186
 187   switch (button)
 188     {
 189     case 0:
 190       return 1;
 191     case 1:
 192       return 3;
 193     case 2:
 194       return 2;
 195     default:
 196       return button + 1;
 197     }
 198 }
 199
 200 static GdkModifierType
 201 get_mouse_button_modifiers_from_ns_event (NSEvent *event)
 202 {
 203   int button;
 204   GdkModifierType state = 0;
 205
 206   /* This maps buttons 1 to 5 to GDK_BUTTON[1-5]_MASK */
 207   button = get_mouse_button_from_ns_event (event);
 208   if (button >= 1 && button <= 5)
 209     state = (1 << (button + 7));
 210
 211   return state;
 212 }
 213
 214 static GdkModifierType
 215 get_keyboard_modifiers_from_ns_event (NSEvent *nsevent)
 216 {
 217   GdkModifierType modifiers = 0;
 218   int nsflags;
 219
 220   nsflags = [nsevent modifierFlags];
 221
 222   if (nsflags & NSAlphaShiftKeyMask)
 223     modifiers |= GDK_LOCK_MASK;
 224   if (nsflags & NSShiftKeyMask)
 225     modifiers |= GDK_SHIFT_MASK;
 226   if (nsflags & NSControlKeyMask)
 227     modifiers |= GDK_CONTROL_MASK;
 228   if (nsflags & NSCommandKeyMask)
 229     modifiers |= GDK_MOD1_MASK;
 230
 231   return modifiers;
 232 }
 233
 234 /* Return an event mask from an NSEvent */
 235 static GdkEventMask
 236 get_event_mask_from_ns_event (NSEvent *nsevent)
 237 {
 238   switch ([nsevent type])
 239     {
 240     case NSLeftMouseDown:
 241     case NSRightMouseDown:
 242     case NSOtherMouseDown:
 243       return GDK_BUTTON_PRESS_MASK;
 244     case NSLeftMouseUp:
 245     case NSRightMouseUp:
 246     case NSOtherMouseUp:
 247       return GDK_BUTTON_RELEASE_MASK;
 248     case NSMouseMoved:
 249       return GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK;
 250     case NSScrollWheel:
 251       /* Since applications that want button press events can get
 252        * scroll events on X11 (since scroll wheel events are really
 253        * button press events there), we need to use GDK_BUTTON_PRESS_MASK too.
 254        */
 255       return GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK;
 256     case NSLeftMouseDragged:
 257       return (GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
 258               GDK_BUTTON_MOTION_MASK | GDK_BUTTON1_MOTION_MASK |
 259               GDK_BUTTON1_MASK);
 260     case NSRightMouseDragged:
 261       return (GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
 262               GDK_BUTTON_MOTION_MASK | GDK_BUTTON3_MOTION_MASK |
 263               GDK_BUTTON3_MASK);
 264     case NSOtherMouseDragged:
 265       {
 266         GdkEventMask mask;
 267
 268         mask = (GDK_POINTER_MOTION_MASK |
 269                 GDK_POINTER_MOTION_HINT_MASK |
 270                 GDK_BUTTON_MOTION_MASK);
 271
 272         if (get_mouse_button_from_ns_event (nsevent) == 2)
 273           mask |= (GDK_BUTTON2_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
 274                    GDK_BUTTON2_MASK);
 275
 276         return mask;
 277       }
 278     case NSKeyDown:
 279     case NSKeyUp:
 280     case NSFlagsChanged:
 281       {
 282         switch (_gdk_quartz_keys_event_type (nsevent))
 283           {
 284           case GDK_KEY_PRESS:
 285             return GDK_KEY_PRESS_MASK;
 286           case GDK_KEY_RELEASE:
 287             return GDK_KEY_RELEASE_MASK;
 288           case GDK_NOTHING:
 289             return 0;
 290           default:
 291             g_assert_not_reached ();
 292           }
 293       }
 294       break;
 295
 296     case NSMouseEntered:
 297       return GDK_ENTER_NOTIFY_MASK;
 298
 299     case NSMouseExited:
 300       return GDK_LEAVE_NOTIFY_MASK;
 301
 302     default:
 303       g_assert_not_reached ();
 304     }
 305
 306   return 0;
 307 }
 308
 309 static GdkEvent *
 310 create_focus_event (GdkWindow *window,
 311                     gboolean   in)
 312 {
 313   GdkEvent *event;
 314   GdkDeviceManagerCore *device_manager;
 315
 316   event = gdk_event_new (GDK_FOCUS_CHANGE);
 317   event->focus_change.window = window;
 318   event->focus_change.in = in;
 319
 320   device_manager = GDK_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
 321   gdk_event_set_device (event, device_manager->core_keyboard);
 322
 323   return event;
 324 }
 325
 326
 327 static void
 328 generate_motion_event (GdkWindow *window)
 329 {
 330   NSPoint point;
 331   NSPoint screen_point;
 332   NSWindow *nswindow;
 333   GdkQuartzView *view;
 334   GdkEvent *event;
 335   gint x, y, x_root, y_root;
 336   GdkDisplay *display;
 337
 338   event = gdk_event_new (GDK_MOTION_NOTIFY);
 339   event->any.window = NULL;
 340   event->any.send_event = TRUE;
 341
 342   nswindow = ((GdkWindowImplQuartz *)window->impl)->toplevel;
 343   view = (GdkQuartzView *)[nswindow contentView];
 344
 345   display = gdk_window_get_display (window);
 346
 347   screen_point = [NSEvent mouseLocation];
 348
 349   _gdk_quartz_window_nspoint_to_gdk_xy (screen_point, &x_root, &y_root);
 350
 351   point = [nswindow convertScreenToBase:screen_point];
 352
 353   x = point.x;
 354   y = window->height - point.y;
 355
 356   event->any.type = GDK_MOTION_NOTIFY;
 357   event->motion.window = window;
 358   event->motion.time = GDK_CURRENT_TIME;
 359   event->motion.x = x;
 360   event->motion.y = y;
 361   event->motion.x_root = x_root;
 362   event->motion.y_root = y_root;
 363   /* FIXME event->axes */
 364   event->motion.state = 0;
 365   event->motion.is_hint = FALSE;
 366   event->motion.device = _gdk_display->core_pointer;
 367
 368   append_event (event, TRUE);
 369 }
 370
 371 /* Note: Used to both set a new focus window and to unset the old one. */
 372 void
 373 _gdk_quartz_events_update_focus_window (GdkWindow *window,
 374                                         gboolean   got_focus)
 375 {
 376   GdkEvent *event;
 377
 378   if (got_focus && window == current_keyboard_window)
 379     return;
 380
 381   /* FIXME: Don't do this when grabbed? Or make GdkQuartzWindow
 382    * disallow it in the first place instead?
 383    */
 384
 385   if (!got_focus && window == current_keyboard_window)
 386     {
 387       event = create_focus_event (current_keyboard_window, FALSE);
 388       append_event (event, FALSE);
 389       g_object_unref (current_keyboard_window);
 390       current_keyboard_window = NULL;
 391     }
 392
 393   if (got_focus)
 394     {
 395       if (current_keyboard_window)
 396         {
 397           event = create_focus_event (current_keyboard_window, FALSE);
 398           append_event (event, FALSE);
 399           g_object_unref (current_keyboard_window);
 400           current_keyboard_window = NULL;
 401         }
 402
 403       event = create_focus_event (window, TRUE);
 404       append_event (event, FALSE);
 405       current_keyboard_window = g_object_ref (window);
 406
 407       /* We just became the active window.  Unlike X11, Mac OS X does
 408        * not send us motion events while the window does not have focus
 409        * ("is not key").  We send a dummy motion notify event now, so that
 410        * everything in the window is set to correct state.
 411        */
 412       generate_motion_event (window);
 413     }
 414 }
 415
 416 void
 417 _gdk_quartz_events_send_enter_notify_event (GdkWindow *window)
 418 {
 419   NSPoint point;
 420   NSPoint screen_point;
 421   NSWindow *nswindow;
 422   GdkEvent *event;
 423   gint x, y, x_root, y_root;
 424
 425   event = gdk_event_new (GDK_ENTER_NOTIFY);
 426   event->any.window = NULL;
 427   event->any.send_event = FALSE;
 428
 429   nswindow = ((GdkWindowImplQuartz *)window->impl)->toplevel;
 430
 431   screen_point = [NSEvent mouseLocation];
 432
 433   _gdk_quartz_window_nspoint_to_gdk_xy (screen_point, &x_root, &y_root);
 434
 435   point = [nswindow convertScreenToBase:screen_point];
 436
 437   x = point.x;
 438   y = window->height - point.y;
 439
 440   event->crossing.window = window;
 441   event->crossing.subwindow = NULL;
 442   event->crossing.time = GDK_CURRENT_TIME;
 443   event->crossing.x = x;
 444   event->crossing.y = y;
 445   event->crossing.x_root = x_root;
 446   event->crossing.y_root = y_root;
 447   event->crossing.mode = GDK_CROSSING_NORMAL;
 448   event->crossing.detail = GDK_NOTIFY_ANCESTOR;
 449   event->crossing.state = 0;
 450
 451   gdk_event_set_device (event, _gdk_display->core_pointer);
 452
 453   append_event (event, TRUE);
 454 }
 455
 456 void
 457 _gdk_quartz_events_send_map_event (GdkWindow *window)
 458 {
 459   GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
 460
 461   if (!impl->toplevel)
 462     return;
 463
 464   if (window->event_mask & GDK_STRUCTURE_MASK)
 465     {
 466       GdkEvent event;
 467
 468       event.any.type = GDK_MAP;
 469       event.any.window = window;
 470
 471       gdk_event_put (&event);
 472     }
 473 }
 474
 475 static GdkWindow *
 476 find_toplevel_under_pointer (GdkDisplay *display,
 477                              NSPoint     screen_point,
 478                              gint       *x,
 479                              gint       *y)
 480 {
 481   GdkWindow *toplevel;
 482   GdkPointerWindowInfo *info;
 483
 484   info = _gdk_display_get_pointer_info (display, display->core_pointer);
 485   toplevel = info->toplevel_under_pointer;
 486   if (toplevel && WINDOW_IS_TOPLEVEL (toplevel))
 487     {
 488       NSWindow *nswindow;
 489       NSPoint point;
 490
 491       nswindow = ((GdkWindowImplQuartz *)toplevel->impl)->toplevel;
 492
 493       point = [nswindow convertScreenToBase:screen_point];
 494
 495       *x = point.x;
 496       *y = toplevel->height - point.y;
 497     }
 498
 499   return toplevel;
 500 }
 501
 502 static GdkWindow *
 503 find_toplevel_for_keyboard_event (NSEvent *nsevent)
 504 {
 505   GList *list, *l;
 506   GdkWindow *window;
 507   GdkDisplay *display;
 508   GdkQuartzView *view;
 509   GdkDeviceManager *device_manager;
 510
 511   view = (GdkQuartzView *)[[nsevent window] contentView];
 512   window = [view gdkWindow];
 513
 514   display = gdk_window_get_display (window);
 515
 516   device_manager = gdk_display_get_device_manager (display);
 517   list = gdk_device_manager_list_devices (device_manager,
 518                                           GDK_DEVICE_TYPE_MASTER);
 519   for (l = list; l; l = l->next)
 520     {
 521       GdkDeviceGrabInfo *grab;
 522       GdkDevice *device = l->data;
 523
 524       if (gdk_device_get_source(device) != GDK_SOURCE_KEYBOARD)
 525         continue;
 526
 527       grab = _gdk_display_get_last_device_grab (display, device);
 528       if (grab && grab->window && !grab->owner_events)
 529         {
 530           window = gdk_window_get_effective_toplevel (grab->window);
 531           break;
 532         }
 533     }
 534
 535   g_list_free (list);
 536
 537   return window;
 538 }
 539
 540 static GdkWindow *
 541 find_toplevel_for_mouse_event (NSEvent    *nsevent,
 542                                gint       *x,
 543                                gint       *y)
 544 {
 545   NSPoint point;
 546   NSPoint screen_point;
 547   NSEventType event_type;
 548   GdkWindow *toplevel;
 549   GdkQuartzView *view;
 550   GdkDisplay *display;
 551   GdkDeviceGrabInfo *grab;
 552
 553   view = (GdkQuartzView *)[[nsevent window] contentView];
 554   toplevel = [view gdkWindow];
 555
 556   display = gdk_window_get_display (toplevel);
 557
 558   event_type = [nsevent type];
 559   point = [nsevent locationInWindow];
 560   screen_point = [[nsevent window] convertBaseToScreen:point];
 561
 562   /* From the docs for XGrabPointer:
 563    *
 564    * If owner_events is True and if a generated pointer event
 565    * would normally be reported to this client, it is reported
 566    * as usual. Otherwise, the event is reported with respect to
 567    * the grab_window and is reported only if selected by
 568    * event_mask. For either value of owner_events, unreported
 569    * events are discarded.
 570    */
 571   grab = _gdk_display_get_last_device_grab (display,
 572                                             display->core_pointer);
 573   if (WINDOW_IS_TOPLEVEL (toplevel) && grab)
 574     {
 575       /* Implicit grabs do not go through XGrabPointer and thus the
 576        * event mask should not be checked.
 577        */
 578       if (!grab->implicit
 579           && (grab->event_mask & get_event_mask_from_ns_event (nsevent)) == 0)
 580         return NULL;
 581
 582       if (grab->owner_events)
 583         {
 584           /* For owner events, we need to use the toplevel under the
 585            * pointer, not the window from the NSEvent, since that is
 586            * reported with respect to the key window, which could be
 587            * wrong.
 588            */
 589           GdkWindow *toplevel_under_pointer;
 590           gint x_tmp, y_tmp;
 591
 592           toplevel_under_pointer = find_toplevel_under_pointer (display,
 593                                                                 screen_point,
 594                                                                 &x_tmp, &y_tmp);
 595           if (toplevel_under_pointer)
 596             {
 597               toplevel = toplevel_under_pointer;
 598               *x = x_tmp;
 599               *y = y_tmp;
 600             }
 601
 602           return toplevel;
 603         }
 604       else
 605         {
 606           /* Finally check the grab window. */
 607           GdkWindow *grab_toplevel;
 608           NSWindow *grab_nswindow;
 609
 610           grab_toplevel = gdk_window_get_effective_toplevel (grab->window);
 611
 612           grab_nswindow = ((GdkWindowImplQuartz *)grab_toplevel->impl)->toplevel;
 613           point = [grab_nswindow convertScreenToBase:screen_point];
 614
 615           /* Note: x_root and y_root are already right. */
 616           *x = point.x;
 617           *y = grab_toplevel->height - point.y;
 618
 619           return grab_toplevel;
 620         }
 621
 622       return NULL;
 623     }
 624   else
 625     {
 626       /* The non-grabbed case. */
 627       GdkWindow *toplevel_under_pointer;
 628       gint x_tmp, y_tmp;
 629
 630       /* Ignore all events but mouse moved that might be on the title
 631        * bar (above the content view). The reason is that otherwise
 632        * gdk gets confused about getting e.g. button presses with no
 633        * window (the title bar is not known to it).
 634        */
 635       if (event_type != NSMouseMoved)
 636         if (*y < 0)
 637           return NULL;
 638
 639       /* As for owner events, we need to use the toplevel under the
 640        * pointer, not the window from the NSEvent.
 641        */
 642       toplevel_under_pointer = find_toplevel_under_pointer (display,
 643                                                             screen_point,
 644                                                             &x_tmp, &y_tmp);
 645       if (toplevel_under_pointer
 646           && WINDOW_IS_TOPLEVEL (toplevel_under_pointer))
 647         {
 648           GdkWindowImplQuartz *toplevel_impl;
 649
 650           toplevel = toplevel_under_pointer;
 651
 652           toplevel_impl = (GdkWindowImplQuartz *)toplevel->impl;
 653
 654           if ([toplevel_impl->toplevel showsResizeIndicator])
 655             {
 656               NSRect frame;
 657
 658               /* If the resize indicator is visible and the event
 659                * is in the lower right 15x15 corner, we leave these
 660                * events to Cocoa as to be handled as resize events.
 661                * Applications may have widgets in this area.  These
 662                * will most likely be larger than 15x15 and for
 663                * scroll bars there are also other means to move
 664                * the scroll bar.  Since the resize indicator is
 665                * the only way of resizing windows on Mac OS, it
 666                * is too important to not make functional.
 667                */
 668               frame = [toplevel_impl->view bounds];
 669               if (x_tmp > frame.size.width - GRIP_WIDTH
 670                   && x_tmp < frame.size.width
 671                   && y_tmp > frame.size.height - GRIP_HEIGHT
 672                   && y_tmp < frame.size.height)
 673                 {
 674                   return NULL;
 675                 }
 676             }
 677
 678           *x = x_tmp;
 679           *y = y_tmp;
 680         }
 681
 682       return toplevel;
 683     }
 684
 685   return NULL;
 686 }
 687
 688 /* This function finds the correct window to send an event to, taking
 689  * into account grabs, event propagation, and event masks.
 690  */
 691 static GdkWindow *
 692 find_window_for_ns_event (NSEvent *nsevent,
 693                           gint    *x,
 694                           gint    *y,
 695                           gint    *x_root,
 696                           gint    *y_root)
 697 {
 698   GdkQuartzView *view;
 699   NSPoint point;
 700   NSPoint screen_point;
 701   NSEventType event_type;
 702   GdkWindow *toplevel;
 703
 704   view = (GdkQuartzView *)[[nsevent window] contentView];
 705   toplevel = [view gdkWindow];
 706
 707   point = [nsevent locationInWindow];
 708   screen_point = [[nsevent window] convertBaseToScreen:point];
 709
 710   *x = point.x;
 711   *y = toplevel->height - point.y;
 712
 713   _gdk_quartz_window_nspoint_to_gdk_xy (screen_point, x_root, y_root);
 714
 715   event_type = [nsevent type];
 716
 717   switch (event_type)
 718     {
 719     case NSLeftMouseDown:
 720     case NSRightMouseDown:
 721     case NSOtherMouseDown:
 722     case NSLeftMouseUp:
 723     case NSRightMouseUp:
 724     case NSOtherMouseUp:
 725     case NSMouseMoved:
 726     case NSScrollWheel:
 727     case NSLeftMouseDragged:
 728     case NSRightMouseDragged:
 729     case NSOtherMouseDragged:
 730       return find_toplevel_for_mouse_event (nsevent, x, y);
 731
 732     case NSMouseEntered:
 733     case NSMouseExited:
 734       /* Only handle our own entered/exited events, not the ones for the
 735        * titlebar buttons.
 736        */
 737       if ([view trackingRect] == [nsevent trackingNumber])
 738         return toplevel;
 739       else
 740         return NULL;
 741
 742     case NSKeyDown:
 743     case NSKeyUp:
 744     case NSFlagsChanged:
 745       return find_toplevel_for_keyboard_event (nsevent);
 746
 747     default:
 748       /* Ignore everything else. */
 749       break;
 750     }
 751
 752   return NULL;
 753 }
 754
 755 static void
 756 fill_crossing_event (GdkWindow       *toplevel,
 757                      GdkEvent        *event,
 758                      NSEvent         *nsevent,
 759                      gint             x,
 760                      gint             y,
 761                      gint             x_root,
 762                      gint             y_root,
 763                      GdkEventType     event_type,
 764                      GdkCrossingMode  mode,
 765                      GdkNotifyType    detail)
 766 {
 767   event->any.type = event_type;
 768   event->crossing.window = toplevel;
 769   event->crossing.subwindow = NULL;
 770   event->crossing.time = get_time_from_ns_event (nsevent);
 771   event->crossing.x = x;
 772   event->crossing.y = y;
 773   event->crossing.x_root = x_root;
 774   event->crossing.y_root = y_root;
 775   event->crossing.mode = mode;
 776   event->crossing.detail = detail;
 777   event->crossing.state = get_keyboard_modifiers_from_ns_event (nsevent);
 778
 779   gdk_event_set_device (event, _gdk_display->core_pointer);
 780
 781   /* FIXME: Focus and button state? */
 782 }
 783
 784 static void
 785 fill_button_event (GdkWindow *window,
 786                    GdkEvent  *event,
 787                    NSEvent   *nsevent,
 788                    gint       x,
 789                    gint       y,
 790                    gint       x_root,
 791                    gint       y_root)
 792 {
 793   GdkEventType type;
 794   gint state;
 795   gint button;
 796
 797   state = get_keyboard_modifiers_from_ns_event (nsevent);
 798
 799   switch ([nsevent type])
 800     {
 801     case NSLeftMouseDown:
 802     case NSRightMouseDown:
 803     case NSOtherMouseDown:
 804       type = GDK_BUTTON_PRESS;
 805       break;
 806     case NSLeftMouseUp:
 807     case NSRightMouseUp:
 808     case NSOtherMouseUp:
 809       type = GDK_BUTTON_RELEASE;
 810       state |= get_mouse_button_modifiers_from_ns_event (nsevent);
 811       break;
 812     default:
 813       g_assert_not_reached ();
 814     }
 815
 816   button = get_mouse_button_from_ns_event (nsevent);
 817
 818   event->any.type = type;
 819   event->button.window = window;
 820   event->button.time = get_time_from_ns_event (nsevent);
 821   event->button.x = x;
 822   event->button.y = y;
 823   event->button.x_root = x_root;
 824   event->button.y_root = y_root;
 825   /* FIXME event->axes */
 826   event->button.state = state;
 827   event->button.button = button;
 828   event->button.device = _gdk_display->core_pointer;
 829 }
 830
 831 static void
 832 fill_motion_event (GdkWindow *window,
 833                    GdkEvent  *event,
 834                    NSEvent   *nsevent,
 835                    gint       x,
 836                    gint       y,
 837                    gint       x_root,
 838                    gint       y_root)
 839 {
 840   GdkModifierType state;
 841
 842   state = get_keyboard_modifiers_from_ns_event (nsevent);
 843
 844   switch ([nsevent type])
 845     {
 846     case NSLeftMouseDragged:
 847     case NSRightMouseDragged:
 848     case NSOtherMouseDragged:
 849       state |= get_mouse_button_modifiers_from_ns_event (nsevent);
 850       break;
 851
 852     case NSMouseMoved:
 853       break;
 854     }
 855
 856   event->any.type = GDK_MOTION_NOTIFY;
 857   event->motion.window = window;
 858   event->motion.time = get_time_from_ns_event (nsevent);
 859   event->motion.x = x;
 860   event->motion.y = y;
 861   event->motion.x_root = x_root;
 862   event->motion.y_root = y_root;
 863   /* FIXME event->axes */
 864   event->motion.state = state;
 865   event->motion.is_hint = FALSE;
 866   event->motion.device = _gdk_display->core_pointer;
 867 }
 868
 869 static void
 870 fill_scroll_event (GdkWindow          *window,
 871                    GdkEvent           *event,
 872                    NSEvent            *nsevent,
 873                    gint                x,
 874                    gint                y,
 875                    gint                x_root,
 876                    gint                y_root,
 877                    GdkScrollDirection  direction)
 878 {
 879   NSPoint point;
 880
 881   point = [nsevent locationInWindow];
 882
 883   event->any.type = GDK_SCROLL;
 884   event->scroll.window = window;
 885   event->scroll.time = get_time_from_ns_event (nsevent);
 886   event->scroll.x = x;
 887   event->scroll.y = y;
 888   event->scroll.x_root = x_root;
 889   event->scroll.y_root = y_root;
 890   event->scroll.state = get_keyboard_modifiers_from_ns_event (nsevent);
 891   event->scroll.direction = direction;
 892   event->scroll.device = _gdk_display->core_pointer;
 893 }
 894
 895 static void
 896 fill_key_event (GdkWindow    *window,
 897                 GdkEvent     *event,
 898                 NSEvent      *nsevent,
 899                 GdkEventType  type)
 900 {
 901   GdkEventPrivate *priv;
 902   GdkDeviceManagerCore *device_manager;
 903   gchar buf[7];
 904   gunichar c = 0;
 905
 906   priv = (GdkEventPrivate *) event;
 907   priv->windowing_data = [nsevent retain];
 908
 909   event->any.type = type;
 910   event->key.window = window;
 911   event->key.time = get_time_from_ns_event (nsevent);
 912   event->key.state = get_keyboard_modifiers_from_ns_event (nsevent);
 913   event->key.hardware_keycode = [nsevent keyCode];
 914   event->key.group = ([nsevent modifierFlags] & NSAlternateKeyMask) ? 1 : 0;
 915   event->key.keyval = GDK_KEY_VoidSymbol;
 916
 917   device_manager = GDK_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
 918   gdk_event_set_device (event, device_manager->core_keyboard);
 919
 920   gdk_keymap_translate_keyboard_state (NULL,
 921                                        event->key.hardware_keycode,
 922                                        event->key.state,
 923                                        event->key.group,
 924                                        &event->key.keyval,
 925                                        NULL, NULL, NULL);
 926
 927   event->key.is_modifier = _gdk_quartz_keys_is_modifier (event->key.hardware_keycode);
 928
 929   /* If the key press is a modifier, the state should include the mask
 930    * for that modifier but only for releases, not presses. This
 931    * matches the X11 backend behavior.
 932    */
 933   if (event->key.is_modifier)
 934     {
 935       int mask = 0;
 936
 937       switch (event->key.keyval)
 938         {
 939         case GDK_KEY_Meta_R:
 940         case GDK_KEY_Meta_L:
 941           mask = GDK_MOD1_MASK;
 942           break;
 943         case GDK_KEY_Shift_R:
 944         case GDK_KEY_Shift_L:
 945           mask = GDK_SHIFT_MASK;
 946           break;
 947         case GDK_KEY_Caps_Lock:
 948           mask = GDK_LOCK_MASK;
 949           break;
 950         case GDK_KEY_Alt_R:
 951         case GDK_KEY_Alt_L:
 952           mask = GDK_MOD5_MASK;
 953           break;
 954         case GDK_KEY_Control_R:
 955         case GDK_KEY_Control_L:
 956           mask = GDK_CONTROL_MASK;
 957           break;
 958         default:
 959           mask = 0;
 960         }
 961
 962       if (type == GDK_KEY_PRESS)
 963         event->key.state &= ~mask;
 964       else if (type == GDK_KEY_RELEASE)
 965         event->key.state |= mask;
 966     }
 967
 968   event->key.state |= current_button_state;
 969
 970   event->key.string = NULL;
 971
 972   /* Fill in ->string since apps depend on it, taken from the x11 backend. */
 973   if (event->key.keyval != GDK_KEY_VoidSymbol)
 974     c = gdk_keyval_to_unicode (event->key.keyval);
 975
 976   if (c)
 977     {
 978       gsize bytes_written;
 979       gint len;
 980
 981       len = g_unichar_to_utf8 (c, buf);
 982       buf[len] = '\0';
 983
 984       event->key.string = g_locale_from_utf8 (buf, len,
 985                                               NULL, &bytes_written,
 986                                               NULL);
 987       if (event->key.string)
 988         event->key.length = bytes_written;
 989     }
 990   else if (event->key.keyval == GDK_KEY_Escape)
 991     {
 992       event->key.length = 1;
 993       event->key.string = g_strdup ("\033");
 994     }
 995   else if (event->key.keyval == GDK_KEY_Return ||
 996           event->key.keyval == GDK_KEY_KP_Enter)
 997     {
 998       event->key.length = 1;
 999       event->key.string = g_strdup ("\r");
1000     }
1001
1002   if (!event->key.string)
1003     {
1004       event->key.length = 0;
1005       event->key.string = g_strdup ("");
1006     }
1007
1008   GDK_NOTE(EVENTS,
1009     g_message ("key %s:\t\twindow: %p  key: %12s  %d",
1010           type == GDK_KEY_PRESS ? "press" : "release",
1011           event->key.window,
1012           event->key.keyval ? gdk_keyval_name (event->key.keyval) : "(none)",
1013           event->key.keyval));
1014 }
1015
1016 static gboolean
1017 synthesize_crossing_event (GdkWindow *window,
1018                            GdkEvent  *event,
1019                            NSEvent   *nsevent,
1020                            gint       x,
1021                            gint       y,
1022                            gint       x_root,
1023                            gint       y_root)
1024 {
1025   switch ([nsevent type])
1026     {
1027     case NSMouseEntered:
1028       /* Enter events are considered always to be from the root window as we
1029        * can't know for sure from what window we enter.
1030        */
1031       if (!(window->event_mask & GDK_ENTER_NOTIFY_MASK))
1032         return FALSE;
1033
1034       fill_crossing_event (window, event, nsevent,
1035                            x, y,
1036                            x_root, y_root,
1037                            GDK_ENTER_NOTIFY,
1038                            GDK_CROSSING_NORMAL,
1039                            GDK_NOTIFY_ANCESTOR);
1040       return TRUE;
1041
1042     case NSMouseExited:
1043       /* Exited always is to the root window as far as we are concerned,
1044        * since there is no way to reliably get information about what new
1045        * window is entered when exiting one.
1046        */
1047       if (!(window->event_mask & GDK_LEAVE_NOTIFY_MASK))
1048         return FALSE;
1049
1050       fill_crossing_event (window, event, nsevent,
1051                            x, y,
1052                            x_root, y_root,
1053                            GDK_LEAVE_NOTIFY,
1054                            GDK_CROSSING_NORMAL,
1055                            GDK_NOTIFY_ANCESTOR);
1056       return TRUE;
1057
1058     default:
1059       break;
1060     }
1061
1062   return FALSE;
1063 }
1064
1065 GdkEventMask
1066 _gdk_quartz_events_get_current_event_mask (void)
1067 {
1068   return current_event_mask;
1069 }
1070
1071 static gboolean
1072 gdk_event_translate (GdkEvent *event,
1073                      NSEvent  *nsevent)
1074 {
1075   NSEventType event_type;
1076   NSWindow *nswindow;
1077   GdkWindow *window;
1078   int x, y;
1079   int x_root, y_root;
1080   gboolean return_val;
1081
1082   /* There is no support for real desktop wide grabs, so we break
1083    * grabs when the application loses focus (gets deactivated).
1084    */
1085   event_type = [nsevent type];
1086   if (event_type == NSAppKitDefined)
1087     {
1088       if ([nsevent subtype] == NSApplicationDeactivatedEventType)
1089         break_all_grabs (get_time_from_ns_event (nsevent));
1090
1091       /* This could potentially be used to break grabs when clicking
1092        * on the title. The subtype 20 is undocumented so it's probably
1093        * not a good idea: else if (subtype == 20) break_all_grabs ();
1094        */
1095
1096       /* Leave all AppKit events to AppKit. */
1097       return FALSE;
1098     }
1099
1100   /* Keep track of button state, since we don't get that information
1101    * for key events.
1102    */
1103   switch (event_type)
1104     {
1105     case NSLeftMouseDown:
1106     case NSRightMouseDown:
1107     case NSOtherMouseDown:
1108       current_button_state |= get_mouse_button_modifiers_from_ns_event (nsevent);
1109       break;
1110     case NSLeftMouseUp:
1111     case NSRightMouseUp:
1112     case NSOtherMouseUp:
1113       current_button_state &= ~get_mouse_button_modifiers_from_ns_event (nsevent);
1114       break;
1115     default:
1116       break;
1117     }
1118
1119   if (_gdk_default_filters)
1120     {
1121       /* Apply global filters */
1122       GdkFilterReturn result;
1123
1124       result = gdk_event_apply_filters (nsevent, event, &_gdk_default_filters);
1125       if (result != GDK_FILTER_CONTINUE)
1126         {
1127           return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
1128           goto done;
1129         }
1130     }
1131
1132   nswindow = [nsevent window];
1133
1134   /* Ignore events for no window or ones not created by GDK. */
1135   if (!nswindow || ![[nswindow contentView] isKindOfClass:[GdkQuartzView class]])
1136     return FALSE;
1137
1138   /* Ignore events and break grabs while the window is being
1139    * dragged. This is a workaround for the window getting events for
1140    * the window title.
1141    */
1142   if ([(GdkQuartzWindow *)nswindow isInMove])
1143     {
1144       break_all_grabs (get_time_from_ns_event (nsevent));
1145       return FALSE;
1146     }
1147
1148   /* Find the right GDK window to send the event to, taking grabs and
1149    * event masks into consideration.
1150    */
1151   window = find_window_for_ns_event (nsevent, &x, &y, &x_root, &y_root);
1152   if (!window)
1153     return FALSE;
1154
1155   /* Apply any window filters. */
1156   if (GDK_IS_WINDOW (window))
1157     {
1158       GdkFilterReturn result;
1159
1160       if (window->filters)
1161         {
1162           g_object_ref (window);
1163
1164           result = gdk_event_apply_filters (nsevent, event, &window->filters);
1165
1166           g_object_unref (window);
1167
1168           if (result != GDK_FILTER_CONTINUE)
1169             {
1170               return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
1171               goto done;
1172             }
1173         }
1174     }
1175
1176   /* If the app is not active leave the event to AppKit so the window gets
1177    * focused correctly and don't do click-through (so we behave like most
1178    * native apps). If the app is active, we focus the window and then handle
1179    * the event, also to match native apps.
1180    */
1181   if ((event_type == NSRightMouseDown ||
1182        event_type == NSOtherMouseDown ||
1183        event_type == NSLeftMouseDown))
1184     {
1185       GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
1186
1187       if (![NSApp isActive])
1188         {
1189           [NSApp activateIgnoringOtherApps:YES];
1190           return FALSE;
1191         }
1192       else if (![impl->toplevel isKeyWindow])
1193         {
1194           GdkDeviceGrabInfo *grab;
1195
1196           grab = _gdk_display_get_last_device_grab (_gdk_display,
1197                                                     _gdk_display->core_pointer);
1198           if (!grab)
1199             [impl->toplevel makeKeyWindow];
1200         }
1201     }
1202
1203   current_event_mask = get_event_mask_from_ns_event (nsevent);
1204
1205   return_val = TRUE;
1206
1207   switch (event_type)
1208     {
1209     case NSLeftMouseDown:
1210     case NSRightMouseDown:
1211     case NSOtherMouseDown:
1212     case NSLeftMouseUp:
1213     case NSRightMouseUp:
1214     case NSOtherMouseUp:
1215       fill_button_event (window, event, nsevent, x, y, x_root, y_root);
1216       break;
1217
1218     case NSLeftMouseDragged:
1219     case NSRightMouseDragged:
1220     case NSOtherMouseDragged:
1221     case NSMouseMoved:
1222       fill_motion_event (window, event, nsevent, x, y, x_root, y_root);
1223       break;
1224
1225     case NSScrollWheel:
1226       {
1227         float dx = [nsevent deltaX];
1228         float dy = [nsevent deltaY];
1229         GdkScrollDirection direction;
1230
1231         if (dy != 0)
1232           {
1233             if (dy < 0.0)
1234               direction = GDK_SCROLL_DOWN;
1235             else
1236               direction = GDK_SCROLL_UP;
1237
1238             fill_scroll_event (window, event, nsevent, x, y, x_root, y_root, direction);
1239           }
1240
1241         if (dx != 0)
1242           {
1243             if (dx < 0.0)
1244               direction = GDK_SCROLL_RIGHT;
1245             else
1246               direction = GDK_SCROLL_LEFT;
1247
1248             fill_scroll_event (window, event, nsevent, x, y, x_root, y_root, direction);
1249           }
1250       }
1251       break;
1252
1253     case NSMouseEntered:
1254     case NSMouseExited:
1255       return_val = synthesize_crossing_event (window, event, nsevent, x, y, x_root, y_root);
1256       break;
1257
1258     case NSKeyDown:
1259     case NSKeyUp:
1260     case NSFlagsChanged:
1261       {
1262         GdkEventType type;
1263
1264         type = _gdk_quartz_keys_event_type (nsevent);
1265         if (type == GDK_NOTHING)
1266           return_val = FALSE;
1267         else
1268           fill_key_event (window, event, nsevent, type);
1269       }
1270       break;
1271
1272     default:
1273       /* Ignore everything elsee. */
1274       return_val = FALSE;
1275       break;
1276     }
1277
1278  done:
1279   if (return_val)
1280     {
1281       if (event->any.window)
1282         g_object_ref (event->any.window);
1283       if (((event->any.type == GDK_ENTER_NOTIFY) ||
1284            (event->any.type == GDK_LEAVE_NOTIFY)) &&
1285           (event->crossing.subwindow != NULL))
1286         g_object_ref (event->crossing.subwindow);
1287     }
1288   else
1289     {
1290       /* Mark this event as having no resources to be freed */
1291       event->any.window = NULL;
1292       event->any.type = GDK_NOTHING;
1293     }
1294
1295   return return_val;
1296 }
1297
1298 void
1299 _gdk_events_queue (GdkDisplay *display)
1300 {
1301   NSEvent *nsevent;
1302
1303   nsevent = _gdk_quartz_event_loop_get_pending ();
1304   if (nsevent)
1305     {
1306       GdkEvent *event;
1307       GList *node;
1308
1309       event = gdk_event_new (GDK_NOTHING);
1310
1311       event->any.window = NULL;
1312       event->any.send_event = FALSE;
1313
1314       ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;
1315
1316       node = _gdk_event_queue_append (display, event);
1317
1318       if (gdk_event_translate (event, nsevent))
1319         {
1320           ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;
1321           _gdk_windowing_got_event (display, node, event, 0);
1322         }
1323       else
1324         {
1325           _gdk_event_queue_remove_link (display, node);
1326           g_list_free_1 (node);
1327           gdk_event_free (event);
1328
1329           GDK_THREADS_LEAVE ();
1330           [NSApp sendEvent:nsevent];
1331           GDK_THREADS_ENTER ();
1332         }
1333
1334       _gdk_quartz_event_loop_release_event (nsevent);
1335     }
1336 }
1337
1338 void
1339 gdk_flush (void)
1340 {
1341   /* Not supported. */
1342 }
1343
1344 void
1345 _gdk_quartz_display_add_client_message_filter (GdkDisplay   *display,
1346                                                GdkAtom       message_type,
1347                                                GdkFilterFunc func,
1348                                                gpointer      data)
1349 {
1350   /* Not supported. */
1351 }
1352
1353 void
1354 _gdk_quartz_display_sync (GdkDisplay *display)
1355 {
1356   /* Not supported. */
1357 }
1358
1359 void
1360 _gdk_quartz_display_flush (GdkDisplay *display)
1361 {
1362   /* Not supported. */
1363 }
1364
1365 gboolean
1366 _gdk_quartz_display_send_client_message (GdkDisplay      *display,
1367                                          GdkEvent        *event,
1368                                          GdkNativeWindow  winid)
1369 {
1370   /* Not supported. */
1371   return FALSE;
1372 }
1373
1374 void
1375 _gdk_quartz_screen_broadcast_client_message (GdkScreen *screen,
1376                                              GdkEvent  *event)
1377 {
1378   /* Not supported. */
1379 }
1380
1381 gboolean
1382 _gdk_quartz_screen_get_setting (GdkScreen   *screen,
1383                                 const gchar *name,
1384                                 GValue      *value)
1385 {
1386   if (strcmp (name, "gtk-double-click-time") == 0)
1387     {
1388       NSUserDefaults *defaults;
1389       float t;
1390
1391       GDK_QUARTZ_ALLOC_POOL;
1392
1393       defaults = [NSUserDefaults standardUserDefaults];
1394
1395       t = [defaults floatForKey:@"com.apple.mouse.doubleClickThreshold"];
1396       if (t == 0.0)
1397         {
1398           /* No user setting, use the default in OS X. */
1399           t = 0.5;
1400         }
1401
1402       GDK_QUARTZ_RELEASE_POOL;
1403
1404       g_value_set_int (value, t * 1000);
1405
1406       return TRUE;
1407     }
1408   else if (strcmp (name, "gtk-font-name") == 0)
1409     {
1410       NSString *name;
1411       char *str;
1412
1413       GDK_QUARTZ_ALLOC_POOL;
1414
1415       name = [[NSFont systemFontOfSize:0] familyName];
1416
1417       /* Let's try to use the "views" font size (12pt) by default. This is
1418        * used for lists/text/other "content" which is the largest parts of
1419        * apps, using the "regular control" size (13pt) looks a bit out of
1420        * place. We might have to tweak this.
1421        */
1422
1423       /* The size has to be hardcoded as there doesn't seem to be a way to
1424        * get the views font size programmatically.
1425        */
1426       str = g_strdup_printf ("%s 12", [name UTF8String]);
1427       g_value_set_string (value, str);
1428       g_free (str);
1429
1430       GDK_QUARTZ_RELEASE_POOL;
1431
1432       return TRUE;
1433     }
1434
1435   /* FIXME: Add more settings */
1436
1437   return FALSE;
1438 }
1439
1440 void
1441 _gdk_windowing_event_data_copy (const GdkEvent *src,
1442                                 GdkEvent       *dst)
1443 {
1444   GdkEventPrivate *priv_src = (GdkEventPrivate *) src;
1445   GdkEventPrivate *priv_dst = (GdkEventPrivate *) dst;
1446
1447   if (priv_src->windowing_data)
1448     {
1449       priv_dst->windowing_data = priv_src->windowing_data;
1450       [(NSEvent *)priv_dst->windowing_data retain];
1451     }
1452 }
1453
1454 void
1455 _gdk_windowing_event_data_free (GdkEvent *event)
1456 {
1457   GdkEventPrivate *priv = (GdkEventPrivate *) event;
1458
1459   if (priv->windowing_data)
1460     {
1461       [(NSEvent *)priv->windowing_data release];
1462       priv->windowing_data = NULL;
1463     }
1464 }