callisto-debian/gtk3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'quartz-monitor' into gtk-3-24

Browse Source
This commit is contained in:
John Ralls 2018-12-08 11:28:32 -08:00
commit 46bee8b9fe
22 changed files with 701 additions and 648 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
gdk/gdkdisplay.c
View File

@ -1257,6 +1257,11 @@ _gdk_display_has_touch_grab (GdkDisplay *display,
{
guint i;
g_return_val_if_fail (display, NULL);
if (!display->touch_implicit_grabs)
return NULL;
for (i = 0; i < display->touch_implicit_grabs->len; i++)
{
GdkTouchGrabInfo *info;
@ -1318,6 +1323,11 @@ _gdk_display_check_grab_ownership (GdkDisplay *display,
GdkGrabOwnership higher_ownership, device_ownership;
gboolean device_is_keyboard;
g_return_val_if_fail (display, TRUE);
if (!display->device_grabs)
return TRUE; /* No hash table, no grabs. */
g_hash_table_iter_init (&iter, display->device_grabs);
higher_ownership = device_ownership = GDK_OWNERSHIP_NONE;
device_is_keyboard = (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD);

95
gdk/quartz/GdkQuartzNSWindow.c
View File

@ -120,6 +120,13 @@
inMove = YES;
}
#ifdef AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
#define NSLeftMouseUp NSEventTypeLeftMouseUp
#define NSLeftMouseDragged NSEventTypeLeftMouseDragged
#define NSMouseEntered NSEventTypeMouseEntered
#endif
-(void)sendEvent:(NSEvent *)event
{
switch ([event type])
@ -189,7 +196,6 @@
GdkWindow *window = [[self contentView] gdkWindow];
GdkEvent *event;
GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
gboolean maximized = gdk_window_get_state (window) & GDK_WINDOW_STATE_MAXIMIZED;
/* In case the window is changed when maximized remove the maximized state */
@ -220,7 +226,6 @@
NSRect content_rect = [self contentRectForFrameRect:[self frame]];
GdkWindow *window = [[self contentView] gdkWindow];
GdkEvent *event;
GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
gboolean maximized = gdk_window_get_state (window) & GDK_WINDOW_STATE_MAXIMIZED;
/* see same in windowDidMove */
@ -256,7 +261,15 @@
[self checkSendEnterNotify];
}
-(id)initWithContentRect:(NSRect)contentRect styleMask:(NSUInteger)styleMask backing:(NSBackingStoreType)backingType defer:(BOOL)flag screen:(NSScreen *)screen
-(id)initWithContentRect:(NSRect)contentRect
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
styleMask:(NSUInteger)styleMask
#else
styleMask:(NSWindowStyleMask)styleMask
#endif
backing:(NSBackingStoreType)backingType
defer:(BOOL)flag
screen:(NSScreen *)screen
{
self = [super initWithContentRect:contentRect
styleMask:styleMask
@ -366,6 +379,22 @@
initialPositionKnown = NO;
}
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
- (NSPoint)convertPointToScreen:(NSPoint)point
{
NSRect inrect = NSMakeRect (point.x, point.y, 0.0, 0.0);
NSRect outrect = [self convertRectToScreen: inrect];
return (NSPoint)((CGRect)outrect).origin;
}
- (NSPoint)convertPointFromScreen:(NSPoint)point
{
NSRect inrect = NSMakeRect (point.x, point.y, 0.0, 0.0);
NSRect outrect = [self convertRectFromScreen: inrect];
return (NSPoint)((CGRect)outrect).origin;
}
#endif
- (BOOL)trackManualMove
{
@ -378,8 +407,11 @@
if (!inManualMove)
return NO;
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
currentLocation = [self convertBaseToScreen:[self mouseLocationOutsideOfEventStream]];
#else
currentLocation = [self convertPointToScreen:[self mouseLocationOutsideOfEventStream]];
#endif
newOrigin.x = currentLocation.x - initialMoveLocation.x;
newOrigin.y = currentLocation.y - initialMoveLocation.y;
@ -410,7 +442,11 @@
inManualMove = YES;
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
initialMoveLocation = [self convertBaseToScreen:[self mouseLocationOutsideOfEventStream]];
#else
initialMoveLocation = [self convertPointToScreen:[self mouseLocationOutsideOfEventStream]];
#endif
initialMoveLocation.x -= frame.origin.x;
initialMoveLocation.y -= frame.origin.y;
}
@ -427,7 +463,11 @@
inTrackManualResize = YES;
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
mouse_location = [self convertBaseToScreen:[self mouseLocationOutsideOfEventStream]];
#else
mouse_location = [self convertPointToScreen:[self mouseLocationOutsideOfEventStream]];
#endif
mdx = initialResizeLocation.x - mouse_location.x;
mdy = initialResizeLocation.y - mouse_location.y;
@ -512,7 +552,12 @@
resizeEdge = edge;
initialResizeFrame = [self frame];
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
initialResizeLocation = [self convertBaseToScreen:[self mouseLocationOutsideOfEventStream]];
#else
initialResizeLocation = [self convertPointToScreen:[self mouseLocationOutsideOfEventStream]];
#endif
}
@ -578,7 +623,7 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)
- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
{
GdkDeviceManager *device_manager;
GdkSeat *seat = NULL;
GdkEvent *event;
GdkWindow *window;
@ -592,10 +637,8 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)
current_context->display = gdk_window_get_display (window);
device_manager = gdk_display_get_device_manager (gdk_display_get_default ());
gdk_drag_context_set_device (current_context,
gdk_device_manager_get_client_pointer (device_manager));
seat = gdk_display_get_default_seat (gdk_display_get_default ());
gdk_drag_context_set_device (current_context, gdk_seat_get_pointer (seat));
event = gdk_event_new (GDK_DRAG_ENTER);
event->dnd.window = g_object_ref (window);
event->dnd.send_event = FALSE;
@ -647,7 +690,13 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)
- (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
{
NSPoint point = [sender draggingLocation];
NSPoint screen_point = [self convertBaseToScreen:point];
NSPoint screen_point;
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
screen_point = [self convertBaseToScreen:point];
#else
screen_point = [self convertPointToScreen:point];
#endif
GdkEvent *event;
int gx, gy;
@ -675,7 +724,13 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)
- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
{
NSPoint point = [sender draggingLocation];
NSPoint screen_point = [self convertBaseToScreen:point];
NSPoint screen_point;
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
screen_point = [self convertBaseToScreen:point];
#else
screen_point = [self convertPointToScreen:point];
#endif
GdkEvent *event;
int gy, gx;
@ -761,17 +816,27 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)
}
#ifdef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
typedef enum
{
GDK_QUARTZ_FULL_SCREEN_MASK = NSFullScreenWindowMask,
} GdkQuartzFullScreen;
#else
typedef enum
{
GDK_QUARTZ_FULL_SCREEN_MASK = NSWindowStyleMaskFullScreen,
} GdkQuartzFullScreen;
#endif
- (void)setStyleMask:(NSUInteger)styleMask
{
gboolean was_fullscreen;
gboolean is_fullscreen;
was_fullscreen = (([self styleMask] & NSFullScreenWindowMask) != 0);
was_fullscreen = (([self styleMask] & GDK_QUARTZ_FULL_SCREEN_MASK) != 0);
[super setStyleMask:styleMask];
is_fullscreen = (([self styleMask] & NSFullScreenWindowMask) != 0);
is_fullscreen = (([self styleMask] & GDK_QUARTZ_FULL_SCREEN_MASK) != 0);
if (was_fullscreen != is_fullscreen)
_gdk_quartz_window_update_fullscreen_state ([[self contentView] gdkWindow]);
@ -800,7 +865,6 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)
{
NSRect screenFrame = [[self screen] visibleFrame];
GdkWindow *window = [[self contentView] gdkWindow];
GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
gboolean maximized = gdk_window_get_state (window) & GDK_WINDOW_STATE_MAXIMIZED;
if (!maximized)
@ -814,7 +878,6 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)
{
GdkWindow *window = [[self contentView] gdkWindow];
GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
gboolean maximized = gdk_window_get_state (window) & GDK_WINDOW_STATE_MAXIMIZED;
if (maximized)

5
gdk/quartz/GdkQuartzNSWindow.h
View File

@ -53,7 +53,10 @@
#ifdef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER
-(void)setStyleMask:(NSUInteger)styleMask;
#endif
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
- (NSPoint)convertPointToScreen:(NSPoint)point;
- (NSPoint)convertPointFromScreen:(NSPoint)point;
#endif
@end

8
gdk/quartz/GdkQuartzView.c
View File

@ -17,6 +17,7 @@
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <AvailabilityMacros.h>
#include "config.h"
#import "GdkQuartzView.h"
#include "gdkquartzwindow.h"
@ -123,7 +124,6 @@
-(void)unmarkText
{
GDK_NOTE (EVENTS, g_message ("unmarkText"));
gchar *prev_str;
markedRange = selectedRange = NSMakeRange (NSNotFound, 0);
g_object_set_data_full (G_OBJECT (gdk_window), TIC_MARKED_TEXT, NULL, g_free);
@ -133,7 +133,6 @@
{
GDK_NOTE (EVENTS, g_message ("setMarkedText"));
const char *str;
gchar *prev_str;
if (replacementRange.location == NSNotFound)
{
@ -183,7 +182,6 @@
GDK_NOTE (EVENTS, g_message ("insertText"));
const char *str;
NSString *string;
gchar *prev_str;
if ([self hasMarkedText])
[self unmarkText];
@ -201,8 +199,12 @@
/* discard invalid text input with Chinese input methods */
str = "";
[self unmarkText];
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
NSInputManager *currentInputManager = [NSInputManager currentInputManager];
[currentInputManager markedTextAbandoned:self];
#else
[[NSTextInputContext currentInputContext] discardMarkedText];
#endif
}
else
{

2
gdk/quartz/gdkdevice-core-quartz.c
View File

@ -130,7 +130,7 @@ gdk_quartz_device_core_get_state (GdkDevice *device,
{
gint x_int, y_int;
gdk_window_get_pointer (window, &x_int, &y_int, mask);
gdk_window_get_device_position (window, device, &x_int, &y_int, mask);
if (axes)
{

1
gdk/quartz/gdkdevicemanager-core-quartz.c
View File

@ -22,6 +22,7 @@
#include <gdk/gdkdeviceprivate.h>
#include <gdk/gdkseatdefaultprivate.h>
#include <gdk/gdkdevicemanagerprivate.h>
#include <gdk/gdkdisplayprivate.h>
#include "gdkdevicemanager-core-quartz.h"
#include "gdkquartzdevice-core.h"
#include "gdkkeysyms.h"

248
gdk/quartz/gdkdisplay-quartz.c
View File

@ -20,6 +20,7 @@
#include <gdk/gdk.h>
#include <gdk/gdkdisplayprivate.h>
#include <gdk/gdkmonitorprivate.h>
#include "gdkprivate-quartz.h"
#include "gdkquartzscreen.h"
@ -29,15 +30,18 @@
#include "gdkscreen.h"
#include "gdkmonitorprivate.h"
#include "gdkdisplay-quartz.h"
#include "gdkmonitor-quartz.h"
static gint MONITORS_CHANGED = 0;
static void display_reconfiguration_callback (CGDirectDisplayID display,
CGDisplayChangeSummaryFlags flags,
void *data);
static GdkWindow *
gdk_quartz_display_get_default_group (GdkDisplay *display)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
/* FIXME: Implement */
/* X11-only. */
return NULL;
}
@ -110,51 +114,49 @@ gdk_quartz_display_beep (GdkDisplay *display)
static void
gdk_quartz_display_sync (GdkDisplay *display)
{
/* Not supported. */
/* Not needed. */
}
static void
gdk_quartz_display_flush (GdkDisplay *display)
{
/* Not supported. */
/* Not needed. */
}
static gboolean
gdk_quartz_display_supports_selection_notification (GdkDisplay *display)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
/* FIXME: Implement */
/* X11-only. */
return FALSE;
}
static gboolean
gdk_quartz_display_request_selection_notification (GdkDisplay *display,
GdkAtom selection)
{
/* FIXME: Implement */
/* X11-only. */
return FALSE;
}
static gboolean
gdk_quartz_display_supports_clipboard_persistence (GdkDisplay *display)
{
/* FIXME: Implement */
/* X11-only */
return FALSE;
}
static gboolean
gdk_quartz_display_supports_shapes (GdkDisplay *display)
{
/* FIXME: Implement */
/* Not needed, nothing ever calls this.*/
return FALSE;
}
static gboolean
gdk_quartz_display_supports_input_shapes (GdkDisplay *display)
{
/* FIXME: Implement */
/* Not needed, nothign ever calls this. */
return FALSE;
}
@ -165,20 +167,23 @@ gdk_quartz_display_store_clipboard (GdkDisplay *display,
const GdkAtom *targets,
gint n_targets)
{
/* FIXME: Implement */
/* MacOS persists pasteboard items automatically, no application
* action is required.
*/
}
static gboolean
gdk_quartz_display_supports_composite (GdkDisplay *display)
{
/* FIXME: Implement */
/* X11-only. */
return FALSE;
}
static gulong
gdk_quartz_display_get_next_serial (GdkDisplay *display)
{
/* X11-only. */
return 0;
}
@ -186,26 +191,134 @@ static void
gdk_quartz_display_notify_startup_complete (GdkDisplay *display,
const gchar *startup_id)
{
/* FIXME: Implement? */
/* This should call finishLaunching, but doing so causes Quartz to throw
* "_createMenuRef called with existing principal MenuRef already"
* " associated with menu".
[NSApp finishLaunching];
*/
}
static void
gdk_quartz_display_push_error_trap (GdkDisplay *display)
{
/* X11-only. */
}
static gint
gdk_quartz_display_pop_error_trap (GdkDisplay *display, gboolean ignore)
{
/* X11 only. */
return 0;
}
/* The display monitor list comprises all of the CGDisplays connected
to the system, some of which may not be drawable either because
they're asleep or are mirroring another monitor. The NSScreens
array contains only the monitors that are currently drawable and we
use the index of the screens array placing GdkNSViews, so we'll use
the same for determining the number of monitors and indexing them.
*/
int
get_active_displays (CGDirectDisplayID **screens)
{
unsigned int displays = 0;
CGGetActiveDisplayList (0, NULL, &displays);
if (screens)
{
*screens = g_new0 (CGDirectDisplayID, displays);
CGGetActiveDisplayList (displays, *screens, &displays);
}
return displays;
}
static void
configure_monitor (GdkMonitor *monitor)
{
GdkQuartzMonitor *quartz_monitor = GDK_QUARTZ_MONITOR (monitor);
CGSize disp_size = CGDisplayScreenSize (quartz_monitor->id);
gint width = (int)trunc (disp_size.width);
gint height = (int)trunc (disp_size.height);
CGRect disp_bounds = CGDisplayBounds (quartz_monitor->id);
GdkRectangle disp_geometry = {(int)trunc (disp_bounds.origin.x),
(int)trunc (disp_bounds.origin.y),
(int)trunc (disp_bounds.size.width),
(int)trunc (disp_bounds.size.height)};
CGDisplayModeRef mode = CGDisplayCopyDisplayMode (quartz_monitor->id);
gint refresh_rate = (int)trunc (CGDisplayModeGetRefreshRate (mode));
monitor->width_mm = width;
monitor->height_mm = height;
monitor->geometry = disp_geometry;
monitor->scale_factor = 1;
monitor->refresh_rate = refresh_rate;
monitor->subpixel_layout = GDK_SUBPIXEL_LAYOUT_UNKNOWN;
CGDisplayModeRelease (mode);
}
static void
display_reconfiguration_callback (CGDirectDisplayID cg_display,
CGDisplayChangeSummaryFlags flags,
void *data)
{
GdkQuartzDisplay *display = data;
GdkQuartzMonitor *monitor;
/* Ignore the begin configuration signal. */
if (flags & kCGDisplayBeginConfigurationFlag)
return;
if (flags & (kCGDisplayMovedFlag | kCGDisplayAddFlag | kCGDisplayEnabledFlag |
kCGDisplaySetMainFlag | kCGDisplayDesktopShapeChangedFlag |
kCGDisplayMirrorFlag | kCGDisplayUnMirrorFlag))
{
monitor = g_hash_table_lookup (display->monitors,
GINT_TO_POINTER (cg_display));
if (!monitor)
{
monitor = g_object_new (GDK_TYPE_QUARTZ_MONITOR,
"display", display, NULL);
monitor->id = cg_display;
g_hash_table_insert (display->monitors, GINT_TO_POINTER (monitor->id),
monitor);
gdk_display_monitor_added (GDK_DISPLAY (display),
GDK_MONITOR (monitor));
}
configure_monitor (GDK_MONITOR (monitor));
}
else if (flags & (kCGDisplayRemoveFlag | kCGDisplayDisabledFlag))
{
GdkMonitor *monitor = g_hash_table_lookup (display->monitors,
GINT_TO_POINTER (cg_display));
gdk_display_monitor_removed (GDK_DISPLAY (display),
GDK_MONITOR (monitor));
g_hash_table_remove (display->monitors, GINT_TO_POINTER (cg_display));
}
g_signal_emit (display, MONITORS_CHANGED, 0);
}
static int
gdk_quartz_display_get_n_monitors (GdkDisplay *display)
{
GdkQuartzDisplay *quartz_display = GDK_QUARTZ_DISPLAY (display);
return quartz_display->monitors->len;
return get_active_displays (NULL);
}
static GdkMonitor *
gdk_quartz_display_get_monitor (GdkDisplay *display,
int monitor_num)
{
GdkQuartzDisplay *quartz_display = GDK_QUARTZ_DISPLAY (display);
CGDirectDisplayID *screens = NULL;
if (0 <= monitor_num || monitor_num < quartz_display->monitors->len)
return (GdkMonitor *)quartz_display->monitors->pdata[monitor_num];
int count = get_active_displays (&screens);
if (monitor_num >= 0 && monitor_num < count)
return g_hash_table_lookup (quartz_display->monitors,
GINT_TO_POINTER (screens[monitor_num]));
return NULL;
}
@ -214,8 +327,23 @@ static GdkMonitor *
gdk_quartz_display_get_primary_monitor (GdkDisplay *display)
{
GdkQuartzDisplay *quartz_display = GDK_QUARTZ_DISPLAY (display);
CGDirectDisplayID primary_id = CGMainDisplayID ();
return quartz_display->monitors->pdata[0];
return g_hash_table_lookup (quartz_display->monitors,
GINT_TO_POINTER (primary_id));
}
static GdkMonitor *
gdk_quartz_display_get_monitor_at_window (GdkDisplay *display,
GdkWindow *window)
{
GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
NSWindow *nswindow = impl->toplevel;
NSScreen *screen = [nswindow screen];
CGDirectDisplayID id = [[[screen deviceDescription]
objectForKey: @"NSScreenNumber"] unsignedIntValue];
return g_hash_table_lookup (GDK_QUARTZ_DISPLAY (display)->monitors,
GINT_TO_POINTER (id));
}
G_DEFINE_TYPE (GdkQuartzDisplay, gdk_quartz_display, GDK_TYPE_DISPLAY)
@ -223,11 +351,26 @@ G_DEFINE_TYPE (GdkQuartzDisplay, gdk_quartz_display, GDK_TYPE_DISPLAY)
static void
gdk_quartz_display_init (GdkQuartzDisplay *display)
{
GDK_QUARTZ_ALLOC_POOL;
uint32_t max_displays = 0, disp;
CGDirectDisplayID *displays;
display->monitors = g_ptr_array_new_with_free_func (g_object_unref);
GDK_QUARTZ_RELEASE_POOL;
CGGetActiveDisplayList (0, NULL, &max_displays);
display->monitors = g_hash_table_new_full (g_direct_hash, NULL,
NULL, g_object_unref);
displays = g_new0 (CGDirectDisplayID, max_displays);
CGGetActiveDisplayList (max_displays, displays, &max_displays);
for (disp = 0; disp < max_displays; ++disp)
{
GdkQuartzMonitor *monitor = g_object_new (GDK_TYPE_QUARTZ_MONITOR,
"display", display, NULL);
monitor->id = displays[disp];
g_hash_table_insert (display->monitors, GINT_TO_POINTER (monitor->id),
monitor);
configure_monitor (GDK_MONITOR (monitor));
}
CGDisplayRegisterReconfigurationCallback (display_reconfiguration_callback,
display);
g_signal_emit (display, MONITORS_CHANGED, 0);
}
static void
@ -235,7 +378,9 @@ gdk_quartz_display_dispose (GObject *object)
{
GdkQuartzDisplay *display_quartz = GDK_QUARTZ_DISPLAY (object);
g_ptr_array_free (display_quartz->monitors, TRUE);
g_hash_table_destroy (display_quartz->monitors);
CGDisplayRemoveReconfigurationCallback (display_reconfiguration_callback,
display_quartz);
G_OBJECT_CLASS (gdk_quartz_display_parent_class)->dispose (object);
}
@ -262,24 +407,28 @@ gdk_quartz_display_class_init (GdkQuartzDisplayClass *class)
display_class->beep = gdk_quartz_display_beep;
display_class->sync = gdk_quartz_display_sync;
display_class->flush = gdk_quartz_display_flush;
display_class->queue_events = _gdk_quartz_display_queue_events;
display_class->has_pending = _gdk_quartz_display_has_pending;
display_class->queue_events = _gdk_quartz_display_queue_events;
display_class->get_default_group = gdk_quartz_display_get_default_group;
display_class->supports_selection_notification = gdk_quartz_display_supports_selection_notification;
display_class->request_selection_notification = gdk_quartz_display_request_selection_notification;
display_class->supports_clipboard_persistence = gdk_quartz_display_supports_clipboard_persistence;
display_class->store_clipboard = gdk_quartz_display_store_clipboard;
display_class->supports_shapes = gdk_quartz_display_supports_shapes;
display_class->supports_input_shapes = gdk_quartz_display_supports_input_shapes;
display_class->supports_composite = gdk_quartz_display_supports_composite;
display_class->get_cursor_for_type = _gdk_quartz_display_get_cursor_for_type;
display_class->get_cursor_for_name = _gdk_quartz_display_get_cursor_for_name;
display_class->get_cursor_for_surface = _gdk_quartz_display_get_cursor_for_surface;
display_class->get_default_cursor_size = _gdk_quartz_display_get_default_cursor_size;
display_class->get_maximal_cursor_size = _gdk_quartz_display_get_maximal_cursor_size;
display_class->supports_cursor_alpha = _gdk_quartz_display_supports_cursor_alpha;
display_class->supports_cursor_color = _gdk_quartz_display_supports_cursor_color;
display_class->supports_clipboard_persistence = gdk_quartz_display_supports_clipboard_persistence;
display_class->store_clipboard = gdk_quartz_display_store_clipboard;
display_class->get_default_cursor_size = _gdk_quartz_display_get_default_cursor_size;
display_class->get_maximal_cursor_size = _gdk_quartz_display_get_maximal_cursor_size;
display_class->get_cursor_for_type = _gdk_quartz_display_get_cursor_for_type;
display_class->get_cursor_for_name = _gdk_quartz_display_get_cursor_for_name;
display_class->get_cursor_for_surface = _gdk_quartz_display_get_cursor_for_surface;
/* display_class->get_app_launch_context = NULL; Has default. */
display_class->before_process_all_updates = _gdk_quartz_display_before_process_all_updates;
display_class->after_process_all_updates = _gdk_quartz_display_after_process_all_updates;
display_class->get_next_serial = gdk_quartz_display_get_next_serial;
@ -288,15 +437,42 @@ gdk_quartz_display_class_init (GdkQuartzDisplayClass *class)
display_class->event_data_free = _gdk_quartz_display_event_data_free;
display_class->create_window_impl = _gdk_quartz_display_create_window_impl;
display_class->get_keymap = _gdk_quartz_display_get_keymap;
display_class->push_error_trap = gdk_quartz_display_push_error_trap;
display_class->pop_error_trap = gdk_quartz_display_pop_error_trap;
display_class->get_selection_owner = _gdk_quartz_display_get_selection_owner;
display_class->set_selection_owner = _gdk_quartz_display_set_selection_owner;
display_class->send_selection_notify = NULL; /* Ignore. X11 stuff removed in master. */
display_class->get_selection_property = _gdk_quartz_display_get_selection_property;
display_class->convert_selection = _gdk_quartz_display_convert_selection;
display_class->text_property_to_utf8_list = _gdk_quartz_display_text_property_to_utf8_list;
display_class->utf8_to_string_target = _gdk_quartz_display_utf8_to_string_target;
/* display_class->get_default_seat; The parent class default works fine. */
display_class->get_n_monitors = gdk_quartz_display_get_n_monitors;
display_class->get_monitor = gdk_quartz_display_get_monitor;
display_class->get_primary_monitor = gdk_quartz_display_get_primary_monitor;
display_class->get_monitor_at_window = gdk_quartz_display_get_monitor_at_window;
/**
* GdkQuartzDisplay::monitors-changed:
* @display: The object on which the signal is emitted
*
* The ::monitors-changed signal is emitted whenever the arrangement
* of the monitors changes, either because of the addition or
* removal of a monitor or because of some other configuration
* change in System Preferences>Displays including a resolution
* change or a position change. Note that enabling or disabling
* mirroring will result in the addition or removal of the mirror
* monitor(s).
*/
MONITORS_CHANGED =
g_signal_new (g_intern_static_string ("monitors-changed"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
0, NULL, NULL, NULL,
G_TYPE_NONE, 0, NULL);
ProcessSerialNumber psn = { 0, kCurrentProcess };

124
gdk/quartz/gdkdisplay-quartz.h
View File

@ -32,119 +32,7 @@ G_BEGIN_DECLS
struct _GdkQuartzDisplay
{
GdkDisplay parent_instance;
/*Display *xdisplay;
GdkScreen *screen;
GList *screens;
GSource *event_source;
gint grab_count;
*/
/* Visual infos for creating Windows */
/*int window_depth;
Visual *window_visual;
Colormap window_colormap;
*/
/* Keyboard related information */
/*gint xkb_event_type;
gboolean use_xkb;
*/
/* Whether we were able to turn on detectable-autorepeat using
* XkbSetDetectableAutorepeat. If FALSE, we'll fall back
* to checking the next event with XPending().
*/
/*gboolean have_xkb_autorepeat;
GdkKeymap *keymap;
guint keymap_serial;
gboolean have_xfixes;
gint xfixes_event_base;
gboolean have_xcomposite;
gboolean have_xdamage;
gint xdamage_event_base;
gboolean have_randr12;
gboolean have_randr13;
gboolean have_randr15;
gint xrandr_event_base;
*/
/* If the SECURITY extension is in place, whether this client holds
* a trusted authorization and so is allowed to make various requests
* (grabs, properties etc.) Otherwise always TRUE.
*/
/*gboolean trusted_client;
*/
/* drag and drop information */
/*GdkDragContext *current_dest_drag;
*/
/* Mapping to/from virtual atoms */
/*GHashTable *atom_from_virtual;
GHashTable *atom_to_virtual;
*/
/* Session Management leader window see ICCCM */
/*Window leader_window;
GdkWindow *leader_gdk_window;
gboolean leader_window_title_set;
*/
/* List of functions to go from extension event => X window */
/*GSList *event_types;
*/
/* X ID hashtable */
/*GHashTable *xid_ht;
*/
/* translation queue */
/*GQueue *translate_queue;
*/
/* input GdkWindow list */
/*GList *input_windows;
*/
GPtrArray *monitors;
/* Startup notification */
/*gchar *startup_notification_id;
*/
/* Time of most recent user interaction. */
/*gulong user_time;
*/
/* Sets of atoms for DND */
/*guint base_dnd_atoms_precached : 1;
guint xdnd_atoms_precached : 1;
guint motif_atoms_precached : 1;
guint use_sync : 1;
guint have_shapes : 1;
guint have_input_shapes : 1;
gint shape_event_base;
GSList *error_traps;
gint wm_moveresize_button;
*/
/* GLX information */
/*gint glx_version;
gint glx_error_base;
gint glx_event_base;
*/
/* Translation between X server time and system-local monotonic time */
/*gint64 server_time_query_time;
gint64 server_time_offset;
*/
/*guint server_time_is_monotonic_time : 1;
guint have_glx : 1;
*/
/* GLX extensions we check */
/*guint has_glx_swap_interval : 1;
guint has_glx_create_context : 1;
guint has_glx_texture_from_pixmap : 1;
guint has_glx_video_sync : 1;
guint has_glx_buffer_age : 1;
guint has_glx_sync_control : 1;
guint has_glx_multisample : 1;
guint has_glx_visual_rating : 1;
guint has_glx_create_es2_context : 1;*/
GHashTable *monitors;
};
struct _GdkQuartzDisplayClass
@ -220,16 +108,6 @@ gint _gdk_quartz_display_text_property_to_utf8_list (GdkDisplay *disp
gchar ***list);
gchar * _gdk_quartz_display_utf8_to_string_target (GdkDisplay *displayt,
const gchar *str);
/*
GdkScreen *_gdk_x11_display_screen_for_xrootwin (GdkDisplay *display,
Window xrootwin);
void _gdk_x11_display_error_event (GdkDisplay *display,
XErrorEvent *error);
GdkFilterReturn _gdk_wm_protocols_filter (GdkXEvent *xev,
GdkEvent *event,
gpointer data);
*/
G_END_DECLS
#endif /* __GDK_QUARTZ_DISPLAY__ */

1
gdk/quartz/gdkdisplaymanager-quartz.c
View File

@ -55,7 +55,6 @@ static void
gdk_quartz_display_manager_class_init (GdkQuartzDisplayManagerClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
GdkDisplayManagerClass *manager_class = GDK_DISPLAY_MANAGER_CLASS (class);
object_class->finalize = gdk_quartz_display_manager_finalize;
}

18
gdk/quartz/gdkeventloop-quartz.c
View File

@ -292,13 +292,19 @@ select_thread_func (void *arg)
}
}
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
#define GDK_QUARTZ_APPLICATION_DEFINED NSApplicationDefined
#else
#define GDK_QUARTZ_APPLICATION_DEFINED NSEventTypeApplicationDefined
#endif
static void
got_fd_activity (void *info)
{
NSEvent *event;
/* Post a message so we'll break out of the message loop */
event = [NSEvent otherEventWithType: NSApplicationDefined
event = [NSEvent otherEventWithType: GDK_QUARTZ_APPLICATION_DEFINED
location: NSZeroPoint
modifierFlags: 0
timestamp: 0
@ -714,6 +720,12 @@ static GSourceFuncs event_funcs = {
********* Our Poll Function *********
************************************************************/
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
#define GDK_QUARTZ_EVENT_MASK_ANY NSAnyEventMask
#else
#define GDK_QUARTZ_EVENT_MASK_ANY NSEventMaskAny
#endif
static gint
poll_func (GPollFD *ufds,
guint nfds,
@ -739,7 +751,7 @@ poll_func (GPollFD *ufds,
limit_date = [NSDate dateWithTimeIntervalSinceNow:timeout_/1000.0];
getting_events++;
event = [NSApp nextEventMatchingMask: NSAnyEventMask
event = [NSApp nextEventMatchingMask: GDK_QUARTZ_EVENT_MASK_ANY
untilDate: limit_date
inMode: NSDefaultRunLoopMode
dequeue: YES];
@ -758,7 +770,7 @@ poll_func (GPollFD *ufds,
n_ready = select_thread_collect_poll (ufds, nfds);
if (event &&
[event type] == NSApplicationDefined &&
[event type] == GDK_QUARTZ_APPLICATION_DEFINED &&
[event subtype] == GDK_QUARTZ_EVENT_SUBTYPE_EVENTLOOP)
{
/* Just used to wake us up; if an event and a FD arrived at the same

305
gdk/quartz/gdkevents-quartz.c
View File

@ -35,6 +35,7 @@
#include "gdkquartzdisplay.h"
#include "gdkprivate-quartz.h"
#include "gdkquartzdevicemanager-core.h"
#include "gdkquartzkeys.h"
#define GRIP_WIDTH 15
#define GRIP_HEIGHT 15
@ -128,27 +129,8 @@ _gdk_quartz_display_has_pending (GdkDisplay *display)
void
_gdk_quartz_events_break_all_grabs (guint32 time)
{
GList *list, *l;
GdkDeviceManager *device_manager;
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)
{
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);
}
g_list_free (list);
GdkSeat *seat = gdk_display_get_default_seat (_gdk_display);
gdk_seat_ungrab (seat);
}
static void
@ -289,15 +271,15 @@ get_keyboard_modifiers_from_ns_flags (NSUInteger nsflags)
{
GdkModifierType modifiers = 0;
if (nsflags & NSAlphaShiftKeyMask)
if (nsflags & GDK_QUARTZ_ALPHA_SHIFT_KEY_MASK)
modifiers |= GDK_LOCK_MASK;
if (nsflags & NSShiftKeyMask)
if (nsflags & GDK_QUARTZ_SHIFT_KEY_MASK)
modifiers |= GDK_SHIFT_MASK;
if (nsflags & NSControlKeyMask)
if (nsflags & GDK_QUARTZ_CONTROL_KEY_MASK)
modifiers |= GDK_CONTROL_MASK;
if (nsflags & NSAlternateKeyMask)
if (nsflags & GDK_QUARTZ_ALTERNATE_KEY_MASK)
modifiers |= GDK_MOD1_MASK;
if (nsflags & NSCommandKeyMask)
if (nsflags & GDK_QUARTZ_COMMAND_KEY_MASK)
modifiers |= GDK_MOD2_MASK;
return modifiers;
@ -315,31 +297,31 @@ get_event_mask_from_ns_event (NSEvent *nsevent)
{
switch ([nsevent type])
{
case NSLeftMouseDown:
case NSRightMouseDown:
case NSOtherMouseDown:
case GDK_QUARTZ_LEFT_MOUSE_DOWN:
case GDK_QUARTZ_RIGHT_MOUSE_DOWN:
case GDK_QUARTZ_OTHER_MOUSE_DOWN:
return GDK_BUTTON_PRESS_MASK;
case NSLeftMouseUp:
case NSRightMouseUp:
case NSOtherMouseUp:
case GDK_QUARTZ_LEFT_MOUSE_UP:
case GDK_QUARTZ_RIGHT_MOUSE_UP:
case GDK_QUARTZ_OTHER_MOUSE_UP:
return GDK_BUTTON_RELEASE_MASK;
case NSMouseMoved:
case GDK_QUARTZ_MOUSE_MOVED:
return GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK;
case NSScrollWheel:
case GDK_QUARTZ_SCROLL_WHEEL:
/* Since applications that want button press events can get
* scroll events on X11 (since scroll wheel events are really
* button press events there), we need to use GDK_BUTTON_PRESS_MASK too.
*/
return GDK_SCROLL_MASK | GDK_BUTTON_PRESS_MASK;
case NSLeftMouseDragged:
case GDK_QUARTZ_LEFT_MOUSE_DRAGGED:
return (GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK | GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON1_MASK);
case NSRightMouseDragged:
case GDK_QUARTZ_RIGHT_MOUSE_DRAGGED:
return (GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK | GDK_BUTTON3_MOTION_MASK |
GDK_BUTTON3_MASK);
case NSOtherMouseDragged:
case GDK_QUARTZ_OTHER_MOUSE_DRAGGED:
{
GdkEventMask mask;
@ -356,9 +338,9 @@ get_event_mask_from_ns_event (NSEvent *nsevent)
case NSEventTypeMagnify:
case NSEventTypeRotate:
return GDK_TOUCHPAD_GESTURE_MASK;
case NSKeyDown:
case NSKeyUp:
case NSFlagsChanged:
case GDK_QUARTZ_KEY_DOWN:
case GDK_QUARTZ_KEY_UP:
case GDK_QUARTZ_FLAGS_CHANGED:
{
switch (_gdk_quartz_keys_event_type (nsevent))
{
@ -374,10 +356,10 @@ get_event_mask_from_ns_event (NSEvent *nsevent)
}
break;
case NSMouseEntered:
case GDK_QUARTZ_MOUSE_ENTERED:
return GDK_ENTER_NOTIFY_MASK;
case NSMouseExited:
case GDK_QUARTZ_MOUSE_EXITED:
return GDK_LEAVE_NOTIFY_MASK;
default:
@ -394,12 +376,15 @@ get_window_point_from_screen_point (GdkWindow *window,
gint *y)
{
NSPoint point;
NSWindow *nswindow;
GdkQuartzNSWindow *nswindow;
nswindow = ((GdkWindowImplQuartz *)window->impl)->toplevel;
nswindow = (GdkQuartzNSWindow*)(((GdkWindowImplQuartz *)window->impl)->toplevel);
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
point = [nswindow convertScreenToBase:screen_point];
#else
point = [nswindow convertPointFromScreen:screen_point];
#endif
*x = point.x;
*y = window->height - point.y;
}
@ -409,10 +394,12 @@ is_mouse_button_press_event (NSEventType type)
{
switch (type)
{
case NSLeftMouseDown:
case NSRightMouseDown:
case NSOtherMouseDown:
case GDK_QUARTZ_LEFT_MOUSE_DOWN:
case GDK_QUARTZ_RIGHT_MOUSE_DOWN:
case GDK_QUARTZ_OTHER_MOUSE_DOWN:
return TRUE;
default:
return FALSE;
}
return FALSE;
@ -473,8 +460,12 @@ get_toplevel_from_ns_event (NSEvent *nsevent,
}
else
{
*screen_point = [[nsevent window] convertBaseToScreen:point];
if (gdk_quartz_osx_version () >= GDK_OSX_LION)
*screen_point = [(GdkQuartzNSWindow*)[nsevent window] convertPointToScreen:point];
#if MAC_OS_X_VERSION_MIN_REQUIRED < 10700
else
*screen_point = [[nsevent window] convertBaseToScreen:point];
#endif
*x = point.x;
*y = toplevel->height - point.y;
}
@ -502,15 +493,15 @@ create_focus_event (GdkWindow *window,
gboolean in)
{
GdkEvent *event;
GdkQuartzDeviceManagerCore *device_manager;
GdkDisplay *display = gdk_window_get_display (window);
GdkSeat *seat = gdk_display_get_default_seat (display);
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);
gdk_event_set_seat (event, gdk_device_get_seat (device_manager->core_keyboard));
gdk_event_set_device (event, gdk_seat_get_keyboard (seat));
gdk_event_set_seat (event, seat);
return event;
}
@ -522,7 +513,8 @@ generate_motion_event (GdkWindow *window)
NSPoint screen_point;
GdkEvent *event;
gint x, y, x_root, y_root;
GdkQuartzDeviceManagerCore *device_manager;
GdkDisplay *display = gdk_window_get_display (window);
GdkSeat *seat = gdk_display_get_default_seat (display);
event = gdk_event_new (GDK_MOTION_NOTIFY);
event->any.window = NULL;
@ -544,9 +536,8 @@ generate_motion_event (GdkWindow *window)
event->motion.state = _gdk_quartz_events_get_current_keyboard_modifiers () |
_gdk_quartz_events_get_current_mouse_modifiers ();
event->motion.is_hint = FALSE;
device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
event->motion.device = device_manager->core_pointer;
gdk_event_set_seat (event, gdk_device_get_seat (device_manager->core_pointer));
event->motion.device = gdk_seat_get_pointer (seat);
gdk_event_set_seat (event, seat);
append_event (event, TRUE);
}
@ -623,8 +614,9 @@ find_toplevel_under_pointer (GdkDisplay *display,
{
GdkWindow *toplevel;
GdkPointerWindowInfo *info;
GdkSeat *seat = gdk_display_get_default_seat (display);
info = _gdk_display_get_pointer_info (display, GDK_QUARTZ_DEVICE_MANAGER_CORE (display->device_manager)->core_pointer);
info = _gdk_display_get_pointer_info (display, gdk_seat_get_pointer (seat));
toplevel = info->toplevel_under_pointer;
if (toplevel && WINDOW_IS_TOPLEVEL (toplevel))
get_window_point_from_screen_point (toplevel, screen_point, x, y);
@ -651,24 +643,20 @@ find_toplevel_for_keyboard_event (NSEvent *nsevent)
GdkWindow *window;
GdkDisplay *display;
GdkQuartzView *view;
GdkDeviceManager *device_manager;
GdkSeat *seat;
view = (GdkQuartzView *)[[nsevent window] contentView];
window = [view gdkWindow];
display = gdk_window_get_display (window);
seat = gdk_display_get_default_seat (display);
device_manager = gdk_display_get_device_manager (display);
list = gdk_device_manager_list_devices (device_manager,
GDK_DEVICE_TYPE_MASTER);
list = gdk_seat_get_slaves (seat, GDK_SEAT_CAPABILITY_KEYBOARD);
for (l = list; l; l = l->next)
{
GdkDeviceGrabInfo *grab;
GdkDevice *device = l->data;
if (gdk_device_get_source(device) != GDK_SOURCE_KEYBOARD)
continue;
grab = _gdk_display_get_last_device_grab (display, device);
if (grab && grab->window && !grab->owner_events)
{
@ -692,11 +680,13 @@ find_toplevel_for_mouse_event (NSEvent *nsevent,
GdkWindow *toplevel;
GdkDisplay *display;
GdkDeviceGrabInfo *grab;
GdkSeat *seat;
toplevel = get_toplevel_from_ns_event (nsevent, &screen_point, x, y);
display = gdk_window_get_display (toplevel);
seat = gdk_display_get_default_seat (_gdk_display);
event_type = [nsevent type];
/* From the docs for XGrabPointer:
@ -709,7 +699,7 @@ find_toplevel_for_mouse_event (NSEvent *nsevent,
* events are discarded.
*/
grab = _gdk_display_get_last_device_grab (display,
GDK_QUARTZ_DEVICE_MANAGER_CORE (display->device_manager)->core_pointer);
gdk_seat_get_pointer (seat));
if (WINDOW_IS_TOPLEVEL (toplevel) && grab)
{
/* Implicit grabs do not go through XGrabPointer and thus the
@ -766,7 +756,7 @@ find_toplevel_for_mouse_event (NSEvent *nsevent,
* 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 (event_type != GDK_QUARTZ_MOUSE_MOVED)
if (*y < 0)
return NULL;
@ -821,23 +811,23 @@ find_window_for_ns_event (NSEvent *nsevent,
switch (event_type)
{
case NSLeftMouseDown:
case NSRightMouseDown:
case NSOtherMouseDown:
case NSLeftMouseUp:
case NSRightMouseUp:
case NSOtherMouseUp:
case NSMouseMoved:
case NSScrollWheel:
case NSLeftMouseDragged:
case NSRightMouseDragged:
case NSOtherMouseDragged:
case GDK_QUARTZ_LEFT_MOUSE_DOWN:
case GDK_QUARTZ_RIGHT_MOUSE_DOWN:
case GDK_QUARTZ_OTHER_MOUSE_DOWN:
case GDK_QUARTZ_LEFT_MOUSE_UP:
case GDK_QUARTZ_RIGHT_MOUSE_UP:
case GDK_QUARTZ_OTHER_MOUSE_UP:
case GDK_QUARTZ_MOUSE_MOVED:
case GDK_QUARTZ_SCROLL_WHEEL:
case GDK_QUARTZ_LEFT_MOUSE_DRAGGED:
case GDK_QUARTZ_RIGHT_MOUSE_DRAGGED:
case GDK_QUARTZ_OTHER_MOUSE_DRAGGED:
case NSEventTypeMagnify:
case NSEventTypeRotate:
return find_toplevel_for_mouse_event (nsevent, x, y);
case NSMouseEntered:
case NSMouseExited:
case GDK_QUARTZ_MOUSE_ENTERED:
case GDK_QUARTZ_MOUSE_EXITED:
/* Only handle our own entered/exited events, not the ones for the
* titlebar buttons.
*/
@ -846,9 +836,9 @@ find_window_for_ns_event (NSEvent *nsevent,
else
return NULL;
case NSKeyDown:
case NSKeyUp:
case NSFlagsChanged:
case GDK_QUARTZ_KEY_DOWN:
case GDK_QUARTZ_KEY_UP:
case GDK_QUARTZ_FLAGS_CHANGED:
return find_toplevel_for_keyboard_event (nsevent);
default:
@ -871,7 +861,7 @@ fill_crossing_event (GdkWindow *toplevel,
GdkCrossingMode mode,
GdkNotifyType detail)
{
GdkQuartzDeviceManagerCore *device_manager;
GdkSeat *seat = gdk_display_get_default_seat (_gdk_display);
event->any.type = event_type;
event->crossing.window = toplevel;
@ -886,9 +876,8 @@ fill_crossing_event (GdkWindow *toplevel,
event->crossing.state = get_keyboard_modifiers_from_ns_event (nsevent) |
_gdk_quartz_events_get_current_mouse_modifiers ();
device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
gdk_event_set_device (event, device_manager->core_pointer);
gdk_event_set_seat (event, gdk_device_get_seat (device_manager->core_pointer));
gdk_event_set_device (event, gdk_seat_get_pointer (seat));
gdk_event_set_seat (event, seat);
/* FIXME: Focus and button state? */
}
@ -921,9 +910,7 @@ fill_pinch_event (GdkWindow *window,
FP_STATE_IDLE,
FP_STATE_UPDATE
} last_state = FP_STATE_IDLE;
GdkQuartzDeviceManagerCore *device_manager;
device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
GdkSeat *seat = gdk_display_get_default_seat (_gdk_display);
event->any.type = GDK_TOUCHPAD_PINCH;
event->touchpad_pinch.window = window;
@ -936,7 +923,7 @@ fill_pinch_event (GdkWindow *window,
event->touchpad_pinch.n_fingers = 2;
event->touchpad_pinch.dx = 0.0;
event->touchpad_pinch.dy = 0.0;
gdk_event_set_device (event, device_manager->core_pointer);
gdk_event_set_device (event, gdk_seat_get_pointer (seat));
switch ([nsevent phase])
{
@ -1015,23 +1002,23 @@ fill_button_event (GdkWindow *window,
{
GdkEventType type;
gint state;
GdkQuartzDeviceManagerCore *device_manager;
GdkSeat *seat = gdk_display_get_default_seat (_gdk_display);
state = get_keyboard_modifiers_from_ns_event (nsevent) |
_gdk_quartz_events_get_current_mouse_modifiers ();
switch ([nsevent type])
{
case NSLeftMouseDown:
case NSRightMouseDown:
case NSOtherMouseDown:
case GDK_QUARTZ_LEFT_MOUSE_DOWN:
case GDK_QUARTZ_RIGHT_MOUSE_DOWN:
case GDK_QUARTZ_OTHER_MOUSE_DOWN:
type = GDK_BUTTON_PRESS;
state &= ~get_mouse_button_modifiers_from_ns_event (nsevent);
break;
case NSLeftMouseUp:
case NSRightMouseUp:
case NSOtherMouseUp:
case GDK_QUARTZ_LEFT_MOUSE_UP:
case GDK_QUARTZ_RIGHT_MOUSE_UP:
case GDK_QUARTZ_OTHER_MOUSE_UP:
type = GDK_BUTTON_RELEASE;
state |= get_mouse_button_modifiers_from_ns_event (nsevent);
break;
@ -1050,9 +1037,9 @@ fill_button_event (GdkWindow *window,
/* FIXME event->axes */
event->button.state = state;
event->button.button = get_mouse_button_from_ns_event (nsevent);
device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
event->button.device = device_manager->core_pointer;
gdk_event_set_seat (event, gdk_device_get_seat (device_manager->core_pointer));
event->button.device = gdk_seat_get_pointer (seat);
gdk_event_set_seat (event, seat);
}
static void
@ -1064,7 +1051,7 @@ fill_motion_event (GdkWindow *window,
gint x_root,
gint y_root)
{
GdkQuartzDeviceManagerCore *device_manager;
GdkSeat *seat = gdk_display_get_default_seat (_gdk_display);
event->any.type = GDK_MOTION_NOTIFY;
event->motion.window = window;
@ -1077,9 +1064,8 @@ fill_motion_event (GdkWindow *window,
event->motion.state = get_keyboard_modifiers_from_ns_event (nsevent) |
_gdk_quartz_events_get_current_mouse_modifiers ();
event->motion.is_hint = FALSE;
device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
event->motion.device = device_manager->core_pointer;
gdk_event_set_seat (event, gdk_device_get_seat (device_manager->core_pointer));
event->motion.device = gdk_seat_get_pointer (seat);
gdk_event_set_seat (event, seat);
}
static void
@ -1094,11 +1080,10 @@ fill_scroll_event (GdkWindow *window,
gdouble delta_y,
GdkScrollDirection direction)
{
GdkQuartzDeviceManagerCore *device_manager;
GdkSeat *seat = gdk_display_get_default_seat (_gdk_display);
NSPoint point;
point = [nsevent locationInWindow];
device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
event->any.type = GDK_SCROLL;
event->scroll.window = window;
@ -1109,10 +1094,10 @@ fill_scroll_event (GdkWindow *window,
event->scroll.y_root = y_root;
event->scroll.state = get_keyboard_modifiers_from_ns_event (nsevent);
event->scroll.direction = direction;
event->scroll.device = device_manager->core_pointer;
event->scroll.device = gdk_seat_get_pointer (seat);
event->scroll.delta_x = delta_x;
event->scroll.delta_y = delta_y;
gdk_event_set_seat (event, gdk_device_get_seat (device_manager->core_pointer));
gdk_event_set_seat (event, seat);
}
static void
@ -1122,7 +1107,7 @@ fill_key_event (GdkWindow *window,
GdkEventType type)
{
GdkEventPrivate *priv;
GdkQuartzDeviceManagerCore *device_manager;
GdkSeat *seat = gdk_display_get_default_seat (_gdk_display);
gchar buf[7];
gunichar c = 0;
@ -1135,16 +1120,15 @@ fill_key_event (GdkWindow *window,
event->key.state = get_keyboard_modifiers_from_ns_event (nsevent);
event->key.hardware_keycode = [nsevent keyCode];
gdk_event_set_scancode (event, [nsevent keyCode]);
event->key.group = ([nsevent modifierFlags] & NSAlternateKeyMask) ? 1 : 0;
event->key.group = ([nsevent modifierFlags] & GDK_QUARTZ_ALTERNATE_KEY_MASK) ? 1 : 0;
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_event_set_seat (event, gdk_device_get_seat (device_manager->core_keyboard));
gdk_event_set_device (event, gdk_seat_get_keyboard (seat));
gdk_event_set_seat (event, seat);
gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (_gdk_display),
event->key.hardware_keycode,
event->key.state,
event->key.state,
event->key.group,
&event->key.keyval,
NULL, NULL, NULL);
@ -1256,7 +1240,7 @@ synthesize_crossing_event (GdkWindow *window,
{
switch ([nsevent type])
{
case NSMouseEntered:
case GDK_QUARTZ_MOUSE_ENTERED:
/* Enter events are considered always to be from another toplevel
* window, this shouldn't negatively affect any app or gtk code,
* and is the only way to make GtkMenu work. EEK EEK EEK.
@ -1272,7 +1256,7 @@ synthesize_crossing_event (GdkWindow *window,
GDK_NOTIFY_NONLINEAR);
return TRUE;
case NSMouseExited:
case GDK_QUARTZ_MOUSE_EXITED:
/* See above */
if (!(window->event_mask & GDK_LEAVE_NOTIFY_MASK))
return FALSE;
@ -1296,7 +1280,7 @@ void
_gdk_quartz_synthesize_null_key_event (GdkWindow *window)
{
GdkEvent *event;
GdkQuartzDeviceManagerCore *device_manager;
GdkSeat *seat = gdk_display_get_default_seat (_gdk_display);
event = gdk_event_new (GDK_KEY_PRESS);
event->any.type = GDK_KEY_PRESS;
@ -1305,9 +1289,9 @@ _gdk_quartz_synthesize_null_key_event (GdkWindow *window)
event->key.hardware_keycode = 0;
event->key.group = 0;
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_event_set_seat (event, gdk_device_get_seat (device_manager->core_keyboard));
gdk_event_set_device (event, gdk_seat_get_keyboard (seat));
gdk_event_set_seat (event, seat);
append_event(event, FALSE);
}
@ -1359,12 +1343,12 @@ 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
/* Resizing from the resize indicator only begins if an GDK_QUARTZ_LEFT_MOUSE_BUTTON
* event is received in the resizing area.
*/
toplevel_impl = (GdkWindowImplQuartz *)toplevel->impl;
if ([toplevel_impl->toplevel showsResizeIndicator])
if ([event type] == NSLeftMouseDown &&
if ([event type] == GDK_QUARTZ_LEFT_MOUSE_DOWN &&
[toplevel_impl->toplevel showsResizeIndicator])
{
NSRect frame;
@ -1403,9 +1387,9 @@ test_resize (NSEvent *event, GdkWindow *toplevel, gint x, gint y)
*/
lion = gdk_quartz_osx_version () >= GDK_OSX_LION;
if (lion &&
([event type] == NSLeftMouseDown ||
[event type] == NSRightMouseDown ||
[event type] == NSOtherMouseDown))
([event type] == GDK_QUARTZ_LEFT_MOUSE_DOWN ||
[event type] == GDK_QUARTZ_RIGHT_MOUSE_DOWN ||
[event type] == GDK_QUARTZ_OTHER_MOUSE_DOWN))
{
if (x < GDK_LION_RESIZE ||
x > toplevel->width - GDK_LION_RESIZE ||
@ -1416,6 +1400,14 @@ test_resize (NSEvent *event, GdkWindow *toplevel, gint x, gint y)
return FALSE;
}
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
#define GDK_QUARTZ_APP_KIT_DEFINED NSAppKitDefined
#define GDK_QUARTZ_APPLICATION_DEACTIVATED NSApplicationDeactivatedEventType
#else
#define GDK_QUARTZ_APP_KIT_DEFINED NSEventTypeAppKitDefined
#define GDK_QUARTZ_APPLICATION_DEACTIVATED NSEventSubtypeApplicationDeactivated
#endif
static gboolean
gdk_event_translate (GdkEvent *event,
NSEvent *nsevent)
@ -1431,9 +1423,9 @@ gdk_event_translate (GdkEvent *event,
* grabs when the application loses focus (gets deactivated).
*/
event_type = [nsevent type];
if (event_type == NSAppKitDefined)
if (event_type == GDK_QUARTZ_APP_KIT_DEFINED)
{
if ([nsevent subtype] == NSApplicationDeactivatedEventType)
if ([nsevent subtype] == GDK_QUARTZ_APPLICATION_DEACTIVATED)
_gdk_quartz_events_break_all_grabs (get_time_from_ns_event (nsevent));
/* This could potentially be used to break grabs when clicking
@ -1469,7 +1461,7 @@ gdk_event_translate (GdkEvent *event,
{
GdkWindow *toplevel = NULL;
if (event_type == NSMouseMoved)
if (event_type == GDK_QUARTZ_MOUSE_MOVED)
{
/* Motion events received after clicking the menu bar do not have the
* window field set. Instead of giving up on the event immediately,
@ -1540,9 +1532,9 @@ gdk_event_translate (GdkEvent *event,
* 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))
if ((event_type == GDK_QUARTZ_RIGHT_MOUSE_DOWN ||
event_type == GDK_QUARTZ_OTHER_MOUSE_DOWN ||
event_type == GDK_QUARTZ_LEFT_MOUSE_DOWN))
{
GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
@ -1554,35 +1546,32 @@ gdk_event_translate (GdkEvent *event,
else if (![impl->toplevel isKeyWindow])
{
GdkDeviceGrabInfo *grab;
GdkSeat *seat = gdk_display_get_default_seat (_gdk_display);
grab = _gdk_display_get_last_device_grab (_gdk_display,
GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager)->core_pointer);
if (!grab)
[impl->toplevel makeKeyWindow];
gdk_seat_get_pointer (seat));
}
return_val = TRUE;
}
return_val = TRUE;
switch (event_type)
{
case NSLeftMouseDown:
case NSRightMouseDown:
case NSOtherMouseDown:
case NSLeftMouseUp:
case NSRightMouseUp:
case NSOtherMouseUp:
case GDK_QUARTZ_LEFT_MOUSE_DOWN:
case GDK_QUARTZ_RIGHT_MOUSE_DOWN:
case GDK_QUARTZ_OTHER_MOUSE_DOWN:
case GDK_QUARTZ_LEFT_MOUSE_UP:
case GDK_QUARTZ_RIGHT_MOUSE_UP:
case GDK_QUARTZ_OTHER_MOUSE_UP:
fill_button_event (window, event, nsevent, x, y, x_root, y_root);
break;
case NSLeftMouseDragged:
case NSRightMouseDragged:
case NSOtherMouseDragged:
case NSMouseMoved:
case GDK_QUARTZ_LEFT_MOUSE_DRAGGED:
case GDK_QUARTZ_RIGHT_MOUSE_DRAGGED:
case GDK_QUARTZ_OTHER_MOUSE_DRAGGED:
case GDK_QUARTZ_MOUSE_MOVED:
fill_motion_event (window, event, nsevent, x, y, x_root, y_root);
break;
case NSScrollWheel:
case GDK_QUARTZ_SCROLL_WHEEL:
{
GdkScrollDirection direction;
float dx;
@ -1659,17 +1648,17 @@ gdk_event_translate (GdkEvent *event,
return_val = FALSE;
break;
#endif
case NSMouseExited:
case GDK_QUARTZ_MOUSE_EXITED:
if (WINDOW_IS_TOPLEVEL (window))
[[NSCursor arrowCursor] set];
/* fall through */
case NSMouseEntered:
case GDK_QUARTZ_MOUSE_ENTERED:
return_val = synthesize_crossing_event (window, event, nsevent, x, y, x_root, y_root);
break;
case NSKeyDown:
case NSKeyUp:
case NSFlagsChanged:
case GDK_QUARTZ_KEY_DOWN:
case GDK_QUARTZ_KEY_UP:
case GDK_QUARTZ_FLAGS_CHANGED:
{
GdkEventType type;

7
gdk/quartz/gdkglobals-quartz.c
View File

@ -32,9 +32,16 @@ gdk_quartz_osx_version (void)
if (minor == GDK_OSX_UNSUPPORTED)
{
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101000
OSErr err = Gestalt (gestaltSystemVersionMinor, (SInt32*)&minor);
g_return_val_if_fail (err == noErr, GDK_OSX_UNSUPPORTED);
#else
NSOperatingSystemVersion version;
version = [[NSProcessInfo processInfo] operatingSystemVersion];
minor = version.minorVersion;
#endif
}
if (minor < GDK_OSX_MIN)

56
gdk/quartz/gdkkeys-quartz.c
View File

@ -87,52 +87,20 @@ _gdk_quartz_display_get_keymap (GdkDisplay *display)
*/
static guint *keyval_array = NULL;
static inline UniChar
macroman2ucs (unsigned char c)
{
/* Precalculated table mapping MacRoman-128 to Unicode. Generated
by creating single element CFStringRefs then extracting the
first character. */
static const unsigned short table[128] = {
0xc4, 0xc5, 0xc7, 0xc9, 0xd1, 0xd6, 0xdc, 0xe1,
0xe0, 0xe2, 0xe4, 0xe3, 0xe5, 0xe7, 0xe9, 0xe8,
0xea, 0xeb, 0xed, 0xec, 0xee, 0xef, 0xf1, 0xf3,
0xf2, 0xf4, 0xf6, 0xf5, 0xfa, 0xf9, 0xfb, 0xfc,
0x2020, 0xb0, 0xa2, 0xa3, 0xa7, 0x2022, 0xb6, 0xdf,
0xae, 0xa9, 0x2122, 0xb4, 0xa8, 0x2260, 0xc6, 0xd8,
0x221e, 0xb1, 0x2264, 0x2265, 0xa5, 0xb5, 0x2202, 0x2211,
0x220f, 0x3c0, 0x222b, 0xaa, 0xba, 0x3a9, 0xe6, 0xf8,
0xbf, 0xa1, 0xac, 0x221a, 0x192, 0x2248, 0x2206, 0xab,
0xbb, 0x2026, 0xa0, 0xc0, 0xc3, 0xd5, 0x152, 0x153,
0x2013, 0x2014, 0x201c, 0x201d, 0x2018, 0x2019, 0xf7, 0x25ca,
0xff, 0x178, 0x2044, 0x20ac, 0x2039, 0x203a, 0xfb01, 0xfb02,
0x2021, 0xb7, 0x201a, 0x201e, 0x2030, 0xc2, 0xca, 0xc1,
0xcb, 0xc8, 0xcd, 0xce, 0xcf, 0xcc, 0xd3, 0xd4,
0xf8ff, 0xd2, 0xda, 0xdb, 0xd9, 0x131, 0x2c6, 0x2dc,
0xaf, 0x2d8, 0x2d9, 0x2da, 0xb8, 0x2dd, 0x2db, 0x2c7
};
if (c < 128)
return c;
else
return table[c - 128];
}
const static struct {
guint keycode;
guint keyval;
unsigned int modmask; /* So we can tell when a mod key is pressed/released */
} modifier_keys[] = {
{ 54, GDK_KEY_Meta_R, NSCommandKeyMask },
{ 55, GDK_KEY_Meta_L, NSCommandKeyMask },
{ 56, GDK_KEY_Shift_L, NSShiftKeyMask },
{ 57, GDK_KEY_Caps_Lock, NSAlphaShiftKeyMask },
{ 58, GDK_KEY_Alt_L, NSAlternateKeyMask },
{ 59, GDK_KEY_Control_L, NSControlKeyMask },
{ 60, GDK_KEY_Shift_R, NSShiftKeyMask },
{ 61, GDK_KEY_Alt_R, NSAlternateKeyMask },
{ 62, GDK_KEY_Control_R, NSControlKeyMask }
{ 54, GDK_KEY_Meta_R, GDK_QUARTZ_COMMAND_KEY_MASK },
{ 55, GDK_KEY_Meta_L, GDK_QUARTZ_COMMAND_KEY_MASK },
{ 56, GDK_KEY_Shift_L, GDK_QUARTZ_SHIFT_KEY_MASK },
{ 57, GDK_KEY_Caps_Lock, GDK_QUARTZ_ALPHA_SHIFT_KEY_MASK },
{ 58, GDK_KEY_Alt_L, GDK_QUARTZ_ALTERNATE_KEY_MASK },
{ 59, GDK_KEY_Control_L, GDK_QUARTZ_CONTROL_KEY_MASK },
{ 60, GDK_KEY_Shift_R, GDK_QUARTZ_SHIFT_KEY_MASK },
{ 61, GDK_KEY_Alt_R, GDK_QUARTZ_ALTERNATE_KEY_MASK },
{ 62, GDK_KEY_Control_R, GDK_QUARTZ_CONTROL_KEY_MASK }
};
const static struct {
@ -783,11 +751,11 @@ _gdk_quartz_keys_event_type (NSEvent *event)
switch ([event type])
{
case NSKeyDown:
case GDK_QUARTZ_KEY_DOWN:
return GDK_KEY_PRESS;
case NSKeyUp:
case GDK_QUARTZ_KEY_UP:
return GDK_KEY_RELEASE;
case NSFlagsChanged:
case GDK_QUARTZ_FLAGS_CHANGED:
break;
default:
g_assert_not_reached ();

3
gdk/quartz/gdkmonitor-quartz.h
View File

@ -29,8 +29,8 @@
struct _GdkQuartzMonitor
{
GdkMonitor parent;
gint monitor_num;
CGDirectDisplayID id;
};
struct _GdkQuartzMonitorClass {
@ -38,4 +38,3 @@ struct _GdkQuartzMonitorClass {
};
#endif

20
gdk/quartz/gdkproperty-quartz.c
View File

@ -128,26 +128,6 @@ ensure_atom_tables (void)
}
}
static GdkAtom
intern_atom_internal (const gchar *atom_name, gboolean allocate)
{
gpointer result;
gchar *name;
g_return_val_if_fail (atom_name != NULL, GDK_NONE);
ensure_atom_tables ();
if (g_hash_table_lookup_extended (names_to_atoms, atom_name, NULL, &result))
return result;
result = GINT_TO_POINTER (atoms_to_names->len);
name = allocate ? g_strdup (atom_name) : (gchar *)atom_name;
g_hash_table_insert(names_to_atoms, name, result);
g_ptr_array_add(atoms_to_names, name);
return result;
}
void
_gdk_quartz_window_delete_property (GdkWindow *window,
GdkAtom property)

73
gdk/quartz/gdkquartzkeys.h
View File

@ -45,6 +45,79 @@ typedef struct _GdkQuartzKeymapClass GdkQuartzKeymapClass;
GDK_AVAILABLE_IN_ALL
GType gdk_quartz_keymap_get_type (void);
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
typedef enum
{
GDK_QUARTZ_FLAGS_CHANGED = NSFlagsChanged,
GDK_QUARTZ_KEY_UP = NSKeyUp,
GDK_QUARTZ_KEY_DOWN = NSKeyDown,
GDK_QUARTZ_MOUSE_ENTERED = NSMouseEntered,
GDK_QUARTZ_MOUSE_EXITED = NSMouseExited,
GDK_QUARTZ_SCROLL_WHEEL = NSScrollWheel,
GDK_QUARTZ_MOUSE_MOVED = NSMouseMoved,
GDK_QUARTZ_OTHER_MOUSE_DRAGGED = NSOtherMouseDragged,
GDK_QUARTZ_RIGHT_MOUSE_DRAGGED = NSRightMouseDragged,
GDK_QUARTZ_LEFT_MOUSE_DRAGGED = NSLeftMouseDragged,
GDK_QUARTZ_OTHER_MOUSE_UP = NSOtherMouseUp,
GDK_QUARTZ_RIGHT_MOUSE_UP = NSRightMouseUp,
GDK_QUARTZ_LEFT_MOUSE_UP = NSLeftMouseUp,
GDK_QUARTZ_OTHER_MOUSE_DOWN = NSOtherMouseDown,
GDK_QUARTZ_RIGHT_MOUSE_DOWN = NSRightMouseDown,
GDK_QUARTZ_LEFT_MOUSE_DOWN = NSLeftMouseDown,
} GdkQuartzEventType;
typedef enum
{
GDK_QUARTZ_ALTERNATE_KEY_MASK = NSAlternateKeyMask,
GDK_QUARTZ_CONTROL_KEY_MASK = NSControlKeyMask,
GDK_QUARTZ_SHIFT_KEY_MASK = NSShiftKeyMask,
GDK_QUARTZ_ALPHA_SHIFT_KEY_MASK = NSAlphaShiftKeyMask,
GDK_QUARTZ_COMMAND_KEY_MASK = NSCommandKeyMask,
GDK_QUARTZ_ANY_EVENT_MASK = NSAnyEventMask,
} GdkQuartzEventModifierFlags;
typedef enum
{
GDK_QUARTZ_EVENT_MASK_ANY = NSAnyEventMask,
} GdkQuartzEventMask;
#else
typedef enum
{
GDK_QUARTZ_FLAGS_CHANGED = NSEventTypeFlagsChanged,
GDK_QUARTZ_KEY_UP = NSEventTypeKeyUp,
GDK_QUARTZ_KEY_DOWN = NSEventTypeKeyDown,
GDK_QUARTZ_MOUSE_ENTERED = NSEventTypeMouseEntered,
GDK_QUARTZ_MOUSE_EXITED = NSEventTypeMouseExited,
GDK_QUARTZ_SCROLL_WHEEL = NSEventTypeScrollWheel,
GDK_QUARTZ_MOUSE_MOVED = NSEventTypeMouseMoved,
GDK_QUARTZ_OTHER_MOUSE_DRAGGED = NSEventTypeOtherMouseDragged,
GDK_QUARTZ_RIGHT_MOUSE_DRAGGED = NSEventTypeRightMouseDragged,
GDK_QUARTZ_LEFT_MOUSE_DRAGGED = NSEventTypeLeftMouseDragged,
GDK_QUARTZ_OTHER_MOUSE_UP = NSEventTypeOtherMouseUp,
GDK_QUARTZ_RIGHT_MOUSE_UP = NSEventTypeRightMouseUp,
GDK_QUARTZ_LEFT_MOUSE_UP = NSEventTypeLeftMouseUp,
GDK_QUARTZ_OTHER_MOUSE_DOWN = NSEventTypeOtherMouseDown,
GDK_QUARTZ_RIGHT_MOUSE_DOWN = NSEventTypeRightMouseDown,
GDK_QUARTZ_LEFT_MOUSE_DOWN = NSEventTypeLeftMouseDown,
} GdkQuartzEventType;
typedef enum
{
GDK_QUARTZ_ALTERNATE_KEY_MASK = NSEventModifierFlagOption,
GDK_QUARTZ_CONTROL_KEY_MASK = NSEventModifierFlagControl,
GDK_QUARTZ_SHIFT_KEY_MASK = NSEventModifierFlagShift,
GDK_QUARTZ_ALPHA_SHIFT_KEY_MASK = NSEventModifierFlagCapsLock,
GDK_QUARTZ_COMMAND_KEY_MASK = NSEventModifierFlagCommand,
} GdkQuartzEventModifierFlags;
typedef enum
{
GDK_QUARTZ_EVENT_MASK_ANY = NSEventMaskAny,
} GdkQuartzEventMask;
#endif
G_END_DECLS
#endif /* __GDK_QUARTZ_KEYS_H__ */

163
gdk/quartz/gdkscreen-quartz.c
View File

@ -63,12 +63,10 @@
static void gdk_quartz_screen_dispose (GObject *object);
static void gdk_quartz_screen_finalize (GObject *object);
static void gdk_quartz_screen_calculate_layout (GdkQuartzScreen *screen);
static void gdk_quartz_screen_reconfigure (GdkQuartzDisplay *dispplay,
GdkQuartzScreen *screen);
static void display_reconfiguration_callback (CGDirectDisplayID display,
CGDisplayChangeSummaryFlags flags,
void *userInfo);
static const double dpi = 72.0;
static gint get_mm_from_pixels (NSScreen *screen, int pixels);
G_DEFINE_TYPE (GdkQuartzScreen, gdk_quartz_screen, GDK_TYPE_SCREEN);
@ -86,13 +84,11 @@ gdk_quartz_screen_init (GdkQuartzScreen *quartz_screen)
* pangocairo-coretext needs to default to that scaling factor.
*/
g_signal_connect (_gdk_display, "monitors-changed",
G_CALLBACK (gdk_quartz_screen_reconfigure), quartz_screen);
/* The first monitors-changed should have fired already. */
_gdk_screen_set_resolution (screen, dpi);
gdk_quartz_screen_calculate_layout (quartz_screen);
CGDisplayRegisterReconfigurationCallback (display_reconfiguration_callback,
screen);
quartz_screen->emit_monitors_changed = FALSE;
}
@ -107,9 +103,6 @@ gdk_quartz_screen_dispose (GObject *object)
screen->screen_changed_id = 0;
}
CGDisplayRemoveReconfigurationCallback (display_reconfiguration_callback,
screen);
G_OBJECT_CLASS (gdk_quartz_screen_parent_class)->dispose (object);
}
@ -127,77 +120,42 @@ gdk_quartz_screen_finalize (GObject *object)
static void
gdk_quartz_screen_calculate_layout (GdkQuartzScreen *screen)
{
NSArray *array;
int i;
int i, monitors;
int max_x, max_y;
GdkDisplay *display = gdk_screen_get_display (GDK_SCREEN (screen));
GdkQuartzDisplay *display_quartz = GDK_QUARTZ_DISPLAY (display);
g_ptr_array_free (display_quartz->monitors, TRUE);
display_quartz->monitors = g_ptr_array_new_with_free_func (g_object_unref);
GDK_QUARTZ_ALLOC_POOL;
array = [NSScreen screens];
screen->width = 0;
screen->height = 0;
screen->min_x = 0;
screen->min_y = 0;
max_x = max_y = 0;
screen->mm_width = 0;
screen->mm_height = 0;
/* We determine the minimum and maximum x and y coordinates
* covered by the monitors. From this we can deduce the width
* and height of the root screen.
*/
for (i = 0; i < [array count]; i++)
monitors = gdk_display_get_n_monitors (display);
for (i = 0; i < monitors; ++i)
{
GdkQuartzMonitor *monitor = g_object_new (GDK_TYPE_QUARTZ_MONITOR,
"display", display,
NULL);
g_ptr_array_add (display_quartz->monitors, monitor);
monitor->monitor_num = i;
GdkQuartzMonitor *monitor =
GDK_QUARTZ_MONITOR (gdk_display_get_monitor (display, i));
GdkRectangle rect;
NSRect rect = [[array objectAtIndex:i] frame];
gdk_monitor_get_geometry (GDK_MONITOR (monitor), &rect);
screen->min_x = MIN (screen->min_x, rect.x);
max_x = MAX (max_x, rect.x + rect.width);
screen->min_x = MIN (screen->min_x, rect.origin.x);
max_x = MAX (max_x, rect.origin.x + rect.size.width);
screen->min_y = MIN (screen->min_y, rect.y);
max_y = MAX (max_y, rect.y + rect.height);
screen->min_y = MIN (screen->min_y, rect.origin.y);
max_y = MAX (max_y, rect.origin.y + rect.size.height);
screen->mm_height += GDK_MONITOR (monitor)->height_mm;
screen->mm_width += GDK_MONITOR (monitor)->width_mm;
}
screen->width = max_x - screen->min_x;
screen->height = max_y - screen->min_y;
for (i = 0; i < [array count] ; i++)
{
NSScreen *nsscreen;
NSRect rect;
GdkMonitor *monitor;
monitor = GDK_MONITOR(display_quartz->monitors->pdata[i]);
nsscreen = [array objectAtIndex:i];
rect = [nsscreen frame];
monitor->geometry.x = rect.origin.x - screen->min_x;
monitor->geometry.y
= screen->height - (rect.origin.y + rect.size.height) + screen->min_y;
monitor->geometry.width = rect.size.width;
monitor->geometry.height = rect.size.height;
if (gdk_quartz_osx_version() >= GDK_OSX_LION)
monitor->scale_factor = [(id <ScaleFactor>) nsscreen backingScaleFactor];
else
monitor->scale_factor = 1;
monitor->width_mm = get_mm_from_pixels(nsscreen, monitor->geometry.width);
monitor->height_mm = get_mm_from_pixels(nsscreen, monitor->geometry.height);
monitor->refresh_rate = 0; // unknown
monitor->manufacturer = NULL; // unknown
monitor->model = NULL; // unknown
monitor->subpixel_layout = GDK_SUBPIXEL_LAYOUT_UNKNOWN; // unknown
}
GDK_QUARTZ_RELEASE_POOL;
}
void
@ -236,7 +194,7 @@ _gdk_quartz_screen_update_window_sizes (GdkScreen *screen)
}
static void
process_display_reconfiguration (GdkQuartzScreen *screen)
gdk_quartz_screen_reconfigure (GdkQuartzDisplay *display, GdkQuartzScreen *screen)
{
int width, height;
@ -258,56 +216,6 @@ process_display_reconfiguration (GdkQuartzScreen *screen)
g_signal_emit_by_name (screen, "size-changed");
}
static gboolean
screen_changed_idle (gpointer data)
{
GdkQuartzScreen *screen = data;
process_display_reconfiguration (data);
screen->screen_changed_id = 0;
return FALSE;
}
static void
display_reconfiguration_callback (CGDirectDisplayID display,
CGDisplayChangeSummaryFlags flags,
void *userInfo)
{
GdkQuartzScreen *screen = userInfo;
if (flags & kCGDisplayBeginConfigurationFlag)
{
/* Ignore the begin configuration signal. */
return;
}
else
{
/* We save information about the changes, so we can emit
* ::monitors-changed when appropriate. This signal must be
* emitted when the number, size of position of one of the
* monitors changes.
*/
if (flags & kCGDisplayMovedFlag
|| flags & kCGDisplayAddFlag
|| flags & kCGDisplayRemoveFlag
|| flags & kCGDisplayEnabledFlag
|| flags & kCGDisplayDisabledFlag)
screen->emit_monitors_changed = TRUE;
/* At this point Cocoa does not know about the new screen data
* yet, so we delay our refresh into an idle handler.
*/
if (!screen->screen_changed_id)
{
screen->screen_changed_id = gdk_threads_add_idle (screen_changed_idle,
screen);
g_source_set_name_by_id (screen->screen_changed_id, "[gtk+] screen_changed_idle");
}
}
}
static GdkDisplay *
gdk_quartz_screen_get_display (GdkScreen *screen)
{
@ -338,13 +246,6 @@ gdk_quartz_screen_get_height (GdkScreen *screen)
return GDK_QUARTZ_SCREEN (screen)->height;
}
static gint
get_mm_from_pixels (NSScreen *screen, int pixels)
{
const float mm_per_inch = 25.4;
return (pixels / dpi) * mm_per_inch;
}
static gchar *
gdk_quartz_screen_make_display_name (GdkScreen *screen)
{
@ -369,34 +270,16 @@ gdk_quartz_screen_is_composited (GdkScreen *screen)
return TRUE;
}
static NSScreen *
get_nsscreen_for_monitor (gint monitor_num)
{
NSArray *array;
NSScreen *screen;
GDK_QUARTZ_ALLOC_POOL;
array = [NSScreen screens];
screen = [array objectAtIndex:monitor_num];
GDK_QUARTZ_RELEASE_POOL;
return screen;
}
static gint
gdk_quartz_screen_get_width_mm (GdkScreen *screen)
{
return get_mm_from_pixels (get_nsscreen_for_monitor (0),
GDK_QUARTZ_SCREEN (screen)->width);
return GDK_QUARTZ_SCREEN (screen)->mm_width;
}
static gint
gdk_quartz_screen_get_height_mm (GdkScreen *screen)
{
return get_mm_from_pixels (get_nsscreen_for_monitor (0),
GDK_QUARTZ_SCREEN (screen)->height);
return GDK_QUARTZ_SCREEN (screen)->mm_height;
}
static void

2
gdk/quartz/gdkscreen-quartz.h
View File

@ -35,6 +35,8 @@ struct _GdkQuartzScreen
gint width;
gint height;
gint mm_width;
gint mm_height;
guint screen_changed_id;

28
gdk/quartz/gdkselection-quartz.c
View File

@ -172,16 +172,28 @@ _gdk_quartz_display_text_property_to_utf8_list (GdkDisplay *display,
}
}
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101400
#define GDK_QUARTZ_URL_PBOARD_TYPE NSURLPboardType
#define GDK_QUARTZ_COLOR_PBOARD_TYPE NSColorPboardType
#define GDK_QUARTZ_STRING_PBOARD_TYPE NSStringPboardType
#define GDK_QUARTZ_TIFF_PBOARD_TYPE NSTIFFPboardType
#else
#define GDK_QUARTZ_URL_PBOARD_TYPE NSPasteboardTypeURL
#define GDK_QUARTZ_COLOR_PBOARD_TYPE NSPasteboardTypeColor
#define GDK_QUARTZ_STRING_PBOARD_TYPE NSPasteboardTypeString
#define GDK_QUARTZ_TIFF_PBOARD_TYPE NSPasteboardTypeTIFF
#endif
GdkAtom
gdk_quartz_pasteboard_type_to_atom_libgtk_only (NSString *type)
{
if ([type isEqualToString:NSStringPboardType])
if ([type isEqualToString:GDK_QUARTZ_STRING_PBOARD_TYPE])
return gdk_atom_intern_static_string ("UTF8_STRING");
else if ([type isEqualToString:NSTIFFPboardType])
else if ([type isEqualToString:GDK_QUARTZ_TIFF_PBOARD_TYPE])
return gdk_atom_intern_static_string ("image/tiff");
else if ([type isEqualToString:NSColorPboardType])
else if ([type isEqualToString:GDK_QUARTZ_COLOR_PBOARD_TYPE])
return gdk_atom_intern_static_string ("application/x-color");
else if ([type isEqualToString:NSURLPboardType])
else if ([type isEqualToString:GDK_QUARTZ_URL_PBOARD_TYPE])
return gdk_atom_intern_static_string ("text/uri-list");
else
return gdk_atom_intern ([type UTF8String], FALSE);
@ -191,13 +203,13 @@ NSString *
gdk_quartz_target_to_pasteboard_type_libgtk_only (const char *target)
{
if (strcmp (target, "UTF8_STRING") == 0)
return NSStringPboardType;
return GDK_QUARTZ_STRING_PBOARD_TYPE;
else if (strcmp (target, "image/tiff") == 0)
return NSTIFFPboardType;
return GDK_QUARTZ_TIFF_PBOARD_TYPE;
else if (strcmp (target, "application/x-color") == 0)
return NSColorPboardType;
return GDK_QUARTZ_COLOR_PBOARD_TYPE;
else if (strcmp (target, "text/uri-list") == 0)
return NSURLPboardType;
return GDK_QUARTZ_URL_PBOARD_TYPE;
else
return [NSString stringWithUTF8String:target];
}

175
gdk/quartz/gdkwindow-quartz.c
View File

@ -52,6 +52,27 @@ typedef struct
GdkWMDecoration decor;
} FullscreenSavedGeometry;
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
typedef enum
{
GDK_QUARTZ_BORDERLESS_WINDOW = NSBorderlessWindowMask,
GDK_QUARTZ_CLOSABLE_WINDOW = NSClosableWindowMask,
GDK_QUARTZ_FULLSCREEN_WINDOW = NSFullScreenWindowMask,
GDK_QUARTZ_MINIATURIZABLE_WINDOW = NSMiniaturizableWindowMask,
GDK_QUARTZ_RESIZABLE_WINDOW = NSResizableWindowMask,
GDK_QUARTZ_TITLED_WINDOW = NSTitledWindowMask,
} GdkQuartzWindowMask;
#else
typedef enum
{
GDK_QUARTZ_BORDERLESS_WINDOW = NSWindowStyleMaskBorderless,
GDK_QUARTZ_CLOSABLE_WINDOW = NSWindowStyleMaskClosable,
GDK_QUARTZ_FULLSCREEN_WINDOW = NSWindowStyleMaskFullScreen,
GDK_QUARTZ_MINIATURIZABLE_WINDOW = NSWindowStyleMaskMiniaturizable,
GDK_QUARTZ_RESIZABLE_WINDOW = NSWindowStyleMaskResizable,
GDK_QUARTZ_TITLED_WINDOW = NSWindowStyleMaskTitled,
} GdkQuartzWindowMask;
#endif
#ifndef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER
static FullscreenSavedGeometry *get_fullscreen_geometry (GdkWindow *window);
@ -120,7 +141,7 @@ static CGContextRef
gdk_window_impl_quartz_get_context (GdkWindowImplQuartz *window_impl,
gboolean antialias)
{
CGContextRef cg_context;
CGContextRef cg_context = NULL;
CGSize scale;
if (GDK_WINDOW_DESTROYED (window_impl->wrapper))
@ -137,10 +158,15 @@ gdk_window_impl_quartz_get_context (GdkWindowImplQuartz *window_impl,
if (![window_impl->view lockFocusIfCanDraw])
return NULL;
}
#if MAC_OS_X_VERSION_MAX_ALLOWED < 101000
cg_context = [[NSGraphicsContext currentContext] graphicsPort];
#else
if (gdk_quartz_osx_version () < GDK_OSX_YOSEMITE)
cg_context = [[NSGraphicsContext currentContext] graphicsPort];
else
cg_context = [[NSGraphicsContext currentContext] CGContext];
#endif
if (!cg_context)
return NULL;
CGContextSaveGState (cg_context);
@ -170,58 +196,14 @@ gdk_window_impl_quartz_release_context (GdkWindowImplQuartz *window_impl,
}
}
static void
check_grab_unmap (GdkWindow *window)
{
GList *list, *l;
GdkDisplay *display = gdk_window_get_display (window);
GdkDeviceManager *device_manager;
device_manager = gdk_display_get_device_manager (display);
list = gdk_device_manager_list_devices (device_manager,
GDK_DEVICE_TYPE_FLOATING);
for (l = list; l; l = l->next)
{
_gdk_display_end_device_grab (display, l->data, 0, window, TRUE);
}
g_list_free (list);
}
static void
check_grab_destroy (GdkWindow *window)
{
GList *list, *l;
GdkDisplay *display = gdk_window_get_display (window);
GdkDeviceManager *device_manager;
/* Make sure there is no lasting grab in this native window */
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)
{
GdkDeviceGrabInfo *grab;
grab = _gdk_display_get_last_device_grab (display, l->data);
if (grab && grab->native_window == window)
{
/* Serials are always 0 in quartz, but for clarity: */
grab->serial_end = grab->serial_start;
grab->implicit_ungrab = TRUE;
}
}
g_list_free (list);
}
static void
gdk_window_impl_quartz_finalize (GObject *object)
{
GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (object);
GdkDisplay *display = gdk_window_get_display (impl->wrapper);
GdkSeat *seat = gdk_display_get_default_seat (display);
check_grab_destroy (GDK_WINDOW_IMPL_QUARTZ (object)->wrapper);
gdk_seat_ungrab (seat);
if (impl->transient_for)
g_object_unref (impl->transient_for);
@ -239,10 +221,14 @@ gdk_window_impl_quartz_finalize (GObject *object)
*
* If drawable NULL, no flushing is done, only registering that a flush was
* done externally.
*
* Note: As of MacOS 10.14 NSWindow flushWindow is deprecated because
* Quartz has the ability to handle deferred drawing on its own.
*/
void
_gdk_quartz_window_flush (GdkWindowImplQuartz *window_impl)
{
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101400
static struct timeval prev_tv;
static gint intervals[4];
static gint index;
@ -268,6 +254,7 @@ _gdk_quartz_window_flush (GdkWindowImplQuartz *window_impl)
}
else
prev_tv = tv;
#endif
}
static cairo_user_data_key_t gdk_quartz_cairo_key;
@ -398,7 +385,7 @@ _gdk_quartz_window_process_updates_recurse (GdkWindow *window,
toplevel_impl = (GdkWindowImplQuartz *)toplevel->impl;
nswindow = toplevel_impl->toplevel;
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101400
/* In theory, we could skip the flush disabling, since we only
* have one NSView.
*/
@ -408,6 +395,7 @@ _gdk_quartz_window_process_updates_recurse (GdkWindow *window,
[nswindow disableFlushWindow];
update_nswindows = g_slist_prepend (update_nswindows, nswindow);
}
#endif
}
}
@ -431,10 +419,12 @@ _gdk_quartz_display_before_process_all_updates (GdkDisplay *display)
{
[NSAnimationContext endGrouping];
}
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101100
else
{
NSDisableScreenUpdates ();
}
#endif
}
void
@ -452,9 +442,10 @@ _gdk_quartz_display_after_process_all_updates (GdkDisplay *display)
[[nswindow contentView] displayIfNeeded];
_gdk_quartz_window_flush (NULL);
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101400
[nswindow enableFlushWindow];
[nswindow flushWindow];
#endif
[nswindow release];
tmp_list = tmp_list->next;
@ -468,10 +459,12 @@ _gdk_quartz_display_after_process_all_updates (GdkDisplay *display)
{
[NSAnimationContext beginGrouping];
}
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101100
else
{
NSEnableScreenUpdates ();
}
#endif
}
static const gchar *
@ -553,7 +546,11 @@ _gdk_quartz_window_debug_highlight (GdkWindow *window, gint number)
[debug_window[number] close];
debug_window[number] = [[NSWindow alloc] initWithContentRect:rect
styleMask:NSBorderlessWindowMask
#if MAC_OS_X_VERSION_MIN_REQUIRED < 101200
styleMask:(NSUInteger)GDK_QUARTZ_BORDERLESS_WINDOW
#else
styleMask:(NSWindowStyleMask)GDK_QUARTZ_BORDERLESS_WINDOW
#endif
backing:NSBackingStoreBuffered
defer:NO];
@ -880,14 +877,14 @@ _gdk_quartz_display_create_window_impl (GdkDisplay *display,
((attributes_mask & GDK_WA_TYPE_HINT) &&
attributes->type_hint == GDK_WINDOW_TYPE_HINT_SPLASHSCREEN))
{
style_mask = NSBorderlessWindowMask;
style_mask = GDK_QUARTZ_BORDERLESS_WINDOW;
}
else
{
style_mask = (NSTitledWindowMask |
NSClosableWindowMask |
NSMiniaturizableWindowMask |
NSResizableWindowMask);
style_mask = (GDK_QUARTZ_TITLED_WINDOW |
GDK_QUARTZ_CLOSABLE_WINDOW |
GDK_QUARTZ_MINIATURIZABLE_WINDOW |
GDK_QUARTZ_RESIZABLE_WINDOW);
}
impl->toplevel = [[GdkQuartzNSWindow alloc] initWithContentRect:content_rect
@ -1147,6 +1144,9 @@ void
gdk_window_quartz_hide (GdkWindow *window)
{
GdkWindowImplQuartz *impl;
GdkDisplay *display = gdk_window_get_display (window);
GdkSeat *seat = gdk_display_get_default_seat (display);
gdk_seat_ungrab (seat);
/* Make sure we're not stuck in fullscreen mode. */
#ifndef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER
@ -1154,8 +1154,6 @@ gdk_window_quartz_hide (GdkWindow *window)
SetSystemUIMode (kUIModeNormal, 0);
#endif
check_grab_unmap (window);
_gdk_window_clear_update_area (window);
impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
@ -1626,7 +1624,7 @@ gdk_window_quartz_get_geometry (GdkWindow *window,
* windows with borders and the root relative coordinates
* otherwise.
*/
if ([impl->toplevel styleMask] == NSBorderlessWindowMask)
if ([impl->toplevel styleMask] == GDK_QUARTZ_BORDERLESS_WINDOW)
{
_gdk_quartz_window_xy_to_gdk_xy (ns_rect.origin.x,
ns_rect.origin.y + ns_rect.size.height,
@ -2353,13 +2351,14 @@ gdk_quartz_window_set_decorations (GdkWindow *window,
if (decorations == 0 || GDK_WINDOW_TYPE (window) == GDK_WINDOW_TEMP ||
impl->type_hint == GDK_WINDOW_TYPE_HINT_SPLASHSCREEN )
{
new_mask = NSBorderlessWindowMask;
new_mask = GDK_QUARTZ_BORDERLESS_WINDOW;
}
else
{
/* FIXME: Honor other GDK_DECOR_* flags. */
new_mask = (NSTitledWindowMask | NSClosableWindowMask |
NSMiniaturizableWindowMask | NSResizableWindowMask);
new_mask = (GDK_QUARTZ_TITLED_WINDOW | GDK_QUARTZ_CLOSABLE_WINDOW |
GDK_QUARTZ_MINIATURIZABLE_WINDOW |
GDK_QUARTZ_RESIZABLE_WINDOW);
}
GDK_QUARTZ_ALLOC_POOL;
@ -2377,14 +2376,14 @@ gdk_quartz_window_set_decorations (GdkWindow *window,
/* Properly update the size of the window when the titlebar is
* added or removed.
*/
if (old_mask == NSBorderlessWindowMask &&
new_mask != NSBorderlessWindowMask)
if (old_mask == GDK_QUARTZ_BORDERLESS_WINDOW &&
new_mask != GDK_QUARTZ_BORDERLESS_WINDOW)
{
rect = [NSWindow frameRectForContentRect:rect styleMask:new_mask];
}
else if (old_mask != NSBorderlessWindowMask &&
new_mask == NSBorderlessWindowMask)
else if (old_mask != GDK_QUARTZ_BORDERLESS_WINDOW &&
new_mask == GDK_QUARTZ_BORDERLESS_WINDOW)
{
rect = [NSWindow contentRectForFrameRect:rect styleMask:old_mask];
}
@ -2400,13 +2399,14 @@ gdk_quartz_window_set_decorations (GdkWindow *window,
[(id<CanSetStyleMask>)impl->toplevel setStyleMask:new_mask];
/* It appears that unsetting and then resetting NSTitledWindowMask
* does not reset the title in the title bar as might be expected.
/* It appears that unsetting and then resetting
* GDK_QUARTZ_TITLED_WINDOW does not reset the title in the
* title bar as might be expected.
*
* In theory we only need to set this if new_mask includes
* NSTitledWindowMask. This behaved extremely oddly when
* GDK_QUARTZ_TITLED_WINDOW. This behaved extremely oddly when
* conditionalized upon that and since it has no side effects (i.e.
* if NSTitledWindowMask is not requested, the title will not be
* if GDK_QUARTZ_TITLED_WINDOW is not requested, the title will not be
* displayed) just do it unconditionally. We also must null check
* 'title' before setting it to avoid crashing.
*/
@ -2439,7 +2439,7 @@ gdk_quartz_window_set_decorations (GdkWindow *window,
[impl->toplevel setContentView:old_view];
}
if (new_mask == NSBorderlessWindowMask)
if (new_mask == GDK_QUARTZ_BORDERLESS_WINDOW)
{
[impl->toplevel setContentSize:rect.size];
[impl->toplevel setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
@ -2474,7 +2474,7 @@ gdk_quartz_window_get_decorations (GdkWindow *window,
if (decorations)
{
/* Borderless is 0, so we can't check it as a bit being set. */
if ([impl->toplevel styleMask] == NSBorderlessWindowMask)
if ([impl->toplevel styleMask] == GDK_QUARTZ_BORDERLESS_WINDOW)
{
*decorations = 0;
}
@ -2517,19 +2517,19 @@ gdk_quartz_window_set_functions (GdkWindow *window,
NSUInteger mask = [impl->toplevel styleMask];
if (min)
mask = mask | NSMiniaturizableWindowMask;
mask = mask | GDK_QUARTZ_MINIATURIZABLE_WINDOW;
else
mask = mask & ~NSMiniaturizableWindowMask;
mask = mask & ~GDK_QUARTZ_MINIATURIZABLE_WINDOW;
if (max)
mask = mask | NSResizableWindowMask;
mask = mask | GDK_QUARTZ_RESIZABLE_WINDOW;
else
mask = mask & ~NSResizableWindowMask;
mask = mask & ~GDK_QUARTZ_RESIZABLE_WINDOW;
if (close)
mask = mask | NSClosableWindowMask;
mask = mask | GDK_QUARTZ_CLOSABLE_WINDOW;
else
mask = mask & ~NSClosableWindowMask;
mask = mask & ~GDK_QUARTZ_CLOSABLE_WINDOW;
[impl->toplevel setStyleMask:mask];
}
@ -2662,7 +2662,7 @@ window_is_fullscreen (GdkWindow *window)
{
GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
return ([impl->toplevel styleMask] & NSFullScreenWindowMask) != 0;
return ([impl->toplevel styleMask] & GDK_QUARTZ_FULLSCREEN_WINDOW) != 0;
}
static void
@ -2838,31 +2838,26 @@ gdk_quartz_window_set_keep_below (GdkWindow *window,
[impl->toplevel setLevel: level - (setting ? 1 : 0)];
}
/* X11 "feature" not useful in other backends. */
static GdkWindow *
gdk_quartz_window_get_group (GdkWindow *window)
{
g_return_val_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD, NULL);
if (GDK_WINDOW_DESTROYED (window) ||
!WINDOW_IS_TOPLEVEL (window))
return NULL;
/* FIXME: Implement */
return NULL;
}
/* X11 "feature" not useful in other backends. */
static void
gdk_quartz_window_set_group (GdkWindow *window,
GdkWindow *leader)
{
/* FIXME: Implement */
}
static void
gdk_quartz_window_destroy_notify (GdkWindow *window)
{
check_grab_destroy (window);
GdkDisplay *display = gdk_window_get_display (window);
GdkSeat *seat = gdk_display_get_default_seat (display);
gdk_seat_ungrab (seat);
}
static void
@ -3108,7 +3103,7 @@ gdk_root_window_impl_quartz_get_context (GdkWindowImplQuartz *window,
colorspace = CGColorSpaceCreateWithName (kCGColorSpaceGenericRGB);
cg_context = CGBitmapContextCreate (NULL,
1, 1, 8, 4, colorspace,
kCGImageAlphaPremultipliedLast);
(CGBitmapInfo)kCGImageAlphaPremultipliedLast);
CGColorSpaceRelease (colorspace);
return cg_context;

3
gtk/gtkicontheme.c
View File

@ -1031,11 +1031,12 @@ void
gtk_icon_theme_add_resource_path (GtkIconTheme *icon_theme,
const gchar *path)
{
GtkIconThemePrivate *priv = icon_theme->priv;
GtkIconThemePrivate *priv = NULL;
g_return_if_fail (GTK_IS_ICON_THEME (icon_theme));
g_return_if_fail (path != NULL);
priv = icon_theme->priv;
priv->resource_paths = g_list_append (priv->resource_paths, g_strdup (path));
do_theme_change (icon_theme);

2
gtk/gtkstyleproviderprivate.c
View File

@ -118,7 +118,7 @@ _gtk_style_provider_private_get_settings (GtkStyleProviderPrivate *provider)
{
GtkStyleProviderPrivateInterface *iface;
gtk_internal_return_val_if_fail (GTK_IS_STYLE_PROVIDER_PRIVATE (provider), NULL);
g_return_val_if_fail (GTK_IS_STYLE_PROVIDER_PRIVATE (provider), NULL);
iface = GTK_STYLE_PROVIDER_PRIVATE_GET_INTERFACE (provider);