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