* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#import <Cocoa/Cocoa.h>
#include <Carbon/Carbon.h>
+#include <gdk/gdkdisplayprivate.h>
+
#include "gdkscreen.h"
#include "gdkkeysyms.h"
+#include "gdkquartz.h"
+#include "gdkquartzdisplay.h"
#include "gdkprivate-quartz.h"
+#include "gdkquartzdevicemanager-core.h"
+
+#define GRIP_WIDTH 15
+#define GRIP_HEIGHT 15
+#define GDK_LION_RESIZE 5
-/* This is the window the mouse is currently over */
-static GdkWindow *current_mouse_window;
+#define WINDOW_IS_TOPLEVEL(window) \
+ (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
+ GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \
+ GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
/* This is the window corresponding to the key window */
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);
-
-static const gchar *
-which_window_is_this (GdkWindow *window)
-{
- static gchar buf[256];
- const gchar *name = NULL;
- gpointer widget;
-
- /* Get rid of compiler warning. */
- if (0) which_window_is_this (window);
-
- if (window == _gdk_root)
- name = "root";
- else if (window == NULL)
- name = "null";
-
- if (window)
- {
- gdk_window_get_user_data (window, &widget);
- if (widget)
- name = G_OBJECT_TYPE_NAME (widget);
- }
- if (!name)
- name = "unknown";
+static void append_event (GdkEvent *event,
+ gboolean windowing);
- snprintf (buf, 256, "<%s (%p)%s>",
- name, window,
- window == current_mouse_window ? ", is mouse" : "");
+static GdkWindow *find_toplevel_under_pointer (GdkDisplay *display,
+ NSPoint screen_point,
+ gint *x,
+ gint *y);
- return buf;
-}
-NSEvent *
-gdk_quartz_event_get_nsevent (GdkEvent *event)
+static void
+gdk_quartz_ns_notification_callback (CFNotificationCenterRef center,
+ void *observer,
+ CFStringRef name,
+ const void *object,
+ CFDictionaryRef userInfo)
{
- /* FIXME: If the event here is unallocated, we crash. */
- return ((GdkEventPrivate *) event)->windowing_data;
-}
+ GdkEvent new_event;
-void
-_gdk_events_init (void)
-{
- _gdk_quartz_event_loop_init ();
+ new_event.type = GDK_SETTING;
+ new_event.setting.window = gdk_screen_get_root_window (_gdk_screen);
+ new_event.setting.send_event = FALSE;
+ new_event.setting.action = GDK_SETTING_ACTION_CHANGED;
+ new_event.setting.name = NULL;
- current_mouse_window = g_object_ref (_gdk_root);
- current_keyboard_window = g_object_ref (_gdk_root);
-}
+ /* Translate name */
+ if (CFStringCompare (name,
+ CFSTR("AppleNoRedisplayAppearancePreferenceChanged"),
+ 0) == kCFCompareEqualTo)
+ new_event.setting.name = "gtk-primary-button-warps-slider";
-gboolean
-gdk_events_pending (void)
-{
- return (_gdk_event_queue_find_first (_gdk_display) ||
- (_gdk_quartz_event_loop_check_pending ()));
-}
+ if (!new_event.setting.name)
+ return;
-GdkEvent*
-gdk_event_get_graphics_expose (GdkWindow *window)
-{
- /* FIXME: Implement */
- return NULL;
+ gdk_event_put (&new_event);
}
-GdkGrabStatus
-gdk_keyboard_grab (GdkWindow *window,
- gint owner_events,
- guint32 time)
+static void
+gdk_quartz_events_init_notifications (void)
{
- GdkDisplay *display;
- GdkWindow *toplevel;
+ static gboolean notifications_initialized = FALSE;
- g_return_val_if_fail (window != NULL, 0);
- g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
-
- display = gdk_drawable_get_display (window);
- toplevel = gdk_window_get_toplevel (window);
-
- _gdk_display_set_has_keyboard_grab (display,
- window,
- toplevel,
- owner_events,
- 0,
- time);
+ if (notifications_initialized)
+ return;
+ notifications_initialized = TRUE;
- return GDK_GRAB_SUCCESS;
-}
+ /* Initialize any handlers for notifications we want to push to GTK
+ * through GdkEventSettings.
+ */
-void
-gdk_display_keyboard_ungrab (GdkDisplay *display,
- guint32 time)
-{
- _gdk_display_unset_has_keyboard_grab (display, FALSE);
+ /* This is an undocumented *distributed* notification to listen for changes
+ * in scrollbar jump behavior. It is used by LibreOffice and WebKit as well.
+ */
+ CFNotificationCenterAddObserver (CFNotificationCenterGetDistributedCenter (),
+ NULL,
+ &gdk_quartz_ns_notification_callback,
+ CFSTR ("AppleNoRedisplayAppearancePreferenceChanged"),
+ NULL,
+ CFNotificationSuspensionBehaviorDeliverImmediately);
}
void
-gdk_display_pointer_ungrab (GdkDisplay *display,
- guint32 time)
+_gdk_quartz_events_init (void)
{
- GdkPointerGrabInfo *grab;
-
- grab = _gdk_display_get_last_pointer_grab (display);
- if (grab)
- {
- /* Serials are always 0 in quartz, but for clarity: */
- grab->serial_end = 0;
- }
+ _gdk_quartz_event_loop_init ();
+ gdk_quartz_events_init_notifications ();
- _gdk_display_pointer_grab_update (display, 0);
+ current_keyboard_window = g_object_ref (_gdk_root);
}
-GdkGrabStatus
-gdk_pointer_grab (GdkWindow *window,
- gboolean owner_events,
- GdkEventMask event_mask,
- GdkWindow *confine_to,
- GdkCursor *cursor,
- guint32 time)
+gboolean
+_gdk_quartz_display_has_pending (GdkDisplay *display)
{
- 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);
-
- 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;
+ return (_gdk_event_queue_find_first (display) ||
+ (_gdk_quartz_event_loop_check_pending ()));
}
-static void
-break_all_grabs (guint32 time)
+void
+_gdk_quartz_events_break_all_grabs (guint32 time)
{
- GdkPointerGrabInfo *grab;
-
- if (_gdk_display->keyboard_grab.window)
- _gdk_display_unset_has_keyboard_grab (_gdk_display, FALSE);
+ GList *list, *l;
+ GdkDeviceManager *device_manager;
- grab = _gdk_display_get_last_pointer_grab (_gdk_display);
- if (grab)
+ device_manager = gdk_display_get_device_manager (_gdk_display);
+ list = gdk_device_manager_list_devices (device_manager,
+ GDK_DEVICE_TYPE_MASTER);
+ for (l = list; l; l = l->next)
{
- /* Serials are always 0 in quartz, but for clarity: */
- grab->serial_end = 0;
- grab->implicit_ungrab = TRUE;
+ GdkDeviceGrabInfo *grab;
+
+ grab = _gdk_display_get_last_device_grab (_gdk_display, l->data);
+ if (grab)
+ {
+ grab->serial_end = 0;
+ grab->implicit_ungrab = TRUE;
+ }
+
+ _gdk_display_device_grab_update (_gdk_display, l->data, NULL, 0);
}
- _gdk_display_pointer_grab_update (_gdk_display, 0);
+ g_list_free (list);
}
static void
}
static void
-append_event (GdkEvent *event)
+append_event (GdkEvent *event,
+ gboolean windowing)
{
+ GList *node;
+
fixup_event (event);
- _gdk_event_queue_append (_gdk_display, event);
+ node = _gdk_event_queue_append (_gdk_display, event);
+
+ if (windowing)
+ _gdk_windowing_got_event (_gdk_display, node, event, 0);
}
static gint
gdk_event_apply_filters (NSEvent *nsevent,
GdkEvent *event,
- GList *filters)
+ GList **filters)
{
GList *tmp_list;
GdkFilterReturn result;
- tmp_list = filters;
+ tmp_list = *filters;
while (tmp_list)
{
GdkEventFilter *filter = (GdkEventFilter*) tmp_list->data;
-
- tmp_list = tmp_list->next;
+ GList *node;
+
+ if ((filter->flags & GDK_EVENT_FILTER_REMOVED) != 0)
+ {
+ tmp_list = tmp_list->next;
+ continue;
+ }
+
+ filter->ref_count++;
result = filter->function (nsevent, event, filter->data);
+
+ /* get the next node after running the function since the
+ function may add or remove a next node */
+ node = tmp_list;
+ tmp_list = tmp_list->next;
+
+ filter->ref_count--;
+ if (filter->ref_count == 0)
+ {
+ *filters = g_list_remove_link (*filters, node);
+ g_list_free_1 (node);
+ g_free (filter);
+ }
+
if (result != GDK_FILTER_CONTINUE)
return result;
}
get_time_from_ns_event (NSEvent *event)
{
double time = [event timestamp];
-
- return time * 1000.0;
+
+ /* cast via double->uint64 conversion to make sure that it is
+ * wrapped on 32-bit machines when it overflows
+ */
+ return (guint32) (guint64) (time * 1000.0);
}
static int
get_mouse_button_from_ns_event (NSEvent *event)
{
- int button;
+ NSInteger button;
button = [event buttonNumber];
}
}
+static GdkModifierType
+get_mouse_button_modifiers_from_ns_buttons (NSUInteger nsbuttons)
+{
+ GdkModifierType modifiers = 0;
+
+ if (nsbuttons & (1 << 0))
+ modifiers |= GDK_BUTTON1_MASK;
+ if (nsbuttons & (1 << 1))
+ modifiers |= GDK_BUTTON3_MASK;
+ if (nsbuttons & (1 << 2))
+ modifiers |= GDK_BUTTON2_MASK;
+ if (nsbuttons & (1 << 3))
+ modifiers |= GDK_BUTTON4_MASK;
+ if (nsbuttons & (1 << 4))
+ modifiers |= GDK_BUTTON5_MASK;
+
+ return modifiers;
+}
+
static GdkModifierType
get_mouse_button_modifiers_from_ns_event (NSEvent *event)
{
}
static GdkModifierType
-get_keyboard_modifiers_from_ns_event (NSEvent *nsevent)
+get_keyboard_modifiers_from_ns_flags (NSUInteger nsflags)
{
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)
+ if (nsflags & NSAlternateKeyMask)
modifiers |= GDK_MOD1_MASK;
+ if (nsflags & NSCommandKeyMask)
+ modifiers |= GDK_MOD2_MASK;
return modifiers;
}
+static GdkModifierType
+get_keyboard_modifiers_from_ns_event (NSEvent *nsevent)
+{
+ return get_keyboard_modifiers_from_ns_flags ([nsevent modifierFlags]);
+}
+
/* Return an event mask from an NSEvent */
static GdkEventMask
get_event_mask_from_ns_event (NSEvent *nsevent)
return 0;
}
+static void
+get_window_point_from_screen_point (GdkWindow *window,
+ NSPoint screen_point,
+ gint *x,
+ gint *y)
+{
+ NSPoint point;
+ NSWindow *nswindow;
+
+ nswindow = ((GdkWindowImplQuartz *)window->impl)->toplevel;
+
+ point = [nswindow convertScreenToBase:screen_point];
+
+ *x = point.x;
+ *y = window->height - point.y;
+}
+
+static GdkWindow *
+get_toplevel_from_ns_event (NSEvent *nsevent,
+ NSPoint *screen_point,
+ gint *x,
+ gint *y)
+{
+ GdkWindow *toplevel;
+
+ if ([nsevent window])
+ {
+ GdkQuartzView *view;
+ NSPoint point;
+
+ view = (GdkQuartzView *)[[nsevent window] contentView];
+
+ toplevel = [view gdkWindow];
+
+ point = [nsevent locationInWindow];
+ *screen_point = [[nsevent window] convertBaseToScreen:point];
+
+ *x = point.x;
+ *y = toplevel->height - point.y;
+ }
+ else
+ {
+ /* Fallback used when no NSWindow set. This happens e.g. when
+ * we allow motion events without a window set in gdk_event_translate()
+ * that occur immediately after the main menu bar was clicked/used.
+ */
+ *screen_point = [NSEvent mouseLocation];
+ toplevel = find_toplevel_under_pointer (_gdk_display,
+ *screen_point,
+ x, y);
+ }
+
+ return toplevel;
+}
+
static GdkEvent *
create_focus_event (GdkWindow *window,
gboolean in)
{
GdkEvent *event;
+ GdkQuartzDeviceManagerCore *device_manager;
event = gdk_event_new (GDK_FOCUS_CHANGE);
event->focus_change.window = window;
event->focus_change.in = in;
+ device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
+ gdk_event_set_device (event, device_manager->core_keyboard);
+
return event;
}
+
+static void
+generate_motion_event (GdkWindow *window)
+{
+ NSPoint screen_point;
+ GdkEvent *event;
+ gint x, y, x_root, y_root;
+
+ event = gdk_event_new (GDK_MOTION_NOTIFY);
+ event->any.window = NULL;
+ event->any.send_event = TRUE;
+
+ screen_point = [NSEvent mouseLocation];
+
+ _gdk_quartz_window_nspoint_to_gdk_xy (screen_point, &x_root, &y_root);
+ get_window_point_from_screen_point (window, screen_point, &x, &y);
+
+ event->any.type = GDK_MOTION_NOTIFY;
+ event->motion.window = window;
+ event->motion.time = GDK_CURRENT_TIME;
+ 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 = _gdk_quartz_events_get_current_keyboard_modifiers () |
+ _gdk_quartz_events_get_current_mouse_modifiers ();
+ event->motion.is_hint = FALSE;
+ event->motion.device = _gdk_display->core_pointer;
+
+ append_event (event, TRUE);
+}
+
/* Note: Used to both set a new focus window and to unset the old one. */
void
_gdk_quartz_events_update_focus_window (GdkWindow *window,
if (got_focus && window == current_keyboard_window)
return;
- /* FIXME: Don't do this when grabbed? Or make GdkQuartzWindow
+ /* FIXME: Don't do this when grabbed? Or make GdkQuartzNSWindow
* disallow it in the first place instead?
*/
if (!got_focus && window == current_keyboard_window)
{
event = create_focus_event (current_keyboard_window, FALSE);
- append_event (event);
+ append_event (event, FALSE);
g_object_unref (current_keyboard_window);
current_keyboard_window = NULL;
}
if (current_keyboard_window)
{
event = create_focus_event (current_keyboard_window, FALSE);
- append_event (event);
+ append_event (event, FALSE);
g_object_unref (current_keyboard_window);
current_keyboard_window = NULL;
}
event = create_focus_event (window, TRUE);
- append_event (event);
+ append_event (event, FALSE);
current_keyboard_window = g_object_ref (window);
+
+ /* We just became the active window. Unlike X11, Mac OS X does
+ * not send us motion events while the window does not have focus
+ * ("is not key"). We send a dummy motion notify event now, so that
+ * everything in the window is set to correct state.
+ */
+ generate_motion_event (window);
}
}
+void
+_gdk_quartz_events_send_enter_notify_event (GdkWindow *window)
+{
+ NSPoint screen_point;
+ GdkEvent *event;
+ gint x, y, x_root, y_root;
+
+ event = gdk_event_new (GDK_ENTER_NOTIFY);
+ event->any.window = NULL;
+ event->any.send_event = FALSE;
+
+ screen_point = [NSEvent mouseLocation];
+
+ _gdk_quartz_window_nspoint_to_gdk_xy (screen_point, &x_root, &y_root);
+ get_window_point_from_screen_point (window, screen_point, &x, &y);
+
+ event->crossing.window = window;
+ event->crossing.subwindow = NULL;
+ event->crossing.time = GDK_CURRENT_TIME;
+ event->crossing.x = x;
+ event->crossing.y = y;
+ event->crossing.x_root = x_root;
+ event->crossing.y_root = y_root;
+ event->crossing.mode = GDK_CROSSING_NORMAL;
+ event->crossing.detail = GDK_NOTIFY_ANCESTOR;
+ event->crossing.state = _gdk_quartz_events_get_current_keyboard_modifiers () |
+ _gdk_quartz_events_get_current_mouse_modifiers ();
+
+ gdk_event_set_device (event, _gdk_display->core_pointer);
+
+ append_event (event, TRUE);
+}
+
void
_gdk_quartz_events_send_map_event (GdkWindow *window)
{
- GdkWindowObject *private = (GdkWindowObject *)window;
- GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
+ GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
if (!impl->toplevel)
return;
- if (private->event_mask & GDK_STRUCTURE_MASK)
+ if (window->event_mask & GDK_STRUCTURE_MASK)
{
GdkEvent event;
}
}
-/* Get current mouse window */
-GdkWindow *
-_gdk_quartz_events_get_mouse_window (gboolean consider_grabs)
+static GdkWindow *
+find_toplevel_under_pointer (GdkDisplay *display,
+ NSPoint screen_point,
+ gint *x,
+ gint *y)
{
- GdkPointerGrabInfo *grab;
+ GdkWindow *toplevel;
+ GdkPointerWindowInfo *info;
- if (!consider_grabs)
- return current_mouse_window;
+ info = _gdk_display_get_pointer_info (display, display->core_pointer);
+ toplevel = info->toplevel_under_pointer;
+ if (toplevel && WINDOW_IS_TOPLEVEL (toplevel))
+ get_window_point_from_screen_point (toplevel, screen_point, x, y);
- grab = _gdk_display_get_last_pointer_grab (_gdk_display);
- if (grab && grab->window && !grab->owner_events)
- return grab->window;
-
- return current_mouse_window;
+ return toplevel;
}
-/* Update mouse window */
-void
-_gdk_quartz_events_update_mouse_window (GdkWindow *window)
+static GdkWindow *
+find_toplevel_for_keyboard_event (NSEvent *nsevent)
{
- if (window == current_mouse_window)
- return;
-
-#ifdef G_ENABLE_DEBUG
- if (_gdk_debug_flags & GDK_DEBUG_EVENTS)
- _gdk_quartz_window_debug_highlight (window, 0);
-#endif /* G_ENABLE_DEBUG */
-
- if (window)
- g_object_ref (window);
- if (current_mouse_window)
- g_object_unref (current_mouse_window);
+ GList *list, *l;
+ GdkWindow *window;
+ GdkDisplay *display;
+ GdkQuartzView *view;
+ GdkDeviceManager *device_manager;
- current_mouse_window = window;
-}
+ view = (GdkQuartzView *)[[nsevent window] contentView];
+ window = [view gdkWindow];
-/* Translates coordinates from an ancestor window + coords, to
- * coordinates that are relative the child window.
- */
-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)
-{
- GdkWindowObject *ancestor_private = GDK_WINDOW_OBJECT (ancestor_window);
- GdkWindowObject *child_private = GDK_WINDOW_OBJECT (child_window);
+ display = gdk_window_get_display (window);
- while (child_private != ancestor_private)
+ device_manager = gdk_display_get_device_manager (display);
+ list = gdk_device_manager_list_devices (device_manager,
+ GDK_DEVICE_TYPE_MASTER);
+ for (l = list; l; l = l->next)
{
- ancestor_x -= child_private->x;
- ancestor_y -= child_private->y;
+ GdkDeviceGrabInfo *grab;
+ GdkDevice *device = l->data;
- child_private = child_private->parent;
- }
+ if (gdk_device_get_source(device) != GDK_SOURCE_KEYBOARD)
+ continue;
- *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
-get_ancestor_coordinates_from_child (GdkWindow *child_window,
- gint child_x,
- gint child_y,
- GdkWindow *ancestor_window,
- gint *ancestor_x,
- gint *ancestor_y)
-{
- GdkWindowObject *child_private = GDK_WINDOW_OBJECT (child_window);
- GdkWindowObject *ancestor_private = GDK_WINDOW_OBJECT (ancestor_window);
-
- while (child_private != ancestor_private)
- {
- child_x += child_private->x;
- child_y += child_private->y;
-
- child_private = child_private->parent;
+ grab = _gdk_display_get_last_device_grab (display, device);
+ if (grab && grab->window && !grab->owner_events)
+ {
+ window = gdk_window_get_effective_toplevel (grab->window);
+ break;
+ }
}
- *ancestor_x = child_x;
- *ancestor_y = child_y;
+ g_list_free (list);
+
+ return window;
}
-/* Translates coordinates relative to one window (in_window) into
- * coordinates relative to another window (out_window).
- */
-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 GdkWindow *
+find_toplevel_for_mouse_event (NSEvent *nsevent,
+ gint *x,
+ gint *y)
{
- GdkWindow *in_toplevel;
- GdkWindow *out_toplevel;
- int in_origin_x, in_origin_y;
- int out_origin_x, out_origin_y;
-
- if (in_window == out_window)
- {
- *out_x = in_x;
- *out_y = in_y;
- return;
- }
+ NSPoint screen_point;
+ NSEventType event_type;
+ GdkWindow *toplevel;
+ GdkDisplay *display;
+ GdkDeviceGrabInfo *grab;
- /* First translate to "in" toplevel coordinates, then on to "out"
- * toplevel coordinates, and finally to "out" child (the passed in
- * window) coordinates.
- */
+ toplevel = get_toplevel_from_ns_event (nsevent, &screen_point, x, y);
- in_toplevel = gdk_window_get_toplevel (in_window);
- out_toplevel = gdk_window_get_toplevel (out_window);
+ display = gdk_window_get_display (toplevel);
- /* 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);
+ event_type = [nsevent type];
- gdk_window_get_origin (in_toplevel, &in_origin_x, &in_origin_y);
- gdk_window_get_origin (out_toplevel, &out_origin_x, &out_origin_y);
+ /* 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.
+ */
+ grab = _gdk_display_get_last_device_grab (display,
+ display->core_pointer);
+ if (WINDOW_IS_TOPLEVEL (toplevel) && grab)
+ {
+ /* Implicit grabs do not go through XGrabPointer and thus the
+ * event mask should not be checked.
+ */
+ if (!grab->implicit
+ && (grab->event_mask & get_event_mask_from_ns_event (nsevent)) == 0)
+ return NULL;
- /* 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;
+ if (grab->owner_events)
+ {
+ /* For owner events, we need to use the toplevel under the
+ * pointer, not the window from the NSEvent, since that is
+ * reported with respect to the key window, which could be
+ * wrong.
+ */
+ GdkWindow *toplevel_under_pointer;
+ gint x_tmp, y_tmp;
+
+ toplevel_under_pointer = find_toplevel_under_pointer (display,
+ screen_point,
+ &x_tmp, &y_tmp);
+ if (toplevel_under_pointer)
+ {
+ toplevel = toplevel_under_pointer;
+ *x = x_tmp;
+ *y = y_tmp;
+ }
+
+ return toplevel;
+ }
+ else
+ {
+ /* Finally check the grab window. */
+ GdkWindow *grab_toplevel;
- get_child_coordinates_from_ancestor (out_toplevel,
- in_x, in_y,
- out_window,
- out_x, out_y);
-}
+ grab_toplevel = gdk_window_get_effective_toplevel (grab->window);
+ get_window_point_from_screen_point (grab_toplevel, screen_point,
+ x, y);
-/* 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)
-{
- 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;
+ return grab_toplevel;
+ }
- 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;
+ return NULL;
}
+ else
+ {
+ /* The non-grabbed case. */
+ GdkWindow *toplevel_under_pointer;
+ gint x_tmp, y_tmp;
+
+ /* Ignore all events but mouse moved that might be on the title
+ * bar (above the content view). The reason is that otherwise
+ * gdk gets confused about getting e.g. button presses with no
+ * window (the title bar is not known to it).
+ */
+ if (event_type != NSMouseMoved)
+ if (*y < 0)
+ return NULL;
- point = [NSEvent mouseLocation];
- x = point.x;
- y = _gdk_quartz_window_get_inverted_screen_y (point.y);
-
- mouse_window = _gdk_quartz_window_find_child (_gdk_root, x, y);
- if (!mouse_window || mouse_window == _gdk_root)
- return;
-
- toplevel = gdk_window_get_toplevel (mouse_window);
+ /* As for owner events, we need to use the toplevel under the
+ * pointer, not the window from the NSEvent.
+ */
+ toplevel_under_pointer = find_toplevel_under_pointer (display,
+ screen_point,
+ &x_tmp, &y_tmp);
+ if (toplevel_under_pointer
+ && WINDOW_IS_TOPLEVEL (toplevel_under_pointer))
+ {
+ GdkWindowImplQuartz *toplevel_impl;
- /* We ignore crossing within the same toplevel since that is already
- * handled elsewhere.
- */
- if (toplevel == gdk_window_get_toplevel (current_mouse_window))
- return;
+ toplevel = toplevel_under_pointer;
- get_converted_window_coordinates (_gdk_root,
- x, y,
- toplevel,
- &x_toplevel, &y_toplevel);
+ toplevel_impl = (GdkWindowImplQuartz *)toplevel->impl;
- get_converted_window_coordinates (_gdk_root,
- x, y,
- mouse_window,
- &x, &y);
+ *x = x_tmp;
+ *y = y_tmp;
+ }
- /* 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];
+ return toplevel;
}
- 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... */
+ return NULL;
}
/* This function finds the correct window to send an event to, taking
gint *x_root,
gint *y_root)
{
+ GdkQuartzView *view;
GdkWindow *toplevel;
- GdkWindowObject *private;
- GdkWindowImplQuartz *impl;
- NSPoint point;
NSPoint screen_point;
NSEventType event_type;
- toplevel = [(GdkQuartzView *)[[nsevent window] contentView] gdkWindow];
- private = GDK_WINDOW_OBJECT (toplevel);
- impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
+ view = (GdkQuartzView *)[[nsevent window] contentView];
- point = [nsevent locationInWindow];
- screen_point = [[nsevent window] convertBaseToScreen:point];
-
- *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);
+ toplevel = get_toplevel_from_ns_event (nsevent, &screen_point, x, y);
+ _gdk_quartz_window_nspoint_to_gdk_xy (screen_point, x_root, y_root);
event_type = [nsevent type];
case NSLeftMouseDragged:
case NSRightMouseDragged:
case NSOtherMouseDragged:
- {
- 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 (grab->owner_events)
- return toplevel;
-
- /* Finally check the grab window. */
- if (grab->event_mask & get_event_mask_from_ns_event (nsevent))
- {
- GdkWindow *grab_toplevel;
- GdkWindowObject *grab_private;
- NSPoint point;
- NSWindow *grab_nswindow;
-
- grab_toplevel = gdk_window_get_toplevel (grab->window);
- grab_private = (GdkWindowObject *)grab_toplevel;
-
- point = [[nsevent window] convertBaseToScreen:[nsevent locationInWindow]];
-
- grab_nswindow = ((GdkWindowImplQuartz *)private->impl)->toplevel;
- point = [grab_nswindow convertScreenToBase:point];
-
- *x = point.x;
- *y = grab_private->height - point.y;
-
- /* Note: x_root and y_root are already right. */
-
- return grab_toplevel;
- }
-
- return NULL;
- }
- else
- {
- /* The non-grabbed case. */
-
- /* Leave events above the window (e.g. possibly on the titlebar)
- * to cocoa.
- */
- if (*y < 0)
- return NULL;
-
- /* FIXME: Also need to leave resize events to cocoa somehow? */
-
- return toplevel;
- }
- }
- break;
+ return find_toplevel_for_mouse_event (nsevent, x, y);
case NSMouseEntered:
case NSMouseExited:
- return toplevel;
+ /* Only handle our own entered/exited events, not the ones for the
+ * titlebar buttons.
+ */
+ if ([view trackingRect] == [nsevent trackingNumber])
+ return toplevel;
+ else
+ return NULL;
case NSKeyDown:
case NSKeyUp:
case NSFlagsChanged:
- {
- if (_gdk_display->keyboard_grab.window && !_gdk_display->keyboard_grab.owner_events)
- return gdk_window_get_toplevel (_gdk_display->keyboard_grab.window);
-
- return toplevel;
- }
- break;
+ return find_toplevel_for_keyboard_event (nsevent);
default:
/* Ignore everything else. */
GdkCrossingMode mode,
GdkNotifyType detail)
{
- GdkWindowObject *private;
- NSPoint point;
-
- private = GDK_WINDOW_OBJECT (toplevel);
-
- point = [nsevent locationInWindow];
-
event->any.type = event_type;
event->crossing.window = toplevel;
event->crossing.subwindow = NULL;
event->crossing.y_root = y_root;
event->crossing.mode = mode;
event->crossing.detail = detail;
- event->crossing.state = get_keyboard_modifiers_from_ns_event (nsevent);
+ event->crossing.state = get_keyboard_modifiers_from_ns_event (nsevent) |
+ _gdk_quartz_events_get_current_mouse_modifiers ();
+
+ gdk_event_set_device (event, _gdk_display->core_pointer);
/* FIXME: Focus and button state? */
}
{
GdkEventType type;
gint state;
- gint button;
- state = get_keyboard_modifiers_from_ns_event (nsevent);
+ state = get_keyboard_modifiers_from_ns_event (nsevent) |
+ _gdk_quartz_events_get_current_mouse_modifiers ();
switch ([nsevent type])
{
case NSRightMouseDown:
case NSOtherMouseDown:
type = GDK_BUTTON_PRESS;
+ state &= ~get_mouse_button_modifiers_from_ns_event (nsevent);
break;
+
case NSLeftMouseUp:
case NSRightMouseUp:
case NSOtherMouseUp:
type = GDK_BUTTON_RELEASE;
state |= get_mouse_button_modifiers_from_ns_event (nsevent);
break;
+
default:
g_assert_not_reached ();
}
-
- button = get_mouse_button_from_ns_event (nsevent);
event->any.type = type;
event->button.window = window;
event->button.y_root = y_root;
/* FIXME event->axes */
event->button.state = state;
- event->button.button = button;
+ event->button.button = get_mouse_button_from_ns_event (nsevent);
event->button.device = _gdk_display->core_pointer;
}
gint x_root,
gint y_root)
{
- GdkModifierType state;
-
- state = get_keyboard_modifiers_from_ns_event (nsevent);
-
- switch ([nsevent type])
- {
- case NSLeftMouseDragged:
- case NSRightMouseDragged:
- case NSOtherMouseDragged:
- state |= get_mouse_button_modifiers_from_ns_event (nsevent);
- break;
-
- case NSMouseMoved:
- break;
- }
-
event->any.type = GDK_MOTION_NOTIFY;
event->motion.window = window;
event->motion.time = get_time_from_ns_event (nsevent);
event->motion.x_root = x_root;
event->motion.y_root = y_root;
/* FIXME event->axes */
- event->motion.state = state;
+ event->motion.state = get_keyboard_modifiers_from_ns_event (nsevent) |
+ _gdk_quartz_events_get_current_mouse_modifiers ();
event->motion.is_hint = FALSE;
event->motion.device = _gdk_display->core_pointer;
}
gint y,
gint x_root,
gint y_root,
+ gdouble delta_x,
+ gdouble delta_y,
GdkScrollDirection direction)
{
- GdkWindowObject *private;
NSPoint point;
- private = GDK_WINDOW_OBJECT (window);
-
point = [nsevent locationInWindow];
event->any.type = GDK_SCROLL;
event->scroll.state = get_keyboard_modifiers_from_ns_event (nsevent);
event->scroll.direction = direction;
event->scroll.device = _gdk_display->core_pointer;
+ event->scroll.delta_x = delta_x;
+ event->scroll.delta_y = delta_y;
}
static void
GdkEventType type)
{
GdkEventPrivate *priv;
+ GdkQuartzDeviceManagerCore *device_manager;
gchar buf[7];
gunichar c = 0;
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;
+ event->key.keyval = GDK_KEY_VoidSymbol;
+
+ device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
+ gdk_event_set_device (event, device_manager->core_keyboard);
- gdk_keymap_translate_keyboard_state (NULL,
+ gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (_gdk_display),
event->key.hardware_keycode,
event->key.state,
event->key.group,
switch (event->key.keyval)
{
- case GDK_Meta_R:
- case GDK_Meta_L:
- mask = GDK_MOD1_MASK;
+ case GDK_KEY_Meta_R:
+ case GDK_KEY_Meta_L:
+ mask = GDK_MOD2_MASK;
break;
- case GDK_Shift_R:
- case GDK_Shift_L:
+ case GDK_KEY_Shift_R:
+ case GDK_KEY_Shift_L:
mask = GDK_SHIFT_MASK;
break;
- case GDK_Caps_Lock:
+ case GDK_KEY_Caps_Lock:
mask = GDK_LOCK_MASK;
break;
- case GDK_Alt_R:
- case GDK_Alt_L:
- mask = GDK_MOD5_MASK;
+ case GDK_KEY_Alt_R:
+ case GDK_KEY_Alt_L:
+ mask = GDK_MOD1_MASK;
break;
- case GDK_Control_R:
- case GDK_Control_L:
+ case GDK_KEY_Control_R:
+ case GDK_KEY_Control_L:
mask = GDK_CONTROL_MASK;
break;
default:
event->key.state |= mask;
}
- event->key.state |= current_button_state;
+ event->key.state |= _gdk_quartz_events_get_current_mouse_modifiers ();
+
+ /* The X11 backend adds the first virtual modifier MOD2..MOD5 are
+ * mapped to. Since we only have one virtual modifier in the quartz
+ * backend, calling the standard function will do.
+ */
+ gdk_keymap_add_virtual_modifiers (gdk_keymap_get_for_display (_gdk_display),
+ &event->key.state);
event->key.string = NULL;
/* Fill in ->string since apps depend on it, taken from the x11 backend. */
- if (event->key.keyval != GDK_VoidSymbol)
+ if (event->key.keyval != GDK_KEY_VoidSymbol)
c = gdk_keyval_to_unicode (event->key.keyval);
- if (c)
+ if (c)
{
gsize bytes_written;
gint len;
if (event->key.string)
event->key.length = bytes_written;
}
- else if (event->key.keyval == GDK_Escape)
+ else if (event->key.keyval == GDK_KEY_Escape)
{
event->key.length = 1;
event->key.string = g_strdup ("\033");
}
- else if (event->key.keyval == GDK_Return ||
- event->key.keyval == GDK_KP_Enter)
+ else if (event->key.keyval == GDK_KEY_Return ||
+ event->key.keyval == GDK_KEY_KP_Enter)
{
event->key.length = 1;
event->key.string = g_strdup ("\r");
gint x_root,
gint y_root)
{
- GdkWindowObject *private;
-
- private = GDK_WINDOW_OBJECT (window);
-
- /* FIXME: had this before csw:
- _gdk_quartz_events_update_mouse_window (window);
- if (window && !_gdk_quartz_pointer_grab_window)
- _gdk_quartz_events_update_cursor (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;
+ /* Enter events are considered always to be from the root window as we
+ * can't know for sure from what window we enter.
+ */
+ if (!(window->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);
- }
+ 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;
+ /* 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 (!(window->event_mask & GDK_LEAVE_NOTIFY_MASK))
+ return FALSE;
- /*if (!mouse_window ||
- gdk_window_get_toplevel (mouse_window) ==
- gdk_window_get_toplevel (current_mouse_window))
- {
- mouse_window = _gdk_root;
- }
- */
-
- fill_crossing_event (window, event, nsevent,
- x, y,
- x_root, y_root,
- GDK_LEAVE_NOTIFY,
- GDK_CROSSING_NORMAL,
- GDK_NOTIFY_ANCESTOR);
- }
+ fill_crossing_event (window, event, nsevent,
+ x, y,
+ x_root, y_root,
+ GDK_LEAVE_NOTIFY,
+ GDK_CROSSING_NORMAL,
+ GDK_NOTIFY_ANCESTOR);
return TRUE;
default:
return FALSE;
}
-GdkEventMask
-_gdk_quartz_events_get_current_event_mask (void)
+GdkModifierType
+_gdk_quartz_events_get_current_keyboard_modifiers (void)
+{
+ if (gdk_quartz_osx_version () >= GDK_OSX_SNOW_LEOPARD)
+ {
+ return get_keyboard_modifiers_from_ns_flags ([NSClassFromString(@"NSEvent") modifierFlags]);
+ }
+ else
+ {
+ guint carbon_modifiers = GetCurrentKeyModifiers ();
+ GdkModifierType modifiers = 0;
+
+ if (carbon_modifiers & alphaLock)
+ modifiers |= GDK_LOCK_MASK;
+ if (carbon_modifiers & shiftKey)
+ modifiers |= GDK_SHIFT_MASK;
+ if (carbon_modifiers & controlKey)
+ modifiers |= GDK_CONTROL_MASK;
+ if (carbon_modifiers & optionKey)
+ modifiers |= GDK_MOD1_MASK;
+ if (carbon_modifiers & cmdKey)
+ modifiers |= GDK_MOD2_MASK;
+
+ return modifiers;
+ }
+}
+
+GdkModifierType
+_gdk_quartz_events_get_current_mouse_modifiers (void)
{
- return current_event_mask;
+ if (gdk_quartz_osx_version () >= GDK_OSX_SNOW_LEOPARD)
+ {
+ return get_mouse_button_modifiers_from_ns_buttons ([NSClassFromString(@"NSEvent") pressedMouseButtons]);
+ }
+ else
+ {
+ return get_mouse_button_modifiers_from_ns_buttons (GetCurrentButtonState ());
+ }
+}
+
+/* Detect window resizing */
+
+static gboolean
+test_resize (NSEvent *event, GdkWindow *toplevel, gint x, gint y)
+{
+ GdkWindowImplQuartz *toplevel_impl;
+ gboolean lion;
+
+ /* Resizing from the resize indicator only begins if an NSLeftMouseButton
+ * event is received in the resizing area.
+ */
+ toplevel_impl = (GdkWindowImplQuartz *)toplevel->impl;
+ if ([toplevel_impl->toplevel showsResizeIndicator])
+ if ([event type] == NSLeftMouseDown &&
+ [toplevel_impl->toplevel showsResizeIndicator])
+ {
+ NSRect frame;
+
+ /* If the resize indicator is visible and the event
+ * is in the lower right 15x15 corner, we leave these
+ * events to Cocoa as to be handled as resize events.
+ * Applications may have widgets in this area. These
+ * will most likely be larger than 15x15 and for
+ * scroll bars there are also other means to move
+ * the scroll bar. Since the resize indicator is
+ * the only way of resizing windows on Mac OS, it
+ * is too important to not make functional.
+ */
+ frame = [toplevel_impl->view bounds];
+ if (x > frame.size.width - GRIP_WIDTH &&
+ x < frame.size.width &&
+ y > frame.size.height - GRIP_HEIGHT &&
+ y < frame.size.height)
+ return TRUE;
+ }
+
+ /* If we're on Lion and within 5 pixels of an edge,
+ * then assume that the user wants to resize, and
+ * return NULL to let Quartz get on with it. We check
+ * the selector isRestorable to see if we're on 10.7.
+ * This extra check is in case the user starts
+ * dragging before GDK recognizes the grab.
+ *
+ * We perform this check for a button press of all buttons, because we
+ * do receive, for instance, a right mouse down event for a GDK window
+ * for x-coordinate range [-3, 0], but we do not want to forward this
+ * into GDK. Forwarding such events into GDK will confuse the pointer
+ * window finding code, because there are no GdkWindows present in
+ * the range [-3, 0].
+ */
+ lion = gdk_quartz_osx_version () >= GDK_OSX_LION;
+ if (lion &&
+ ([event type] == NSLeftMouseDown ||
+ [event type] == NSRightMouseDown ||
+ [event type] == NSOtherMouseDown))
+ {
+ if (x < GDK_LION_RESIZE ||
+ x > toplevel->width - GDK_LION_RESIZE ||
+ y > toplevel->height - GDK_LION_RESIZE)
+ return TRUE;
+ }
+
+ return FALSE;
}
static gboolean
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).
*/
if (event_type == NSAppKitDefined)
{
if ([nsevent subtype] == NSApplicationDeactivatedEventType)
- break_all_grabs (get_time_from_ns_event (nsevent));
+ _gdk_quartz_events_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
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;
- result = gdk_event_apply_filters (nsevent, event, _gdk_default_filters);
+ result = gdk_event_apply_filters (nsevent, event, &_gdk_default_filters);
if (result != GDK_FILTER_CONTINUE)
{
return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
nswindow = [nsevent window];
- /* Ignore events for no window or ones not created by GDK. */
- if (!nswindow || ![[nswindow contentView] isKindOfClass:[GdkQuartzView class]])
+ /* Ignore events for windows not created by GDK. */
+ if (nswindow && ![[nswindow contentView] isKindOfClass:[GdkQuartzView class]])
return FALSE;
+ /* Ignore events for ones with no windows */
+ if (!nswindow)
+ {
+ GdkWindow *toplevel = NULL;
+
+ if (event_type == NSMouseMoved)
+ {
+ /* Motion events received after clicking the menu bar do not have the
+ * window field set. Instead of giving up on the event immediately,
+ * we first check whether this event is within our window bounds.
+ */
+ NSPoint screen_point = [NSEvent mouseLocation];
+ gint x_tmp, y_tmp;
+
+ toplevel = find_toplevel_under_pointer (_gdk_display,
+ screen_point,
+ &x_tmp, &y_tmp);
+ }
+
+ if (!toplevel)
+ 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 ([(GdkQuartzNSWindow *)nswindow isInMove])
{
- break_all_grabs (get_time_from_ns_event (nsevent));
+ _gdk_quartz_events_break_all_grabs (get_time_from_ns_event (nsevent));
return FALSE;
}
+ /* Also when in a manual resize, we ignore events so that these are
+ * pushed to GdkQuartzWindow's sendEvent handler.
+ */
+ if ([(GdkQuartzWindow *)nswindow isInManualResize])
+ return FALSE;
+
/* Find the right GDK window to send the event to, taking grabs and
* event masks into consideration.
*/
if (!window)
return FALSE;
+ /* Quartz handles resizing on its own, so we want to stay out of the way. */
+ if (test_resize (nsevent, window, x, y))
+ return FALSE;
+
/* Apply any window filters. */
if (GDK_IS_WINDOW (window))
{
- GdkWindowObject *filter_private = (GdkWindowObject *) window;
GdkFilterReturn result;
- if (filter_private->filters)
+ if (window->filters)
{
g_object_ref (window);
- result = gdk_event_apply_filters (nsevent, event, filter_private->filters);
+ result = gdk_event_apply_filters (nsevent, event, &window->filters);
g_object_unref (window);
}
}
- /* 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 the app is not active leave the event to AppKit so the window gets
+ * focused correctly and don't do click-through (so we behave like most
+ * native apps). If the app is active, we focus the window and then handle
+ * the event, also to match native apps.
*/
if ((event_type == NSRightMouseDown ||
event_type == NSOtherMouseDown ||
event_type == NSLeftMouseDown))
{
- GdkWindowObject *private = (GdkWindowObject *)window;
- GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
+ GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
if (![NSApp isActive])
- return FALSE;
+ {
+ [NSApp activateIgnoringOtherApps:YES];
+ return FALSE;
+ }
else if (![impl->toplevel isKeyWindow])
- return FALSE;
- }
+ {
+ GdkDeviceGrabInfo *grab;
- current_event_mask = get_event_mask_from_ns_event (nsevent);
+ grab = _gdk_display_get_last_device_grab (_gdk_display,
+ _gdk_display->core_pointer);
+ if (!grab)
+ [impl->toplevel makeKeyWindow];
+ }
+ }
return_val = TRUE;
case NSLeftMouseDown:
case NSRightMouseDown:
case NSOtherMouseDown:
- fill_button_event (window, event, nsevent, x, y, x_root, y_root);
- break;
-
case NSLeftMouseUp:
case NSRightMouseUp:
case NSOtherMouseUp:
case NSScrollWheel:
{
- float dx = [nsevent deltaX];
- float dy = [nsevent deltaY];
- GdkScrollDirection direction;
+ GdkScrollDirection direction;
+ float dx;
+ float dy;
+#ifdef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER
+ if (gdk_quartz_osx_version() >= GDK_OSX_LION &&
+ [nsevent hasPreciseScrollingDeltas])
+ {
+ dx = [nsevent scrollingDeltaX];
+ dy = [nsevent scrollingDeltaY];
+ direction = GDK_SCROLL_SMOOTH;
+
+ fill_scroll_event (window, event, nsevent, x, y, x_root, y_root,
+ -dx, -dy, direction);
+
+ /* Fall through for scroll buttons emulation */
+ }
+#endif
+ dx = [nsevent deltaX];
+ dy = [nsevent deltaY];
- if (dy != 0)
+ if (dy != 0.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);
+ dy = fabs (dy);
+ dx = 0.0;
}
-
- if (dx != 0)
+ else if (dx != 0.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);
+ dx = fabs (dx);
+ dy = 0.0;
+ }
+
+ if (dx != 0.0 || dy != 0.0)
+ {
+#ifdef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER
+ if (gdk_quartz_osx_version() >= GDK_OSX_LION &[nsevent hasPreciseScrollingDeltas])
+ {
+ GdkEvent *emulated_event;
+
+ emulated_event = gdk_event_new (GDK_SCROLL);
+ _gdk_event_set_pointer_emulated (emulated_event, TRUE);
+ fill_scroll_event (window, emulated_event, nsevent,
+ x, y, x_root, y_root,
+ dx, dy, direction);
+ append_event (emulated_event, TRUE);
+ }
+ else
+#endif
+ fill_scroll_event (window, event, nsevent,
+ x, y, x_root, y_root,
+ dx, dy, direction);
}
}
break;
}
void
-_gdk_events_queue (GdkDisplay *display)
+_gdk_quartz_display_queue_events (GdkDisplay *display)
{
NSEvent *nsevent;
g_list_free_1 (node);
gdk_event_free (event);
- GDK_THREADS_LEAVE ();
+ gdk_threads_leave ();
[NSApp sendEvent:nsevent];
- GDK_THREADS_ENTER ();
+ gdk_threads_enter ();
}
_gdk_quartz_event_loop_release_event (nsevent);
}
void
-gdk_flush (void)
-{
- /* Not supported. */
-}
-
-void
-gdk_display_add_client_message_filter (GdkDisplay *display,
- GdkAtom message_type,
- GdkFilterFunc func,
- gpointer data)
-{
- /* Not supported. */
-}
-
-void
-gdk_add_client_message_filter (GdkAtom message_type,
- GdkFilterFunc func,
- gpointer data)
-{
- /* Not supported. */
-}
-
-void
-gdk_display_sync (GdkDisplay *display)
-{
- /* Not supported. */
-}
-
-void
-gdk_display_flush (GdkDisplay *display)
-{
- /* Not supported. */
-}
-
-gboolean
-gdk_event_send_client_message_for_display (GdkDisplay *display,
- GdkEvent *event,
- GdkNativeWindow winid)
-{
- /* Not supported. */
- return FALSE;
-}
-
-void
-gdk_screen_broadcast_client_message (GdkScreen *screen,
- GdkEvent *event)
+_gdk_quartz_screen_broadcast_client_message (GdkScreen *screen,
+ GdkEvent *event)
{
/* Not supported. */
}
gboolean
-gdk_screen_get_setting (GdkScreen *screen,
- const gchar *name,
- GValue *value)
+_gdk_quartz_screen_get_setting (GdkScreen *screen,
+ const gchar *name,
+ GValue *value)
{
if (strcmp (name, "gtk-double-click-time") == 0)
{
GDK_QUARTZ_RELEASE_POOL;
+ return TRUE;
+ }
+ else if (strcmp (name, "gtk-primary-button-warps-slider") == 0)
+ {
+ GDK_QUARTZ_ALLOC_POOL;
+
+ BOOL setting = [[NSUserDefaults standardUserDefaults] boolForKey:@"AppleScrollerPagingBehavior"];
+
+ /* If the Apple property is YES, it means "warp" */
+ g_value_set_boolean (value, setting == YES);
+
+ GDK_QUARTZ_RELEASE_POOL;
+
return TRUE;
}
}
void
-_gdk_windowing_event_data_copy (const GdkEvent *src,
- GdkEvent *dst)
+_gdk_quartz_display_event_data_copy (GdkDisplay *display,
+ const GdkEvent *src,
+ GdkEvent *dst)
{
GdkEventPrivate *priv_src = (GdkEventPrivate *) src;
GdkEventPrivate *priv_dst = (GdkEventPrivate *) dst;
}
void
-_gdk_windowing_event_data_free (GdkEvent *event)
+_gdk_quartz_display_event_data_free (GdkDisplay *display,
+ GdkEvent *event)
{
GdkEventPrivate *priv = (GdkEventPrivate *) event;