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