/* gdksurface-quartz.c * * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * Copyright (C) 2005-2007 Imendio AB * * 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 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 . */ #include "config.h" #include #include #include #include "gdksurfaceimpl.h" #include "gdkprivate-quartz.h" #include "gdkglcontext-quartz.h" #include "gdkquartzscreen.h" #include "gdkquartzcursor.h" #include #include #include #include static gpointer parent_class; static gpointer root_window_parent_class; static GSList *update_nswindows; static gboolean in_process_all_updates = FALSE; static GSList *main_window_stack; void _gdk_quartz_surface_flush (GdkSurfaceImplQuartz *surface_impl); typedef struct { gint x, y; gint width, height; GdkWMDecoration decor; } FullscreenSavedGeometry; #ifndef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER static FullscreenSavedGeometry *get_fullscreen_geometry (GdkSurface *window); #endif #define FULLSCREEN_DATA "fullscreen-data" static void update_toplevel_order (void); static void clear_toplevel_order (void); #define SURFACE_IS_TOPLEVEL(window) (GDK_SURFACE_TYPE (window) != GDK_SURFACE_CHILD) /* * GdkQuartzSurface */ struct _GdkQuartzSurface { GdkSurface parent; }; struct _GdkQuartzSurfaceClass { GdkSurfaceClass parent_class; }; G_DEFINE_TYPE (GdkQuartzSurface, gdk_quartz_surface, GDK_TYPE_SURFACE); static void gdk_quartz_surface_class_init (GdkQuartzSurfaceClass *quartz_surface_class) { } static void gdk_quartz_surface_init (GdkQuartzSurface *quartz_surface) { } /* * GdkQuartzSurfaceImpl */ NSView * gdk_quartz_surface_get_nsview (GdkSurface *window) { if (GDK_SURFACE_DESTROYED (window)) return NULL; return ((GdkSurfaceImplQuartz *)window->impl)->view; } NSWindow * gdk_quartz_surface_get_nswindow (GdkSurface *window) { if (GDK_SURFACE_DESTROYED (window)) return NULL; return ((GdkSurfaceImplQuartz *)window->impl)->toplevel; } static CGContextRef gdk_surface_impl_quartz_get_context (GdkSurfaceImplQuartz *surface_impl, gboolean antialias) { CGContextRef cg_context; CGSize scale; if (GDK_SURFACE_DESTROYED (surface_impl->wrapper)) return NULL; /* Lock focus when not called as part of a drawRect call. This * is needed when called from outside "real" expose events, for * example for synthesized expose events when realizing windows * and for widgets that send fake expose events like the arrow * buttons in spinbuttons or the position marker in rulers. */ if (surface_impl->in_paint_rect_count == 0) { if (![surface_impl->view lockFocusIfCanDraw]) return NULL; } cg_context = [[NSGraphicsContext currentContext] graphicsPort]; CGContextSaveGState (cg_context); CGContextSetAllowsAntialiasing (cg_context, antialias); /* Undo the default scaling transform, since we apply our own * in gdk_quartz_ref_cairo_surface () */ scale = CGContextConvertSizeToDeviceSpace (cg_context, CGSizeMake (1.0, 1.0)); CGContextScaleCTM (cg_context, 1.0 / scale.width, 1.0 / scale.height); return cg_context; } static void gdk_surface_impl_quartz_release_context (GdkSurfaceImplQuartz *surface_impl, CGContextRef cg_context) { CGContextRestoreGState (cg_context); CGContextSetAllowsAntialiasing (cg_context, TRUE); /* See comment in gdk_quartz_surface_get_context(). */ if (surface_impl->in_paint_rect_count == 0) { _gdk_quartz_surface_flush (surface_impl); [surface_impl->view unlockFocus]; } } static void check_grab_destroy (GdkSurface *window) { GList *devices = NULL, *l; GdkDisplay *display = gdk_surface_get_display (window); GdkSeat *seat; seat = gdk_display_get_default_seat (display); devices = g_list_prepend (devices, gdk_seat_get_keyboard (seat)); devices = g_list_prepend (devices, gdk_seat_get_pointer (seat)); for (l = devices; l; l = l->next) { GdkDeviceGrabInfo *grab; grab = _gdk_display_get_last_device_grab (display, l->data); if (grab && grab->native_surface == window) { /* Serials are always 0 in quartz, but for clarity: */ grab->serial_end = grab->serial_start; grab->implicit_ungrab = TRUE; } } g_list_free (devices); } static void gdk_surface_impl_quartz_finalize (GObject *object) { GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (object); check_grab_destroy (GDK_SURFACE_IMPL_QUARTZ (object)->wrapper); if (impl->transient_for) g_object_unref (impl->transient_for); G_OBJECT_CLASS (parent_class)->finalize (object); } /* Help preventing "beam sync penalty" where CG makes all graphics code * block until the next vsync if we try to flush (including call display on * a view) too often. We do this by limiting the manual flushing done * outside of expose calls to less than some frequency when measured over * the last 4 flushes. This is a bit arbitray, but seems to make it possible * for some quick manual flushes (such as gtkruler or gimp’s marching ants) * without hitting the max flush frequency. * * If drawable NULL, no flushing is done, only registering that a flush was * done externally. */ void _gdk_quartz_surface_flush (GdkSurfaceImplQuartz *surface_impl) { static struct timeval prev_tv; static gint intervals[4]; static gint index; struct timeval tv; gint ms; gettimeofday (&tv, NULL); ms = (tv.tv_sec - prev_tv.tv_sec) * 1000 + (tv.tv_usec - prev_tv.tv_usec) / 1000; intervals[index++ % 4] = ms; if (surface_impl) { ms = intervals[0] + intervals[1] + intervals[2] + intervals[3]; /* ~25Hz on average. */ if (ms > 4*40) { if (surface_impl) [surface_impl->toplevel flushWindow]; prev_tv = tv; } } else prev_tv = tv; } static cairo_user_data_key_t gdk_quartz_cairo_key; typedef struct { GdkSurfaceImplQuartz *surface_impl; CGContextRef cg_context; } GdkQuartzCairoSurfaceData; static void gdk_quartz_cairo_surface_destroy (void *data) { GdkQuartzCairoSurfaceData *surface_data = data; surface_data->surface_impl->cairo_surface = NULL; gdk_quartz_surface_release_context (surface_data->surface_impl, surface_data->cg_context); g_free (surface_data); } static cairo_surface_t * gdk_quartz_create_cairo_surface (GdkSurfaceImplQuartz *impl, int width, int height) { CGContextRef cg_context; GdkQuartzCairoSurfaceData *surface_data; cairo_surface_t *surface; cg_context = gdk_quartz_surface_get_context (impl, TRUE); if (!cg_context) return NULL; surface_data = g_new (GdkQuartzCairoSurfaceData, 1); surface_data->surface_impl = impl; surface_data->cg_context = cg_context; surface = cairo_quartz_surface_create_for_cg_context (cg_context, width, height); cairo_surface_set_user_data (surface, &gdk_quartz_cairo_key, surface_data, gdk_quartz_cairo_surface_destroy); return surface; } static cairo_surface_t * gdk_quartz_ref_cairo_surface (GdkSurface *window) { GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (GDK_SURFACE_DESTROYED (window)) return NULL; if (!impl->cairo_surface) { gint scale = gdk_surface_get_scale_factor (impl->wrapper); impl->cairo_surface = gdk_quartz_create_cairo_surface (impl, gdk_surface_get_width (impl->wrapper) * scale, gdk_surface_get_height (impl->wrapper) * scale); cairo_surface_set_device_scale (impl->cairo_surface, scale, scale); } else cairo_surface_reference (impl->cairo_surface); return impl->cairo_surface; } static void gdk_surface_impl_quartz_init (GdkSurfaceImplQuartz *impl) { impl->type_hint = GDK_SURFACE_TYPE_HINT_NORMAL; } static gboolean gdk_surface_impl_quartz_begin_paint (GdkSurface *window) { return FALSE; } static void gdk_quartz_surface_set_needs_display_in_region (GdkSurface *window, cairo_region_t *region) { GdkSurfaceImplQuartz *impl; int i, n_rects; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (!impl->needs_display_region) impl->needs_display_region = cairo_region_create (); cairo_region_union (impl->needs_display_region, region); n_rects = cairo_region_num_rectangles (region); for (i = 0; i < n_rects; i++) { cairo_rectangle_int_t rect; cairo_region_get_rectangle (region, i, &rect); [impl->view setNeedsDisplayInRect:NSMakeRect (rect.x, rect.y, rect.width, rect.height)]; } } void _gdk_quartz_surface_process_updates_recurse (GdkSurface *window, cairo_region_t *region) { /* Make sure to only flush each toplevel at most once if we're called * from process_all_updates. */ if (in_process_all_updates) { GdkSurface *toplevel; toplevel = gdk_surface_get_toplevel (window); if (toplevel && SURFACE_IS_TOPLEVEL (toplevel)) { GdkSurfaceImplQuartz *toplevel_impl; NSWindow *nswindow; toplevel_impl = (GdkSurfaceImplQuartz *)toplevel->impl; nswindow = toplevel_impl->toplevel; /* In theory, we could skip the flush disabling, since we only * have one NSView. */ if (nswindow && ![nswindow isFlushWindowDisabled]) { [nswindow retain]; [nswindow disableFlushWindow]; update_nswindows = g_slist_prepend (update_nswindows, nswindow); } } } if (SURFACE_IS_TOPLEVEL (window)) gdk_quartz_surface_set_needs_display_in_region (window, region); else _gdk_surface_process_updates_recurse (window, region); /* NOTE: I'm not sure if we should displayIfNeeded here. It slows down a * lot (since it triggers the beam syncing) and things seem to work * without it. */ } static const gchar * get_default_title (void) { const char *title; title = g_get_application_name (); if (!title) title = g_get_prgname (); return title; } static void get_ancestor_coordinates_from_child (GdkSurface *child_window, gint child_x, gint child_y, GdkSurface *ancestor_window, gint *ancestor_x, gint *ancestor_y) { while (child_window != ancestor_window) { child_x += child_window->x; child_y += child_window->y; child_window = child_window->parent; } *ancestor_x = child_x; *ancestor_y = child_y; } void _gdk_quartz_surface_debug_highlight (GdkSurface *window, gint number) { gint x, y; gint gx, gy; GdkSurface *toplevel; gint tx, ty; static NSWindow *debug_window[10]; static NSRect old_rect[10]; NSRect rect; NSColor *color; g_return_if_fail (number >= 0 && number <= 9); if (window == _gdk_root) return; if (window == NULL) { if (debug_window[number]) [debug_window[number] close]; debug_window[number] = NULL; return; } toplevel = gdk_surface_get_toplevel (window); get_ancestor_coordinates_from_child (window, 0, 0, toplevel, &x, &y); gdk_surface_get_origin (toplevel, &tx, &ty); x += tx; y += ty; _gdk_quartz_surface_gdk_xy_to_xy (x, y + window->height, &gx, &gy); rect = NSMakeRect (gx, gy, window->width, window->height); if (debug_window[number] && NSEqualRects (rect, old_rect[number])) return; old_rect[number] = rect; if (debug_window[number]) [debug_window[number] close]; debug_window[number] = [[NSWindow alloc] initWithContentRect:rect styleMask:NSBorderlessWindowMask backing:NSBackingStoreBuffered defer:NO]; switch (number) { case 0: color = [NSColor redColor]; break; case 1: color = [NSColor blueColor]; break; case 2: color = [NSColor greenColor]; break; case 3: color = [NSColor yellowColor]; break; case 4: color = [NSColor brownColor]; break; case 5: color = [NSColor purpleColor]; break; default: color = [NSColor blackColor]; break; } [debug_window[number] setBackgroundColor:color]; [debug_window[number] setAlphaValue:0.4]; [debug_window[number] setOpaque:NO]; [debug_window[number] setReleasedWhenClosed:YES]; [debug_window[number] setIgnoresMouseEvents:YES]; [debug_window[number] setLevel:NSFloatingWindowLevel]; [debug_window[number] orderFront:nil]; } gboolean _gdk_quartz_surface_is_ancestor (GdkSurface *ancestor, GdkSurface *window) { if (ancestor == NULL || window == NULL) return FALSE; return (gdk_surface_get_parent (window) == ancestor || _gdk_quartz_surface_is_ancestor (ancestor, gdk_surface_get_parent (window))); } /* See notes on top of gdkscreen-quartz.c */ void _gdk_quartz_surface_gdk_xy_to_xy (gint gdk_x, gint gdk_y, gint *ns_x, gint *ns_y) { GdkQuartzScreen *screen_quartz = GDK_QUARTZ_SCREEN (_gdk_screen); if (ns_y) *ns_y = screen_quartz->height - gdk_y + screen_quartz->min_y; if (ns_x) *ns_x = gdk_x + screen_quartz->min_x; } void _gdk_quartz_surface_xy_to_gdk_xy (gint ns_x, gint ns_y, gint *gdk_x, gint *gdk_y) { GdkQuartzScreen *screen_quartz = GDK_QUARTZ_SCREEN (_gdk_screen); if (gdk_y) *gdk_y = screen_quartz->height - ns_y + screen_quartz->min_y; if (gdk_x) *gdk_x = ns_x - screen_quartz->min_x; } void _gdk_quartz_surface_nspoint_to_gdk_xy (NSPoint point, gint *x, gint *y) { _gdk_quartz_surface_xy_to_gdk_xy (point.x, point.y, x, y); } static GdkSurface * find_child_window_helper (GdkSurface *window, gint x, gint y, gint x_offset, gint y_offset, gboolean get_toplevel) { GdkSurfaceImplQuartz *impl; GList *l; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (window == _gdk_root) update_toplevel_order (); for (l = impl->sorted_children; l; l = l->next) { GdkSurface *child = l->data; GdkSurfaceImplQuartz *child_impl = GDK_SURFACE_IMPL_QUARTZ (child->impl); int temp_x, temp_y; if (!GDK_SURFACE_IS_MAPPED (child)) continue; temp_x = x_offset + child->x; temp_y = y_offset + child->y; /* Special-case the root window. We have to include the title * bar in the checks, otherwise the window below the title bar * will be found i.e. events punch through. (If we can find a * better way to deal with the events in gdkevents-quartz, this * might not be needed.) */ if (window == _gdk_root) { NSRect frame = NSMakeRect (0, 0, 100, 100); NSRect content; NSUInteger mask; int titlebar_height; mask = [child_impl->toplevel styleMask]; /* Get the title bar height. */ content = [NSWindow contentRectForFrameRect:frame styleMask:mask]; titlebar_height = frame.size.height - content.size.height; if (titlebar_height > 0 && x >= temp_x && y >= temp_y - titlebar_height && x < temp_x + child->width && y < temp_y) { /* The root means "unknown" i.e. a window not managed by * GDK. */ return (GdkSurface *)_gdk_root; } } if ((!get_toplevel || (get_toplevel && window == _gdk_root)) && x >= temp_x && y >= temp_y && x < temp_x + child->width && y < temp_y + child->height) { /* Look for child windows. */ return find_child_window_helper (l->data, x, y, temp_x, temp_y, get_toplevel); } } return window; } /* Given a GdkSurface and coordinates relative to it, returns the * innermost subwindow that contains the point. If the coordinates are * outside the passed in window, NULL is returned. */ GdkSurface * _gdk_quartz_surface_find_child (GdkSurface *window, gint x, gint y, gboolean get_toplevel) { if (x >= 0 && y >= 0 && x < window->width && y < window->height) return find_child_window_helper (window, x, y, 0, 0, get_toplevel); return NULL; } void _gdk_quartz_surface_did_become_main (GdkSurface *window) { main_window_stack = g_slist_remove (main_window_stack, window); if (window->surface_type != GDK_SURFACE_TEMP) main_window_stack = g_slist_prepend (main_window_stack, window); clear_toplevel_order (); } void _gdk_quartz_surface_did_resign_main (GdkSurface *window) { GdkSurface *new_window = NULL; if (main_window_stack) new_window = main_window_stack->data; else { GList *toplevels; toplevels = get_toplevels (); if (toplevels) new_window = toplevels->data; } if (new_window && new_window != window && GDK_SURFACE_IS_MAPPED (new_window) && SURFACE_IS_TOPLEVEL (new_window)) { GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (new_window->impl); [impl->toplevel makeKeyAndOrderFront:impl->toplevel]; } clear_toplevel_order (); } static NSScreen * get_nsscreen_for_point (gint x, gint y) { int i; NSArray *screens; NSScreen *screen = NULL; GDK_QUARTZ_ALLOC_POOL; screens = [NSScreen screens]; for (i = 0; i < [screens count]; i++) { NSRect rect = [[screens objectAtIndex:i] frame]; if (x >= rect.origin.x && x <= rect.origin.x + rect.size.width && y >= rect.origin.y && y <= rect.origin.y + rect.size.height) { screen = [screens objectAtIndex:i]; break; } } GDK_QUARTZ_RELEASE_POOL; return screen; } void _gdk_quartz_display_create_surface_impl (GdkDisplay *display, GdkSurface *window, GdkSurface *real_parent, GdkEventMask event_mask, GdkSurfaceAttr *attributes) { GdkSurfaceImplQuartz *impl; GdkSurfaceImplQuartz *parent_impl; GDK_QUARTZ_ALLOC_POOL; impl = g_object_new (GDK_TYPE_SURFACE_IMPL_QUARTZ, NULL); window->impl = GDK_SURFACE_IMPL (impl); impl->wrapper = window; parent_impl = GDK_SURFACE_IMPL_QUARTZ (window->parent->impl); switch (window->surface_type) { case GDK_SURFACE_TOPLEVEL: case GDK_SURFACE_TEMP: if (GDK_SURFACE_TYPE (window->parent) != GDK_SURFACE_ROOT) { /* The common code warns for this case */ parent_impl = GDK_SURFACE_IMPL_QUARTZ (_gdk_root->impl); } } /* Maintain the z-ordered list of children. */ if (window->parent != _gdk_root) parent_impl->sorted_children = g_list_prepend (parent_impl->sorted_children, window); else clear_toplevel_order (); impl->view = NULL; switch (window->surface_type) { case GDK_SURFACE_TOPLEVEL: case GDK_SURFACE_TEMP: { NSScreen *screen; NSRect screen_rect; NSRect content_rect; NSUInteger style_mask; int nx, ny; /* initWithContentRect will place on the mainScreen by default. * We want to select the screen to place on ourselves. We need * to find the screen the window will be on and correct the * content_rect coordinates to be relative to that screen. */ _gdk_quartz_surface_gdk_xy_to_xy (window->x, window->y, &nx, &ny); screen = get_nsscreen_for_point (nx, ny); screen_rect = [screen frame]; nx -= screen_rect.origin.x; ny -= screen_rect.origin.y; content_rect = NSMakeRect (nx, ny - window->height, window->width, window->height); if (window->surface_type == GDK_SURFACE_TEMP) { style_mask = NSBorderlessWindowMask; } else { style_mask = (NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSResizableWindowMask); } impl->toplevel = [[GdkQuartzNSWindow alloc] initWithContentRect:content_rect styleMask:style_mask backing:NSBackingStoreBuffered defer:NO screen:screen]; gdk_surface_set_title (window, get_default_title ()); [impl->toplevel setOpaque:NO]; [impl->toplevel setBackgroundColor:[NSColor clearColor]]; content_rect.origin.x = 0; content_rect.origin.y = 0; impl->view = [[GdkQuartzView alloc] initWithFrame:content_rect]; [impl->view setGdkSurface:window]; [impl->toplevel setContentView:impl->view]; [impl->view release]; } break; case GDK_SURFACE_CHILD: { GdkSurfaceImplQuartz *parent_impl = GDK_SURFACE_IMPL_QUARTZ (window->parent->impl); if (!window->input_only) { NSRect frame_rect = NSMakeRect (window->x + window->parent->abs_x, window->y + window->parent->abs_y, window->width, window->height); impl->view = [[GdkQuartzView alloc] initWithFrame:frame_rect]; [impl->view setGdkSurface:window]; /* GdkSurfaces should be hidden by default */ [impl->view setHidden:YES]; [parent_impl->view addSubview:impl->view]; [impl->view release]; } } break; default: g_assert_not_reached (); } GDK_QUARTZ_RELEASE_POOL; } void _gdk_quartz_surface_update_position (GdkSurface *window) { NSRect frame_rect; NSRect content_rect; GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); GDK_QUARTZ_ALLOC_POOL; frame_rect = [impl->toplevel frame]; content_rect = [impl->toplevel contentRectForFrameRect:frame_rect]; _gdk_quartz_surface_xy_to_gdk_xy (content_rect.origin.x, content_rect.origin.y + content_rect.size.height, &window->x, &window->y); GDK_QUARTZ_RELEASE_POOL; } void _gdk_quartz_surface_init_windowing (GdkDisplay *display) { GdkSurfaceImplQuartz *impl; g_assert (_gdk_root == NULL); _gdk_root = _gdk_display_create_window (display); _gdk_root->impl = g_object_new (_gdk_root_surface_impl_quartz_get_type (), NULL); _gdk_root->impl_surface = _gdk_root; impl = GDK_SURFACE_IMPL_QUARTZ (_gdk_root->impl); _gdk_quartz_screen_update_window_sizes (screen); _gdk_root->state = 0; /* We don't want GDK_SURFACE_STATE_WITHDRAWN here */ _gdk_root->surface_type = GDK_SURFACE_ROOT; _gdk_root->viewable = TRUE; impl->wrapper = _gdk_root; } static void gdk_quartz_surface_destroy (GdkSurface *window, gboolean recursing, gboolean foreign_destroy) { GdkSurfaceImplQuartz *impl; GdkSurface *parent; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); main_window_stack = g_slist_remove (main_window_stack, window); g_list_free (impl->sorted_children); impl->sorted_children = NULL; parent = window->parent; if (parent) { GdkSurfaceImplQuartz *parent_impl = GDK_SURFACE_IMPL_QUARTZ (parent->impl); parent_impl->sorted_children = g_list_remove (parent_impl->sorted_children, window); } if (impl->cairo_surface) { cairo_surface_finish (impl->cairo_surface); cairo_surface_set_user_data (impl->cairo_surface, &gdk_quartz_cairo_key, NULL, NULL); impl->cairo_surface = NULL; } if (!recursing && !foreign_destroy) { GDK_QUARTZ_ALLOC_POOL; if (impl->toplevel) [impl->toplevel close]; else if (impl->view) [impl->view removeFromSuperview]; GDK_QUARTZ_RELEASE_POOL; } } /* FIXME: This might be possible to simplify with client-side windows. Also * note that already_mapped is not used yet, see the x11 backend. */ static void gdk_surface_quartz_show (GdkSurface *window, gboolean already_mapped) { GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); gboolean focus_on_map; GDK_QUARTZ_ALLOC_POOL; if (!GDK_SURFACE_IS_MAPPED (window)) focus_on_map = window->focus_on_map; else focus_on_map = TRUE; if (SURFACE_IS_TOPLEVEL (window) && impl->toplevel) { gboolean make_key; make_key = (window->accept_focus && focus_on_map && window->surface_type != GDK_SURFACE_TEMP); [(GdkQuartzNSWindow*)impl->toplevel showAndMakeKey:make_key]; clear_toplevel_order (); _gdk_quartz_events_send_map_event (window); } else { [impl->view setHidden:NO]; } [impl->view setNeedsDisplay:YES]; gdk_synthesize_surface_state (window, GDK_SURFACE_STATE_WITHDRAWN, 0); if (window->state & GDK_SURFACE_STATE_MAXIMIZED) gdk_surface_maximize (window); if (window->state & GDK_SURFACE_STATE_ICONIFIED) gdk_surface_iconify (window); if (impl->transient_for && !GDK_SURFACE_DESTROYED (impl->transient_for)) _gdk_quartz_surface_attach_to_parent (window); GDK_QUARTZ_RELEASE_POOL; } /* Temporarily unsets the parent window, if the window is a * transient. */ void _gdk_quartz_surface_detach_from_parent (GdkSurface *window) { GdkSurfaceImplQuartz *impl; g_return_if_fail (GDK_IS_SURFACE (window)); impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); g_return_if_fail (impl->toplevel != NULL); if (impl->transient_for && !GDK_SURFACE_DESTROYED (impl->transient_for)) { GdkSurfaceImplQuartz *parent_impl; parent_impl = GDK_SURFACE_IMPL_QUARTZ (impl->transient_for->impl); [parent_impl->toplevel removeChildWindow:impl->toplevel]; clear_toplevel_order (); } } /* Re-sets the parent window, if the window is a transient. */ void _gdk_quartz_surface_attach_to_parent (GdkSurface *window) { GdkSurfaceImplQuartz *impl; g_return_if_fail (GDK_IS_SURFACE (window)); impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); g_return_if_fail (impl->toplevel != NULL); if (impl->transient_for && !GDK_SURFACE_DESTROYED (impl->transient_for)) { GdkSurfaceImplQuartz *parent_impl; parent_impl = GDK_SURFACE_IMPL_QUARTZ (impl->transient_for->impl); [parent_impl->toplevel addChildWindow:impl->toplevel ordered:NSWindowAbove]; clear_toplevel_order (); } } void gdk_surface_quartz_hide (GdkSurface *window) { GdkSurfaceImplQuartz *impl; /* Make sure we're not stuck in fullscreen mode. */ #ifndef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER if (get_fullscreen_geometry (window)) SetSystemUIMode (kUIModeNormal, 0); #endif _gdk_surface_clear_update_area (window); impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (SURFACE_IS_TOPLEVEL (window)) { /* Update main window. */ main_window_stack = g_slist_remove (main_window_stack, window); if ([NSApp mainWindow] == impl->toplevel) _gdk_quartz_surface_did_resign_main (window); if (impl->transient_for) _gdk_quartz_surface_detach_from_parent (window); [(GdkQuartzNSWindow*)impl->toplevel hide]; } else if (impl->view) { [impl->view setHidden:YES]; } } void gdk_surface_quartz_withdraw (GdkSurface *window) { gdk_surface_hide (window); } static void move_resize_window_internal (GdkSurface *window, gint x, gint y, gint width, gint height) { GdkSurfaceImplQuartz *impl; GdkRectangle old_visible; GdkRectangle new_visible; GdkRectangle scroll_rect; cairo_region_t *old_region; cairo_region_t *expose_region; NSSize delta; if (GDK_SURFACE_DESTROYED (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if ((x == -1 || (x == window->x)) && (y == -1 || (y == window->y)) && (width == -1 || (width == window->width)) && (height == -1 || (height == window->height))) { return; } if (!impl->toplevel) { /* The previously visible area of this window in a coordinate * system rooted at the origin of this window. */ old_visible.x = -window->x; old_visible.y = -window->y; old_visible.width = window->width; old_visible.height = window->height; } if (x != -1) { delta.width = x - window->x; window->x = x; } else { delta.width = 0; } if (y != -1) { delta.height = y - window->y; window->y = y; } else { delta.height = 0; } if (width != -1) window->width = width; if (height != -1) window->height = height; GDK_QUARTZ_ALLOC_POOL; if (impl->toplevel) { NSRect content_rect; NSRect frame_rect; gint gx, gy; _gdk_quartz_surface_gdk_xy_to_xy (window->x, window->y + window->height, &gx, &gy); content_rect = NSMakeRect (gx, gy, window->width, window->height); frame_rect = [impl->toplevel frameRectForContentRect:content_rect]; [impl->toplevel setFrame:frame_rect display:YES]; } else { if (!window->input_only) { NSRect nsrect; nsrect = NSMakeRect (window->x, window->y, window->width, window->height); /* The newly visible area of this window in a coordinate * system rooted at the origin of this window. */ new_visible.x = -window->x; new_visible.y = -window->y; new_visible.width = old_visible.width; /* parent has not changed size */ new_visible.height = old_visible.height; /* parent has not changed size */ expose_region = cairo_region_create_rectangle (&new_visible); old_region = cairo_region_create_rectangle (&old_visible); cairo_region_subtract (expose_region, old_region); /* Determine what (if any) part of the previously visible * part of the window can be copied without a redraw */ scroll_rect = old_visible; scroll_rect.x -= delta.width; scroll_rect.y -= delta.height; gdk_rectangle_intersect (&scroll_rect, &old_visible, &scroll_rect); if (!cairo_region_is_empty (expose_region)) { if (scroll_rect.width != 0 && scroll_rect.height != 0) { [impl->view scrollRect:NSMakeRect (scroll_rect.x, scroll_rect.y, scroll_rect.width, scroll_rect.height) by:delta]; } [impl->view setFrame:nsrect]; gdk_quartz_surface_set_needs_display_in_region (window, expose_region); } else { [impl->view setFrame:nsrect]; [impl->view setNeedsDisplay:YES]; } cairo_region_destroy (expose_region); cairo_region_destroy (old_region); } } GDK_QUARTZ_RELEASE_POOL; } static inline void window_quartz_move (GdkSurface *window, gint x, gint y) { g_return_if_fail (GDK_IS_SURFACE (window)); if (window->state & GDK_SURFACE_STATE_FULLSCREEN) return; move_resize_window_internal (window, x, y, -1, -1); } static inline void window_quartz_resize (GdkSurface *window, gint width, gint height) { g_return_if_fail (GDK_IS_SURFACE (window)); if (window->state & GDK_SURFACE_STATE_FULLSCREEN) return; if (width < 1) width = 1; if (height < 1) height = 1; move_resize_window_internal (window, -1, -1, width, height); } static inline void window_quartz_move_resize (GdkSurface *window, gint x, gint y, gint width, gint height) { if (width < 1) width = 1; if (height < 1) height = 1; move_resize_window_internal (window, x, y, width, height); } static void gdk_surface_quartz_move_resize (GdkSurface *window, gboolean with_move, gint x, gint y, gint width, gint height) { if (with_move && (width < 0 && height < 0)) window_quartz_move (window, x, y); else { if (with_move) window_quartz_move_resize (window, x, y, width, height); else window_quartz_resize (window, width, height); } } /* Get the toplevel ordering from NSApp and update our own list. We do * this on demand since the NSApp’s list is not up to date directly * after we get windowDidBecomeMain. */ static void update_toplevel_order (void) { GdkSurfaceImplQuartz *root_impl; NSEnumerator *enumerator; id nswindow; GList *toplevels = NULL; root_impl = GDK_SURFACE_IMPL_QUARTZ (_gdk_root->impl); if (root_impl->sorted_children) return; GDK_QUARTZ_ALLOC_POOL; enumerator = [[NSApp orderedWindows] objectEnumerator]; while ((nswindow = [enumerator nextObject])) { GdkSurface *window; if (![[nswindow contentView] isKindOfClass:[GdkQuartzView class]]) continue; window = [(GdkQuartzView *)[nswindow contentView] gdkSurface]; toplevels = g_list_prepend (toplevels, window); } GDK_QUARTZ_RELEASE_POOL; root_impl->sorted_children = g_list_reverse (toplevels); } static void clear_toplevel_order (void) { GdkSurfaceImplQuartz *root_impl; root_impl = GDK_SURFACE_IMPL_QUARTZ (_gdk_root->impl); g_list_free (root_impl->sorted_children); root_impl->sorted_children = NULL; } static void gdk_surface_quartz_raise (GdkSurface *window) { if (GDK_SURFACE_DESTROYED (window)) return; if (SURFACE_IS_TOPLEVEL (window)) { GdkSurfaceImplQuartz *impl; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); [impl->toplevel orderFront:impl->toplevel]; clear_toplevel_order (); } else { GdkSurface *parent = window->parent; if (parent) { GdkSurfaceImplQuartz *impl; impl = (GdkSurfaceImplQuartz *)parent->impl; impl->sorted_children = g_list_remove (impl->sorted_children, window); impl->sorted_children = g_list_prepend (impl->sorted_children, window); } } } static void gdk_surface_quartz_lower (GdkSurface *window) { if (GDK_SURFACE_DESTROYED (window)) return; if (SURFACE_IS_TOPLEVEL (window)) { GdkSurfaceImplQuartz *impl; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); [impl->toplevel orderBack:impl->toplevel]; clear_toplevel_order (); } else { GdkSurface *parent = window->parent; if (parent) { GdkSurfaceImplQuartz *impl; impl = (GdkSurfaceImplQuartz *)parent->impl; impl->sorted_children = g_list_remove (impl->sorted_children, window); impl->sorted_children = g_list_append (impl->sorted_children, window); } } } static void gdk_surface_quartz_restack_toplevel (GdkSurface *window, GdkSurface *sibling, gboolean above) { GdkSurfaceImplQuartz *impl; gint sibling_num; impl = GDK_SURFACE_IMPL_QUARTZ (sibling->impl); sibling_num = [impl->toplevel windowNumber]; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (above) [impl->toplevel orderWindow:NSWindowAbove relativeTo:sibling_num]; else [impl->toplevel orderWindow:NSWindowBelow relativeTo:sibling_num]; } static void gdk_surface_quartz_get_geometry (GdkSurface *window, gint *x, gint *y, gint *width, gint *height) { GdkSurfaceImplQuartz *impl; NSRect ns_rect; if (GDK_SURFACE_DESTROYED (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (window == _gdk_root) { if (x) *x = 0; if (y) *y = 0; if (width) *width = window->width; if (height) *height = window->height; } else if (SURFACE_IS_TOPLEVEL (window)) { ns_rect = [impl->toplevel contentRectForFrameRect:[impl->toplevel frame]]; /* This doesn't work exactly as in X. There doesn't seem to be a * way to get the coords relative to the parent window (usually * the window frame), but that seems useless except for * borderless windows where it's relative to the root window. So * we return (0, 0) (should be something like (0, 22)) for * windows with borders and the root relative coordinates * otherwise. */ if ([impl->toplevel styleMask] == NSBorderlessWindowMask) { _gdk_quartz_surface_xy_to_gdk_xy (ns_rect.origin.x, ns_rect.origin.y + ns_rect.size.height, x, y); } else { if (x) *x = 0; if (y) *y = 0; } if (width) *width = ns_rect.size.width; if (height) *height = ns_rect.size.height; } else { ns_rect = [impl->view frame]; if (x) *x = ns_rect.origin.x; if (y) *y = ns_rect.origin.y; if (width) *width = ns_rect.size.width; if (height) *height = ns_rect.size.height; } } static void gdk_surface_quartz_get_root_coords (GdkSurface *window, gint x, gint y, gint *root_x, gint *root_y) { int tmp_x = 0, tmp_y = 0; GdkSurface *toplevel; NSRect content_rect; GdkSurfaceImplQuartz *impl; if (GDK_SURFACE_DESTROYED (window)) { if (root_x) *root_x = 0; if (root_y) *root_y = 0; return; } if (window == _gdk_root) { if (root_x) *root_x = x; if (root_y) *root_y = y; return; } toplevel = gdk_surface_get_toplevel (window); impl = GDK_SURFACE_IMPL_QUARTZ (toplevel->impl); content_rect = [impl->toplevel contentRectForFrameRect:[impl->toplevel frame]]; _gdk_quartz_surface_xy_to_gdk_xy (content_rect.origin.x, content_rect.origin.y + content_rect.size.height, &tmp_x, &tmp_y); tmp_x += x; tmp_y += y; while (window != toplevel) { if (_gdk_surface_has_impl ((GdkSurface *)window)) { tmp_x += window->x; tmp_y += window->y; } window = window->parent; } if (root_x) *root_x = tmp_x; if (root_y) *root_y = tmp_y; } /* Returns coordinates relative to the passed in window. */ static GdkSurface * gdk_surface_quartz_get_device_state_helper (GdkSurface *window, GdkDevice *device, gdouble *x, gdouble *y, GdkModifierType *mask) { NSPoint point; gint x_tmp, y_tmp; GdkSurface *toplevel; GdkSurface *found_window; g_return_val_if_fail (window == NULL || GDK_IS_SURFACE (window), NULL); if (GDK_SURFACE_DESTROYED (window)) { *x = 0; *y = 0; *mask = 0; return NULL; } toplevel = gdk_surface_get_toplevel (window); *mask = _gdk_quartz_events_get_current_keyboard_modifiers () | _gdk_quartz_events_get_current_mouse_modifiers (); /* Get the y coordinate, needs to be flipped. */ if (window == _gdk_root) { point = [NSEvent mouseLocation]; _gdk_quartz_surface_nspoint_to_gdk_xy (point, &x_tmp, &y_tmp); } else { GdkSurfaceImplQuartz *impl; NSWindow *nswindow; impl = GDK_SURFACE_IMPL_QUARTZ (toplevel->impl); nswindow = impl->toplevel; point = [nswindow mouseLocationOutsideOfEventStream]; x_tmp = point.x; y_tmp = toplevel->height - point.y; window = (GdkSurface *)toplevel; } found_window = _gdk_quartz_surface_find_child (window, x_tmp, y_tmp, FALSE); /* We never return the root window. */ if (found_window == _gdk_root) found_window = NULL; *x = x_tmp; *y = y_tmp; return found_window; } static gboolean gdk_surface_quartz_get_device_state (GdkSurface *window, GdkDevice *device, gdouble *x, gdouble *y, GdkModifierType *mask) { return gdk_surface_quartz_get_device_state_helper (window, device, x, y, mask) != NULL; } static GdkEventMask gdk_surface_quartz_get_events (GdkSurface *window) { if (GDK_SURFACE_DESTROYED (window)) return 0; else return window->event_mask; } static void gdk_surface_quartz_set_events (GdkSurface *window, GdkEventMask event_mask) { /* The mask is set in the common code. */ } static void gdk_quartz_surface_set_urgency_hint (GdkSurface *window, gboolean urgent) { if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; /* FIXME: Implement */ } static void gdk_quartz_surface_set_geometry_hints (GdkSurface *window, const GdkGeometry *geometry, GdkSurfaceHints geom_mask) { GdkSurfaceImplQuartz *impl; g_return_if_fail (geometry != NULL); if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (!impl->toplevel) return; if (geom_mask & GDK_HINT_POS) { /* FIXME: Implement */ } if (geom_mask & GDK_HINT_USER_POS) { /* FIXME: Implement */ } if (geom_mask & GDK_HINT_USER_SIZE) { /* FIXME: Implement */ } if (geom_mask & GDK_HINT_MIN_SIZE) { NSSize size; size.width = geometry->min_width; size.height = geometry->min_height; [impl->toplevel setContentMinSize:size]; } if (geom_mask & GDK_HINT_MAX_SIZE) { NSSize size; size.width = geometry->max_width; size.height = geometry->max_height; [impl->toplevel setContentMaxSize:size]; } if (geom_mask & GDK_HINT_BASE_SIZE) { /* FIXME: Implement */ } if (geom_mask & GDK_HINT_RESIZE_INC) { NSSize size; size.width = geometry->width_inc; size.height = geometry->height_inc; [impl->toplevel setContentResizeIncrements:size]; } if (geom_mask & GDK_HINT_ASPECT) { NSSize size; if (geometry->min_aspect != geometry->max_aspect) { g_warning ("Only equal minimum and maximum aspect ratios are supported on Mac OS. Using minimum aspect ratio..."); } size.width = geometry->min_aspect; size.height = 1.0; [impl->toplevel setContentAspectRatio:size]; } if (geom_mask & GDK_HINT_WIN_GRAVITY) { /* FIXME: Implement */ } } static void gdk_quartz_surface_set_title (GdkSurface *window, const gchar *title) { GdkSurfaceImplQuartz *impl; g_return_if_fail (title != NULL); if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (impl->toplevel) { GDK_QUARTZ_ALLOC_POOL; [impl->toplevel setTitle:[NSString stringWithUTF8String:title]]; GDK_QUARTZ_RELEASE_POOL; } } static void gdk_quartz_surface_set_role (GdkSurface *window, const gchar *role) { if (GDK_SURFACE_DESTROYED (window) || SURFACE_IS_TOPLEVEL (window)) return; /* FIXME: Implement */ } static void gdk_quartz_surface_set_startup_id (GdkSurface *window, const gchar *startup_id) { /* FIXME: Implement? */ } static void gdk_quartz_surface_set_transient_for (GdkSurface *window, GdkSurface *parent) { GdkSurfaceImplQuartz *surface_impl; GdkSurfaceImplQuartz *parent_impl; if (GDK_SURFACE_DESTROYED (window) || GDK_SURFACE_DESTROYED (parent) || !SURFACE_IS_TOPLEVEL (window)) return; surface_impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (!surface_impl->toplevel) return; GDK_QUARTZ_ALLOC_POOL; if (surface_impl->transient_for) { _gdk_quartz_surface_detach_from_parent (window); g_object_unref (surface_impl->transient_for); surface_impl->transient_for = NULL; } parent_impl = GDK_SURFACE_IMPL_QUARTZ (parent->impl); if (parent_impl->toplevel) { /* We save the parent because it needs to be unset/reset when * hiding and showing the window. */ /* We don't set transients for tooltips, they are already * handled by the window level being the top one. If we do, then * the parent window will be brought to the top just because the * tooltip is, which is not what we want. */ if (gdk_surface_get_type_hint (window) != GDK_SURFACE_TYPE_HINT_TOOLTIP) { surface_impl->transient_for = g_object_ref (parent); /* We only add the window if it is shown, otherwise it will * be shown unconditionally here. If it is not shown, the * window will be added in show() instead. */ if (!(window->state & GDK_SURFACE_STATE_WITHDRAWN)) _gdk_quartz_surface_attach_to_parent (window); } } GDK_QUARTZ_RELEASE_POOL; } static void gdk_surface_quartz_input_shape_combine_region (GdkSurface *window, const cairo_region_t *shape_region, gint offset_x, gint offset_y) { /* FIXME: Implement */ } static void gdk_quartz_surface_set_accept_focus (GdkSurface *window, gboolean accept_focus) { window->accept_focus = accept_focus != FALSE; } static void gdk_quartz_surface_set_focus_on_map (GdkSurface *window, gboolean focus_on_map) { window->focus_on_map = focus_on_map != FALSE; } static void gdk_quartz_surface_set_icon_name (GdkSurface *window, const gchar *name) { /* FIXME: Implement */ } static void gdk_quartz_surface_focus (GdkSurface *window, guint32 timestamp) { GdkSurfaceImplQuartz *impl; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; if (window->accept_focus && window->surface_type != GDK_SURFACE_TEMP) { GDK_QUARTZ_ALLOC_POOL; [impl->toplevel makeKeyAndOrderFront:impl->toplevel]; clear_toplevel_order (); GDK_QUARTZ_RELEASE_POOL; } } static gint surface_type_hint_to_level (GdkSurfaceTypeHint hint) { /* the order in this switch statement corresponds to the actual * stacking order: the first group is top, the last group is bottom */ switch (hint) { case GDK_SURFACE_TYPE_HINT_POPUP_MENU: case GDK_SURFACE_TYPE_HINT_COMBO: case GDK_SURFACE_TYPE_HINT_DND: case GDK_SURFACE_TYPE_HINT_TOOLTIP: return NSPopUpMenuWindowLevel; case GDK_SURFACE_TYPE_HINT_NOTIFICATION: case GDK_SURFACE_TYPE_HINT_SPLASHSCREEN: return NSStatusWindowLevel; case GDK_SURFACE_TYPE_HINT_MENU: /* Torn-off menu */ case GDK_SURFACE_TYPE_HINT_DROPDOWN_MENU: /* Menu from menubar */ return NSTornOffMenuWindowLevel; case GDK_SURFACE_TYPE_HINT_DOCK: return NSFloatingWindowLevel; /* NSDockWindowLevel is deprecated, and not replaced */ case GDK_SURFACE_TYPE_HINT_UTILITY: case GDK_SURFACE_TYPE_HINT_DIALOG: /* Dialog window */ case GDK_SURFACE_TYPE_HINT_NORMAL: /* Normal toplevel window */ case GDK_SURFACE_TYPE_HINT_TOOLBAR: /* Window used to implement toolbars */ return NSNormalWindowLevel; case GDK_SURFACE_TYPE_HINT_DESKTOP: return kCGDesktopWindowLevelKey; /* doesn't map to any real Cocoa model */ default: break; } return NSNormalWindowLevel; } static gboolean surface_type_hint_to_shadow (GdkSurfaceTypeHint hint) { switch (hint) { case GDK_SURFACE_TYPE_HINT_NORMAL: /* Normal toplevel window */ case GDK_SURFACE_TYPE_HINT_DIALOG: /* Dialog window */ case GDK_SURFACE_TYPE_HINT_DOCK: case GDK_SURFACE_TYPE_HINT_UTILITY: case GDK_SURFACE_TYPE_HINT_MENU: /* Torn-off menu */ case GDK_SURFACE_TYPE_HINT_DROPDOWN_MENU: /* Menu from menubar */ case GDK_SURFACE_TYPE_HINT_SPLASHSCREEN: case GDK_SURFACE_TYPE_HINT_POPUP_MENU: case GDK_SURFACE_TYPE_HINT_COMBO: case GDK_SURFACE_TYPE_HINT_NOTIFICATION: case GDK_SURFACE_TYPE_HINT_TOOLTIP: return TRUE; case GDK_SURFACE_TYPE_HINT_TOOLBAR: /* Window used to implement toolbars */ case GDK_SURFACE_TYPE_HINT_DESKTOP: /* N/A */ case GDK_SURFACE_TYPE_HINT_DND: break; default: break; } return FALSE; } static gboolean surface_type_hint_to_hides_on_deactivate (GdkSurfaceTypeHint hint) { switch (hint) { case GDK_SURFACE_TYPE_HINT_UTILITY: case GDK_SURFACE_TYPE_HINT_MENU: /* Torn-off menu */ case GDK_SURFACE_TYPE_HINT_SPLASHSCREEN: case GDK_SURFACE_TYPE_HINT_NOTIFICATION: case GDK_SURFACE_TYPE_HINT_TOOLTIP: return TRUE; default: break; } return FALSE; } static void _gdk_quartz_surface_update_has_shadow (GdkSurfaceImplQuartz *impl) { gboolean has_shadow; /* In case there is any shadow set we have to turn off the * NSWindow setHasShadow as the system drawn ones wont match our * window boundary anymore */ has_shadow = (surface_type_hint_to_shadow (impl->type_hint) && !impl->shadow_max); [impl->toplevel setHasShadow: has_shadow]; } static void gdk_quartz_surface_set_type_hint (GdkSurface *window, GdkSurfaceTypeHint hint) { GdkSurfaceImplQuartz *impl; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); impl->type_hint = hint; /* Match the documentation, only do something if we're not mapped yet. */ if (GDK_SURFACE_IS_MAPPED (window)) return; _gdk_quartz_surface_update_has_shadow (impl); [impl->toplevel setLevel: surface_type_hint_to_level (hint)]; [impl->toplevel setHidesOnDeactivate: surface_type_hint_to_hides_on_deactivate (hint)]; } static GdkSurfaceTypeHint gdk_quartz_surface_get_type_hint (GdkSurface *window) { if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return GDK_SURFACE_TYPE_HINT_NORMAL; return GDK_SURFACE_IMPL_QUARTZ (window->impl)->type_hint; } static void gdk_quartz_surface_set_modal_hint (GdkSurface *window, gboolean modal) { if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; /* FIXME: Implement */ } static void gdk_quartz_surface_set_skip_taskbar_hint (GdkSurface *window, gboolean skips_taskbar) { if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; /* FIXME: Implement */ } static void gdk_quartz_surface_set_skip_pager_hint (GdkSurface *window, gboolean skips_pager) { if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; /* FIXME: Implement */ } static void gdk_quartz_surface_begin_resize_drag (GdkSurface *window, GdkSurfaceEdge edge, GdkDevice *device, gint button, gint root_x, gint root_y, guint32 timestamp) { GdkSurfaceImplQuartz *impl; g_return_if_fail (GDK_IS_SURFACE (window)); if (GDK_SURFACE_DESTROYED (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (!impl->toplevel) { g_warning ("Can't call gdk_surface_begin_resize_drag on non-toplevel window"); return; } [(GdkQuartzNSWindow *)impl->toplevel beginManualResize:edge]; } static void gdk_quartz_surface_begin_move_drag (GdkSurface *window, GdkDevice *device, gint button, gint root_x, gint root_y, guint32 timestamp) { GdkSurfaceImplQuartz *impl; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (!impl->toplevel) { g_warning ("Can't call gdk_surface_begin_move_drag on non-toplevel window"); return; } [(GdkQuartzNSWindow *)impl->toplevel beginManualMove]; } static void gdk_quartz_surface_set_icon_list (GdkSurface *window, GList *surfaces) { /* FIXME: Implement */ } static void gdk_quartz_surface_get_frame_extents (GdkSurface *window, GdkRectangle *rect) { GdkSurface *toplevel; GdkSurfaceImplQuartz *impl; NSRect ns_rect; g_return_if_fail (rect != NULL); rect->x = 0; rect->y = 0; rect->width = 1; rect->height = 1; toplevel = gdk_surface_get_toplevel (window); impl = GDK_SURFACE_IMPL_QUARTZ (toplevel->impl); ns_rect = [impl->toplevel frame]; _gdk_quartz_surface_xy_to_gdk_xy (ns_rect.origin.x, ns_rect.origin.y + ns_rect.size.height, &rect->x, &rect->y); rect->width = ns_rect.size.width; rect->height = ns_rect.size.height; } /* Fake protocol to make gcc think that it's OK to call setStyleMask even if it isn't. We check to make sure before actually calling it. */ @protocol CanSetStyleMask - (void)setStyleMask:(int)mask; @end static void gdk_quartz_surface_set_decorations (GdkSurface *window, GdkWMDecoration decorations) { GdkSurfaceImplQuartz *impl; NSUInteger old_mask, new_mask; NSView *old_view; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (decorations == 0 || GDK_SURFACE_TYPE (window) == GDK_SURFACE_TEMP || impl->type_hint == GDK_SURFACE_TYPE_HINT_SPLASHSCREEN ) { new_mask = NSBorderlessWindowMask; } else { /* FIXME: Honor other GDK_DECOR_* flags. */ new_mask = (NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSResizableWindowMask); } GDK_QUARTZ_ALLOC_POOL; old_mask = [impl->toplevel styleMask]; if (old_mask != new_mask) { NSRect rect; old_view = [[impl->toplevel contentView] retain]; rect = [impl->toplevel frame]; /* Properly update the size of the window when the titlebar is * added or removed. */ if (old_mask == NSBorderlessWindowMask && new_mask != NSBorderlessWindowMask) { rect = [NSWindow frameRectForContentRect:rect styleMask:new_mask]; } else if (old_mask != NSBorderlessWindowMask && new_mask == NSBorderlessWindowMask) { rect = [NSWindow contentRectForFrameRect:rect styleMask:old_mask]; } /* Note, before OS 10.6 there doesn't seem to be a way to change this * without recreating the toplevel. From 10.6 onward, a simple call to * setStyleMask takes care of most of this, except for ensuring that the * title is set. */ if ([impl->toplevel respondsToSelector:@selector(setStyleMask:)]) { NSString *title = [impl->toplevel title]; [(id)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. * * In theory we only need to set this if new_mask includes * NSTitledWindowMask. 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 * displayed) just do it unconditionally. We also must null check * 'title' before setting it to avoid crashing. */ if (title) [impl->toplevel setTitle:title]; } else { NSString *title = [impl->toplevel title]; NSColor *bg = [impl->toplevel backgroundColor]; NSScreen *screen = [impl->toplevel screen]; /* Make sure the old window is closed, recall that releasedWhenClosed * is set on GdkQuartzSurfaces. */ [impl->toplevel close]; impl->toplevel = [[GdkQuartzNSWindow alloc] initWithContentRect:rect styleMask:new_mask backing:NSBackingStoreBuffered defer:NO screen:screen]; _gdk_quartz_surface_update_has_shadow (impl); [impl->toplevel setLevel: surface_type_hint_to_level (impl->type_hint)]; if (title) [impl->toplevel setTitle:title]; [impl->toplevel setBackgroundColor:bg]; [impl->toplevel setHidesOnDeactivate: surface_type_hint_to_hides_on_deactivate (impl->type_hint)]; [impl->toplevel setContentView:old_view]; } if (new_mask == NSBorderlessWindowMask) { [impl->toplevel setContentSize:rect.size]; [impl->toplevel setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary]; } else [impl->toplevel setFrame:rect display:YES]; /* Invalidate the window shadow for non-opaque views that have shadow * enabled, to get the shadow shape updated. */ if (![old_view isOpaque] && [impl->toplevel hasShadow]) [(GdkQuartzView*)old_view setNeedsInvalidateShadow:YES]; [old_view release]; } GDK_QUARTZ_RELEASE_POOL; } static gboolean gdk_quartz_surface_get_decorations (GdkSurface *window, GdkWMDecoration *decorations) { GdkSurfaceImplQuartz *impl; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return FALSE; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (decorations) { /* Borderless is 0, so we can't check it as a bit being set. */ if ([impl->toplevel styleMask] == NSBorderlessWindowMask) { *decorations = 0; } else { /* FIXME: Honor the other GDK_DECOR_* flags. */ *decorations = GDK_DECOR_ALL; } } return TRUE; } static void gdk_quartz_surface_set_functions (GdkSurface *window, GdkWMFunction functions) { GdkSurfaceImplQuartz *impl; gboolean min, max, close; g_return_if_fail (GDK_IS_SURFACE (window)); impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (functions & GDK_FUNC_ALL) { min = !(functions & GDK_FUNC_MINIMIZE); max = !(functions & GDK_FUNC_MAXIMIZE); close = !(functions & GDK_FUNC_CLOSE); } else { min = (functions & GDK_FUNC_MINIMIZE); max = (functions & GDK_FUNC_MAXIMIZE); close = (functions & GDK_FUNC_CLOSE); } if (impl->toplevel) { NSUInteger mask = [impl->toplevel styleMask]; if (min) mask = mask | NSMiniaturizableWindowMask; else mask = mask & ~NSMiniaturizableWindowMask; if (max) mask = mask | NSResizableWindowMask; else mask = mask & ~NSResizableWindowMask; if (close) mask = mask | NSClosableWindowMask; else mask = mask & ~NSClosableWindowMask; [impl->toplevel setStyleMask:mask]; } } static void gdk_quartz_surface_stick (GdkSurface *window) { if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; } static void gdk_quartz_surface_unstick (GdkSurface *window) { if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; } static void gdk_quartz_surface_maximize (GdkSurface *window) { GdkSurfaceImplQuartz *impl; gboolean maximized; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); maximized = gdk_surface_get_state (window) & GDK_SURFACE_STATE_MAXIMIZED; if (GDK_SURFACE_IS_MAPPED (window)) { GDK_QUARTZ_ALLOC_POOL; if (impl->toplevel && !maximized) [impl->toplevel zoom:nil]; GDK_QUARTZ_RELEASE_POOL; } } static void gdk_quartz_surface_unmaximize (GdkSurface *window) { GdkSurfaceImplQuartz *impl; gboolean maximized; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); maximized = gdk_surface_get_state (window) & GDK_SURFACE_STATE_MAXIMIZED; if (GDK_SURFACE_IS_MAPPED (window)) { GDK_QUARTZ_ALLOC_POOL; if (impl->toplevel && maximized) [impl->toplevel zoom:nil]; GDK_QUARTZ_RELEASE_POOL; } } static void gdk_quartz_surface_iconify (GdkSurface *window) { GdkSurfaceImplQuartz *impl; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (GDK_SURFACE_IS_MAPPED (window)) { GDK_QUARTZ_ALLOC_POOL; if (impl->toplevel) [impl->toplevel miniaturize:nil]; GDK_QUARTZ_RELEASE_POOL; } else { gdk_synthesize_surface_state (window, 0, GDK_SURFACE_STATE_ICONIFIED); } } static void gdk_quartz_surface_deiconify (GdkSurface *window) { GdkSurfaceImplQuartz *impl; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (GDK_SURFACE_IS_MAPPED (window)) { GDK_QUARTZ_ALLOC_POOL; if (impl->toplevel) [impl->toplevel deminiaturize:nil]; GDK_QUARTZ_RELEASE_POOL; } else { gdk_synthesize_surface_state (window, GDK_SURFACE_STATE_ICONIFIED, 0); } } #ifdef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER static gboolean window_is_fullscreen (GdkSurface *window) { GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); return ([impl->toplevel styleMask] & NSFullScreenWindowMask) != 0; } static void gdk_quartz_surface_fullscreen (GdkSurface *window) { GdkSurfaceImplQuartz *impl; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (!window_is_fullscreen (window)) [impl->toplevel toggleFullScreen:nil]; } static void gdk_quartz_surface_unfullscreen (GdkSurface *window) { GdkSurfaceImplQuartz *impl; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (window_is_fullscreen (window)) [impl->toplevel toggleFullScreen:nil]; } void _gdk_quartz_surface_update_fullscreen_state (GdkSurface *window) { gboolean is_fullscreen; gboolean was_fullscreen; is_fullscreen = window_is_fullscreen (window); was_fullscreen = (gdk_surface_get_state (window) & GDK_SURFACE_STATE_FULLSCREEN) != 0; if (is_fullscreen != was_fullscreen) { if (is_fullscreen) gdk_synthesize_surface_state (window, 0, GDK_SURFACE_STATE_FULLSCREEN); else gdk_synthesize_surface_state (window, GDK_SURFACE_STATE_FULLSCREEN, 0); } } #else static FullscreenSavedGeometry * get_fullscreen_geometry (GdkSurface *window) { return g_object_get_data (G_OBJECT (window), FULLSCREEN_DATA); } static void gdk_quartz_surface_fullscreen (GdkSurface *window) { FullscreenSavedGeometry *geometry; GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); NSRect frame; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; geometry = get_fullscreen_geometry (window); if (!geometry) { geometry = g_new (FullscreenSavedGeometry, 1); geometry->x = window->x; geometry->y = window->y; geometry->width = window->width; geometry->height = window->height; if (!gdk_surface_get_decorations (window, &geometry->decor)) geometry->decor = GDK_DECOR_ALL; g_object_set_data_full (G_OBJECT (window), FULLSCREEN_DATA, geometry, g_free); gdk_surface_set_decorations (window, 0); frame = [[impl->toplevel screen] frame]; move_resize_window_internal (window, 0, 0, frame.size.width, frame.size.height); [impl->toplevel setContentSize:frame.size]; [impl->toplevel makeKeyAndOrderFront:impl->toplevel]; clear_toplevel_order (); } SetSystemUIMode (kUIModeAllHidden, kUIOptionAutoShowMenuBar); gdk_synthesize_surface_state (window, 0, GDK_SURFACE_STATE_FULLSCREEN); } static void gdk_quartz_surface_unfullscreen (GdkSurface *window) { GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); FullscreenSavedGeometry *geometry; if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; geometry = get_fullscreen_geometry (window); if (geometry) { SetSystemUIMode (kUIModeNormal, 0); move_resize_window_internal (window, geometry->x, geometry->y, geometry->width, geometry->height); gdk_surface_set_decorations (window, geometry->decor); g_object_set_data (G_OBJECT (window), FULLSCREEN_DATA, NULL); [impl->toplevel makeKeyAndOrderFront:impl->toplevel]; clear_toplevel_order (); gdk_synthesize_surface_state (window, GDK_SURFACE_STATE_FULLSCREEN, 0); } } #endif static void gdk_quartz_surface_set_keep_above (GdkSurface *window, gboolean setting) { GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); gint level; g_return_if_fail (GDK_IS_SURFACE (window)); if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; level = surface_type_hint_to_level (gdk_surface_get_type_hint (window)); /* Adjust normal window level by one if necessary. */ [impl->toplevel setLevel: level + (setting ? 1 : 0)]; } static void gdk_quartz_surface_set_keep_below (GdkSurface *window, gboolean setting) { GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); gint level; g_return_if_fail (GDK_IS_SURFACE (window)); if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; level = surface_type_hint_to_level (gdk_surface_get_type_hint (window)); /* Adjust normal window level by one if necessary. */ [impl->toplevel setLevel: level - (setting ? 1 : 0)]; } static GdkSurface * gdk_quartz_surface_get_group (GdkSurface *window) { g_return_val_if_fail (GDK_SURFACE_TYPE (window) != GDK_SURFACE_CHILD, NULL); if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return NULL; /* FIXME: Implement */ return NULL; } static void gdk_quartz_surface_set_group (GdkSurface *window, GdkSurface *leader) { /* FIXME: Implement */ } static void gdk_quartz_surface_destroy_notify (GdkSurface *window) { check_grab_destroy (window); } static void gdk_quartz_surface_set_opacity (GdkSurface *window, gdouble opacity) { GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); g_return_if_fail (GDK_IS_SURFACE (window)); g_return_if_fail (SURFACE_IS_TOPLEVEL (window)); if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; if (opacity < 0) opacity = 0; else if (opacity > 1) opacity = 1; [impl->toplevel setAlphaValue: opacity]; } static void gdk_quartz_surface_set_shadow_width (GdkSurface *window, gint left, gint right, gint top, gint bottom) { GdkSurfaceImplQuartz *impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); g_return_if_fail (GDK_IS_SURFACE (window)); g_return_if_fail (SURFACE_IS_TOPLEVEL (window)); if (GDK_SURFACE_DESTROYED (window) || !SURFACE_IS_TOPLEVEL (window)) return; impl->shadow_top = top; impl->shadow_max = MAX (MAX (left, right), MAX (top, bottom)); _gdk_quartz_surface_update_has_shadow (impl); } /* Protocol to build cleanly for OSX < 10.7 */ @protocol ScaleFactor - (CGFloat) backingScaleFactor; @end static gint gdk_quartz_surface_get_scale_factor (GdkSurface *window) { GdkSurfaceImplQuartz *impl; if (GDK_SURFACE_DESTROYED (window)) return 1; impl = GDK_SURFACE_IMPL_QUARTZ (window->impl); if (impl->toplevel != NULL && gdk_quartz_osx_version() >= GDK_OSX_LION) return [(id ) impl->toplevel backingScaleFactor]; return 1; } static void gdk_surface_impl_quartz_class_init (GdkSurfaceImplQuartzClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GdkSurfaceImplClass *impl_class = GDK_SURFACE_IMPL_CLASS (klass); GdkSurfaceImplQuartzClass *impl_quartz_class = GDK_SURFACE_IMPL_QUARTZ_CLASS (klass); parent_class = g_type_class_peek_parent (klass); object_class->finalize = gdk_surface_impl_quartz_finalize; impl_class->ref_cairo_surface = gdk_quartz_ref_cairo_surface; impl_class->show = gdk_surface_quartz_show; impl_class->hide = gdk_surface_quartz_hide; impl_class->withdraw = gdk_surface_quartz_withdraw; impl_class->set_events = gdk_surface_quartz_set_events; impl_class->get_events = gdk_surface_quartz_get_events; impl_class->raise = gdk_surface_quartz_raise; impl_class->lower = gdk_surface_quartz_lower; impl_class->restack_toplevel = gdk_surface_quartz_restack_toplevel; impl_class->move_resize = gdk_surface_quartz_move_resize; impl_class->get_geometry = gdk_surface_quartz_get_geometry; impl_class->get_root_coords = gdk_surface_quartz_get_root_coords; impl_class->get_device_state = gdk_surface_quartz_get_device_state; impl_class->input_shape_combine_region = gdk_surface_quartz_input_shape_combine_region; impl_class->destroy = gdk_quartz_surface_destroy; impl_class->begin_paint = gdk_surface_impl_quartz_begin_paint; impl_class->get_scale_factor = gdk_quartz_surface_get_scale_factor; impl_class->focus = gdk_quartz_surface_focus; impl_class->set_type_hint = gdk_quartz_surface_set_type_hint; impl_class->get_type_hint = gdk_quartz_surface_get_type_hint; impl_class->set_modal_hint = gdk_quartz_surface_set_modal_hint; impl_class->set_skip_taskbar_hint = gdk_quartz_surface_set_skip_taskbar_hint; impl_class->set_skip_pager_hint = gdk_quartz_surface_set_skip_pager_hint; impl_class->set_urgency_hint = gdk_quartz_surface_set_urgency_hint; impl_class->set_geometry_hints = gdk_quartz_surface_set_geometry_hints; impl_class->set_title = gdk_quartz_surface_set_title; impl_class->set_role = gdk_quartz_surface_set_role; impl_class->set_startup_id = gdk_quartz_surface_set_startup_id; impl_class->set_transient_for = gdk_quartz_surface_set_transient_for; impl_class->get_frame_extents = gdk_quartz_surface_get_frame_extents; impl_class->set_accept_focus = gdk_quartz_surface_set_accept_focus; impl_class->set_focus_on_map = gdk_quartz_surface_set_focus_on_map; impl_class->set_icon_list = gdk_quartz_surface_set_icon_list; impl_class->set_icon_name = gdk_quartz_surface_set_icon_name; impl_class->iconify = gdk_quartz_surface_iconify; impl_class->deiconify = gdk_quartz_surface_deiconify; impl_class->stick = gdk_quartz_surface_stick; impl_class->unstick = gdk_quartz_surface_unstick; impl_class->maximize = gdk_quartz_surface_maximize; impl_class->unmaximize = gdk_quartz_surface_unmaximize; impl_class->fullscreen = gdk_quartz_surface_fullscreen; impl_class->unfullscreen = gdk_quartz_surface_unfullscreen; impl_class->set_keep_above = gdk_quartz_surface_set_keep_above; impl_class->set_keep_below = gdk_quartz_surface_set_keep_below; impl_class->get_group = gdk_quartz_surface_get_group; impl_class->set_group = gdk_quartz_surface_set_group; impl_class->set_decorations = gdk_quartz_surface_set_decorations; impl_class->get_decorations = gdk_quartz_surface_get_decorations; impl_class->set_functions = gdk_quartz_surface_set_functions; impl_class->set_functions = gdk_quartz_surface_set_functions; impl_class->begin_resize_drag = gdk_quartz_surface_begin_resize_drag; impl_class->begin_move_drag = gdk_quartz_surface_begin_move_drag; impl_class->set_opacity = gdk_quartz_surface_set_opacity; impl_class->set_shadow_width = gdk_quartz_surface_set_shadow_width; impl_class->destroy_notify = gdk_quartz_surface_destroy_notify; impl_class->register_dnd = _gdk_quartz_surface_register_dnd; impl_class->drag_begin = _gdk_quartz_surface_drag_begin; impl_class->process_updates_recurse = _gdk_quartz_surface_process_updates_recurse; impl_class->create_gl_context = gdk_quartz_surface_create_gl_context; impl_quartz_class->get_context = gdk_surface_impl_quartz_get_context; impl_quartz_class->release_context = gdk_surface_impl_quartz_release_context; } GType _gdk_surface_impl_quartz_get_type (void) { static GType object_type = 0; if (!object_type) { const GTypeInfo object_info = { sizeof (GdkSurfaceImplQuartzClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gdk_surface_impl_quartz_class_init, NULL, /* class_finalize */ NULL, /* class_data */ sizeof (GdkSurfaceImplQuartz), 0, /* n_preallocs */ (GInstanceInitFunc) gdk_surface_impl_quartz_init, }; object_type = g_type_register_static (GDK_TYPE_SURFACE_IMPL, "GdkSurfaceImplQuartz", &object_info, 0); } return object_type; } CGContextRef gdk_quartz_surface_get_context (GdkSurfaceImplQuartz *window, gboolean antialias) { if (!GDK_SURFACE_IMPL_QUARTZ_GET_CLASS (window)->get_context) { g_warning ("%s doesn't implement GdkSurfaceImplQuartzClass::get_context()", G_OBJECT_TYPE_NAME (window)); return NULL; } return GDK_SURFACE_IMPL_QUARTZ_GET_CLASS (window)->get_context (window, antialias); } void gdk_quartz_surface_release_context (GdkSurfaceImplQuartz *window, CGContextRef cg_context) { if (!GDK_SURFACE_IMPL_QUARTZ_GET_CLASS (window)->release_context) { g_warning ("%s doesn't implement GdkSurfaceImplQuartzClass::release_context()", G_OBJECT_TYPE_NAME (window)); return; } GDK_SURFACE_IMPL_QUARTZ_GET_CLASS (window)->release_context (window, cg_context); } static CGContextRef gdk_root_surface_impl_quartz_get_context (GdkSurfaceImplQuartz *window, gboolean antialias) { CGColorSpaceRef colorspace; CGContextRef cg_context; GdkSurfaceImplQuartz *surface_impl = GDK_SURFACE_IMPL_QUARTZ (window); if (GDK_SURFACE_DESTROYED (surface_impl->wrapper)) return NULL; /* We do not have the notion of a root window on OS X. We fake this * by creating a 1x1 bitmap and return a context to that. */ colorspace = CGColorSpaceCreateWithName (kCGColorSpaceGenericRGB); cg_context = CGBitmapContextCreate (NULL, 1, 1, 8, 4, colorspace, kCGImageAlphaPremultipliedLast); CGColorSpaceRelease (colorspace); return cg_context; } static void gdk_root_surface_impl_quartz_release_context (GdkSurfaceImplQuartz *window, CGContextRef cg_context) { CGContextRelease (cg_context); } static void gdk_root_surface_impl_quartz_class_init (GdkRootWindowImplQuartzClass *klass) { GdkSurfaceImplQuartzClass *window_quartz_class = GDK_SURFACE_IMPL_QUARTZ_CLASS (klass); root_window_parent_class = g_type_class_peek_parent (klass); window_quartz_class->get_context = gdk_root_surface_impl_quartz_get_context; window_quartz_class->release_context = gdk_root_surface_impl_quartz_release_context; } static void gdk_root_surface_impl_quartz_init (GdkRootWindowImplQuartz *impl) { } GType _gdk_root_surface_impl_quartz_get_type (void) { static GType object_type = 0; if (!object_type) { const GTypeInfo object_info = { sizeof (GdkRootWindowImplQuartzClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gdk_root_surface_impl_quartz_class_init, NULL, /* class_finalize */ NULL, /* class_data */ sizeof (GdkRootWindowImplQuartz), 0, /* n_preallocs */ (GInstanceInitFunc) gdk_root_surface_impl_quartz_init, }; object_type = g_type_register_static (GDK_TYPE_SURFACE_IMPL_QUARTZ, "GdkRootWindowQuartz", &object_info, 0); } return object_type; } GList * get_toplevels (void) { update_toplevel_order (); return GDK_SURFACE_IMPL_QUARTZ (_gdk_root->impl)->sorted_children; }