AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-14 12:41:07 +00:00
Code Issues Projects Releases Wiki Activity
87e8265a2d
gtk/gdk/macos/gdkmacosdisplay-translate.c
Arjan Molenaar b7f3beda00 macos: Map Cmd directly to Meta 
Why need a mapping via a MOD2 mask?
2024-06-28 10:29:57 +02:00

1291 lines
40 KiB
C
Raw Blame History

/*
* Copyright 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
* Copyright 1998-2002 Tor Lillqvist
* Copyright 2005-2008 Imendio AB
* Copyright 2020 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* 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, see <http://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include "config.h"
#import "GdkMacosWindow.h"
#import "GdkMacosBaseView.h"
#include "gdkmacosdisplay-private.h"
#include "gdkmacoskeymap-private.h"
#include "gdkmacossurface-private.h"
#include "gdkmacosseat-private.h"
#include "gdk/gdkeventsprivate.h"
#define GRIP_WIDTH 15
#define GRIP_HEIGHT 15
#define GDK_LION_RESIZE 5
static gboolean
test_resize (NSEvent *event,
GdkMacosSurface *surface,
int x,
int y)
{
NSWindow *window;
g_assert (event != NULL);
g_assert (GDK_IS_MACOS_SURFACE (surface));
window = _gdk_macos_surface_get_native (surface);
/* Resizing from the resize indicator only begins if an NSLeftMouseButton
* event is received in the resizing area.
*/
if ([event type] == NSEventTypeLeftMouseDown &&
[window 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 = [[window contentView] 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 surface
* 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 GdkSurfaces present in
* the range [-3, 0].
*/
if (([event type] == NSEventTypeLeftMouseDown ||
[event type] == NSEventTypeRightMouseDown ||
[event type] == NSEventTypeOtherMouseDown))
{
if (x < GDK_LION_RESIZE ||
x > GDK_SURFACE (surface)->width - GDK_LION_RESIZE ||
y > GDK_SURFACE (surface)->height - GDK_LION_RESIZE)
return TRUE;
}
return FALSE;
}
static guint32
get_time_from_ns_event (NSEvent *event)
{
double time = [event timestamp];
/* 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)
{
NSInteger button = [event buttonNumber];
switch (button)
{
case 0:
return 1;
case 1:
return 3;
case 2:
return 2;
default:
return button + 1;
}
}
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)
{
GdkModifierType state = 0;
int button;
/* 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_flags (NSUInteger nsflags)
{
GdkModifierType modifiers = 0;
if (nsflags & NSEventModifierFlagCapsLock)
modifiers |= GDK_LOCK_MASK;
if (nsflags & NSEventModifierFlagShift)
modifiers |= GDK_SHIFT_MASK;
if (nsflags & NSEventModifierFlagControl)
modifiers |= GDK_CONTROL_MASK;
if (nsflags & NSEventModifierFlagOption)
modifiers |= GDK_ALT_MASK;
if (nsflags & NSEventModifierFlagCommand)
modifiers |= GDK_META_MASK;
return modifiers;
}
static GdkModifierType
get_keyboard_modifiers_from_ns_event (NSEvent *nsevent)
{
return get_keyboard_modifiers_from_ns_flags ([nsevent modifierFlags]);
}
GdkModifierType
_gdk_macos_display_get_current_mouse_modifiers (GdkMacosDisplay *self)
{
return get_mouse_button_modifiers_from_ns_buttons ([NSEvent pressedMouseButtons]);
}
GdkModifierType
_gdk_macos_display_get_current_keyboard_modifiers (GdkMacosDisplay *self)
{
return get_keyboard_modifiers_from_ns_flags ([NSEvent modifierFlags]);
}
static GdkEvent *
fill_button_event (GdkMacosDisplay *display,
GdkMacosSurface *surface,
NSEvent *nsevent,
int x,
int y)
{
GdkSeat *seat;
GdkEventType type;
GdkModifierType state;
GdkDevice *pointer = NULL;
GdkDeviceTool *tool = NULL;
double *axes = NULL;
cairo_region_t *input_region;
g_assert (GDK_IS_MACOS_DISPLAY (display));
g_assert (GDK_IS_MACOS_SURFACE (surface));
seat = gdk_display_get_default_seat (GDK_DISPLAY (display));
state = get_keyboard_modifiers_from_ns_event (nsevent) |
_gdk_macos_display_get_current_mouse_modifiers (display);
input_region = GDK_SURFACE (surface)->input_region;
switch ((int)[nsevent type])
{
case NSEventTypeLeftMouseDown:
case NSEventTypeRightMouseDown:
case NSEventTypeOtherMouseDown:
type = GDK_BUTTON_PRESS;
state &= ~get_mouse_button_modifiers_from_ns_event (nsevent);
break;
case NSEventTypeLeftMouseUp:
case NSEventTypeRightMouseUp:
case NSEventTypeOtherMouseUp:
type = GDK_BUTTON_RELEASE;
state |= get_mouse_button_modifiers_from_ns_event (nsevent);
break;
default:
g_assert_not_reached ();
}
/* Ignore button press events outside the window coords but
* allow for button release which can happen during grabs.
*/
if (type == GDK_BUTTON_PRESS &&
(x < 0 || x > GDK_SURFACE (surface)->width ||
y < 0 || y > GDK_SURFACE (surface)->height ||
(input_region && !cairo_region_contains_point (input_region, x, y))))
return NULL;
if (([nsevent subtype] == NSEventSubtypeTabletPoint) &&
_gdk_macos_seat_get_tablet (GDK_MACOS_SEAT (seat), &pointer, &tool))
axes = _gdk_macos_seat_get_tablet_axes_from_nsevent (GDK_MACOS_SEAT (seat), nsevent);
else
pointer = gdk_seat_get_pointer (seat);
return gdk_button_event_new (type,
GDK_SURFACE (surface),
pointer,
tool,
get_time_from_ns_event (nsevent),
state,
get_mouse_button_from_ns_event (nsevent),
x,
y,
axes);
}
static GdkEvent *
synthesize_crossing_event (GdkMacosDisplay *display,
GdkMacosSurface *surface,
NSEvent *nsevent,
int x,
int y)
{
GdkEventType event_type;
GdkModifierType state;
GdkSeat *seat;
switch ((int)[nsevent type])
{
case NSEventTypeMouseEntered:
event_type = GDK_ENTER_NOTIFY;
break;
case NSEventTypeMouseExited:
event_type = GDK_LEAVE_NOTIFY;
break;
default:
g_return_val_if_reached (NULL);
}
state = get_keyboard_modifiers_from_ns_event (nsevent) |
_gdk_macos_display_get_current_mouse_modifiers (display);
seat = gdk_display_get_default_seat (GDK_DISPLAY (display));
return gdk_crossing_event_new (event_type,
GDK_SURFACE (surface),
gdk_seat_get_pointer (seat),
get_time_from_ns_event (nsevent),
state,
x,
y,
GDK_CROSSING_NORMAL,
GDK_NOTIFY_NONLINEAR);
}
static inline guint
get_group_from_ns_event (NSEvent *nsevent)
{
return ([nsevent modifierFlags] & NSEventModifierFlagOption) ? 1 : 0;
}
static GdkEvent *
fill_key_event (GdkMacosDisplay *display,
GdkMacosSurface *surface,
NSEvent *nsevent,
GdkEventType type)
{
GdkTranslatedKey translated = {0};
GdkTranslatedKey no_lock = {0};
GdkModifierType consumed;
GdkModifierType state;
GdkKeymap *keymap;
gboolean is_modifier;
GdkSeat *seat;
guint keycode;
guint keyval;
guint group;
int layout;
int level;
g_assert (GDK_IS_MACOS_DISPLAY (display));
g_assert (GDK_IS_MACOS_SURFACE (surface));
g_assert (nsevent != NULL);
seat = gdk_display_get_default_seat (GDK_DISPLAY (display));
keymap = gdk_display_get_keymap (GDK_DISPLAY (display));
keycode = [nsevent keyCode];
keyval = GDK_KEY_VoidSymbol;
state = get_keyboard_modifiers_from_ns_event (nsevent);
group = get_group_from_ns_event (nsevent);
is_modifier = _gdk_macos_keymap_is_modifier (keycode);
gdk_keymap_translate_keyboard_state (keymap, keycode, state, group,
&keyval, &layout, &level, &consumed);
/* 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 (is_modifier)
{
guint mask = 0;
switch (keyval)
{
case GDK_KEY_Meta_R:
case GDK_KEY_Meta_L:
mask = GDK_META_MASK;
break;
case GDK_KEY_Shift_R:
case GDK_KEY_Shift_L:
mask = GDK_SHIFT_MASK;
break;
case GDK_KEY_Caps_Lock:
mask = GDK_LOCK_MASK;
break;
case GDK_KEY_Alt_R:
case GDK_KEY_Alt_L:
mask = GDK_ALT_MASK;
break;
case GDK_KEY_Control_R:
case GDK_KEY_Control_L:
mask = GDK_CONTROL_MASK;
break;
default:
mask = 0;
}
if (type == GDK_KEY_PRESS)
state &= ~mask;
else if (type == GDK_KEY_RELEASE)
state |= mask;
}
state |= _gdk_macos_display_get_current_mouse_modifiers (display);
translated.keyval = keyval;
translated.consumed = consumed;
translated.layout = layout;
translated.level = level;
if (state & GDK_LOCK_MASK)
{
gdk_keymap_translate_keyboard_state (keymap,
keycode,
state & ~GDK_LOCK_MASK,
group,
&keyval,
&layout,
&level,
&consumed);
no_lock.keyval = keycode;
no_lock.consumed = consumed;
no_lock.layout = layout;
no_lock.level = level;
}
else
{
no_lock = translated;
}
return gdk_key_event_new (type,
GDK_SURFACE (surface),
gdk_seat_get_keyboard (seat),
get_time_from_ns_event (nsevent),
[nsevent keyCode],
state,
is_modifier,
&translated,
&no_lock,
NULL);
}
static GdkEvent *
fill_pinch_event (GdkMacosDisplay *display,
GdkMacosSurface *surface,
NSEvent *nsevent,
int x,
int y)
{
static double last_scale = 1.0;
static enum {
FP_STATE_IDLE,
FP_STATE_UPDATE
} last_state = FP_STATE_IDLE;
GdkSeat *seat;
GdkTouchpadGesturePhase phase;
double angle_delta = 0.0;
g_assert (GDK_IS_MACOS_DISPLAY (display));
g_assert (GDK_IS_MACOS_SURFACE (surface));
/* fill_pinch_event handles the conversion from the two OSX gesture events
* NSEventTypeMagnfiy and NSEventTypeRotate to the GDK_TOUCHPAD_PINCH event.
* The normal behavior of the OSX events is that they produce as sequence of
* 1 x NSEventPhaseBegan,
* n x NSEventPhaseChanged,
* 1 x NSEventPhaseEnded
* This can happen for both the Magnify and the Rotate events independently.
* As both events are summarized in one GDK_TOUCHPAD_PINCH event sequence, a
* little state machine handles the case of two NSEventPhaseBegan events in
* a sequence, e.g. Magnify(Began), Magnify(Changed)..., Rotate(Began)...
* such that PINCH(STARTED), PINCH(UPDATE).... will not show a second
* PINCH(STARTED) event.
*/
switch ((int)[nsevent phase])
{
case NSEventPhaseBegan:
switch (last_state)
{
case FP_STATE_IDLE:
phase = GDK_TOUCHPAD_GESTURE_PHASE_BEGIN;
last_state = FP_STATE_UPDATE;
last_scale = 1.0;
break;
case FP_STATE_UPDATE:
/* We have already received a PhaseBegan event but no PhaseEnded
event. This can happen, e.g. Magnify(Began), Magnify(Change)...
Rotate(Began), Rotate (Change),...., Magnify(End) Rotate(End)
*/
phase = GDK_TOUCHPAD_GESTURE_PHASE_UPDATE;
break;
}
break;
case NSEventPhaseChanged:
phase = GDK_TOUCHPAD_GESTURE_PHASE_UPDATE;
break;
case NSEventPhaseEnded:
phase = GDK_TOUCHPAD_GESTURE_PHASE_END;
switch (last_state)
{
case FP_STATE_IDLE:
/* We are idle but have received a second PhaseEnded event.
This can happen because we have Magnify and Rotate OSX
event sequences. We just send a second end GDK_PHASE_END.
*/
break;
case FP_STATE_UPDATE:
last_state = FP_STATE_IDLE;
break;
}
break;
case NSEventPhaseCancelled:
phase = GDK_TOUCHPAD_GESTURE_PHASE_CANCEL;
last_state = FP_STATE_IDLE;
break;
case NSEventPhaseMayBegin:
case NSEventPhaseStationary:
phase = GDK_TOUCHPAD_GESTURE_PHASE_CANCEL;
break;
default:
g_assert_not_reached ();
break;
}
switch ((int)[nsevent type])
{
case NSEventTypeMagnify:
last_scale *= [nsevent magnification] + 1.0;
angle_delta = 0.0;
break;
case NSEventTypeRotate:
angle_delta = - [nsevent rotation] * G_PI / 180.0;
break;
default:
g_assert_not_reached ();
}
seat = gdk_display_get_default_seat (GDK_DISPLAY (display));
return gdk_touchpad_event_new_pinch (GDK_SURFACE (surface),
NULL, /* FIXME make up sequences */
gdk_seat_get_pointer (seat),
get_time_from_ns_event (nsevent),
get_keyboard_modifiers_from_ns_event (nsevent),
phase,
x,
y,
2,
0.0,
0.0,
last_scale,
angle_delta);
}
static gboolean
is_motion_event (NSEventType event_type)
{
return (event_type == NSEventTypeLeftMouseDragged ||
event_type == NSEventTypeRightMouseDragged ||
event_type == NSEventTypeOtherMouseDragged ||
event_type == NSEventTypeMouseMoved);
}
static GdkEvent *
fill_motion_event (GdkMacosDisplay *display,
GdkMacosSurface *surface,
NSEvent *nsevent,
int x,
int y)
{
GdkSeat *seat;
GdkModifierType state;
GdkDevice *pointer = NULL;
GdkDeviceTool *tool = NULL;
double *axes = NULL;
g_assert (GDK_IS_MACOS_SURFACE (surface));
g_assert (nsevent != NULL);
g_assert (is_motion_event ([nsevent type]));
seat = gdk_display_get_default_seat (GDK_DISPLAY (display));
state = get_keyboard_modifiers_from_ns_event (nsevent) |
_gdk_macos_display_get_current_mouse_modifiers (display);
if (([nsevent subtype] == NSEventSubtypeTabletPoint) &&
_gdk_macos_seat_get_tablet (GDK_MACOS_SEAT (seat), &pointer, &tool))
axes = _gdk_macos_seat_get_tablet_axes_from_nsevent (GDK_MACOS_SEAT (seat), nsevent);
else
pointer = gdk_seat_get_pointer (seat);
return gdk_motion_event_new (GDK_SURFACE (surface),
pointer,
tool,
get_time_from_ns_event (nsevent),
state,
x,
y,
axes);
}
static GdkEvent *
fill_scroll_event (GdkMacosDisplay *self,
GdkMacosSurface *surface,
NSEvent *nsevent,
int x,
int y)
{
GdkScrollDirection direction = 0;
GdkModifierType state;
GdkDevice *pointer;
GdkEvent *ret = NULL;
NSEventPhase phase;
NSEventPhase momentumPhase;
GdkSeat *seat;
double dx;
double dy;
g_assert (GDK_IS_MACOS_SURFACE (surface));
g_assert (nsevent != NULL);
phase = [nsevent phase];
momentumPhase = [nsevent momentumPhase];
/* Ignore kinetic scroll events from the display server as we already
* handle those internally.
*/
if (phase == 0 && momentumPhase != 0)
return GDK_MACOS_EVENT_DROP;
seat = gdk_display_get_default_seat (GDK_DISPLAY (self));
pointer = gdk_seat_get_pointer (seat);
state = _gdk_macos_display_get_current_mouse_modifiers (self) |
_gdk_macos_display_get_current_keyboard_modifiers (self);
/* If we are starting a new phase, send a stop so any previous
* scrolling immediately stops.
*/
if (phase == NSEventPhaseMayBegin)
return gdk_scroll_event_new (GDK_SURFACE (surface),
pointer,
NULL,
get_time_from_ns_event (nsevent),
state,
0.0, 0.0, TRUE,
GDK_SCROLL_UNIT_SURFACE);
dx = [nsevent deltaX];
dy = [nsevent deltaY];
if ([nsevent hasPreciseScrollingDeltas])
{
double sx;
double sy;
sx = [nsevent scrollingDeltaX];
sy = [nsevent scrollingDeltaY];
if (sx != 0.0 || sy != 0.0)
ret = gdk_scroll_event_new (GDK_SURFACE (surface),
pointer,
NULL,
get_time_from_ns_event (nsevent),
state,
-sx,
-sy,
FALSE,
GDK_SCROLL_UNIT_SURFACE);
/* Fall through for scroll emulation */
}
if (dy != 0.0)
{
if (dy < 0.0)
direction = GDK_SCROLL_DOWN;
else
direction = GDK_SCROLL_UP;
dx = 0.0;
}
else if (dx != 0.0)
{
if (dx < 0.0)
direction = GDK_SCROLL_RIGHT;
else
direction = GDK_SCROLL_LEFT;
dy = 0.0;
}
if ((dx != 0.0 || dy != 0.0) && ![nsevent hasPreciseScrollingDeltas])
{
g_assert (ret == NULL);
ret = gdk_scroll_event_new_discrete (GDK_SURFACE (surface),
pointer,
NULL,
get_time_from_ns_event (nsevent),
state,
direction);
}
if (phase == NSEventPhaseEnded || phase == NSEventPhaseCancelled)
{
/* The user must have released their fingers in a touchpad
* scroll, so try to send a scroll is_stop event.
*/
if (ret != NULL)
_gdk_event_queue_append (GDK_DISPLAY (self), g_steal_pointer (&ret));
ret = gdk_scroll_event_new (GDK_SURFACE (surface),
pointer,
NULL,
get_time_from_ns_event (nsevent),
state,
0.0, 0.0, TRUE,
GDK_SCROLL_UNIT_SURFACE);
}
return g_steal_pointer (&ret);
}
static GdkEvent *
fill_event (GdkMacosDisplay *self,
GdkMacosWindow *window,
NSEvent *nsevent,
int x,
int y)
{
GdkMacosSurface *surface = [window gdkSurface];
NSEventType event_type = [nsevent type];
GdkEvent *ret = NULL;
switch ((int)event_type)
{
case NSEventTypeLeftMouseDown:
case NSEventTypeRightMouseDown:
case NSEventTypeOtherMouseDown:
case NSEventTypeLeftMouseUp:
case NSEventTypeRightMouseUp:
case NSEventTypeOtherMouseUp:
ret = fill_button_event (self, surface, nsevent, x, y);
break;
case NSEventTypeLeftMouseDragged:
case NSEventTypeRightMouseDragged:
case NSEventTypeOtherMouseDragged:
case NSEventTypeMouseMoved:
ret = fill_motion_event (self, surface, nsevent, x, y);
break;
case NSEventTypeMagnify:
case NSEventTypeRotate:
ret = fill_pinch_event (self, surface, nsevent, x, y);
break;
case NSEventTypeMouseExited:
case NSEventTypeMouseEntered:
{
GdkSeat *seat = gdk_display_get_default_seat (GDK_DISPLAY (self));
GdkDevice *pointer = gdk_seat_get_pointer (seat);
GdkDeviceGrabInfo *grab = _gdk_display_get_last_device_grab (GDK_DISPLAY (self), pointer);
if ([(GdkMacosWindow *)window isInManualResizeOrMove])
{
ret = GDK_MACOS_EVENT_DROP;
}
else if (grab == NULL || grab->owner_events)
{
if (event_type == NSEventTypeMouseExited)
[[NSCursor arrowCursor] set];
ret = synthesize_crossing_event (self, surface, nsevent, x, y);
}
}
break;
case NSEventTypeKeyDown:
case NSEventTypeKeyUp:
case NSEventTypeFlagsChanged: {
GdkEventType type = _gdk_macos_keymap_get_event_type (nsevent);
if (type)
ret = fill_key_event (self, surface, nsevent, type);
break;
}
case NSEventTypeScrollWheel:
ret = fill_scroll_event (self, surface, nsevent, x, y);
break;
default:
break;
}
return ret;
}
static gboolean
is_mouse_button_press_event (NSEventType type)
{
switch ((int)type)
{
case NSEventTypeLeftMouseDown:
case NSEventTypeRightMouseDown:
case NSEventTypeOtherMouseDown:
return TRUE;
default:
return FALSE;
}
}
static void
get_surface_point_from_screen_point (GdkSurface *surface,
NSPoint screen_point,
int *x,
int *y)
{
NSWindow *nswindow;
NSPoint point;
nswindow = _gdk_macos_surface_get_native (GDK_MACOS_SURFACE (surface));
point = convert_nspoint_from_screen (nswindow, screen_point);
*x = point.x;
*y = surface->height - point.y;
}
static GdkSurface *
find_surface_under_pointer (GdkMacosDisplay *self,
NSPoint screen_point,
int *x,
int *y)
{
GdkMacosSurface *surface;
int x_tmp, y_tmp;
surface = _gdk_macos_display_get_surface_at_display_coords (self,
screen_point.x,
screen_point.y,
&x_tmp,
&y_tmp);
if (surface != NULL)
{
_gdk_macos_display_from_display_coords (self,
screen_point.x,
screen_point.y,
&x_tmp, &y_tmp);
*x = x_tmp - surface->root_x;
*y = y_tmp - surface->root_y;
/* If the coordinates are out of window bounds, this surface is not
* under the pointer and we thus return NULL. This can occur when
* surface under pointer has not yet been updated due to a very recent
* window resize. Alternatively, we should no longer be relying on
* the surface_under_pointer value which is maintained in gdkwindow.c.
*/
if (*x < 0 ||
*y < 0 ||
*x >= GDK_SURFACE (surface)->width ||
*y >= GDK_SURFACE (surface)->height)
surface = NULL;
}
return GDK_SURFACE (surface);
}
static GdkSurface *
get_surface_from_ns_event (GdkMacosDisplay *self,
NSEvent *nsevent,
NSPoint *screen_point,
int *x,
int *y)
{
GdkSurface *surface = NULL;
NSWindow *nswindow = [nsevent window];
if (GDK_IS_MACOS_WINDOW (nswindow))
{
GdkMacosBaseView *view;
NSPoint point, view_point;
NSRect view_frame;
view = (GdkMacosBaseView *)[nswindow contentView];
if (!GDK_IS_MACOS_BASE_VIEW (view))
goto find_under_pointer;
surface = GDK_SURFACE ([view gdkSurface]);
point = [nsevent locationInWindow];
view_point = [view convertPoint:point fromView:nil];
view_frame = [view frame];
/* NSEvents come in with a window set, but with window coordinates
* out of window bounds. For e.g. moved events this is fine, we use
* this information to properly handle enter/leave notify and motion
* events. For mouse button press/release, we want to avoid forwarding
* these events however, because the window they relate to is not the
* window set in the event. This situation appears to occur when button
* presses come in just before (or just after?) a window is resized and
* also when a button press occurs on the OS X window titlebar.
*
* By setting surface to NULL, we do another attempt to get the right
* surface window below.
*/
if (is_mouse_button_press_event ([nsevent type]) &&
(view_point.x < view_frame.origin.x ||
view_point.x >= view_frame.origin.x + view_frame.size.width ||
view_point.y < view_frame.origin.y ||
view_point.y >= view_frame.origin.y + view_frame.size.height))
{
NSRect windowRect = [nswindow frame];
surface = NULL;
/* This is a hack for button presses to break all grabs. E.g. if
* a menu is open and one clicks on the title bar (or anywhere
* out of window bounds), we really want to pop down the menu (by
* breaking the grabs) before OS X handles the action of the title
* bar button.
*
* Because we cannot ingest this event into GDK, we have to do it
* here, not very nice.
*/
_gdk_macos_display_break_all_grabs (self, get_time_from_ns_event (nsevent));
/* If the X,Y is on the frame itself, then we don't want to discover
* the surface under the pointer at all so that we let OS X handle
* it instead. We add padding to include resize operations too.
*/
windowRect.origin.x = -GDK_LION_RESIZE;
windowRect.origin.y = -GDK_LION_RESIZE;
windowRect.size.width += (2 * GDK_LION_RESIZE);
windowRect.size.height += (2 * GDK_LION_RESIZE);
if (NSPointInRect (point, windowRect))
return NULL;
}
else
{
*screen_point = convert_nspoint_to_screen ([nsevent window], point);
*x = point.x;
*y = surface->height - point.y;
}
}
find_under_pointer:
if (surface == NULL && nswindow == NULL)
{
/* 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.
* This fallback will not return coordinates contained in a window's
* titlebar.
*/
*screen_point = [NSEvent mouseLocation];
surface = find_surface_under_pointer (self, *screen_point, x, y);
}
return surface;
}
static GdkMacosSurface *
find_surface_for_keyboard_event (NSEvent *nsevent)
{
NSView *nsview = [[nsevent window] contentView];
if (GDK_IS_MACOS_BASE_VIEW (nsview))
{
GdkMacosBaseView *view = (GdkMacosBaseView *)nsview;
GdkSurface *surface = GDK_SURFACE ([view gdkSurface]);
GdkDisplay *display = gdk_surface_get_display (surface);
GdkSeat *seat = gdk_display_get_default_seat (display);
GdkDevice *device = gdk_seat_get_keyboard (seat);
GdkDeviceGrabInfo *grab = _gdk_display_get_last_device_grab (display, device);
if (grab && grab->surface && !grab->owner_events)
return GDK_MACOS_SURFACE (grab->surface);
return GDK_MACOS_SURFACE (surface);
}
return NULL;
}
static GdkMacosSurface *
find_surface_for_mouse_event (GdkMacosDisplay *self,
NSEvent *nsevent,
int *x,
int *y)
{
NSPoint point;
NSEventType event_type;
GdkSurface *surface;
GdkDisplay *display;
GdkDevice *pointer;
GdkDeviceGrabInfo *grab;
GdkSeat *seat;
/* Even if we had a surface window, it might be for something outside
* the input region (shadow) which we might want to ignore. This is
* handled for us deeper in the event unwrapping.
*/
if (!(surface = get_surface_from_ns_event (self, nsevent, &point, x, y)))
return NULL;
display = gdk_surface_get_display (surface);
seat = gdk_display_get_default_seat (GDK_DISPLAY (self));
pointer = gdk_seat_get_pointer (seat);
event_type = [nsevent type];
/* 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.
*/
if ((grab = _gdk_display_get_last_device_grab (display, pointer)))
{
if (grab->owner_events)
{
/* For owner events, we need to use the surface under the
* pointer, not the window from the NSEvent, since that is
* reported with respect to the key window, which could be
* wrong.
*/
GdkSurface *surface_under_pointer;
int x_tmp, y_tmp;
surface_under_pointer = find_surface_under_pointer (self, point, &x_tmp, &y_tmp);
if (surface_under_pointer)
{
surface = surface_under_pointer;
*x = x_tmp;
*y = y_tmp;
}
return GDK_MACOS_SURFACE (surface);
}
else
{
/* Finally check the grab window. */
GdkSurface *grab_surface = grab->surface;
get_surface_point_from_screen_point (grab_surface, point, x, y);
return GDK_MACOS_SURFACE (grab_surface);
}
return NULL;
}
else
{
/* The non-grabbed case. */
GdkSurface *surface_under_pointer;
int 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 != NSEventTypeMouseMoved)
{
if (*y < 0)
return NULL;
}
/* As for owner events, we need to use the surface under the
* pointer, not the window from the NSEvent.
*/
surface_under_pointer = find_surface_under_pointer (self, point, &x_tmp, &y_tmp);
if (surface_under_pointer != NULL)
{
surface = surface_under_pointer;
*x = x_tmp;
*y = y_tmp;
}
return GDK_MACOS_SURFACE (surface);
}
return NULL;
}
/* This function finds the correct window to send an event to, taking
* into account grabs, event propagation, and event masks.
*/
static GdkMacosSurface *
find_surface_for_ns_event (GdkMacosDisplay *self,
NSEvent *nsevent,
int *x,
int *y)
{
GdkMacosBaseView *view;
GdkSurface *surface;
NSPoint point;
g_assert (GDK_IS_MACOS_DISPLAY (self));
g_assert (nsevent != NULL);
g_assert (x != NULL);
g_assert (y != NULL);
switch ((int)[nsevent type])
{
case NSEventTypeLeftMouseDown:
case NSEventTypeRightMouseDown:
case NSEventTypeOtherMouseDown:
case NSEventTypeLeftMouseUp:
case NSEventTypeRightMouseUp:
case NSEventTypeOtherMouseUp:
case NSEventTypeLeftMouseDragged:
case NSEventTypeRightMouseDragged:
case NSEventTypeOtherMouseDragged:
case NSEventTypeMouseMoved:
case NSEventTypeScrollWheel:
case NSEventTypeMagnify:
case NSEventTypeRotate:
return find_surface_for_mouse_event (self, nsevent, x, y);
case NSEventTypeMouseEntered:
case NSEventTypeMouseExited:
/* Only handle our own entered/exited events, not the ones for the
* titlebar buttons.
*/
if ((surface = get_surface_from_ns_event (self, nsevent, &point, x, y)) &&
(view = (GdkMacosBaseView *)[GDK_MACOS_SURFACE (surface)->window contentView]) &&
([nsevent trackingArea] == [view trackingArea]))
return GDK_MACOS_SURFACE (surface);
else
return NULL;
case NSEventTypeKeyDown:
case NSEventTypeKeyUp:
case NSEventTypeFlagsChanged:
return find_surface_for_keyboard_event (nsevent);
default:
/* Ignore everything else. */
return NULL;
}
}
GdkEvent *
_gdk_macos_display_translate (GdkMacosDisplay *self,
NSEvent *nsevent)
{
GdkMacosSurface *surface;
GdkMacosWindow *window;
NSEventType event_type;
NSWindow *event_window;
int x;
int y;
g_return_val_if_fail (GDK_IS_MACOS_DISPLAY (self), NULL);
g_return_val_if_fail (nsevent != NULL, NULL);
/* 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 == NSEventTypeAppKitDefined)
{
if ([nsevent subtype] == NSEventSubtypeApplicationDeactivated)
_gdk_macos_display_break_all_grabs (self, 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 NULL;
}
/* We need to register the proximity event from any point on the screen
* to properly register the devices
* FIXME: is there a better way to detect if a tablet has been plugged?
*/
if (event_type == NSEventTypeTabletProximity)
{
GdkSeat *seat = gdk_display_get_default_seat (GDK_DISPLAY (self));
_gdk_macos_seat_handle_tablet_tool_event (GDK_MACOS_SEAT (seat), nsevent);
/* FIXME: we might want to cache this proximity event and propagate it
* but proximity events in gdk work at a window level while on macos
* works at a screen level. For now we just skip them.
*/
return NULL;
}
/* If the event was delivered to NSWindow that is foreign (or rather,
* Cocoa native), then we should pass the event along to that window.
*/
if ((event_window = [nsevent window]) && !GDK_IS_MACOS_WINDOW (event_window))
return NULL;
/* If we can't find a GdkSurface to deliver the event to, then we
* should pass it along to the NSApp.
*/
if (!(surface = find_surface_for_ns_event (self, nsevent, &x, &y)))
return NULL;
if (!(window = (GdkMacosWindow *)_gdk_macos_surface_get_native (surface)) ||
!GDK_IS_MACOS_WINDOW (window))
return NULL;
/* 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 ([window isInMove])
{
_gdk_macos_display_break_all_grabs (self, get_time_from_ns_event (nsevent));
return NULL;
}
/* Also when in a manual resize or move , we ignore events so that
* these are pushed to GdkMacosNSWindow's sendEvent handler.
*/
if ([window isInManualResizeOrMove])
return NULL;
/* Make sure we have a GdkSurface */
if (!(surface = [window gdkSurface]))
return NULL;
/* Quartz handles resizing on its own, so stay out of the way. */
if (test_resize (nsevent, surface, x, y))
return NULL;
if (event_type == NSEventTypeRightMouseDown ||
event_type == NSEventTypeOtherMouseDown ||
event_type == NSEventTypeLeftMouseDown)
{
if (![NSApp isActive])
[NSApp activateIgnoringOtherApps:YES];
if (![window isKeyWindow])
{
NSWindow *orig_window = [nsevent window];
/* To get NSApp to supress activating the window we might
* have clicked through the shadow of, we need to dispatch
* the event and handle it in GdkMacosView:mouseDown to call
* [NSApp preventWindowOrdering]. Calling it here will not
* do anything as the event is not registered.
*/
if (orig_window &&
GDK_IS_MACOS_WINDOW (orig_window) &&
[(GdkMacosWindow *)orig_window needsMouseDownQuirk])
[NSApp sendEvent:nsevent];
[window showAndMakeKey:YES];
_gdk_macos_display_clear_sorting (self);
}
}
else if (is_motion_event(event_type))
{
NSWindow *orig_window = [nsevent window];
if (orig_window && GDK_IS_MACOS_WINDOW (orig_window))
[NSApp sendEvent:nsevent];
}
return fill_event (self, window, nsevent, x, y);
}
void
_gdk_macos_display_send_event (GdkMacosDisplay *self,
NSEvent *nsevent)
{
GdkMacosSurface *surface;
GdkMacosWindow *window;
GdkEvent *event;
int x;
int y;
g_return_if_fail (GDK_IS_MACOS_DISPLAY (self));
g_return_if_fail (nsevent != NULL);
if ((surface = find_surface_for_ns_event (self, nsevent, &x, &y)) &&
(window = (GdkMacosWindow *)_gdk_macos_surface_get_native (surface)) &&
(event = fill_event (self, window, nsevent, x, y)))
_gdk_windowing_got_event (GDK_DISPLAY (self),
_gdk_event_queue_append (GDK_DISPLAY (self), event),
event,
_gdk_display_get_next_serial (GDK_DISPLAY (self)));
}
Reference in New Issue View Git Blame Copy Permalink