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
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.
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.
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.
24 #include <sys/types.h>
25 #include <sys/sysctl.h>
29 #import <Cocoa/Cocoa.h>
30 #include <Carbon/Carbon.h>
32 #include <gdk/gdkdisplayprivate.h>
34 #include "gdkscreen.h"
35 #include "gdkkeysyms.h"
36 #include "gdkquartzdisplay.h"
37 #include "gdkprivate-quartz.h"
38 #include "gdkquartzdevicemanager-core.h"
41 #define GRIP_HEIGHT 15
43 #define WINDOW_IS_TOPLEVEL(window) \
44 (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
45 GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \
46 GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
48 /* This is the window corresponding to the key window */
49 static GdkWindow *current_keyboard_window;
51 /* This is the event mask and button state from the last event */
52 static GdkEventMask current_event_mask;
53 static int current_button_state;
55 static void append_event (GdkEvent *event,
59 _gdk_quartz_events_init (void)
61 _gdk_quartz_event_loop_init ();
63 current_keyboard_window = g_object_ref (_gdk_root);
67 _gdk_quartz_display_has_pending (GdkDisplay *display)
69 return (_gdk_event_queue_find_first (display) ||
70 (_gdk_quartz_event_loop_check_pending ()));
74 break_all_grabs (guint32 time)
77 GdkDeviceManager *device_manager;
79 device_manager = gdk_display_get_device_manager (_gdk_display);
80 list = gdk_device_manager_list_devices (device_manager,
81 GDK_DEVICE_TYPE_MASTER);
82 for (l = list; l; l = l->next)
84 GdkDeviceGrabInfo *grab;
86 grab = _gdk_display_get_last_device_grab (_gdk_display, l->data);
90 grab->implicit_ungrab = TRUE;
93 _gdk_display_device_grab_update (_gdk_display, l->data, NULL, 0);
100 fixup_event (GdkEvent *event)
102 if (event->any.window)
103 g_object_ref (event->any.window);
104 if (((event->any.type == GDK_ENTER_NOTIFY) ||
105 (event->any.type == GDK_LEAVE_NOTIFY)) &&
106 (event->crossing.subwindow != NULL))
107 g_object_ref (event->crossing.subwindow);
108 event->any.send_event = FALSE;
112 append_event (GdkEvent *event,
118 node = _gdk_event_queue_append (_gdk_display, event);
121 _gdk_windowing_got_event (_gdk_display, node, event, 0);
125 gdk_event_apply_filters (NSEvent *nsevent,
130 GdkFilterReturn result;
136 GdkEventFilter *filter = (GdkEventFilter*) tmp_list->data;
139 if ((filter->flags & GDK_EVENT_FILTER_REMOVED) != 0)
141 tmp_list = tmp_list->next;
146 result = filter->function (nsevent, event, filter->data);
148 /* get the next node after running the function since the
149 function may add or remove a next node */
151 tmp_list = tmp_list->next;
154 if (filter->ref_count == 0)
156 *filters = g_list_remove_link (*filters, node);
157 g_list_free_1 (node);
161 if (result != GDK_FILTER_CONTINUE)
165 return GDK_FILTER_CONTINUE;
169 get_time_from_ns_event (NSEvent *event)
171 double time = [event timestamp];
173 return time * 1000.0;
177 get_mouse_button_from_ns_event (NSEvent *event)
181 button = [event buttonNumber];
196 static GdkModifierType
197 get_mouse_button_modifiers_from_ns_event (NSEvent *event)
200 GdkModifierType state = 0;
202 /* This maps buttons 1 to 5 to GDK_BUTTON[1-5]_MASK */
203 button = get_mouse_button_from_ns_event (event);
204 if (button >= 1 && button <= 5)
205 state = (1 << (button + 7));
210 static GdkModifierType
211 get_keyboard_modifiers_from_ns_event (NSEvent *nsevent)
213 GdkModifierType modifiers = 0;
216 nsflags = [nsevent modifierFlags];
218 if (nsflags & NSAlphaShiftKeyMask)
219 modifiers |= GDK_LOCK_MASK;
220 if (nsflags & NSShiftKeyMask)
221 modifiers |= GDK_SHIFT_MASK;
222 if (nsflags & NSControlKeyMask)
223 modifiers |= GDK_CONTROL_MASK;
224 if (nsflags & NSCommandKeyMask)
225 modifiers |= GDK_MOD1_MASK;
230 /* Return an event mask from an NSEvent */
232 get_event_mask_from_ns_event (NSEvent *nsevent)
234 switch ([nsevent type])
236 case NSLeftMouseDown:
237 case NSRightMouseDown:
238 case NSOtherMouseDown:
239 return GDK_BUTTON_PRESS_MASK;
243 return GDK_BUTTON_RELEASE_MASK;
245 return GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK;
247 /* Since applications that want button press events can get
248 * scroll events on X11 (since scroll wheel events are really
249 * button press events there), we need to use GDK_BUTTON_PRESS_MASK too.
251 return GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK;
252 case NSLeftMouseDragged:
253 return (GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
254 GDK_BUTTON_MOTION_MASK | GDK_BUTTON1_MOTION_MASK |
256 case NSRightMouseDragged:
257 return (GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
258 GDK_BUTTON_MOTION_MASK | GDK_BUTTON3_MOTION_MASK |
260 case NSOtherMouseDragged:
264 mask = (GDK_POINTER_MOTION_MASK |
265 GDK_POINTER_MOTION_HINT_MASK |
266 GDK_BUTTON_MOTION_MASK);
268 if (get_mouse_button_from_ns_event (nsevent) == 2)
269 mask |= (GDK_BUTTON2_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
278 switch (_gdk_quartz_keys_event_type (nsevent))
281 return GDK_KEY_PRESS_MASK;
282 case GDK_KEY_RELEASE:
283 return GDK_KEY_RELEASE_MASK;
287 g_assert_not_reached ();
293 return GDK_ENTER_NOTIFY_MASK;
296 return GDK_LEAVE_NOTIFY_MASK;
299 g_assert_not_reached ();
306 create_focus_event (GdkWindow *window,
310 GdkQuartzDeviceManagerCore *device_manager;
312 event = gdk_event_new (GDK_FOCUS_CHANGE);
313 event->focus_change.window = window;
314 event->focus_change.in = in;
316 device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
317 gdk_event_set_device (event, device_manager->core_keyboard);
324 generate_motion_event (GdkWindow *window)
327 NSPoint screen_point;
331 gint x, y, x_root, y_root;
334 event = gdk_event_new (GDK_MOTION_NOTIFY);
335 event->any.window = NULL;
336 event->any.send_event = TRUE;
338 nswindow = ((GdkWindowImplQuartz *)window->impl)->toplevel;
339 view = (GdkQuartzView *)[nswindow contentView];
341 display = gdk_window_get_display (window);
343 screen_point = [NSEvent mouseLocation];
345 _gdk_quartz_window_nspoint_to_gdk_xy (screen_point, &x_root, &y_root);
347 point = [nswindow convertScreenToBase:screen_point];
350 y = window->height - point.y;
352 event->any.type = GDK_MOTION_NOTIFY;
353 event->motion.window = window;
354 event->motion.time = GDK_CURRENT_TIME;
357 event->motion.x_root = x_root;
358 event->motion.y_root = y_root;
359 /* FIXME event->axes */
360 event->motion.state = 0;
361 event->motion.is_hint = FALSE;
362 event->motion.device = _gdk_display->core_pointer;
364 append_event (event, TRUE);
367 /* Note: Used to both set a new focus window and to unset the old one. */
369 _gdk_quartz_events_update_focus_window (GdkWindow *window,
374 if (got_focus && window == current_keyboard_window)
377 /* FIXME: Don't do this when grabbed? Or make GdkQuartzNSWindow
378 * disallow it in the first place instead?
381 if (!got_focus && window == current_keyboard_window)
383 event = create_focus_event (current_keyboard_window, FALSE);
384 append_event (event, FALSE);
385 g_object_unref (current_keyboard_window);
386 current_keyboard_window = NULL;
391 if (current_keyboard_window)
393 event = create_focus_event (current_keyboard_window, FALSE);
394 append_event (event, FALSE);
395 g_object_unref (current_keyboard_window);
396 current_keyboard_window = NULL;
399 event = create_focus_event (window, TRUE);
400 append_event (event, FALSE);
401 current_keyboard_window = g_object_ref (window);
403 /* We just became the active window. Unlike X11, Mac OS X does
404 * not send us motion events while the window does not have focus
405 * ("is not key"). We send a dummy motion notify event now, so that
406 * everything in the window is set to correct state.
408 generate_motion_event (window);
413 _gdk_quartz_events_send_enter_notify_event (GdkWindow *window)
416 NSPoint screen_point;
419 gint x, y, x_root, y_root;
421 event = gdk_event_new (GDK_ENTER_NOTIFY);
422 event->any.window = NULL;
423 event->any.send_event = FALSE;
425 nswindow = ((GdkWindowImplQuartz *)window->impl)->toplevel;
427 screen_point = [NSEvent mouseLocation];
429 _gdk_quartz_window_nspoint_to_gdk_xy (screen_point, &x_root, &y_root);
431 point = [nswindow convertScreenToBase:screen_point];
434 y = window->height - point.y;
436 event->crossing.window = window;
437 event->crossing.subwindow = NULL;
438 event->crossing.time = GDK_CURRENT_TIME;
439 event->crossing.x = x;
440 event->crossing.y = y;
441 event->crossing.x_root = x_root;
442 event->crossing.y_root = y_root;
443 event->crossing.mode = GDK_CROSSING_NORMAL;
444 event->crossing.detail = GDK_NOTIFY_ANCESTOR;
445 event->crossing.state = 0;
447 gdk_event_set_device (event, _gdk_display->core_pointer);
449 append_event (event, TRUE);
453 _gdk_quartz_events_send_map_event (GdkWindow *window)
455 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
460 if (window->event_mask & GDK_STRUCTURE_MASK)
464 event.any.type = GDK_MAP;
465 event.any.window = window;
467 gdk_event_put (&event);
472 find_toplevel_under_pointer (GdkDisplay *display,
473 NSPoint screen_point,
478 GdkPointerWindowInfo *info;
480 info = _gdk_display_get_pointer_info (display, display->core_pointer);
481 toplevel = info->toplevel_under_pointer;
482 if (toplevel && WINDOW_IS_TOPLEVEL (toplevel))
487 nswindow = ((GdkWindowImplQuartz *)toplevel->impl)->toplevel;
489 point = [nswindow convertScreenToBase:screen_point];
492 *y = toplevel->height - point.y;
499 find_toplevel_for_keyboard_event (NSEvent *nsevent)
505 GdkDeviceManager *device_manager;
507 view = (GdkQuartzView *)[[nsevent window] contentView];
508 window = [view gdkWindow];
510 display = gdk_window_get_display (window);
512 device_manager = gdk_display_get_device_manager (display);
513 list = gdk_device_manager_list_devices (device_manager,
514 GDK_DEVICE_TYPE_MASTER);
515 for (l = list; l; l = l->next)
517 GdkDeviceGrabInfo *grab;
518 GdkDevice *device = l->data;
520 if (gdk_device_get_source(device) != GDK_SOURCE_KEYBOARD)
523 grab = _gdk_display_get_last_device_grab (display, device);
524 if (grab && grab->window && !grab->owner_events)
526 window = gdk_window_get_effective_toplevel (grab->window);
537 find_toplevel_for_mouse_event (NSEvent *nsevent,
542 NSPoint screen_point;
543 NSEventType event_type;
547 GdkDeviceGrabInfo *grab;
549 view = (GdkQuartzView *)[[nsevent window] contentView];
550 toplevel = [view gdkWindow];
552 display = gdk_window_get_display (toplevel);
554 event_type = [nsevent type];
555 point = [nsevent locationInWindow];
556 screen_point = [[nsevent window] convertBaseToScreen:point];
558 /* From the docs for XGrabPointer:
560 * If owner_events is True and if a generated pointer event
561 * would normally be reported to this client, it is reported
562 * as usual. Otherwise, the event is reported with respect to
563 * the grab_window and is reported only if selected by
564 * event_mask. For either value of owner_events, unreported
565 * events are discarded.
567 grab = _gdk_display_get_last_device_grab (display,
568 display->core_pointer);
569 if (WINDOW_IS_TOPLEVEL (toplevel) && grab)
571 /* Implicit grabs do not go through XGrabPointer and thus the
572 * event mask should not be checked.
575 && (grab->event_mask & get_event_mask_from_ns_event (nsevent)) == 0)
578 if (grab->owner_events)
580 /* For owner events, we need to use the toplevel under the
581 * pointer, not the window from the NSEvent, since that is
582 * reported with respect to the key window, which could be
585 GdkWindow *toplevel_under_pointer;
588 toplevel_under_pointer = find_toplevel_under_pointer (display,
591 if (toplevel_under_pointer)
593 toplevel = toplevel_under_pointer;
602 /* Finally check the grab window. */
603 GdkWindow *grab_toplevel;
604 NSWindow *grab_nswindow;
606 grab_toplevel = gdk_window_get_effective_toplevel (grab->window);
608 grab_nswindow = ((GdkWindowImplQuartz *)grab_toplevel->impl)->toplevel;
609 point = [grab_nswindow convertScreenToBase:screen_point];
611 /* Note: x_root and y_root are already right. */
613 *y = grab_toplevel->height - point.y;
615 return grab_toplevel;
622 /* The non-grabbed case. */
623 GdkWindow *toplevel_under_pointer;
626 /* Ignore all events but mouse moved that might be on the title
627 * bar (above the content view). The reason is that otherwise
628 * gdk gets confused about getting e.g. button presses with no
629 * window (the title bar is not known to it).
631 if (event_type != NSMouseMoved)
635 /* As for owner events, we need to use the toplevel under the
636 * pointer, not the window from the NSEvent.
638 toplevel_under_pointer = find_toplevel_under_pointer (display,
641 if (toplevel_under_pointer
642 && WINDOW_IS_TOPLEVEL (toplevel_under_pointer))
644 GdkWindowImplQuartz *toplevel_impl;
646 toplevel = toplevel_under_pointer;
648 toplevel_impl = (GdkWindowImplQuartz *)toplevel->impl;
650 if ([toplevel_impl->toplevel showsResizeIndicator])
654 /* If the resize indicator is visible and the event
655 * is in the lower right 15x15 corner, we leave these
656 * events to Cocoa as to be handled as resize events.
657 * Applications may have widgets in this area. These
658 * will most likely be larger than 15x15 and for
659 * scroll bars there are also other means to move
660 * the scroll bar. Since the resize indicator is
661 * the only way of resizing windows on Mac OS, it
662 * is too important to not make functional.
664 frame = [toplevel_impl->view bounds];
665 if (x_tmp > frame.size.width - GRIP_WIDTH
666 && x_tmp < frame.size.width
667 && y_tmp > frame.size.height - GRIP_HEIGHT
668 && y_tmp < frame.size.height)
684 /* This function finds the correct window to send an event to, taking
685 * into account grabs, event propagation, and event masks.
688 find_window_for_ns_event (NSEvent *nsevent,
696 NSPoint screen_point;
697 NSEventType event_type;
700 view = (GdkQuartzView *)[[nsevent window] contentView];
701 toplevel = [view gdkWindow];
703 point = [nsevent locationInWindow];
704 screen_point = [[nsevent window] convertBaseToScreen:point];
707 *y = toplevel->height - point.y;
709 _gdk_quartz_window_nspoint_to_gdk_xy (screen_point, x_root, y_root);
711 event_type = [nsevent type];
715 case NSLeftMouseDown:
716 case NSRightMouseDown:
717 case NSOtherMouseDown:
723 case NSLeftMouseDragged:
724 case NSRightMouseDragged:
725 case NSOtherMouseDragged:
726 return find_toplevel_for_mouse_event (nsevent, x, y);
730 /* Only handle our own entered/exited events, not the ones for the
733 if ([view trackingRect] == [nsevent trackingNumber])
741 return find_toplevel_for_keyboard_event (nsevent);
744 /* Ignore everything else. */
752 fill_crossing_event (GdkWindow *toplevel,
759 GdkEventType event_type,
760 GdkCrossingMode mode,
761 GdkNotifyType detail)
763 event->any.type = event_type;
764 event->crossing.window = toplevel;
765 event->crossing.subwindow = NULL;
766 event->crossing.time = get_time_from_ns_event (nsevent);
767 event->crossing.x = x;
768 event->crossing.y = y;
769 event->crossing.x_root = x_root;
770 event->crossing.y_root = y_root;
771 event->crossing.mode = mode;
772 event->crossing.detail = detail;
773 event->crossing.state = get_keyboard_modifiers_from_ns_event (nsevent);
775 gdk_event_set_device (event, _gdk_display->core_pointer);
777 /* FIXME: Focus and button state? */
781 fill_button_event (GdkWindow *window,
793 state = get_keyboard_modifiers_from_ns_event (nsevent);
795 switch ([nsevent type])
797 case NSLeftMouseDown:
798 case NSRightMouseDown:
799 case NSOtherMouseDown:
800 type = GDK_BUTTON_PRESS;
805 type = GDK_BUTTON_RELEASE;
806 state |= get_mouse_button_modifiers_from_ns_event (nsevent);
809 g_assert_not_reached ();
812 button = get_mouse_button_from_ns_event (nsevent);
814 event->any.type = type;
815 event->button.window = window;
816 event->button.time = get_time_from_ns_event (nsevent);
819 event->button.x_root = x_root;
820 event->button.y_root = y_root;
821 /* FIXME event->axes */
822 event->button.state = state;
823 event->button.button = button;
824 event->button.device = _gdk_display->core_pointer;
828 fill_motion_event (GdkWindow *window,
836 GdkModifierType state;
838 state = get_keyboard_modifiers_from_ns_event (nsevent);
840 switch ([nsevent type])
842 case NSLeftMouseDragged:
843 case NSRightMouseDragged:
844 case NSOtherMouseDragged:
845 state |= get_mouse_button_modifiers_from_ns_event (nsevent);
852 event->any.type = GDK_MOTION_NOTIFY;
853 event->motion.window = window;
854 event->motion.time = get_time_from_ns_event (nsevent);
857 event->motion.x_root = x_root;
858 event->motion.y_root = y_root;
859 /* FIXME event->axes */
860 event->motion.state = state;
861 event->motion.is_hint = FALSE;
862 event->motion.device = _gdk_display->core_pointer;
866 fill_scroll_event (GdkWindow *window,
873 GdkScrollDirection direction)
877 point = [nsevent locationInWindow];
879 event->any.type = GDK_SCROLL;
880 event->scroll.window = window;
881 event->scroll.time = get_time_from_ns_event (nsevent);
884 event->scroll.x_root = x_root;
885 event->scroll.y_root = y_root;
886 event->scroll.state = get_keyboard_modifiers_from_ns_event (nsevent);
887 event->scroll.direction = direction;
888 event->scroll.device = _gdk_display->core_pointer;
892 fill_key_event (GdkWindow *window,
897 GdkEventPrivate *priv;
898 GdkQuartzDeviceManagerCore *device_manager;
902 priv = (GdkEventPrivate *) event;
903 priv->windowing_data = [nsevent retain];
905 event->any.type = type;
906 event->key.window = window;
907 event->key.time = get_time_from_ns_event (nsevent);
908 event->key.state = get_keyboard_modifiers_from_ns_event (nsevent);
909 event->key.hardware_keycode = [nsevent keyCode];
910 event->key.group = ([nsevent modifierFlags] & NSAlternateKeyMask) ? 1 : 0;
911 event->key.keyval = GDK_KEY_VoidSymbol;
913 device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
914 gdk_event_set_device (event, device_manager->core_keyboard);
916 gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (_gdk_display),
917 event->key.hardware_keycode,
923 event->key.is_modifier = _gdk_quartz_keys_is_modifier (event->key.hardware_keycode);
925 /* If the key press is a modifier, the state should include the mask
926 * for that modifier but only for releases, not presses. This
927 * matches the X11 backend behavior.
929 if (event->key.is_modifier)
933 switch (event->key.keyval)
937 mask = GDK_MOD1_MASK;
939 case GDK_KEY_Shift_R:
940 case GDK_KEY_Shift_L:
941 mask = GDK_SHIFT_MASK;
943 case GDK_KEY_Caps_Lock:
944 mask = GDK_LOCK_MASK;
948 mask = GDK_MOD5_MASK;
950 case GDK_KEY_Control_R:
951 case GDK_KEY_Control_L:
952 mask = GDK_CONTROL_MASK;
958 if (type == GDK_KEY_PRESS)
959 event->key.state &= ~mask;
960 else if (type == GDK_KEY_RELEASE)
961 event->key.state |= mask;
964 event->key.state |= current_button_state;
966 event->key.string = NULL;
968 /* Fill in ->string since apps depend on it, taken from the x11 backend. */
969 if (event->key.keyval != GDK_KEY_VoidSymbol)
970 c = gdk_keyval_to_unicode (event->key.keyval);
977 len = g_unichar_to_utf8 (c, buf);
980 event->key.string = g_locale_from_utf8 (buf, len,
981 NULL, &bytes_written,
983 if (event->key.string)
984 event->key.length = bytes_written;
986 else if (event->key.keyval == GDK_KEY_Escape)
988 event->key.length = 1;
989 event->key.string = g_strdup ("\033");
991 else if (event->key.keyval == GDK_KEY_Return ||
992 event->key.keyval == GDK_KEY_KP_Enter)
994 event->key.length = 1;
995 event->key.string = g_strdup ("\r");
998 if (!event->key.string)
1000 event->key.length = 0;
1001 event->key.string = g_strdup ("");
1005 g_message ("key %s:\t\twindow: %p key: %12s %d",
1006 type == GDK_KEY_PRESS ? "press" : "release",
1008 event->key.keyval ? gdk_keyval_name (event->key.keyval) : "(none)",
1009 event->key.keyval));
1013 synthesize_crossing_event (GdkWindow *window,
1021 switch ([nsevent type])
1023 case NSMouseEntered:
1024 /* Enter events are considered always to be from the root window as we
1025 * can't know for sure from what window we enter.
1027 if (!(window->event_mask & GDK_ENTER_NOTIFY_MASK))
1030 fill_crossing_event (window, event, nsevent,
1034 GDK_CROSSING_NORMAL,
1035 GDK_NOTIFY_ANCESTOR);
1039 /* Exited always is to the root window as far as we are concerned,
1040 * since there is no way to reliably get information about what new
1041 * window is entered when exiting one.
1043 if (!(window->event_mask & GDK_LEAVE_NOTIFY_MASK))
1046 fill_crossing_event (window, event, nsevent,
1050 GDK_CROSSING_NORMAL,
1051 GDK_NOTIFY_ANCESTOR);
1062 _gdk_quartz_events_get_current_event_mask (void)
1064 return current_event_mask;
1068 gdk_event_translate (GdkEvent *event,
1071 NSEventType event_type;
1076 gboolean return_val;
1078 /* There is no support for real desktop wide grabs, so we break
1079 * grabs when the application loses focus (gets deactivated).
1081 event_type = [nsevent type];
1082 if (event_type == NSAppKitDefined)
1084 if ([nsevent subtype] == NSApplicationDeactivatedEventType)
1085 break_all_grabs (get_time_from_ns_event (nsevent));
1087 /* This could potentially be used to break grabs when clicking
1088 * on the title. The subtype 20 is undocumented so it's probably
1089 * not a good idea: else if (subtype == 20) break_all_grabs ();
1092 /* Leave all AppKit events to AppKit. */
1096 /* Keep track of button state, since we don't get that information
1101 case NSLeftMouseDown:
1102 case NSRightMouseDown:
1103 case NSOtherMouseDown:
1104 current_button_state |= get_mouse_button_modifiers_from_ns_event (nsevent);
1107 case NSRightMouseUp:
1108 case NSOtherMouseUp:
1109 current_button_state &= ~get_mouse_button_modifiers_from_ns_event (nsevent);
1115 if (_gdk_default_filters)
1117 /* Apply global filters */
1118 GdkFilterReturn result;
1120 result = gdk_event_apply_filters (nsevent, event, &_gdk_default_filters);
1121 if (result != GDK_FILTER_CONTINUE)
1123 return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
1128 nswindow = [nsevent window];
1130 /* Ignore events for no window or ones not created by GDK. */
1131 if (!nswindow || ![[nswindow contentView] isKindOfClass:[GdkQuartzView class]])
1134 /* Ignore events and break grabs while the window is being
1135 * dragged. This is a workaround for the window getting events for
1138 if ([(GdkQuartzNSWindow *)nswindow isInMove])
1140 break_all_grabs (get_time_from_ns_event (nsevent));
1144 /* Find the right GDK window to send the event to, taking grabs and
1145 * event masks into consideration.
1147 window = find_window_for_ns_event (nsevent, &x, &y, &x_root, &y_root);
1151 /* Apply any window filters. */
1152 if (GDK_IS_WINDOW (window))
1154 GdkFilterReturn result;
1156 if (window->filters)
1158 g_object_ref (window);
1160 result = gdk_event_apply_filters (nsevent, event, &window->filters);
1162 g_object_unref (window);
1164 if (result != GDK_FILTER_CONTINUE)
1166 return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
1172 /* If the app is not active leave the event to AppKit so the window gets
1173 * focused correctly and don't do click-through (so we behave like most
1174 * native apps). If the app is active, we focus the window and then handle
1175 * the event, also to match native apps.
1177 if ((event_type == NSRightMouseDown ||
1178 event_type == NSOtherMouseDown ||
1179 event_type == NSLeftMouseDown))
1181 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
1183 if (![NSApp isActive])
1185 [NSApp activateIgnoringOtherApps:YES];
1188 else if (![impl->toplevel isKeyWindow])
1190 GdkDeviceGrabInfo *grab;
1192 grab = _gdk_display_get_last_device_grab (_gdk_display,
1193 _gdk_display->core_pointer);
1195 [impl->toplevel makeKeyWindow];
1199 current_event_mask = get_event_mask_from_ns_event (nsevent);
1205 case NSLeftMouseDown:
1206 case NSRightMouseDown:
1207 case NSOtherMouseDown:
1209 case NSRightMouseUp:
1210 case NSOtherMouseUp:
1211 fill_button_event (window, event, nsevent, x, y, x_root, y_root);
1214 case NSLeftMouseDragged:
1215 case NSRightMouseDragged:
1216 case NSOtherMouseDragged:
1218 fill_motion_event (window, event, nsevent, x, y, x_root, y_root);
1223 float dx = [nsevent deltaX];
1224 float dy = [nsevent deltaY];
1225 GdkScrollDirection direction;
1230 direction = GDK_SCROLL_DOWN;
1232 direction = GDK_SCROLL_UP;
1234 fill_scroll_event (window, event, nsevent, x, y, x_root, y_root, direction);
1240 direction = GDK_SCROLL_RIGHT;
1242 direction = GDK_SCROLL_LEFT;
1244 fill_scroll_event (window, event, nsevent, x, y, x_root, y_root, direction);
1249 case NSMouseEntered:
1251 return_val = synthesize_crossing_event (window, event, nsevent, x, y, x_root, y_root);
1256 case NSFlagsChanged:
1260 type = _gdk_quartz_keys_event_type (nsevent);
1261 if (type == GDK_NOTHING)
1264 fill_key_event (window, event, nsevent, type);
1269 /* Ignore everything elsee. */
1277 if (event->any.window)
1278 g_object_ref (event->any.window);
1279 if (((event->any.type == GDK_ENTER_NOTIFY) ||
1280 (event->any.type == GDK_LEAVE_NOTIFY)) &&
1281 (event->crossing.subwindow != NULL))
1282 g_object_ref (event->crossing.subwindow);
1286 /* Mark this event as having no resources to be freed */
1287 event->any.window = NULL;
1288 event->any.type = GDK_NOTHING;
1295 _gdk_quartz_display_queue_events (GdkDisplay *display)
1299 nsevent = _gdk_quartz_event_loop_get_pending ();
1305 event = gdk_event_new (GDK_NOTHING);
1307 event->any.window = NULL;
1308 event->any.send_event = FALSE;
1310 ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;
1312 node = _gdk_event_queue_append (display, event);
1314 if (gdk_event_translate (event, nsevent))
1316 ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;
1317 _gdk_windowing_got_event (display, node, event, 0);
1321 _gdk_event_queue_remove_link (display, node);
1322 g_list_free_1 (node);
1323 gdk_event_free (event);
1325 GDK_THREADS_LEAVE ();
1326 [NSApp sendEvent:nsevent];
1327 GDK_THREADS_ENTER ();
1330 _gdk_quartz_event_loop_release_event (nsevent);
1335 _gdk_quartz_display_add_client_message_filter (GdkDisplay *display,
1336 GdkAtom message_type,
1340 /* Not supported. */
1345 _gdk_quartz_display_send_client_message (GdkDisplay *display,
1347 GdkNativeWindow winid)
1349 /* Not supported. */
1354 _gdk_quartz_screen_broadcast_client_message (GdkScreen *screen,
1357 /* Not supported. */
1361 _gdk_quartz_screen_get_setting (GdkScreen *screen,
1365 if (strcmp (name, "gtk-double-click-time") == 0)
1367 NSUserDefaults *defaults;
1370 GDK_QUARTZ_ALLOC_POOL;
1372 defaults = [NSUserDefaults standardUserDefaults];
1374 t = [defaults floatForKey:@"com.apple.mouse.doubleClickThreshold"];
1377 /* No user setting, use the default in OS X. */
1381 GDK_QUARTZ_RELEASE_POOL;
1383 g_value_set_int (value, t * 1000);
1387 else if (strcmp (name, "gtk-font-name") == 0)
1392 GDK_QUARTZ_ALLOC_POOL;
1394 name = [[NSFont systemFontOfSize:0] familyName];
1396 /* Let's try to use the "views" font size (12pt) by default. This is
1397 * used for lists/text/other "content" which is the largest parts of
1398 * apps, using the "regular control" size (13pt) looks a bit out of
1399 * place. We might have to tweak this.
1402 /* The size has to be hardcoded as there doesn't seem to be a way to
1403 * get the views font size programmatically.
1405 str = g_strdup_printf ("%s 12", [name UTF8String]);
1406 g_value_set_string (value, str);
1409 GDK_QUARTZ_RELEASE_POOL;
1414 /* FIXME: Add more settings */
1420 _gdk_quartz_display_event_data_copy (GdkDisplay *display,
1421 const GdkEvent *src,
1424 GdkEventPrivate *priv_src = (GdkEventPrivate *) src;
1425 GdkEventPrivate *priv_dst = (GdkEventPrivate *) dst;
1427 if (priv_src->windowing_data)
1429 priv_dst->windowing_data = priv_src->windowing_data;
1430 [(NSEvent *)priv_dst->windowing_data retain];
1435 _gdk_quartz_display_event_data_free (GdkDisplay *display,
1438 GdkEventPrivate *priv = (GdkEventPrivate *) event;
1440 if (priv->windowing_data)
1442 [(NSEvent *)priv->windowing_data release];
1443 priv->windowing_data = NULL;