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