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