*
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
* Copyright (C) 1998-2002 Tor Lillqvist
- * Copyright (C) 2005-2006 Imendio AB
+ * Copyright (C) 2005-2008 Imendio AB
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* Boston, MA 02111-1307, USA.
*/
-#include <config.h>
+#include "config.h"
#include <sys/types.h>
#include <sys/sysctl.h>
#include <pthread.h>
#include <unistd.h>
+#import <Cocoa/Cocoa.h>
#include <Carbon/Carbon.h>
#include "gdkscreen.h"
#include "gdkkeysyms.h"
-
#include "gdkprivate-quartz.h"
-/* This is the window the mouse is currently over */
-static GdkWindow *current_mouse_window;
-
/* This is the window corresponding to the key window */
-static GdkWindow *current_keyboard_window;
-
-/* This is the pointer grab window */
-GdkWindow *_gdk_quartz_pointer_grab_window;
-static gboolean pointer_grab_owner_events;
-static GdkEventMask pointer_grab_event_mask;
-static gboolean pointer_grab_implicit;
-
-/* This is the keyboard grab window */
-GdkWindow *_gdk_quartz_keyboard_grab_window;
-static gboolean keyboard_grab_owner_events;
-
-static void append_event (GdkEvent *event);
+static GdkWindow *current_keyboard_window;
+
+/* This is the event mask and button state from the last event */
+static GdkEventMask current_event_mask;
+static int current_button_state;
+
+static void get_child_coordinates_from_ancestor (GdkWindow *ancestor_window,
+ gint ancestor_x,
+ gint ancestor_y,
+ GdkWindow *child_window,
+ gint *child_x,
+ gint *child_y);
+static void get_ancestor_coordinates_from_child (GdkWindow *child_window,
+ gint child_x,
+ gint child_y,
+ GdkWindow *ancestor_window,
+ gint *ancestor_x,
+ gint *ancestor_y);
+static void get_converted_window_coordinates (GdkWindow *in_window,
+ gint in_x,
+ gint in_y,
+ GdkWindow *out_window,
+ gint *out_x,
+ gint *out_y);
+static void append_event (GdkEvent *event);
+
+NSEvent *
+gdk_quartz_event_get_nsevent (GdkEvent *event)
+{
+ /* FIXME: If the event here is unallocated, we crash. */
+ return ((GdkEventPrivate *) event)->windowing_data;
+}
-void
+void
_gdk_events_init (void)
{
_gdk_quartz_event_loop_init ();
- current_mouse_window = g_object_ref (_gdk_root);
current_keyboard_window = g_object_ref (_gdk_root);
}
gdk_events_pending (void)
{
return (_gdk_event_queue_find_first (_gdk_display) ||
- (_gdk_quartz_event_loop_get_current () != NULL));
+ (_gdk_quartz_event_loop_check_pending ()));
}
GdkEvent*
return NULL;
}
-static void
-generate_grab_broken_event (GdkWindow *window,
- gboolean keyboard,
- gboolean implicit,
- GdkWindow *grab_window)
-{
- if (!GDK_WINDOW_DESTROYED (window))
- {
- GdkEvent *event = gdk_event_new (GDK_GRAB_BROKEN);
-
- event->grab_broken.window = window;
- event->grab_broken.send_event = 0;
- event->grab_broken.keyboard = keyboard;
- event->grab_broken.implicit = implicit;
- event->grab_broken.grab_window = grab_window;
-
- append_event (event);
- }
-}
-
GdkGrabStatus
gdk_keyboard_grab (GdkWindow *window,
gint owner_events,
guint32 time)
{
+ GdkDisplay *display;
+ GdkWindow *toplevel;
+
g_return_val_if_fail (window != NULL, 0);
g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
- if (_gdk_quartz_keyboard_grab_window)
- {
- if (_gdk_quartz_keyboard_grab_window != window)
- generate_grab_broken_event (_gdk_quartz_keyboard_grab_window,
- TRUE, FALSE, window);
-
- g_object_unref (_gdk_quartz_keyboard_grab_window);
- }
+ display = gdk_drawable_get_display (window);
+ toplevel = gdk_window_get_toplevel (window);
- _gdk_quartz_keyboard_grab_window = g_object_ref (window);
- keyboard_grab_owner_events = owner_events;
+ _gdk_display_set_has_keyboard_grab (display,
+ window,
+ toplevel,
+ owner_events,
+ 0,
+ time);
return GDK_GRAB_SUCCESS;
}
gdk_display_keyboard_ungrab (GdkDisplay *display,
guint32 time)
{
- if (_gdk_quartz_keyboard_grab_window)
- g_object_unref (_gdk_quartz_keyboard_grab_window);
- _gdk_quartz_keyboard_grab_window = NULL;
-}
-
-gboolean
-gdk_keyboard_grab_info_libgtk_only (GdkDisplay *display,
- GdkWindow **grab_window,
- gboolean *owner_events)
-{
- if (_gdk_quartz_keyboard_grab_window)
- {
- if (grab_window)
- *grab_window = _gdk_quartz_keyboard_grab_window;
- if (owner_events)
- *owner_events = keyboard_grab_owner_events;
-
- return TRUE;
- }
-
- return FALSE;
-}
-
-static void
-pointer_ungrab_internal (gboolean only_if_implicit)
-{
- if (!_gdk_quartz_pointer_grab_window)
- return;
-
- if (only_if_implicit && !pointer_grab_implicit)
- return;
-
- g_object_unref (_gdk_quartz_pointer_grab_window);
- _gdk_quartz_pointer_grab_window = NULL;
-
- /* FIXME: Send crossing events */
-}
-
-gboolean
-gdk_display_pointer_is_grabbed (GdkDisplay *display)
-{
- return _gdk_quartz_pointer_grab_window != NULL;
-}
-
-gboolean
-gdk_pointer_grab_info_libgtk_only (GdkDisplay *display,
- GdkWindow **grab_window,
- gboolean *owner_events)
-{
- if (!_gdk_quartz_pointer_grab_window)
- return FALSE;
-
- if (grab_window)
- *grab_window = _gdk_quartz_pointer_grab_window;
-
- if (owner_events)
- *owner_events = pointer_grab_owner_events;
-
- return FALSE;
+ _gdk_display_unset_has_keyboard_grab (display, FALSE);
}
void
gdk_display_pointer_ungrab (GdkDisplay *display,
guint32 time)
{
- pointer_ungrab_internal (FALSE);
-}
+ GdkPointerGrabInfo *grab;
-static GdkGrabStatus
-pointer_grab_internal (GdkWindow *window,
- gboolean owner_events,
- GdkEventMask event_mask,
- GdkWindow *confine_to,
- GdkCursor *cursor,
- gboolean implicit)
-{
- /* FIXME: Send crossing events */
-
- _gdk_quartz_pointer_grab_window = g_object_ref (window);
- pointer_grab_owner_events = owner_events;
- pointer_grab_event_mask = event_mask;
- pointer_grab_implicit = implicit;
+ grab = _gdk_display_get_last_pointer_grab (display);
+ if (grab)
+ grab->serial_end = 0;
- return GDK_GRAB_SUCCESS;
+ _gdk_display_pointer_grab_update (display, 0);
}
GdkGrabStatus
GdkCursor *cursor,
guint32 time)
{
+ GdkWindow *native;
+
g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
- if (_gdk_quartz_pointer_grab_window)
+ native = gdk_window_get_toplevel (window);
+
+ /* TODO: What do we do for offscreens and their children? We need to proxy the grab somehow */
+ if (!GDK_IS_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (native)->impl))
+ return GDK_GRAB_SUCCESS;
+
+ if (!_gdk_window_has_impl (window) &&
+ !gdk_window_is_viewable (window))
+ return GDK_GRAB_NOT_VIEWABLE;
+
+ _gdk_display_add_pointer_grab (_gdk_display,
+ window,
+ native,
+ owner_events,
+ event_mask,
+ 0,
+ time,
+ FALSE);
+
+ return GDK_GRAB_SUCCESS;
+}
+
+static void
+break_all_grabs (guint32 time)
+{
+ GdkPointerGrabInfo *grab;
+
+ if (_gdk_display->keyboard_grab.window)
+ _gdk_display_unset_has_keyboard_grab (_gdk_display, FALSE);
+
+ grab = _gdk_display_get_last_pointer_grab (_gdk_display);
+ if (grab)
{
- if (_gdk_quartz_pointer_grab_window == window && !pointer_grab_implicit)
- return GDK_GRAB_ALREADY_GRABBED;
- else
- {
- if (_gdk_quartz_pointer_grab_window != window)
- generate_grab_broken_event (_gdk_quartz_pointer_grab_window,
- FALSE, pointer_grab_implicit, window);
- pointer_ungrab_internal (TRUE);
- }
+ grab->serial_end = 0;
+ grab->implicit_ungrab = TRUE;
}
- return pointer_grab_internal (window, owner_events, event_mask,
- confine_to, cursor, FALSE);
+ _gdk_display_pointer_grab_update (_gdk_display, 0);
}
static void
_gdk_event_queue_append (_gdk_display, event);
}
-static GdkFilterReturn
-apply_filters (GdkWindow *window,
- NSEvent *nsevent,
- GList *filters)
+static gint
+gdk_event_apply_filters (NSEvent *nsevent,
+ GdkEvent *event,
+ GList *filters)
{
- GdkFilterReturn result = GDK_FILTER_CONTINUE;
- GdkEvent *event;
- GList *node;
GList *tmp_list;
-
- event = gdk_event_new (GDK_NOTHING);
- if (window != NULL)
- event->any.window = g_object_ref (window);
- ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;
-
- /* I think GdkFilterFunc semantics require the passed-in event
- * to already be in the queue. The filter func can generate
- * more events and append them after it if it likes.
- */
- node = _gdk_event_queue_append (_gdk_display, event);
+ GdkFilterReturn result;
tmp_list = filters;
+
while (tmp_list)
{
- GdkEventFilter *filter = (GdkEventFilter *) tmp_list->data;
+ GdkEventFilter *filter = (GdkEventFilter*) tmp_list->data;
tmp_list = tmp_list->next;
result = filter->function (nsevent, event, filter->data);
- if (result != GDK_FILTER_CONTINUE)
- break;
- }
-
- if (result == GDK_FILTER_CONTINUE || result == GDK_FILTER_REMOVE)
- {
- _gdk_event_queue_remove_link (_gdk_display, node);
- g_list_free_1 (node);
- gdk_event_free (event);
- }
- else /* GDK_FILTER_TRANSLATE */
- {
- ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;
- fixup_event (event);
- }
- return result;
-}
-
-/* This function checks if the passed in window is interested in the
- * event mask. If so, it's returned. If not, the event can be propagated
- * to its parent.
- */
-static GdkWindow *
-find_window_interested_in_event_mask (GdkWindow *window,
- GdkEventMask event_mask,
- gboolean propagate)
-{
- while (window)
- {
- GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
-
- if (private->event_mask & event_mask)
- return window;
-
- if (!propagate)
- return NULL;
- else
- window = GDK_WINDOW (private->parent);
+ if (result != GDK_FILTER_CONTINUE)
+ return result;
}
- return NULL;
+ return GDK_FILTER_CONTINUE;
}
static guint32
-get_event_time (NSEvent *event)
+get_time_from_ns_event (NSEvent *event)
{
double time = [event timestamp];
}
static int
-convert_mouse_button_number (int button)
+get_mouse_button_from_ns_event (NSEvent *event)
{
+ int button;
+
+ button = [event buttonNumber];
+
switch (button)
{
case 0:
}
}
+static GdkModifierType
+get_mouse_button_modifiers_from_ns_event (NSEvent *event)
+{
+ int button;
+ GdkModifierType state = 0;
+
+ /* This maps buttons 1 to 5 to GDK_BUTTON[1-5]_MASK */
+ button = get_mouse_button_from_ns_event (event);
+ if (button >= 1 && button <= 5)
+ state = (1 << (button + 7));
+
+ return state;
+}
+
+static GdkModifierType
+get_keyboard_modifiers_from_ns_event (NSEvent *nsevent)
+{
+ GdkModifierType modifiers = 0;
+ int nsflags;
+
+ nsflags = [nsevent modifierFlags];
+
+ if (nsflags & NSAlphaShiftKeyMask)
+ modifiers |= GDK_LOCK_MASK;
+ if (nsflags & NSShiftKeyMask)
+ modifiers |= GDK_SHIFT_MASK;
+ if (nsflags & NSControlKeyMask)
+ modifiers |= GDK_CONTROL_MASK;
+ if (nsflags & NSCommandKeyMask)
+ modifiers |= GDK_MOD1_MASK;
+
+ return modifiers;
+}
+
/* Return an event mask from an NSEvent */
static GdkEventMask
get_event_mask_from_ns_event (NSEvent *nsevent)
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK);
- if (convert_mouse_button_number ([nsevent buttonNumber]) == 2)
+ if (get_mouse_button_from_ns_event (nsevent) == 2)
mask |= (GDK_BUTTON2_MOTION_MASK | GDK_BUTTON2_MOTION_MASK |
GDK_BUTTON2_MASK);
g_assert_not_reached ();
}
}
+ break;
+
+ case NSMouseEntered:
+ return GDK_ENTER_NOTIFY_MASK;
+
+ case NSMouseExited:
+ return GDK_LEAVE_NOTIFY_MASK;
+
default:
g_assert_not_reached ();
}
if (!got_focus && window == current_keyboard_window)
{
- event = create_focus_event (current_keyboard_window, FALSE);
- append_event (event);
- g_object_unref (current_keyboard_window);
- current_keyboard_window = NULL;
+ event = create_focus_event (current_keyboard_window, FALSE);
+ append_event (event);
+ g_object_unref (current_keyboard_window);
+ current_keyboard_window = NULL;
}
if (got_focus)
}
}
-static gboolean
-gdk_window_is_ancestor (GdkWindow *ancestor,
- GdkWindow *window)
+void
+_gdk_quartz_events_send_map_event (GdkWindow *window)
{
- if (ancestor == NULL || window == NULL)
- return FALSE;
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
- return (gdk_window_get_parent (window) == ancestor ||
- gdk_window_is_ancestor (ancestor, gdk_window_get_parent (window)));
-}
+ if (!impl->toplevel)
+ return;
-static GdkModifierType
-get_keyboard_modifiers_from_nsevent (NSEvent *nsevent)
-{
- GdkModifierType modifiers = 0;
- int nsflags;
+ if (private->event_mask & GDK_STRUCTURE_MASK)
+ {
+ GdkEvent event;
- nsflags = [nsevent modifierFlags];
+ event.any.type = GDK_MAP;
+ event.any.window = window;
- if (nsflags & NSAlphaShiftKeyMask)
- modifiers |= GDK_LOCK_MASK;
- if (nsflags & NSShiftKeyMask)
- modifiers |= GDK_SHIFT_MASK;
- if (nsflags & NSControlKeyMask)
- modifiers |= GDK_CONTROL_MASK;
- if (nsflags & NSCommandKeyMask)
- modifiers |= GDK_MOD1_MASK;
-
- /* FIXME: Support GDK_BUTTON_MASK */
-
- return modifiers;
+ gdk_event_put (&event);
+ }
}
+/* Translates coordinates from an ancestor window + coords, to
+ * coordinates that are relative the child window.
+ */
static void
-convert_window_coordinates_to_root (GdkWindow *window,
- gdouble x,
- gdouble y,
- gdouble *x_root,
- gdouble *y_root)
+get_child_coordinates_from_ancestor (GdkWindow *ancestor_window,
+ gint ancestor_x,
+ gint ancestor_y,
+ GdkWindow *child_window,
+ gint *child_x,
+ gint *child_y)
{
- gint ox, oy;
+ GdkWindowObject *ancestor_private = GDK_WINDOW_OBJECT (ancestor_window);
+ GdkWindowObject *child_private = GDK_WINDOW_OBJECT (child_window);
- *x_root = x;
- *y_root = y;
-
- if (gdk_window_get_origin (window, &ox, &oy))
+ while (child_private != ancestor_private)
{
- *x_root += ox;
- *y_root += oy;
- }
-}
-
-static GdkEvent *
-create_crossing_event (GdkWindow *window,
- NSEvent *nsevent,
- GdkEventType event_type,
- GdkCrossingMode mode,
- GdkNotifyType detail)
-{
- GdkEvent *event;
- NSPoint point;
-
- event = gdk_event_new (event_type);
-
- event->crossing.window = window;
- event->crossing.subwindow = NULL; /* FIXME */
- event->crossing.time = get_event_time (nsevent);
+ ancestor_x -= child_private->x;
+ ancestor_y -= child_private->y;
- point = [nsevent locationInWindow];
- event->crossing.x = point.x;
- event->crossing.y = point.y;
- convert_window_coordinates_to_root (window, event->crossing.x, event->crossing.y,
- &event->crossing.x_root,
- &event->crossing.y_root);
-
- event->crossing.mode = mode;
- event->crossing.detail = detail;
- /* FIXME: focus */
- /* FIXME: state, (button state too) */
+ child_private = child_private->parent;
+ }
- return event;
+ *child_x = ancestor_x;
+ *child_y = ancestor_y;
}
+/* Translates coordinates from a child window + coords, to
+ * coordinates that are relative the ancestor window.
+ */
static void
-synthesize_enter_event (GdkWindow *window,
- NSEvent *nsevent,
- GdkCrossingMode mode,
- GdkNotifyType detail)
+get_ancestor_coordinates_from_child (GdkWindow *child_window,
+ gint child_x,
+ gint child_y,
+ GdkWindow *ancestor_window,
+ gint *ancestor_x,
+ gint *ancestor_y)
{
- GdkEvent *event;
-
- if (_gdk_quartz_pointer_grab_window != NULL &&
- !pointer_grab_owner_events &&
- !(pointer_grab_event_mask & GDK_ENTER_NOTIFY_MASK))
- return;
-
- if (!(GDK_WINDOW_OBJECT (window)->event_mask & GDK_ENTER_NOTIFY_MASK))
- return;
+ GdkWindowObject *child_private = GDK_WINDOW_OBJECT (child_window);
+ GdkWindowObject *ancestor_private = GDK_WINDOW_OBJECT (ancestor_window);
- event = create_crossing_event (window, nsevent, GDK_ENTER_NOTIFY,
- mode, detail);
+ while (child_private != ancestor_private)
+ {
+ child_x += child_private->x;
+ child_y += child_private->y;
- append_event (event);
-}
-
-static void
-synthesize_enter_events (GdkWindow *from,
- GdkWindow *to,
- NSEvent *nsevent,
- GdkCrossingMode mode,
- GdkNotifyType detail)
-{
- GdkWindow *prev = gdk_window_get_parent (to);
+ child_private = child_private->parent;
+ }
- if (prev != from)
- synthesize_enter_events (from, prev, nsevent, mode, detail);
- synthesize_enter_event (to, nsevent, mode, detail);
+ *ancestor_x = child_x;
+ *ancestor_y = child_y;
}
+/* Translates coordinates relative to one window (in_window) into
+ * coordinates relative to another window (out_window).
+ */
static void
-synthesize_leave_event (GdkWindow *window,
- NSEvent *nsevent,
- GdkCrossingMode mode,
- GdkNotifyType detail)
-{
- GdkEvent *event;
-
- if (_gdk_quartz_pointer_grab_window != NULL &&
- !pointer_grab_owner_events &&
- !(pointer_grab_event_mask & GDK_LEAVE_NOTIFY_MASK))
- return;
-
- if (!(GDK_WINDOW_OBJECT (window)->event_mask & GDK_LEAVE_NOTIFY_MASK))
- return;
-
- event = create_crossing_event (window, nsevent, GDK_LEAVE_NOTIFY,
- mode, detail);
-
- append_event (event);
-}
-
-static void
-synthesize_leave_events (GdkWindow *from,
- GdkWindow *to,
- NSEvent *nsevent,
- GdkCrossingMode mode,
- GdkNotifyType detail)
-{
- GdkWindow *next = gdk_window_get_parent (from);
-
- synthesize_leave_event (from, nsevent, mode, detail);
- if (next != to)
- synthesize_leave_events (next, to, nsevent, mode, detail);
-}
-
-static void
-synthesize_crossing_events (GdkWindow *window,
- GdkCrossingMode mode,
- NSEvent *nsevent,
- gint x,
- gint y)
+get_converted_window_coordinates (GdkWindow *in_window,
+ gint in_x,
+ gint in_y,
+ GdkWindow *out_window,
+ gint *out_x,
+ gint *out_y)
{
- GdkWindow *intermediate, *tem, *common_ancestor;
+ GdkWindow *in_toplevel;
+ GdkWindow *out_toplevel;
+ int in_origin_x, in_origin_y;
+ int out_origin_x, out_origin_y;
- if (gdk_window_is_ancestor (current_mouse_window, window))
+ if (in_window == out_window)
{
- /* Pointer has moved to an inferior window. */
- synthesize_leave_event (current_mouse_window, nsevent, mode, GDK_NOTIFY_INFERIOR);
-
- /* If there are intermediate windows, generate ENTER_NOTIFY
- * events for them
- */
- intermediate = gdk_window_get_parent (window);
-
- if (intermediate != current_mouse_window)
- {
- synthesize_enter_events (current_mouse_window, intermediate, nsevent, mode, GDK_NOTIFY_VIRTUAL);
- }
-
- synthesize_enter_event (window, nsevent, mode, GDK_NOTIFY_ANCESTOR);
+ *out_x = in_x;
+ *out_y = in_y;
+ return;
}
- else if (gdk_window_is_ancestor (window, current_mouse_window))
- {
- /* Pointer has moved to an ancestor window. */
- synthesize_leave_event (current_mouse_window, nsevent, mode, GDK_NOTIFY_ANCESTOR);
-
- /* If there are intermediate windows, generate LEAVE_NOTIFY
- * events for them
- */
- intermediate = gdk_window_get_parent (current_mouse_window);
- if (intermediate != window)
- {
- synthesize_leave_events (intermediate, window, nsevent, mode, GDK_NOTIFY_VIRTUAL);
- }
- synthesize_enter_event (window, nsevent, mode, GDK_NOTIFY_INFERIOR);
- }
- else if (current_mouse_window)
- {
- /* Find least common ancestor of current_mouse_window and window */
- tem = current_mouse_window;
- do {
- common_ancestor = gdk_window_get_parent (tem);
- tem = common_ancestor;
- } while (common_ancestor &&
- !gdk_window_is_ancestor (common_ancestor, window));
- if (common_ancestor)
- {
- synthesize_leave_event (current_mouse_window, nsevent, mode, GDK_NOTIFY_NONLINEAR);
- intermediate = gdk_window_get_parent (current_mouse_window);
- if (intermediate != common_ancestor)
- {
- synthesize_leave_events (intermediate, common_ancestor,
- nsevent, mode, GDK_NOTIFY_NONLINEAR_VIRTUAL);
- }
- intermediate = gdk_window_get_parent (window);
- if (intermediate != common_ancestor)
- {
- synthesize_enter_events (common_ancestor, intermediate,
- nsevent, mode, GDK_NOTIFY_NONLINEAR_VIRTUAL);
- }
- synthesize_enter_event (window, nsevent, mode, GDK_NOTIFY_NONLINEAR);
- }
- }
- else
- {
- /* This means we have not current_mouse_window. FIXME: Should
- * we make sure to always set the root window instead of NULL?
- */
+ /* First translate to "in" toplevel coordinates, then on to "out"
+ * toplevel coordinates, and finally to "out" child (the passed in
+ * window) coordinates.
+ */
- /* FIXME: Figure out why this is being called with window being
- * NULL. The check works around a crash for now.
- */
- if (window)
- synthesize_enter_event (window, nsevent, mode, GDK_NOTIFY_UNKNOWN);
- }
-
- _gdk_quartz_events_update_mouse_window (window);
-}
+ in_toplevel = gdk_window_get_toplevel (in_window);
+ out_toplevel = gdk_window_get_toplevel (out_window);
-void
-_gdk_quartz_events_send_map_events (GdkWindow *window)
-{
- GList *list;
- GdkWindow *interested_window;
- GdkWindowObject *private = (GdkWindowObject *)window;
+ /* Translate in_x, in_y to "in" toplevel coordinates. */
+ get_ancestor_coordinates_from_child (in_window, in_x, in_y,
+ in_toplevel, &in_x, &in_y);
- interested_window = find_window_interested_in_event_mask (window,
- GDK_STRUCTURE_MASK,
- TRUE);
-
- if (interested_window)
- {
- GdkEvent *event = gdk_event_new (GDK_MAP);
- event->any.window = interested_window;
- append_event (event);
- }
+ gdk_window_get_origin (in_toplevel, &in_origin_x, &in_origin_y);
+ gdk_window_get_origin (out_toplevel, &out_origin_x, &out_origin_y);
- for (list = private->children; list != NULL; list = list->next)
- _gdk_quartz_events_send_map_events ((GdkWindow *)list->data);
-}
+ /* Translate in_x, in_y to "out" toplevel coordinates. */
+ in_x -= out_origin_x - in_origin_x;
+ in_y -= out_origin_y - in_origin_y;
-/* Get current mouse window */
-GdkWindow *
-_gdk_quartz_events_get_mouse_window (void)
-{
- if (_gdk_quartz_pointer_grab_window && !pointer_grab_owner_events)
- return _gdk_quartz_pointer_grab_window;
-
- return current_mouse_window;
+ get_child_coordinates_from_ancestor (out_toplevel,
+ in_x, in_y,
+ out_window,
+ out_x, out_y);
}
-/* Update mouse window */
-void
-_gdk_quartz_events_update_mouse_window (GdkWindow *window)
+/* Trigger crossing events if necessary. This is used when showing a new
+ * window, since the tracking rect API doesn't work reliably when a window
+ * shows up under the mouse cursor. It's done by finding the topmost window
+ * under the mouse pointer and synthesizing crossing events into that
+ * window.
+ */
+void
+_gdk_quartz_events_trigger_crossing_events (gboolean defer_to_mainloop)
{
- if (window)
- g_object_ref (window);
- if (current_mouse_window)
- g_object_unref (current_mouse_window);
+ NSPoint point;
+ gint x, y;
+ gint x_toplevel, y_toplevel;
+ GdkWindow *mouse_window;
+ GdkWindow *toplevel;
+ GdkWindowImplQuartz *impl;
+ GdkWindowObject *private;
+ guint flags = 0;
+ NSTimeInterval timestamp = 0;
+ NSEvent *current_event;
+ NSEvent *nsevent;
+
+ if (defer_to_mainloop)
+ {
+ nsevent = [NSEvent otherEventWithType:NSApplicationDefined
+ location:NSZeroPoint
+ modifierFlags:0
+ timestamp:0
+ windowNumber:0
+ context:nil
+ subtype:GDK_QUARTZ_EVENT_SUBTYPE_FAKE_CROSSING
+ data1:0
+ data2:0];
+ [NSApp postEvent:nsevent atStart:NO];
+ return;
+ }
- current_mouse_window = window;
-}
+ point = [NSEvent mouseLocation];
+ x = point.x;
+ y = _gdk_quartz_window_get_inverted_screen_y (point.y);
-/* Update current cursor */
-void
-_gdk_quartz_events_update_cursor (GdkWindow *window)
-{
- GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
- NSCursor *nscursor = nil;
+ mouse_window = _gdk_quartz_window_find_child (_gdk_root, x, y);
+ if (!mouse_window || mouse_window == _gdk_root)
+ return;
- while (private) {
- GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
+ toplevel = gdk_window_get_toplevel (mouse_window);
- nscursor = impl->nscursor;
- if (nscursor)
- break;
+ get_converted_window_coordinates (_gdk_root,
+ x, y,
+ toplevel,
+ &x_toplevel, &y_toplevel);
- private = private->parent;
- }
+ get_converted_window_coordinates (_gdk_root,
+ x, y,
+ mouse_window,
+ &x, &y);
- if (!nscursor)
- nscursor = [NSCursor arrowCursor];
+ /* Fix up the event to be less fake if possible. */
+ current_event = [NSApp currentEvent];
+ if (current_event)
+ {
+ flags = [current_event modifierFlags];
+ timestamp = [current_event timestamp];
+ }
- if ([NSCursor currentCursor] != nscursor)
- [nscursor set];
+ if (timestamp == 0)
+ timestamp = GetCurrentEventTime ();
+
+ impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (toplevel)->impl);
+ private = GDK_WINDOW_OBJECT (toplevel);
+ nsevent = [NSEvent otherEventWithType:NSApplicationDefined
+ location:NSMakePoint (x_toplevel, private->height - y_toplevel)
+ modifierFlags:flags
+ timestamp:timestamp
+ windowNumber:[impl->toplevel windowNumber]
+ context:nil
+ subtype:GDK_QUARTZ_EVENT_SUBTYPE_FAKE_CROSSING
+ data1:0
+ data2:0];
+
+#ifdef G_ENABLE_DEBUG
+ /*_gdk_quartz_window_debug_highlight (mouse_window, 0);*/
+#endif
+
+ /* FIXME: create an event, fill it, put on the queue... */
}
-/* This function finds the correct window to send an event to,
- * taking into account grabs (FIXME: not done yet), event propagation,
- * and event masks.
+/* This function finds the correct window to send an event to, taking
+ * into account grabs, event propagation, and event masks.
*/
static GdkWindow *
-find_window_for_event (NSEvent *nsevent, gint *x, gint *y)
+find_window_for_ns_event (NSEvent *nsevent,
+ gint *x,
+ gint *y,
+ gint *x_root,
+ gint *y_root)
{
- NSWindow *nswindow = [nsevent window];
- NSEventType event_type = [nsevent type];
-
- if (!nswindow)
- return NULL;
-
- /* Window where not created by GDK so the event should be handled by Quartz */
- if (![[nswindow contentView] isKindOfClass:[GdkQuartzView class]])
- return NULL;
-
- if (event_type == NSMouseMoved ||
- event_type == NSLeftMouseDragged ||
- event_type == NSRightMouseDragged ||
- event_type == NSOtherMouseDragged)
- {
- GdkWindow *toplevel = [(GdkQuartzView *)[nswindow contentView] gdkWindow];
- NSPoint point = [nsevent locationInWindow];
- GdkWindow *mouse_window;
+ GdkWindow *toplevel;
+ GdkWindowObject *private;
+ GdkWindowImplQuartz *impl;
+ NSPoint point;
+ NSPoint screen_point;
+ NSEventType event_type;
- mouse_window = _gdk_quartz_window_find_child_by_point (toplevel, point.x, point.y, x, y);
+ toplevel = [(GdkQuartzView *)[[nsevent window] contentView] gdkWindow];
+ private = GDK_WINDOW_OBJECT (toplevel);
+ impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
- if (!mouse_window)
- mouse_window = _gdk_root;
+ point = [nsevent locationInWindow];
+ screen_point = [[nsevent window] convertBaseToScreen:point];
- if (_gdk_quartz_pointer_grab_window)
- {
- if (mouse_window != current_mouse_window)
- synthesize_crossing_events (mouse_window, GDK_CROSSING_NORMAL, nsevent, *x, *y);
- }
- else
- {
- if (current_mouse_window != mouse_window)
- {
- synthesize_crossing_events (mouse_window, GDK_CROSSING_NORMAL, nsevent, *x, *y);
-
- _gdk_quartz_events_update_cursor (mouse_window);
- }
- }
- }
+ *x = point.x;
+ *y = private->height - point.y;
+
+ *x_root = screen_point.x;
+ *y_root = _gdk_quartz_window_get_inverted_screen_y (screen_point.y);
+
+ event_type = [nsevent type];
switch (event_type)
{
case NSRightMouseDragged:
case NSOtherMouseDragged:
{
- GdkWindow *toplevel = [(GdkQuartzView *)[nswindow contentView] gdkWindow];
- NSPoint point = [nsevent locationInWindow];
- GdkWindow *mouse_window;
- GdkEventMask event_mask;
- GdkWindow *real_window;
-
- if (_gdk_quartz_pointer_grab_window && !pointer_grab_owner_events)
+ GdkDisplay *display;
+ GdkPointerGrabInfo *grab;
+
+ display = gdk_drawable_get_display (toplevel);
+
+ /* From the docs for XGrabPointer:
+ *
+ * If owner_events is True and if a generated pointer event
+ * would normally be reported to this client, it is reported
+ * as usual. Otherwise, the event is reported with respect to
+ * the grab_window and is reported only if selected by
+ * event_mask. For either value of owner_events, unreported
+ * events are discarded.
+ *
+ * This means we first try the owner, then the grab window,
+ * then give up.
+ */
+ grab = _gdk_display_get_last_pointer_grab (display);
+ if (grab && grab->window)
{
- if (pointer_grab_event_mask & get_event_mask_from_ns_event (nsevent))
+ if (grab->owner_events)
+ return toplevel;
+
+ /* Finally check the grab window. */
+ if (grab->event_mask & get_event_mask_from_ns_event (nsevent))
{
- int tempx, tempy;
- GdkWindowObject *w;
- GdkWindowObject *grab_toplevel;
+ GdkWindow *grab_toplevel;
+ GdkWindowObject *grab_private;
+ NSPoint point;
+ NSWindow *grab_nswindow;
- w = GDK_WINDOW_OBJECT (_gdk_quartz_pointer_grab_window);
- grab_toplevel = GDK_WINDOW_OBJECT (gdk_window_get_toplevel (_gdk_quartz_pointer_grab_window));
+ grab_toplevel = gdk_window_get_toplevel (grab->window);
+ grab_private = (GdkWindowObject *)grab_toplevel;
- tempx = point.x;
- tempy = GDK_WINDOW_IMPL_QUARTZ (grab_toplevel->impl)->height -
- point.y;
+ point = [[nsevent window] convertBaseToScreen:[nsevent locationInWindow]];
- while (w != grab_toplevel)
- {
- tempx -= w->x;
- tempy -= w->y;
+ grab_nswindow = ((GdkWindowImplQuartz *)private->impl)->toplevel;
+ point = [grab_nswindow convertScreenToBase:point];
- w = w->parent;
- }
+ *x = point.x;
+ *y = grab_private->height - point.y;
- *x = tempx;
- *y = tempy;
+ /* Note: x_root and y_root are already right. */
- return _gdk_quartz_pointer_grab_window;
- }
- else
- {
- return NULL;
+ return grab_toplevel;
}
- }
- if (!nswindow)
- {
- mouse_window = _gdk_root;
+ return NULL;
}
- else
+ else
{
- mouse_window = _gdk_quartz_window_find_child_by_point (toplevel, point.x, point.y, x, y);
- }
+ /* The non-grabbed case. */
+
+ /* Leave events above the window (e.g. possibly on the titlebar)
+ * to cocoa.
+ */
+ if (*y < 0)
+ return NULL;
- event_mask = get_event_mask_from_ns_event (nsevent);
- real_window = find_window_interested_in_event_mask (mouse_window, event_mask, TRUE);
-
- return real_window;
+ /* FIXME: Also need to leave resize events to cocoa somehow? */
+
+ return toplevel;
+ }
}
break;
case NSMouseEntered:
- {
- NSPoint point;
- GdkWindow *toplevel;
- GdkWindow *mouse_window;
-
- point = [nsevent locationInWindow];
- toplevel = [(GdkQuartzView *)[nswindow contentView] gdkWindow];
-
- mouse_window = _gdk_quartz_window_find_child_by_point (toplevel, point.x, point.y, x, y);
-
- synthesize_crossing_events (mouse_window, GDK_CROSSING_NORMAL, nsevent, *x, *y);
- }
- break;
-
case NSMouseExited:
- synthesize_crossing_events (_gdk_root, GDK_CROSSING_NORMAL, nsevent, *x, *y);
- break;
+ return toplevel;
case NSKeyDown:
case NSKeyUp:
case NSFlagsChanged:
- {
- GdkEventMask event_mask;
+ if (_gdk_display->keyboard_grab.window && !_gdk_display->keyboard_grab.owner_events)
+ return gdk_window_get_toplevel (_gdk_display->keyboard_grab.window);
- if (_gdk_quartz_keyboard_grab_window && !keyboard_grab_owner_events)
- return _gdk_quartz_keyboard_grab_window;
-
- event_mask = get_event_mask_from_ns_event (nsevent);
- return find_window_interested_in_event_mask (current_keyboard_window, event_mask, TRUE);
- }
- break;
+ return toplevel;
- case NSAppKitDefined:
- case NSSystemDefined:
- /* We ignore these events */
- break;
default:
- NSLog(@"Unhandled event %@", nsevent);
+ /* Ignore everything else. */
+ break;
}
return NULL;
}
-static GdkEvent *
-create_button_event (GdkWindow *window, NSEvent *nsevent,
- gint x, gint y)
+static void
+fill_crossing_event (GdkWindow *toplevel,
+ GdkEvent *event,
+ NSEvent *nsevent,
+ gint x,
+ gint y,
+ gint x_root,
+ gint y_root,
+ GdkEventType event_type,
+ GdkCrossingMode mode,
+ GdkNotifyType detail)
+{
+ event->any.type = event_type;
+ event->crossing.window = toplevel;
+ event->crossing.subwindow = NULL;
+ event->crossing.time = get_time_from_ns_event (nsevent);
+ event->crossing.x = x;
+ event->crossing.y = y;
+ event->crossing.x_root = x_root;
+ event->crossing.y_root = y_root;
+ event->crossing.mode = mode;
+ event->crossing.detail = detail;
+ event->crossing.state = get_keyboard_modifiers_from_ns_event (nsevent);
+
+ /* FIXME: Focus and button state? */
+}
+
+static void
+fill_button_event (GdkWindow *window,
+ GdkEvent *event,
+ NSEvent *nsevent,
+ gint x,
+ gint y,
+ gint x_root,
+ gint y_root)
{
- GdkEvent *event;
GdkEventType type;
- guint button;
+ gint state;
+ gint button;
+
+ state = get_keyboard_modifiers_from_ns_event (nsevent);
switch ([nsevent type])
{
case NSRightMouseUp:
case NSOtherMouseUp:
type = GDK_BUTTON_RELEASE;
+ state |= get_mouse_button_modifiers_from_ns_event (nsevent);
break;
default:
g_assert_not_reached ();
}
- button = convert_mouse_button_number ([nsevent buttonNumber]);
+ button = get_mouse_button_from_ns_event (nsevent);
- event = gdk_event_new (type);
+ event->any.type = type;
event->button.window = window;
- event->button.time = get_event_time (nsevent);
+ event->button.time = get_time_from_ns_event (nsevent);
event->button.x = x;
event->button.y = y;
+ event->button.x_root = x_root;
+ event->button.y_root = y_root;
/* FIXME event->axes */
- event->button.state = get_keyboard_modifiers_from_nsevent (nsevent);
+ event->button.state = state;
event->button.button = button;
event->button.device = _gdk_display->core_pointer;
- convert_window_coordinates_to_root (window, x, y,
- &event->button.x_root,
- &event->button.y_root);
-
- return event;
}
-static GdkEvent *
-create_motion_event (GdkWindow *window, NSEvent *nsevent, gint x, gint y)
+static void
+fill_motion_event (GdkWindow *window,
+ GdkEvent *event,
+ NSEvent *nsevent,
+ gint x,
+ gint y,
+ gint x_root,
+ gint y_root)
{
- GdkEvent *event;
- GdkEventType type;
- GdkModifierType state = 0;
- int button = 0;
+ GdkModifierType state;
+
+ state = get_keyboard_modifiers_from_ns_event (nsevent);
switch ([nsevent type])
{
case NSLeftMouseDragged:
case NSRightMouseDragged:
case NSOtherMouseDragged:
- button = convert_mouse_button_number ([nsevent buttonNumber]);
- /* Fall through */
+ state |= get_mouse_button_modifiers_from_ns_event (nsevent);
+ break;
+
case NSMouseMoved:
- type = GDK_MOTION_NOTIFY;
break;
- default:
- g_assert_not_reached ();
}
- /* This maps buttons 1 to 5 to GDK_BUTTON[1-5]_MASK */
- if (button >= 1 && button <= 5)
- state = (1 << (button + 7));
-
- state |= get_keyboard_modifiers_from_nsevent (nsevent);
-
- event = gdk_event_new (type);
+ event->any.type = GDK_MOTION_NOTIFY;
event->motion.window = window;
- event->motion.time = get_event_time (nsevent);
+ event->motion.time = get_time_from_ns_event (nsevent);
event->motion.x = x;
event->motion.y = y;
+ event->motion.x_root = x_root;
+ event->motion.y_root = y_root;
/* FIXME event->axes */
event->motion.state = state;
event->motion.is_hint = FALSE;
event->motion.device = _gdk_display->core_pointer;
- convert_window_coordinates_to_root (window, x, y,
- &event->motion.x_root, &event->motion.y_root);
-
- return event;
}
-static GdkEvent *
-create_scroll_event (GdkWindow *window, NSEvent *nsevent, GdkScrollDirection direction)
+static void
+fill_scroll_event (GdkWindow *window,
+ GdkEvent *event,
+ NSEvent *nsevent,
+ gint x,
+ gint y,
+ gint x_root,
+ gint y_root,
+ GdkScrollDirection direction)
{
- GdkEvent *event;
+ GdkWindowObject *private;
NSPoint point;
-
- event = gdk_event_new (GDK_SCROLL);
- event->scroll.window = window;
- event->scroll.time = get_event_time (nsevent);
+
+ private = GDK_WINDOW_OBJECT (window);
point = [nsevent locationInWindow];
- event->scroll.x = point.x;
- event->scroll.y = point.y;
- convert_window_coordinates_to_root (window, event->scroll.x, event->scroll.y,
- &event->scroll.x_root,
- &event->scroll.y_root);
+ event->any.type = GDK_SCROLL;
+ event->scroll.window = window;
+ event->scroll.time = get_time_from_ns_event (nsevent);
+ event->scroll.x = x;
+ event->scroll.y = y;
+ event->scroll.x_root = x_root;
+ event->scroll.y_root = y_root;
+ event->scroll.state = get_keyboard_modifiers_from_ns_event (nsevent);
event->scroll.direction = direction;
event->scroll.device = _gdk_display->core_pointer;
-
- return event;
}
-static GdkEvent *
-create_key_event (GdkWindow *window, NSEvent *nsevent, GdkEventType type)
+static void
+fill_key_event (GdkWindow *window,
+ GdkEvent *event,
+ NSEvent *nsevent,
+ GdkEventType type)
{
- GdkEvent *event;
+ GdkEventPrivate *priv;
gchar buf[7];
gunichar c = 0;
- event = gdk_event_new (type);
+ priv = (GdkEventPrivate *) event;
+ priv->windowing_data = [nsevent retain];
+
+ event->any.type = type;
event->key.window = window;
- event->key.time = get_event_time (nsevent);
- event->key.state = get_keyboard_modifiers_from_nsevent (nsevent);
+ event->key.time = get_time_from_ns_event (nsevent);
+ event->key.state = get_keyboard_modifiers_from_ns_event (nsevent);
event->key.hardware_keycode = [nsevent keyCode];
event->key.group = ([nsevent modifierFlags] & NSAlternateKeyMask) ? 1 : 0;
-
event->key.keyval = GDK_VoidSymbol;
gdk_keymap_translate_keyboard_state (NULL,
event->key.is_modifier = _gdk_quartz_keys_is_modifier (event->key.hardware_keycode);
+ /* If the key press is a modifier, the state should include the mask
+ * for that modifier but only for releases, not presses. This
+ * matches the X11 backend behavior.
+ */
+ if (event->key.is_modifier)
+ {
+ int mask = 0;
+
+ switch (event->key.keyval)
+ {
+ case GDK_Meta_R:
+ case GDK_Meta_L:
+ mask = GDK_MOD1_MASK;
+ break;
+ case GDK_Shift_R:
+ case GDK_Shift_L:
+ mask = GDK_SHIFT_MASK;
+ break;
+ case GDK_Caps_Lock:
+ mask = GDK_LOCK_MASK;
+ break;
+ case GDK_Alt_R:
+ case GDK_Alt_L:
+ mask = GDK_MOD5_MASK;
+ break;
+ case GDK_Control_R:
+ case GDK_Control_L:
+ mask = GDK_CONTROL_MASK;
+ break;
+ default:
+ mask = 0;
+ }
+
+ if (type == GDK_KEY_PRESS)
+ event->key.state &= ~mask;
+ else if (type == GDK_KEY_RELEASE)
+ event->key.state |= mask;
+ }
+
+ event->key.state |= current_button_state;
+
event->key.string = NULL;
/* Fill in ->string since apps depend on it, taken from the x11 backend. */
if (event->key.keyval != GDK_VoidSymbol)
c = gdk_keyval_to_unicode (event->key.keyval);
- if (c)
+ if (c)
{
gsize bytes_written;
gint len;
event->key.window,
event->key.keyval ? gdk_keyval_name (event->key.keyval) : "(none)",
event->key.keyval));
- return event;
}
-static GdkEventMask current_mask = 0;
+static gboolean
+synthesize_crossing_event (GdkWindow *window,
+ GdkEvent *event,
+ NSEvent *nsevent,
+ gint x,
+ gint y,
+ gint x_root,
+ gint y_root)
+{
+ GdkWindowObject *private;
+
+ private = GDK_WINDOW_OBJECT (window);
+
+ switch ([nsevent type])
+ {
+ case NSMouseEntered:
+ /* Enter events are considered always to be from the root window as we
+ * can't know for sure from what window we enter.
+ */
+ if (!(private->event_mask & GDK_ENTER_NOTIFY_MASK))
+ return FALSE;
+
+ fill_crossing_event (window, event, nsevent,
+ x, y,
+ x_root, y_root,
+ GDK_ENTER_NOTIFY,
+ GDK_CROSSING_NORMAL,
+ GDK_NOTIFY_ANCESTOR);
+ return TRUE;
+
+ case NSMouseExited:
+ /* Exited always is to the root window as far as we are concerned,
+ * since there is no way to reliably get information about what new
+ * window is entered when exiting one.
+ */
+ if (!(private->event_mask & GDK_LEAVE_NOTIFY_MASK))
+ return FALSE;
+
+ fill_crossing_event (window, event, nsevent,
+ x, y,
+ x_root, y_root,
+ GDK_LEAVE_NOTIFY,
+ GDK_CROSSING_NORMAL,
+ GDK_NOTIFY_ANCESTOR);
+ return TRUE;
+
+ default:
+ break;
+ }
+
+ return FALSE;
+}
+
GdkEventMask
_gdk_quartz_events_get_current_event_mask (void)
{
- return current_mask;
+ return current_event_mask;
}
static gboolean
-gdk_event_translate (NSEvent *nsevent)
+gdk_event_translate (GdkEvent *event,
+ NSEvent *nsevent)
{
+ NSEventType event_type;
+ NSWindow *nswindow;
GdkWindow *window;
- GdkFilterReturn result;
- GdkEvent *event;
int x, y;
+ int x_root, y_root;
+ gboolean return_val;
+
+ /* Ignore events altogether when we're not active, otherwise we get
+ * tooltips etc for inactive apps.
+ */
+ if (![NSApp isActive])
+ return FALSE;
+
+ /* There is no support for real desktop wide grabs, so we break
+ * grabs when the application loses focus (gets deactivated).
+ */
+ event_type = [nsevent type];
+ if (event_type == NSAppKitDefined)
+ {
+ if ([nsevent subtype] == NSApplicationDeactivatedEventType)
+ break_all_grabs (get_time_from_ns_event (nsevent));
+
+ /* This could potentially be used to break grabs when clicking
+ * on the title. The subtype 20 is undocumented so it's probably
+ * not a good idea: else if (subtype == 20) break_all_grabs ();
+ */
+
+ /* Leave all AppKit events to AppKit. */
+ return FALSE;
+ }
+
+ /* Handle our generated "fake" crossing events. */
+ if (event_type == NSApplicationDefined &&
+ [nsevent subtype] == GDK_QUARTZ_EVENT_SUBTYPE_FAKE_CROSSING)
+ {
+ /* FIXME: This needs to actually fill in the event we have... */
+ _gdk_quartz_events_trigger_crossing_events (FALSE);
+ return FALSE; /* ...and return TRUE instead. */
+ }
+
+ /* Keep track of button state, since we don't get that information
+ * for key events.
+ */
+ switch (event_type)
+ {
+ case NSLeftMouseDown:
+ case NSRightMouseDown:
+ case NSOtherMouseDown:
+ current_button_state |= get_mouse_button_modifiers_from_ns_event (nsevent);
+ break;
+ case NSLeftMouseUp:
+ case NSRightMouseUp:
+ case NSOtherMouseUp:
+ current_button_state &= ~get_mouse_button_modifiers_from_ns_event (nsevent);
+ break;
+ default:
+ break;
+ }
if (_gdk_default_filters)
{
/* Apply global filters */
+ GdkFilterReturn result;
- GdkFilterReturn result = apply_filters (NULL, nsevent, _gdk_default_filters);
-
- /* If result is GDK_FILTER_CONTINUE, we continue as if nothing
- * happened. If it is GDK_FILTER_REMOVE,
- * we return TRUE and won't send the message to Quartz.
- */
- if (result == GDK_FILTER_REMOVE)
- return TRUE;
+ result = gdk_event_apply_filters (nsevent, event, _gdk_default_filters);
+ if (result != GDK_FILTER_CONTINUE)
+ {
+ return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
+ goto done;
+ }
}
- /* Catch the case where the entire app loses focus, and break any grabs. */
- if ([nsevent type] == NSAppKitDefined)
+ nswindow = [nsevent window];
+
+ /* Ignore events for no window or ones not created by GDK. */
+ if (!nswindow || ![[nswindow contentView] isKindOfClass:[GdkQuartzView class]])
+ return FALSE;
+
+ /* Ignore events and break grabs while the window is being
+ * dragged. This is a workaround for the window getting events for
+ * the window title.
+ */
+ if ([(GdkQuartzWindow *)nswindow isInMove])
{
- if ([nsevent subtype] == NSApplicationDeactivatedEventType)
+ break_all_grabs (get_time_from_ns_event (nsevent));
+ return FALSE;
+ }
+
+ /* Find the right GDK window to send the event to, taking grabs and
+ * event masks into consideration.
+ */
+ window = find_window_for_ns_event (nsevent, &x, &y, &x_root, &y_root);
+ if (!window)
+ return FALSE;
+
+ /* Apply any window filters. */
+ if (GDK_IS_WINDOW (window))
+ {
+ GdkWindowObject *filter_private = (GdkWindowObject *) window;
+ GdkFilterReturn result;
+
+ if (filter_private->filters)
{
- if (_gdk_quartz_keyboard_grab_window)
- {
- generate_grab_broken_event (_gdk_quartz_keyboard_grab_window,
- TRUE, FALSE,
- NULL);
- g_object_unref (_gdk_quartz_keyboard_grab_window);
- _gdk_quartz_keyboard_grab_window = NULL;
- }
+ g_object_ref (window);
+
+ result = gdk_event_apply_filters (nsevent, event, filter_private->filters);
- if (_gdk_quartz_pointer_grab_window)
+ g_object_unref (window);
+
+ if (result != GDK_FILTER_CONTINUE)
{
- generate_grab_broken_event (_gdk_quartz_pointer_grab_window,
- FALSE, pointer_grab_implicit,
- NULL);
- g_object_unref (_gdk_quartz_pointer_grab_window);
- _gdk_quartz_pointer_grab_window = NULL;
+ return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
+ goto done;
}
}
}
- window = find_window_for_event (nsevent, &x, &y);
-
- /* FIXME: During owner_event grabs, we don't find a window when there is a
- * click on a no-window widget, which makes popups etc still stay up. Need
- * to figure out why that is.
+ /* We only activate the application on click if it's not already active,
+ * or if it's active but the window isn't focused. This matches most use
+ * cases of native apps (no click-through).
*/
-
- if (!window)
- return FALSE;
+ if ((event_type == NSRightMouseDown ||
+ event_type == NSOtherMouseDown ||
+ event_type == NSLeftMouseDown))
+ {
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
- result = apply_filters (window, nsevent, ((GdkWindowObject *) window)->filters);
+ if (![NSApp isActive])
+ return FALSE;
+ else if (![impl->toplevel isKeyWindow])
+ return FALSE;
+ }
- if (result == GDK_FILTER_REMOVE)
- return TRUE;
+ current_event_mask = get_event_mask_from_ns_event (nsevent);
- current_mask = get_event_mask_from_ns_event (nsevent);
+ return_val = TRUE;
- switch ([nsevent type])
+ switch (event_type)
{
case NSLeftMouseDown:
case NSRightMouseDown:
case NSOtherMouseDown:
- {
- GdkEventMask event_mask;
-
- /* Emulate implicit grab, when the window has both PRESS and RELEASE
- * in its mask, like X (and make it owner_events since that's what
- * implicit grabs are like).
- */
- event_mask = (GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK);
- if (!_gdk_quartz_pointer_grab_window &&
- (GDK_WINDOW_OBJECT (window)->event_mask & event_mask) == event_mask)
- {
- pointer_grab_internal (window, TRUE,
- GDK_WINDOW_OBJECT (window)->event_mask,
- NULL, NULL, TRUE);
- }
- }
-
- event = create_button_event (window, nsevent, x, y);
- append_event (event);
-
- _gdk_event_button_generate (_gdk_display, event);
- break;
-
case NSLeftMouseUp:
case NSRightMouseUp:
case NSOtherMouseUp:
- event = create_button_event (window, nsevent, x, y);
- append_event (event);
-
- /* Ungrab implicit grab */
- if (_gdk_quartz_pointer_grab_window &&
- pointer_grab_implicit)
- pointer_ungrab_internal (TRUE);
+ fill_button_event (window, event, nsevent, x, y, x_root, y_root);
break;
case NSLeftMouseDragged:
case NSRightMouseDragged:
case NSOtherMouseDragged:
case NSMouseMoved:
- event = create_motion_event (window, nsevent, x, y);
- append_event (event);
+ fill_motion_event (window, event, nsevent, x, y, x_root, y_root);
break;
case NSScrollWheel:
float dy = [nsevent deltaY];
GdkScrollDirection direction;
- /* The delta is how much the mouse wheel has moved. Since there's no such thing in GTK+
- * we accomodate by sending a different number of scroll wheel events.
- */
-
- /* First do y events */
- if (dy < 0.0)
- {
- dy = -dy;
- direction = GDK_SCROLL_DOWN;
- }
- else
- direction = GDK_SCROLL_UP;
-
- while (dy > 0.0)
- {
- event = create_scroll_event (window, nsevent, direction);
- append_event (event);
- dy--;
- }
-
- /* Now do x events */
- if (dx < 0.0)
- {
- dx = -dx;
- direction = GDK_SCROLL_RIGHT;
- }
- else
- direction = GDK_SCROLL_LEFT;
+ if (dy != 0)
+ {
+ if (dy < 0.0)
+ direction = GDK_SCROLL_DOWN;
+ else
+ direction = GDK_SCROLL_UP;
+
+ fill_scroll_event (window, event, nsevent, x, y, x_root, y_root, direction);
+ }
+
+ if (dx != 0)
+ {
+ if (dx < 0.0)
+ direction = GDK_SCROLL_RIGHT;
+ else
+ direction = GDK_SCROLL_LEFT;
+
+ fill_scroll_event (window, event, nsevent, x, y, x_root, y_root, direction);
+ }
+ }
+ break;
- while (dx > 0.0)
- {
- event = create_scroll_event (window, nsevent, direction);
- append_event (event);
- dx--;
- }
+ case NSMouseEntered:
+ case NSMouseExited:
+ return_val = synthesize_crossing_event (window, event, nsevent, x, y, x_root, y_root);
+ break;
- break;
- }
case NSKeyDown:
case NSKeyUp:
case NSFlagsChanged:
type = _gdk_quartz_keys_event_type (nsevent);
if (type == GDK_NOTHING)
- return FALSE;
-
- event = create_key_event (window, nsevent, type);
- append_event (event);
- return TRUE;
+ return_val = FALSE;
+ else
+ fill_key_event (window, event, nsevent, type);
}
break;
+
default:
- NSLog(@"Untranslated: %@", nsevent);
+ /* Ignore everything elsee. */
+ return_val = FALSE;
+ break;
}
- return FALSE;
+ done:
+ if (return_val)
+ {
+ if (event->any.window)
+ g_object_ref (event->any.window);
+ if (((event->any.type == GDK_ENTER_NOTIFY) ||
+ (event->any.type == GDK_LEAVE_NOTIFY)) &&
+ (event->crossing.subwindow != NULL))
+ g_object_ref (event->crossing.subwindow);
+ }
+ else
+ {
+ /* Mark this event as having no resources to be freed */
+ event->any.window = NULL;
+ event->any.type = GDK_NOTHING;
+ }
+
+ return return_val;
}
void
_gdk_events_queue (GdkDisplay *display)
{
- NSEvent *current_event = _gdk_quartz_event_loop_get_current ();
+ NSEvent *nsevent;
- if (current_event)
+ nsevent = _gdk_quartz_event_loop_get_pending ();
+ if (nsevent)
{
- if (!gdk_event_translate (current_event))
- [NSApp sendEvent:current_event];
-
- _gdk_quartz_event_loop_release_current ();
+ GdkEvent *event;
+ GList *node;
+
+ event = gdk_event_new (GDK_NOTHING);
+
+ event->any.window = NULL;
+ event->any.send_event = FALSE;
+
+ ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;
+
+ node = _gdk_event_queue_append (display, event);
+
+ if (gdk_event_translate (event, nsevent))
+ {
+ ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;
+ _gdk_windowing_got_event (display, node, event, 0);
+ }
+ else
+ {
+ _gdk_event_queue_remove_link (display, node);
+ g_list_free_1 (node);
+ gdk_event_free (event);
+
+ GDK_THREADS_LEAVE ();
+ [NSApp sendEvent:nsevent];
+ GDK_THREADS_ENTER ();
+ }
+
+ _gdk_quartz_event_loop_release_event (nsevent);
}
}
/* Not supported. */
}
-void
+void
gdk_display_add_client_message_filter (GdkDisplay *display,
GdkAtom message_type,
GdkFilterFunc func,
/* Not supported. */
}
-void
+void
gdk_add_client_message_filter (GdkAtom message_type,
GdkFilterFunc func,
gpointer data)
{
if (strcmp (name, "gtk-double-click-time") == 0)
{
- NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+ NSUserDefaults *defaults;
float t;
GDK_QUARTZ_ALLOC_POOL;
+
+ defaults = [NSUserDefaults standardUserDefaults];
t = [defaults floatForKey:@"com.apple.mouse.doubleClickThreshold"];
if (t == 0.0)
GDK_QUARTZ_RELEASE_POOL;
g_value_set_int (value, t * 1000);
+
+ return TRUE;
+ }
+ else if (strcmp (name, "gtk-font-name") == 0)
+ {
+ NSString *name;
+ char *str;
+
+ GDK_QUARTZ_ALLOC_POOL;
+
+ name = [[NSFont systemFontOfSize:0] familyName];
+
+ /* Let's try to use the "views" font size (12pt) by default. This is
+ * used for lists/text/other "content" which is the largest parts of
+ * apps, using the "regular control" size (13pt) looks a bit out of
+ * place. We might have to tweak this.
+ */
+
+ /* The size has to be hardcoded as there doesn't seem to be a way to
+ * get the views font size programmatically.
+ */
+ str = g_strdup_printf ("%s 12", [name UTF8String]);
+ g_value_set_string (value, str);
+ g_free (str);
+
+ GDK_QUARTZ_RELEASE_POOL;
+
return TRUE;
}
return FALSE;
}
+void
+_gdk_windowing_event_data_copy (const GdkEvent *src,
+ GdkEvent *dst)
+{
+ GdkEventPrivate *priv_src = (GdkEventPrivate *) src;
+ GdkEventPrivate *priv_dst = (GdkEventPrivate *) dst;
+
+ if (priv_src->windowing_data)
+ {
+ priv_dst->windowing_data = priv_src->windowing_data;
+ [(NSEvent *)priv_dst->windowing_data retain];
+ }
+}
+
+void
+_gdk_windowing_event_data_free (GdkEvent *event)
+{
+ GdkEventPrivate *priv = (GdkEventPrivate *) event;
+
+ if (priv->windowing_data)
+ {
+ [(NSEvent *)priv->windowing_data release];
+ priv->windowing_data = NULL;
+ }
+}
projects / ~andy / gtk / blobdiff