3 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * Copyright (C) 2005-2007 Imendio AB
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 02111-1307, USA.
23 #include <Carbon/Carbon.h>
26 #include "gdkdeviceprivate.h"
27 #include "gdkwindowimpl.h"
28 #include "gdkprivate-quartz.h"
29 #include "gdkscreen-quartz.h"
30 #include "gdkinputprivate.h"
32 static gpointer parent_class;
34 static GSList *update_nswindows;
35 static gboolean in_process_all_updates = FALSE;
37 static GSList *main_window_stack;
39 #define FULLSCREEN_DATA "fullscreen-data"
45 GdkWMDecoration decor;
46 } FullscreenSavedGeometry;
49 static void update_toplevel_order (void);
50 static void clear_toplevel_order (void);
52 static FullscreenSavedGeometry *get_fullscreen_geometry (GdkWindow *window);
54 #define WINDOW_IS_TOPLEVEL(window) \
55 (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
56 GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \
57 GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
59 static void gdk_window_impl_iface_init (GdkWindowImplIface *iface);
62 gdk_quartz_window_get_nsview (GdkWindow *window)
64 GdkWindowObject *private = (GdkWindowObject *)window;
66 if (GDK_WINDOW_DESTROYED (window))
69 return ((GdkWindowImplQuartz *)private->impl)->view;
73 gdk_quartz_window_get_nswindow (GdkWindow *window)
75 GdkWindowObject *private = (GdkWindowObject *)window;
77 if (GDK_WINDOW_DESTROYED (window))
80 return ((GdkWindowImplQuartz *)private->impl)->toplevel;
84 gdk_window_impl_quartz_get_context (GdkDrawable *drawable,
87 GdkDrawableImplQuartz *drawable_impl = GDK_DRAWABLE_IMPL_QUARTZ (drawable);
88 GdkWindowImplQuartz *window_impl = GDK_WINDOW_IMPL_QUARTZ (drawable);
89 CGContextRef cg_context;
91 if (GDK_WINDOW_DESTROYED (drawable_impl->wrapper))
94 /* Lock focus when not called as part of a drawRect call. This
95 * is needed when called from outside "real" expose events, for
96 * example for synthesized expose events when realizing windows
97 * and for widgets that send fake expose events like the arrow
98 * buttons in spinbuttons or the position marker in rulers.
100 if (window_impl->in_paint_rect_count == 0)
102 if (![window_impl->view lockFocusIfCanDraw])
106 cg_context = [[NSGraphicsContext currentContext] graphicsPort];
107 CGContextSaveGState (cg_context);
108 CGContextSetAllowsAntialiasing (cg_context, antialias);
110 /* We'll emulate the clipping caused by double buffering here */
111 if (window_impl->begin_paint_count != 0)
117 n_rects = cairo_region_num_rectangles (window_impl->paint_clip_region);
122 cg_rects = g_new (CGRect, n_rects);
124 for (i = 0; i < n_rects; i++)
126 cairo_rectangle_int_t cairo_rect;
127 cairo_region_get_rectangle (window_impl->paint_clip_region,
129 cg_rects[i].origin.x = cairo_rect.x;
130 cg_rects[i].origin.y = cairo_rect.y;
131 cg_rects[i].size.width = cairo_rect.width;
132 cg_rects[i].size.height = cairo_rect.height;
135 CGContextClipToRects (cg_context, cg_rects, n_rects);
137 if (cg_rects != &rect)
145 check_grab_unmap (GdkWindow *window)
148 GdkDisplay *display = gdk_drawable_get_display (window);
149 GdkDeviceManager *device_manager;
151 device_manager = gdk_display_get_device_manager (display);
152 list = gdk_device_manager_list_devices (device_manager,
153 GDK_DEVICE_TYPE_FLOATING);
154 for (l = list; l; l = l->next)
156 _gdk_display_end_device_grab (display, l->data, 0, window, TRUE);
163 check_grab_destroy (GdkWindow *window)
166 GdkDisplay *display = gdk_drawable_get_display (window);
167 GdkDeviceManager *device_manager;
169 /* Make sure there is no lasting grab in this native window */
170 device_manager = gdk_display_get_device_manager (display);
171 list = gdk_device_manager_list_devices (device_manager,
172 GDK_DEVICE_TYPE_MASTER);
174 for (l = list; l; l = l->next)
176 GdkDeviceGrabInfo *grab;
178 grab = _gdk_display_get_last_device_grab (display, l->data);
179 if (grab && grab->native_window == window)
181 /* Serials are always 0 in quartz, but for clarity: */
182 grab->serial_end = grab->serial_start;
183 grab->implicit_ungrab = TRUE;
191 gdk_window_impl_quartz_finalize (GObject *object)
193 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (object);
195 check_grab_destroy (GDK_DRAWABLE_IMPL_QUARTZ (object)->wrapper);
197 if (impl->paint_clip_region)
198 cairo_region_destroy (impl->paint_clip_region);
200 if (impl->transient_for)
201 g_object_unref (impl->transient_for);
203 G_OBJECT_CLASS (parent_class)->finalize (object);
207 gdk_window_impl_quartz_class_init (GdkWindowImplQuartzClass *klass)
209 GObjectClass *object_class = G_OBJECT_CLASS (klass);
210 GdkDrawableImplQuartzClass *drawable_quartz_class = GDK_DRAWABLE_IMPL_QUARTZ_CLASS (klass);
212 parent_class = g_type_class_peek_parent (klass);
214 object_class->finalize = gdk_window_impl_quartz_finalize;
216 drawable_quartz_class->get_context = gdk_window_impl_quartz_get_context;
220 gdk_window_impl_quartz_init (GdkWindowImplQuartz *impl)
222 impl->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
226 gdk_window_impl_quartz_begin_paint_region (GdkPaintable *paintable,
228 const cairo_region_t *region)
230 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (paintable);
231 GdkWindowObject *private = (GdkWindowObject*)window;
232 GdkPixmap *bg_pixmap;
233 cairo_region_t *clipped_and_offset_region;
236 bg_pixmap = private->bg_pixmap;
238 clipped_and_offset_region = cairo_region_copy (region);
240 cairo_region_intersect (clipped_and_offset_region,
241 private->clip_region_with_children);
242 cairo_region_translate (clipped_and_offset_region,
243 private->abs_x, private->abs_y);
245 if (impl->begin_paint_count == 0)
246 impl->paint_clip_region = cairo_region_reference (clipped_and_offset_region);
248 cairo_region_union (impl->paint_clip_region, clipped_and_offset_region);
250 impl->begin_paint_count++;
252 if (bg_pixmap == GDK_NO_BG ||
253 cairo_region_is_empty (clipped_and_offset_region))
256 cr = gdk_cairo_create (window);
258 cairo_translate (cr, -private->abs_x, -private->abs_y);
260 gdk_cairo_region (cr, clipped_and_offset_region);
263 if (bg_pixmap == NULL)
265 gdk_cairo_set_source_color (cr, &private->bg_color);
269 int x_offset, y_offset;
271 x_offset = y_offset = 0;
273 while (window && bg_pixmap == GDK_PARENT_RELATIVE_BG)
275 /* If this window should have the same background as the parent,
276 * fetch the parent. (And if the same goes for the parent, fetch
277 * the grandparent, etc.)
279 x_offset += ((GdkWindowObject *) window)->x;
280 y_offset += ((GdkWindowObject *) window)->y;
281 window = GDK_WINDOW (((GdkWindowObject *) window)->parent);
282 bg_pixmap = ((GdkWindowObject *) window)->bg_pixmap;
285 /* If we have a parent relative background or we don't have a pixmap,
286 * clear the area to transparent.
288 if (bg_pixmap == NULL || bg_pixmap == GDK_NO_BG || bg_pixmap == GDK_PARENT_RELATIVE_BG)
294 gdk_cairo_set_source_pixmap (cr, bg_pixmap, x_offset, y_offset);
295 cairo_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
298 /* Can use cairo_paint() here, we clipped above */
304 cairo_region_destroy (clipped_and_offset_region);
308 gdk_window_impl_quartz_end_paint (GdkPaintable *paintable)
310 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (paintable);
312 impl->begin_paint_count--;
314 if (impl->begin_paint_count == 0)
316 cairo_region_destroy (impl->paint_clip_region);
317 impl->paint_clip_region = NULL;
322 _gdk_quartz_window_set_needs_display_in_region (GdkWindow *window,
323 cairo_region_t *region)
325 GdkWindowObject *private;
326 GdkWindowImplQuartz *impl;
329 private = GDK_WINDOW_OBJECT (window);
330 impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
332 if (!impl->needs_display_region)
333 impl->needs_display_region = cairo_region_create ();
335 cairo_region_union (impl->needs_display_region, region);
337 n_rects = cairo_region_num_rectangles (region);
338 for (i = 0; i < n_rects; i++)
340 cairo_rectangle_int_t rect;
341 cairo_region_get_rectangle (region, i, &rect);
342 [impl->view setNeedsDisplayInRect:NSMakeRect (rect.x, rect.y,
343 rect.width, rect.height)];
348 _gdk_windowing_window_process_updates_recurse (GdkWindow *window,
349 cairo_region_t *region)
351 /* Make sure to only flush each toplevel at most once if we're called
352 * from process_all_updates.
354 if (in_process_all_updates)
358 toplevel = gdk_window_get_effective_toplevel (window);
359 if (toplevel && WINDOW_IS_TOPLEVEL (toplevel))
361 GdkWindowObject *toplevel_private;
362 GdkWindowImplQuartz *toplevel_impl;
365 toplevel_private = (GdkWindowObject *)toplevel;
366 toplevel_impl = (GdkWindowImplQuartz *)toplevel_private->impl;
367 nswindow = toplevel_impl->toplevel;
369 /* In theory, we could skip the flush disabling, since we only
372 if (nswindow && ![nswindow isFlushWindowDisabled])
375 [nswindow disableFlushWindow];
376 update_nswindows = g_slist_prepend (update_nswindows, nswindow);
381 if (WINDOW_IS_TOPLEVEL (window))
382 _gdk_quartz_window_set_needs_display_in_region (window, region);
384 _gdk_window_process_updates_recurse (window, region);
386 /* NOTE: I'm not sure if we should displayIfNeeded here. It slows down a
387 * lot (since it triggers the beam syncing) and things seem to work
393 _gdk_windowing_before_process_all_updates (void)
395 in_process_all_updates = TRUE;
397 NSDisableScreenUpdates ();
401 _gdk_windowing_after_process_all_updates (void)
403 GSList *old_update_nswindows = update_nswindows;
404 GSList *tmp_list = update_nswindows;
406 update_nswindows = NULL;
410 NSWindow *nswindow = tmp_list->data;
412 [[nswindow contentView] displayIfNeeded];
414 _gdk_quartz_drawable_flush (NULL);
416 [nswindow enableFlushWindow];
417 [nswindow flushWindow];
420 tmp_list = tmp_list->next;
423 g_slist_free (old_update_nswindows);
425 in_process_all_updates = FALSE;
427 NSEnableScreenUpdates ();
431 gdk_window_impl_quartz_paintable_init (GdkPaintableIface *iface)
433 iface->begin_paint_region = gdk_window_impl_quartz_begin_paint_region;
434 iface->end_paint = gdk_window_impl_quartz_end_paint;
438 _gdk_window_impl_quartz_get_type (void)
440 static GType object_type = 0;
444 const GTypeInfo object_info =
446 sizeof (GdkWindowImplQuartzClass),
447 (GBaseInitFunc) NULL,
448 (GBaseFinalizeFunc) NULL,
449 (GClassInitFunc) gdk_window_impl_quartz_class_init,
450 NULL, /* class_finalize */
451 NULL, /* class_data */
452 sizeof (GdkWindowImplQuartz),
454 (GInstanceInitFunc) gdk_window_impl_quartz_init,
457 const GInterfaceInfo paintable_info =
459 (GInterfaceInitFunc) gdk_window_impl_quartz_paintable_init,
464 const GInterfaceInfo window_impl_info =
466 (GInterfaceInitFunc) gdk_window_impl_iface_init,
471 object_type = g_type_register_static (GDK_TYPE_DRAWABLE_IMPL_QUARTZ,
472 "GdkWindowImplQuartz",
474 g_type_add_interface_static (object_type,
477 g_type_add_interface_static (object_type,
478 GDK_TYPE_WINDOW_IMPL,
486 _gdk_window_impl_get_type (void)
488 return _gdk_window_impl_quartz_get_type ();
492 get_default_title (void)
496 title = g_get_application_name ();
498 title = g_get_prgname ();
504 get_ancestor_coordinates_from_child (GdkWindow *child_window,
507 GdkWindow *ancestor_window,
511 GdkWindowObject *child_private = GDK_WINDOW_OBJECT (child_window);
512 GdkWindowObject *ancestor_private = GDK_WINDOW_OBJECT (ancestor_window);
514 while (child_private != ancestor_private)
516 child_x += child_private->x;
517 child_y += child_private->y;
519 child_private = child_private->parent;
522 *ancestor_x = child_x;
523 *ancestor_y = child_y;
527 _gdk_quartz_window_debug_highlight (GdkWindow *window, gint number)
529 GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
534 static NSWindow *debug_window[10];
535 static NSRect old_rect[10];
539 g_return_if_fail (number >= 0 && number <= 9);
541 if (window == _gdk_root)
546 if (debug_window[number])
547 [debug_window[number] close];
548 debug_window[number] = NULL;
553 toplevel = gdk_window_get_toplevel (window);
554 get_ancestor_coordinates_from_child (window, 0, 0, toplevel, &x, &y);
556 gdk_window_get_origin (toplevel, &tx, &ty);
560 _gdk_quartz_window_gdk_xy_to_xy (x, y + private->height,
563 rect = NSMakeRect (gx, gy, private->width, private->height);
565 if (debug_window[number] && NSEqualRects (rect, old_rect[number]))
568 old_rect[number] = rect;
570 if (debug_window[number])
571 [debug_window[number] close];
573 debug_window[number] = [[NSWindow alloc] initWithContentRect:rect
574 styleMask:NSBorderlessWindowMask
575 backing:NSBackingStoreBuffered
581 color = [NSColor redColor];
584 color = [NSColor blueColor];
587 color = [NSColor greenColor];
590 color = [NSColor yellowColor];
593 color = [NSColor brownColor];
596 color = [NSColor purpleColor];
599 color = [NSColor blackColor];
603 [debug_window[number] setBackgroundColor:color];
604 [debug_window[number] setAlphaValue:0.4];
605 [debug_window[number] setOpaque:NO];
606 [debug_window[number] setReleasedWhenClosed:YES];
607 [debug_window[number] setIgnoresMouseEvents:YES];
608 [debug_window[number] setLevel:NSFloatingWindowLevel];
610 [debug_window[number] orderFront:nil];
614 _gdk_quartz_window_is_ancestor (GdkWindow *ancestor,
617 if (ancestor == NULL || window == NULL)
620 return (gdk_window_get_parent (window) == ancestor ||
621 _gdk_quartz_window_is_ancestor (ancestor,
622 gdk_window_get_parent (window)));
626 /* See notes on top of gdkscreen-quartz.c */
628 _gdk_quartz_window_gdk_xy_to_xy (gint gdk_x,
633 GdkScreenQuartz *screen_quartz = GDK_SCREEN_QUARTZ (_gdk_screen);
636 *ns_y = screen_quartz->height - gdk_y + screen_quartz->min_y;
639 *ns_x = gdk_x + screen_quartz->min_x;
643 _gdk_quartz_window_xy_to_gdk_xy (gint ns_x,
648 GdkScreenQuartz *screen_quartz = GDK_SCREEN_QUARTZ (_gdk_screen);
651 *gdk_y = screen_quartz->height - ns_y + screen_quartz->min_y;
654 *gdk_x = ns_x - screen_quartz->min_x;
658 _gdk_quartz_window_nspoint_to_gdk_xy (NSPoint point,
662 _gdk_quartz_window_xy_to_gdk_xy (point.x, point.y,
667 find_child_window_helper (GdkWindow *window,
672 gboolean get_toplevel)
674 GdkWindowImplQuartz *impl;
677 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
679 if (window == _gdk_root)
680 update_toplevel_order ();
682 for (l = impl->sorted_children; l; l = l->next)
684 GdkWindowObject *child_private = l->data;
685 GdkWindowImplQuartz *child_impl = GDK_WINDOW_IMPL_QUARTZ (child_private->impl);
688 if (!GDK_WINDOW_IS_MAPPED (child_private))
691 temp_x = x_offset + child_private->x;
692 temp_y = y_offset + child_private->y;
694 /* Special-case the root window. We have to include the title
695 * bar in the checks, otherwise the window below the title bar
696 * will be found i.e. events punch through. (If we can find a
697 * better way to deal with the events in gdkevents-quartz, this
698 * might not be needed.)
700 if (window == _gdk_root)
702 NSRect frame = NSMakeRect (0, 0, 100, 100);
707 mask = [child_impl->toplevel styleMask];
709 /* Get the title bar height. */
710 content = [NSWindow contentRectForFrameRect:frame
712 titlebar_height = frame.size.height - content.size.height;
714 if (titlebar_height > 0 &&
715 x >= temp_x && y >= temp_y - titlebar_height &&
716 x < temp_x + child_private->width && y < temp_y)
718 /* The root means "unknown" i.e. a window not managed by
721 return (GdkWindow *)_gdk_root;
725 if ((!get_toplevel || (get_toplevel && window == _gdk_root)) &&
726 x >= temp_x && y >= temp_y &&
727 x < temp_x + child_private->width && y < temp_y + child_private->height)
729 /* Look for child windows. */
730 return find_child_window_helper (l->data,
740 /* Given a GdkWindow and coordinates relative to it, returns the
741 * innermost subwindow that contains the point. If the coordinates are
742 * outside the passed in window, NULL is returned.
745 _gdk_quartz_window_find_child (GdkWindow *window,
748 gboolean get_toplevel)
750 GdkWindowObject *private = GDK_WINDOW_OBJECT (window);
752 if (x >= 0 && y >= 0 && x < private->width && y < private->height)
753 return find_child_window_helper (window, x, y, 0, 0, get_toplevel);
760 _gdk_quartz_window_did_become_main (GdkWindow *window)
762 main_window_stack = g_slist_remove (main_window_stack, window);
764 if (GDK_WINDOW_OBJECT (window)->window_type != GDK_WINDOW_TEMP)
765 main_window_stack = g_slist_prepend (main_window_stack, window);
767 clear_toplevel_order ();
771 _gdk_quartz_window_did_resign_main (GdkWindow *window)
773 GdkWindow *new_window = NULL;
775 if (main_window_stack)
776 new_window = main_window_stack->data;
781 toplevels = gdk_screen_get_toplevel_windows (gdk_screen_get_default ());
783 new_window = toplevels->data;
784 g_list_free (toplevels);
788 new_window != window &&
789 GDK_WINDOW_IS_MAPPED (new_window) &&
790 WINDOW_IS_TOPLEVEL (new_window))
792 GdkWindowObject *private = (GdkWindowObject *) new_window;
793 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
795 [impl->toplevel makeKeyAndOrderFront:impl->toplevel];
798 clear_toplevel_order ();
802 get_nsscreen_for_point (gint x, gint y)
806 NSScreen *screen = NULL;
808 GDK_QUARTZ_ALLOC_POOL;
810 screens = [NSScreen screens];
812 for (i = 0; i < [screens count]; i++)
814 NSRect rect = [[screens objectAtIndex:i] frame];
816 if (x >= rect.origin.x && x <= rect.origin.x + rect.size.width &&
817 y >= rect.origin.y && y <= rect.origin.y + rect.size.height)
819 screen = [screens objectAtIndex:i];
824 GDK_QUARTZ_RELEASE_POOL;
830 _gdk_window_impl_new (GdkWindow *window,
831 GdkWindow *real_parent,
834 GdkEventMask event_mask,
835 GdkWindowAttr *attributes,
836 gint attributes_mask)
838 GdkWindowObject *private;
839 GdkWindowImplQuartz *impl;
840 GdkDrawableImplQuartz *draw_impl;
841 GdkWindowImplQuartz *parent_impl;
843 GDK_QUARTZ_ALLOC_POOL;
845 private = (GdkWindowObject *)window;
847 impl = g_object_new (_gdk_window_impl_get_type (), NULL);
848 private->impl = (GdkDrawable *)impl;
849 draw_impl = GDK_DRAWABLE_IMPL_QUARTZ (impl);
850 draw_impl->wrapper = GDK_DRAWABLE (window);
852 parent_impl = GDK_WINDOW_IMPL_QUARTZ (private->parent->impl);
854 switch (private->window_type)
856 case GDK_WINDOW_TOPLEVEL:
857 case GDK_WINDOW_DIALOG:
858 case GDK_WINDOW_TEMP:
859 if (GDK_WINDOW_TYPE (private->parent) != GDK_WINDOW_ROOT)
861 /* The common code warns for this case */
862 parent_impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (_gdk_root)->impl);
866 if (!private->input_only)
868 if (attributes_mask & GDK_WA_COLORMAP)
870 draw_impl->colormap = attributes->colormap;
871 g_object_ref (attributes->colormap);
875 if (visual == gdk_screen_get_system_visual (_gdk_screen))
877 draw_impl->colormap = gdk_screen_get_system_colormap (_gdk_screen);
878 g_object_ref (draw_impl->colormap);
880 else if (visual == gdk_screen_get_rgba_visual (_gdk_screen))
882 draw_impl->colormap = gdk_screen_get_rgba_colormap (_gdk_screen);
883 g_object_ref (draw_impl->colormap);
887 draw_impl->colormap = gdk_colormap_new (visual, FALSE);
893 draw_impl->colormap = gdk_screen_get_system_colormap (_gdk_screen);
894 g_object_ref (draw_impl->colormap);
897 /* Maintain the z-ordered list of children. */
898 if (private->parent != (GdkWindowObject *)_gdk_root)
899 parent_impl->sorted_children = g_list_prepend (parent_impl->sorted_children, window);
901 clear_toplevel_order ();
903 gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
904 (attributes->cursor) :
909 switch (attributes->window_type)
911 case GDK_WINDOW_TOPLEVEL:
912 case GDK_WINDOW_DIALOG:
913 case GDK_WINDOW_TEMP:
918 NSUInteger style_mask;
922 /* initWithContentRect will place on the mainScreen by default.
923 * We want to select the screen to place on ourselves. We need
924 * to find the screen the window will be on and correct the
925 * content_rect coordinates to be relative to that screen.
927 _gdk_quartz_window_gdk_xy_to_xy (private->x, private->y, &nx, &ny);
929 screen = get_nsscreen_for_point (nx, ny);
930 screen_rect = [screen frame];
931 nx -= screen_rect.origin.x;
932 ny -= screen_rect.origin.y;
934 content_rect = NSMakeRect (nx, ny - private->height,
938 if (attributes->window_type == GDK_WINDOW_TEMP ||
939 attributes->type_hint == GDK_WINDOW_TYPE_HINT_SPLASHSCREEN)
941 style_mask = NSBorderlessWindowMask;
945 style_mask = (NSTitledWindowMask |
946 NSClosableWindowMask |
947 NSMiniaturizableWindowMask |
948 NSResizableWindowMask);
951 impl->toplevel = [[GdkQuartzWindow alloc] initWithContentRect:content_rect
953 backing:NSBackingStoreBuffered
957 if (attributes_mask & GDK_WA_TITLE)
958 title = attributes->title;
960 title = get_default_title ();
962 gdk_window_set_title (window, title);
964 if (draw_impl->colormap == gdk_screen_get_rgba_colormap (_gdk_screen))
966 [impl->toplevel setOpaque:NO];
967 [impl->toplevel setBackgroundColor:[NSColor clearColor]];
970 content_rect.origin.x = 0;
971 content_rect.origin.y = 0;
973 impl->view = [[GdkQuartzView alloc] initWithFrame:content_rect];
974 [impl->view setGdkWindow:window];
975 [impl->toplevel setContentView:impl->view];
976 [impl->view release];
980 case GDK_WINDOW_CHILD:
982 GdkWindowImplQuartz *parent_impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (private->parent)->impl);
984 if (!private->input_only)
986 NSRect frame_rect = NSMakeRect (private->x + private->parent->abs_x,
987 private->y + private->parent->abs_y,
991 impl->view = [[GdkQuartzView alloc] initWithFrame:frame_rect];
993 [impl->view setGdkWindow:window];
995 /* GdkWindows should be hidden by default */
996 [impl->view setHidden:YES];
997 [parent_impl->view addSubview:impl->view];
998 [impl->view release];
1004 g_assert_not_reached ();
1007 GDK_QUARTZ_RELEASE_POOL;
1009 if (attributes_mask & GDK_WA_TYPE_HINT)
1010 gdk_window_set_type_hint (window, attributes->type_hint);
1014 _gdk_quartz_window_update_position (GdkWindow *window)
1017 NSRect content_rect;
1018 GdkWindowObject *private = (GdkWindowObject *)window;
1019 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
1021 GDK_QUARTZ_ALLOC_POOL;
1023 frame_rect = [impl->toplevel frame];
1024 content_rect = [impl->toplevel contentRectForFrameRect:frame_rect];
1026 _gdk_quartz_window_xy_to_gdk_xy (content_rect.origin.x,
1027 content_rect.origin.y + content_rect.size.height,
1028 &private->x, &private->y);
1031 GDK_QUARTZ_RELEASE_POOL;
1035 _gdk_windowing_update_window_sizes (GdkScreen *screen)
1037 GList *windows, *list;
1038 GdkWindowObject *private = (GdkWindowObject *)_gdk_root;
1040 /* The size of the root window is so that it can contain all
1041 * monitors attached to this machine. The monitors are laid out
1042 * within this root window. We calculate the size of the root window
1043 * and the positions of the different monitors in gdkscreen-quartz.c.
1045 * This data is updated when the monitor configuration is changed.
1051 private->width = gdk_screen_get_width (screen);
1052 private->height = gdk_screen_get_height (screen);
1054 windows = gdk_screen_get_toplevel_windows (screen);
1056 for (list = windows; list; list = list->next)
1057 _gdk_quartz_window_update_position (list->data);
1059 g_list_free (windows);
1063 _gdk_windowing_window_init (void)
1065 GdkWindowObject *private;
1066 GdkWindowImplQuartz *impl;
1067 GdkDrawableImplQuartz *drawable_impl;
1069 g_assert (_gdk_root == NULL);
1071 _gdk_root = g_object_new (GDK_TYPE_WINDOW, NULL);
1073 private = (GdkWindowObject *)_gdk_root;
1074 private->impl = g_object_new (_gdk_window_impl_get_type (), NULL);
1075 private->impl_window = private;
1077 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (_gdk_root)->impl);
1079 _gdk_windowing_update_window_sizes (_gdk_screen);
1081 private->state = 0; /* We don't want GDK_WINDOW_STATE_WITHDRAWN here */
1082 private->window_type = GDK_WINDOW_ROOT;
1083 private->depth = 24;
1084 private->viewable = TRUE;
1086 drawable_impl = GDK_DRAWABLE_IMPL_QUARTZ (private->impl);
1088 drawable_impl->wrapper = GDK_DRAWABLE (private);
1089 drawable_impl->colormap = gdk_screen_get_system_colormap (_gdk_screen);
1090 g_object_ref (drawable_impl->colormap);
1094 _gdk_quartz_window_destroy (GdkWindow *window,
1096 gboolean foreign_destroy)
1098 GdkWindowObject *private;
1099 GdkWindowImplQuartz *impl;
1100 GdkWindowObject *parent;
1102 private = GDK_WINDOW_OBJECT (window);
1103 impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
1105 main_window_stack = g_slist_remove (main_window_stack, window);
1107 g_list_free (impl->sorted_children);
1108 impl->sorted_children = NULL;
1110 parent = private->parent;
1113 GdkWindowImplQuartz *parent_impl = GDK_WINDOW_IMPL_QUARTZ (parent->impl);
1115 parent_impl->sorted_children = g_list_remove (parent_impl->sorted_children, window);
1118 _gdk_quartz_drawable_finish (GDK_DRAWABLE (impl));
1120 if (!recursing && !foreign_destroy)
1122 GDK_QUARTZ_ALLOC_POOL;
1125 [impl->toplevel close];
1126 else if (impl->view)
1127 [impl->view removeFromSuperview];
1129 GDK_QUARTZ_RELEASE_POOL;
1134 _gdk_windowing_window_destroy_foreign (GdkWindow *window)
1136 /* Foreign windows aren't supported in OSX. */
1139 /* FIXME: This might be possible to simplify with client-side windows. Also
1140 * note that already_mapped is not used yet, see the x11 backend.
1143 gdk_window_quartz_show (GdkWindow *window, gboolean already_mapped)
1145 GdkWindowObject *private = (GdkWindowObject *)window;
1146 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
1147 gboolean focus_on_map;
1149 GDK_QUARTZ_ALLOC_POOL;
1151 if (!GDK_WINDOW_IS_MAPPED (window))
1152 focus_on_map = private->focus_on_map;
1154 focus_on_map = TRUE;
1156 if (WINDOW_IS_TOPLEVEL (window) && impl->toplevel)
1160 make_key = (private->accept_focus && focus_on_map &&
1161 private->window_type != GDK_WINDOW_TEMP);
1163 [(GdkQuartzWindow*)impl->toplevel showAndMakeKey:make_key];
1164 clear_toplevel_order ();
1166 _gdk_quartz_events_send_map_event (window);
1170 [impl->view setHidden:NO];
1173 [impl->view setNeedsDisplay:YES];
1175 gdk_synthesize_window_state (window, GDK_WINDOW_STATE_WITHDRAWN, 0);
1177 if (private->state & GDK_WINDOW_STATE_MAXIMIZED)
1178 gdk_window_maximize (window);
1180 if (private->state & GDK_WINDOW_STATE_ICONIFIED)
1181 gdk_window_iconify (window);
1183 if (impl->transient_for && !GDK_WINDOW_DESTROYED (impl->transient_for))
1184 _gdk_quartz_window_attach_to_parent (window);
1186 GDK_QUARTZ_RELEASE_POOL;
1189 /* Temporarily unsets the parent window, if the window is a
1193 _gdk_quartz_window_detach_from_parent (GdkWindow *window)
1195 GdkWindowImplQuartz *impl;
1197 g_return_if_fail (GDK_IS_WINDOW (window));
1199 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
1201 g_return_if_fail (impl->toplevel != NULL);
1203 if (impl->transient_for && !GDK_WINDOW_DESTROYED (impl->transient_for))
1205 GdkWindowImplQuartz *parent_impl;
1207 parent_impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (impl->transient_for)->impl);
1208 [parent_impl->toplevel removeChildWindow:impl->toplevel];
1209 clear_toplevel_order ();
1213 /* Re-sets the parent window, if the window is a transient. */
1215 _gdk_quartz_window_attach_to_parent (GdkWindow *window)
1217 GdkWindowImplQuartz *impl;
1219 g_return_if_fail (GDK_IS_WINDOW (window));
1221 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
1223 g_return_if_fail (impl->toplevel != NULL);
1225 if (impl->transient_for && !GDK_WINDOW_DESTROYED (impl->transient_for))
1227 GdkWindowImplQuartz *parent_impl;
1229 parent_impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (impl->transient_for)->impl);
1230 [parent_impl->toplevel addChildWindow:impl->toplevel ordered:NSWindowAbove];
1231 clear_toplevel_order ();
1236 gdk_window_quartz_hide (GdkWindow *window)
1238 GdkWindowObject *private = (GdkWindowObject *)window;
1239 GdkWindowImplQuartz *impl;
1241 /* Make sure we're not stuck in fullscreen mode. */
1242 if (get_fullscreen_geometry (window))
1243 SetSystemUIMode (kUIModeNormal, 0);
1245 check_grab_unmap (window);
1247 _gdk_window_clear_update_area (window);
1249 impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
1251 if (WINDOW_IS_TOPLEVEL (window))
1253 /* Update main window. */
1254 main_window_stack = g_slist_remove (main_window_stack, window);
1255 if ([NSApp mainWindow] == impl->toplevel)
1256 _gdk_quartz_window_did_resign_main (window);
1258 if (impl->transient_for)
1259 _gdk_quartz_window_detach_from_parent (window);
1261 [(GdkQuartzWindow*)impl->toplevel hide];
1263 else if (impl->view)
1265 [impl->view setHidden:YES];
1270 gdk_window_quartz_withdraw (GdkWindow *window)
1272 gdk_window_hide (window);
1276 move_resize_window_internal (GdkWindow *window,
1282 GdkWindowObject *private = (GdkWindowObject *)window;
1283 GdkWindowImplQuartz *impl;
1284 GdkRectangle old_visible;
1285 GdkRectangle new_visible;
1286 GdkRectangle scroll_rect;
1287 cairo_region_t *old_region;
1288 cairo_region_t *expose_region;
1291 if (GDK_WINDOW_DESTROYED (window))
1294 impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
1296 if ((x == -1 || (x == private->x)) &&
1297 (y == -1 || (y == private->y)) &&
1298 (width == -1 || (width == private->width)) &&
1299 (height == -1 || (height == private->height)))
1304 if (!impl->toplevel)
1306 /* The previously visible area of this window in a coordinate
1307 * system rooted at the origin of this window.
1309 old_visible.x = -private->x;
1310 old_visible.y = -private->y;
1312 gdk_drawable_get_size (GDK_DRAWABLE (private->parent),
1314 &old_visible.height);
1319 delta.width = x - private->x;
1329 delta.height = y - private->y;
1338 private->width = width;
1341 private->height = height;
1343 GDK_QUARTZ_ALLOC_POOL;
1347 NSRect content_rect;
1351 _gdk_quartz_window_gdk_xy_to_xy (private->x, private->y + private->height,
1354 content_rect = NSMakeRect (gx, gy, private->width, private->height);
1356 frame_rect = [impl->toplevel frameRectForContentRect:content_rect];
1357 [impl->toplevel setFrame:frame_rect display:YES];
1361 if (!private->input_only)
1365 nsrect = NSMakeRect (private->x, private->y, private->width, private->height);
1367 /* The newly visible area of this window in a coordinate
1368 * system rooted at the origin of this window.
1370 new_visible.x = -private->x;
1371 new_visible.y = -private->y;
1372 new_visible.width = old_visible.width; /* parent has not changed size */
1373 new_visible.height = old_visible.height; /* parent has not changed size */
1375 expose_region = cairo_region_create_rectangle (&new_visible);
1376 old_region = cairo_region_create_rectangle (&old_visible);
1377 cairo_region_subtract (expose_region, old_region);
1379 /* Determine what (if any) part of the previously visible
1380 * part of the window can be copied without a redraw
1382 scroll_rect = old_visible;
1383 scroll_rect.x -= delta.width;
1384 scroll_rect.y -= delta.height;
1385 gdk_rectangle_intersect (&scroll_rect, &old_visible, &scroll_rect);
1387 if (!cairo_region_is_empty (expose_region))
1389 if (scroll_rect.width != 0 && scroll_rect.height != 0)
1391 [impl->view scrollRect:NSMakeRect (scroll_rect.x,
1398 [impl->view setFrame:nsrect];
1400 _gdk_quartz_window_set_needs_display_in_region (window, expose_region);
1404 [impl->view setFrame:nsrect];
1405 [impl->view setNeedsDisplay:YES];
1408 cairo_region_destroy (expose_region);
1409 cairo_region_destroy (old_region);
1413 GDK_QUARTZ_RELEASE_POOL;
1417 window_quartz_move (GdkWindow *window,
1421 g_return_if_fail (GDK_IS_WINDOW (window));
1423 if (((GdkWindowObject *)window)->state & GDK_WINDOW_STATE_FULLSCREEN)
1426 move_resize_window_internal (window, x, y, -1, -1);
1430 window_quartz_resize (GdkWindow *window,
1434 g_return_if_fail (GDK_IS_WINDOW (window));
1436 if (((GdkWindowObject *)window)->state & GDK_WINDOW_STATE_FULLSCREEN)
1444 move_resize_window_internal (window, -1, -1, width, height);
1448 window_quartz_move_resize (GdkWindow *window,
1459 move_resize_window_internal (window, x, y, width, height);
1463 gdk_window_quartz_move_resize (GdkWindow *window,
1470 if (with_move && (width < 0 && height < 0))
1471 window_quartz_move (window, x, y);
1475 window_quartz_move_resize (window, x, y, width, height);
1477 window_quartz_resize (window, width, height);
1481 /* FIXME: This might need fixing (reparenting didn't work before client-side
1485 gdk_window_quartz_reparent (GdkWindow *window,
1486 GdkWindow *new_parent,
1490 GdkWindowObject *private, *old_parent_private, *new_parent_private;
1491 GdkWindowImplQuartz *impl, *old_parent_impl, *new_parent_impl;
1492 NSView *view, *new_parent_view;
1494 if (new_parent == _gdk_root)
1496 /* Could be added, just needs implementing. */
1497 g_warning ("Reparenting to root window is not supported yet in the Mac OS X backend");
1501 private = GDK_WINDOW_OBJECT (window);
1502 impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
1505 new_parent_private = GDK_WINDOW_OBJECT (new_parent);
1506 new_parent_impl = GDK_WINDOW_IMPL_QUARTZ (new_parent_private->impl);
1507 new_parent_view = new_parent_impl->view;
1509 old_parent_private = GDK_WINDOW_OBJECT (private->parent);
1510 old_parent_impl = GDK_WINDOW_IMPL_QUARTZ (old_parent_private->impl);
1514 [view removeFromSuperview];
1515 [new_parent_view addSubview:view];
1519 private->parent = new_parent_private;
1521 if (old_parent_private)
1523 old_parent_impl->sorted_children = g_list_remove (old_parent_impl->sorted_children, window);
1526 new_parent_impl->sorted_children = g_list_prepend (new_parent_impl->sorted_children, window);
1531 /* Get the toplevel ordering from NSApp and update our own list. We do
1532 * this on demand since the NSApp's list is not up to date directly
1533 * after we get windowDidBecomeMain.
1536 update_toplevel_order (void)
1538 GdkWindowObject *root;
1539 GdkWindowImplQuartz *root_impl;
1540 NSEnumerator *enumerator;
1542 GList *toplevels = NULL;
1544 root = GDK_WINDOW_OBJECT (_gdk_root);
1545 root_impl = GDK_WINDOW_IMPL_QUARTZ (root->impl);
1547 if (root_impl->sorted_children)
1550 GDK_QUARTZ_ALLOC_POOL;
1552 enumerator = [[NSApp orderedWindows] objectEnumerator];
1553 while ((nswindow = [enumerator nextObject]))
1557 if (![[nswindow contentView] isKindOfClass:[GdkQuartzView class]])
1560 window = [(GdkQuartzView *)[nswindow contentView] gdkWindow];
1561 toplevels = g_list_prepend (toplevels, window);
1564 GDK_QUARTZ_RELEASE_POOL;
1566 root_impl->sorted_children = g_list_reverse (toplevels);
1570 clear_toplevel_order (void)
1572 GdkWindowObject *root;
1573 GdkWindowImplQuartz *root_impl;
1575 root = GDK_WINDOW_OBJECT (_gdk_root);
1576 root_impl = GDK_WINDOW_IMPL_QUARTZ (root->impl);
1578 g_list_free (root_impl->sorted_children);
1579 root_impl->sorted_children = NULL;
1583 gdk_window_quartz_raise (GdkWindow *window)
1585 if (GDK_WINDOW_DESTROYED (window))
1588 if (WINDOW_IS_TOPLEVEL (window))
1590 GdkWindowImplQuartz *impl;
1592 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
1593 [impl->toplevel orderFront:impl->toplevel];
1595 clear_toplevel_order ();
1599 GdkWindowObject *parent = GDK_WINDOW_OBJECT (window)->parent;
1603 GdkWindowImplQuartz *impl;
1605 impl = (GdkWindowImplQuartz *)parent->impl;
1607 impl->sorted_children = g_list_remove (impl->sorted_children, window);
1608 impl->sorted_children = g_list_prepend (impl->sorted_children, window);
1614 gdk_window_quartz_lower (GdkWindow *window)
1616 if (GDK_WINDOW_DESTROYED (window))
1619 if (WINDOW_IS_TOPLEVEL (window))
1621 GdkWindowImplQuartz *impl;
1623 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
1624 [impl->toplevel orderBack:impl->toplevel];
1626 clear_toplevel_order ();
1630 GdkWindowObject *parent = GDK_WINDOW_OBJECT (window)->parent;
1634 GdkWindowImplQuartz *impl;
1636 impl = (GdkWindowImplQuartz *)parent->impl;
1638 impl->sorted_children = g_list_remove (impl->sorted_children, window);
1639 impl->sorted_children = g_list_append (impl->sorted_children, window);
1645 gdk_window_quartz_restack_toplevel (GdkWindow *window,
1649 /* FIXME: Implement this */
1653 gdk_window_quartz_set_background (GdkWindow *window,
1654 const GdkColor *color)
1656 /* FIXME: We could theoretically set the background color for toplevels
1657 * here. (Currently we draw the background before emitting expose events)
1662 gdk_window_quartz_set_back_pixmap (GdkWindow *window,
1665 /* FIXME: Could theoretically set some background image here. (Currently
1666 * the back pixmap is drawn before emitting expose events.
1671 gdk_window_quartz_set_device_cursor (GdkWindow *window,
1675 GdkCursorPrivate *cursor_private;
1678 cursor_private = (GdkCursorPrivate *)cursor;
1680 if (GDK_WINDOW_DESTROYED (window))
1684 nscursor = [NSCursor arrowCursor];
1686 nscursor = cursor_private->nscursor;
1692 gdk_window_quartz_get_geometry (GdkWindow *window,
1699 GdkWindowImplQuartz *impl;
1700 GdkWindowObject *private;
1703 if (GDK_WINDOW_DESTROYED (window))
1706 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
1707 private = GDK_WINDOW_OBJECT (window);
1708 if (window == _gdk_root)
1716 *width = private->width;
1718 *height = private->height;
1720 else if (WINDOW_IS_TOPLEVEL (window))
1722 ns_rect = [impl->toplevel contentRectForFrameRect:[impl->toplevel frame]];
1724 /* This doesn't work exactly as in X. There doesn't seem to be a
1725 * way to get the coords relative to the parent window (usually
1726 * the window frame), but that seems useless except for
1727 * borderless windows where it's relative to the root window. So
1728 * we return (0, 0) (should be something like (0, 22)) for
1729 * windows with borders and the root relative coordinates
1732 if ([impl->toplevel styleMask] == NSBorderlessWindowMask)
1734 _gdk_quartz_window_xy_to_gdk_xy (ns_rect.origin.x,
1735 ns_rect.origin.y + ns_rect.size.height,
1747 *width = ns_rect.size.width;
1749 *height = ns_rect.size.height;
1753 ns_rect = [impl->view frame];
1756 *x = ns_rect.origin.x;
1758 *y = ns_rect.origin.y;
1760 *width = ns_rect.size.width;
1762 *height = ns_rect.size.height;
1766 *depth = gdk_drawable_get_depth (window);
1770 gdk_window_quartz_get_root_coords (GdkWindow *window,
1776 GdkWindowObject *private;
1777 int tmp_x = 0, tmp_y = 0;
1778 GdkWindow *toplevel;
1779 NSRect content_rect;
1780 GdkWindowImplQuartz *impl;
1782 if (GDK_WINDOW_DESTROYED (window))
1792 if (window == _gdk_root)
1802 private = GDK_WINDOW_OBJECT (window);
1804 toplevel = gdk_window_get_toplevel (window);
1805 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (toplevel)->impl);
1807 content_rect = [impl->toplevel contentRectForFrameRect:[impl->toplevel frame]];
1809 _gdk_quartz_window_xy_to_gdk_xy (content_rect.origin.x,
1810 content_rect.origin.y + content_rect.size.height,
1816 while (private != GDK_WINDOW_OBJECT (toplevel))
1818 if (_gdk_window_has_impl ((GdkWindow *)private))
1820 tmp_x += private->x;
1821 tmp_y += private->y;
1824 private = private->parent;
1836 gdk_window_quartz_get_deskrelative_origin (GdkWindow *window,
1840 return gdk_window_get_origin (window, x, y);
1844 gdk_window_get_root_origin (GdkWindow *window,
1853 gdk_window_get_frame_extents (window, &rect);
1862 /* Returns coordinates relative to the passed in window. */
1864 gdk_window_quartz_get_device_state_helper (GdkWindow *window,
1868 GdkModifierType *mask)
1870 GdkWindowObject *toplevel;
1871 GdkWindowObject *private;
1874 GdkWindow *found_window;
1876 g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
1878 if (GDK_WINDOW_DESTROYED (window))
1886 toplevel = GDK_WINDOW_OBJECT (gdk_window_get_toplevel (window));
1888 *mask = _gdk_quartz_events_get_current_event_mask ();
1890 /* Get the y coordinate, needs to be flipped. */
1891 if (window == _gdk_root)
1893 point = [NSEvent mouseLocation];
1894 _gdk_quartz_window_nspoint_to_gdk_xy (point, &x_tmp, &y_tmp);
1898 GdkWindowImplQuartz *impl;
1901 impl = GDK_WINDOW_IMPL_QUARTZ (toplevel->impl);
1902 private = GDK_WINDOW_OBJECT (toplevel);
1903 nswindow = impl->toplevel;
1905 point = [nswindow mouseLocationOutsideOfEventStream];
1908 y_tmp = private->height - point.y;
1910 window = (GdkWindow *)toplevel;
1913 found_window = _gdk_quartz_window_find_child (window, x_tmp, y_tmp,
1916 /* We never return the root window. */
1917 if (found_window == _gdk_root)
1918 found_window = NULL;
1923 return found_window;
1927 gdk_window_quartz_get_device_state (GdkWindow *window,
1931 GdkModifierType *mask)
1933 return gdk_window_quartz_get_device_state_helper (window,
1935 x, y, mask) != NULL;
1938 /* Returns coordinates relative to the root. */
1940 _gdk_windowing_get_device_state (GdkDisplay *display,
1945 GdkModifierType *mask)
1947 g_return_if_fail (display == _gdk_display);
1949 *screen = _gdk_screen;
1950 gdk_window_quartz_get_device_state_helper (_gdk_root, device, x, y, mask);
1954 gdk_display_warp_pointer (GdkDisplay *display,
1959 CGDisplayMoveCursorToPoint (CGMainDisplayID (), CGPointMake (x, y));
1962 /* Returns coordinates relative to the found window. */
1964 _gdk_windowing_window_at_pointer (GdkDisplay *display,
1967 GdkModifierType *mask,
1968 gboolean get_toplevel)
1970 GdkWindow *found_window;
1972 GdkModifierType tmp_mask = 0;
1974 found_window = gdk_window_quartz_get_device_state_helper (_gdk_root,
1975 display->core_pointer,
1980 GdkWindowObject *private;
1982 /* The coordinates returned above are relative the root, we want
1983 * coordinates relative the window here.
1985 private = GDK_WINDOW_OBJECT (found_window);
1986 while (private != GDK_WINDOW_OBJECT (_gdk_root))
1991 private = private->parent;
1999 /* Mimic the X backend here, -1,-1 for unknown windows. */
2009 GdkWindowObject *w = (GdkWindowObject *)found_window;
2010 /* Requested toplevel, find it. */
2011 /* TODO: This can be implemented more efficient by never
2012 recursing into children in the first place */
2015 /* Convert to toplevel */
2016 while (w->parent != NULL &&
2017 w->parent->window_type != GDK_WINDOW_ROOT)
2023 found_window = (GdkWindow *)w;
2027 return found_window;
2031 _gdk_windowing_window_at_device_position (GdkDisplay *display,
2035 GdkModifierType *mask,
2036 gboolean get_toplevel)
2038 return GDK_DEVICE_GET_CLASS (device)->window_at_position (device,
2046 gdk_window_quartz_get_events (GdkWindow *window)
2048 if (GDK_WINDOW_DESTROYED (window))
2051 return GDK_WINDOW_OBJECT (window)->event_mask;
2055 gdk_window_quartz_set_events (GdkWindow *window,
2056 GdkEventMask event_mask)
2058 /* The mask is set in the common code. */
2062 gdk_window_set_urgency_hint (GdkWindow *window,
2065 if (GDK_WINDOW_DESTROYED (window) ||
2066 !WINDOW_IS_TOPLEVEL (window))
2069 /* FIXME: Implement */
2073 gdk_window_set_geometry_hints (GdkWindow *window,
2074 const GdkGeometry *geometry,
2075 GdkWindowHints geom_mask)
2077 GdkWindowImplQuartz *impl;
2079 g_return_if_fail (geometry != NULL);
2081 if (GDK_WINDOW_DESTROYED (window) ||
2082 !WINDOW_IS_TOPLEVEL (window))
2085 impl = GDK_WINDOW_IMPL_QUARTZ (((GdkWindowObject *) window)->impl);
2086 if (!impl->toplevel)
2089 if (geom_mask & GDK_HINT_POS)
2091 /* FIXME: Implement */
2094 if (geom_mask & GDK_HINT_USER_POS)
2096 /* FIXME: Implement */
2099 if (geom_mask & GDK_HINT_USER_SIZE)
2101 /* FIXME: Implement */
2104 if (geom_mask & GDK_HINT_MIN_SIZE)
2108 size.width = geometry->min_width;
2109 size.height = geometry->min_height;
2111 [impl->toplevel setContentMinSize:size];
2114 if (geom_mask & GDK_HINT_MAX_SIZE)
2118 size.width = geometry->max_width;
2119 size.height = geometry->max_height;
2121 [impl->toplevel setContentMaxSize:size];
2124 if (geom_mask & GDK_HINT_BASE_SIZE)
2126 /* FIXME: Implement */
2129 if (geom_mask & GDK_HINT_RESIZE_INC)
2133 size.width = geometry->width_inc;
2134 size.height = geometry->height_inc;
2136 [impl->toplevel setContentResizeIncrements:size];
2139 if (geom_mask & GDK_HINT_ASPECT)
2141 /* FIXME: Implement */
2144 if (geom_mask & GDK_HINT_WIN_GRAVITY)
2146 /* FIXME: Implement */
2151 gdk_window_set_title (GdkWindow *window,
2154 GdkWindowImplQuartz *impl;
2156 g_return_if_fail (title != NULL);
2158 if (GDK_WINDOW_DESTROYED (window) ||
2159 !WINDOW_IS_TOPLEVEL (window))
2162 impl = GDK_WINDOW_IMPL_QUARTZ (((GdkWindowObject *)window)->impl);
2166 GDK_QUARTZ_ALLOC_POOL;
2167 [impl->toplevel setTitle:[NSString stringWithUTF8String:title]];
2168 GDK_QUARTZ_RELEASE_POOL;
2173 gdk_window_set_role (GdkWindow *window,
2176 if (GDK_WINDOW_DESTROYED (window) ||
2177 WINDOW_IS_TOPLEVEL (window))
2180 /* FIXME: Implement */
2184 gdk_window_set_transient_for (GdkWindow *window,
2187 GdkWindowImplQuartz *window_impl;
2188 GdkWindowImplQuartz *parent_impl;
2190 if (GDK_WINDOW_DESTROYED (window) || GDK_WINDOW_DESTROYED (parent) ||
2191 !WINDOW_IS_TOPLEVEL (window))
2194 window_impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
2195 if (!window_impl->toplevel)
2198 GDK_QUARTZ_ALLOC_POOL;
2200 if (window_impl->transient_for)
2202 _gdk_quartz_window_detach_from_parent (window);
2204 g_object_unref (window_impl->transient_for);
2205 window_impl->transient_for = NULL;
2208 parent_impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (parent)->impl);
2209 if (parent_impl->toplevel)
2211 /* We save the parent because it needs to be unset/reset when
2212 * hiding and showing the window.
2215 /* We don't set transients for tooltips, they are already
2216 * handled by the window level being the top one. If we do, then
2217 * the parent window will be brought to the top just because the
2218 * tooltip is, which is not what we want.
2220 if (gdk_window_get_type_hint (window) != GDK_WINDOW_TYPE_HINT_TOOLTIP)
2222 window_impl->transient_for = g_object_ref (parent);
2224 /* We only add the window if it is shown, otherwise it will
2225 * be shown unconditionally here. If it is not shown, the
2226 * window will be added in show() instead.
2228 if (!(GDK_WINDOW_OBJECT (window)->state & GDK_WINDOW_STATE_WITHDRAWN))
2229 _gdk_quartz_window_attach_to_parent (window);
2233 GDK_QUARTZ_RELEASE_POOL;
2237 gdk_window_quartz_shape_combine_region (GdkWindow *window,
2238 const cairo_region_t *shape,
2242 /* FIXME: Implement */
2246 gdk_window_quartz_input_shape_combine_region (GdkWindow *window,
2247 const cairo_region_t *shape_region,
2251 /* FIXME: Implement */
2255 gdk_window_set_override_redirect (GdkWindow *window,
2256 gboolean override_redirect)
2258 /* FIXME: Implement */
2262 gdk_window_set_accept_focus (GdkWindow *window,
2263 gboolean accept_focus)
2265 GdkWindowObject *private;
2267 private = (GdkWindowObject *)window;
2269 private->accept_focus = accept_focus != FALSE;
2273 gdk_window_quartz_set_static_gravities (GdkWindow *window,
2274 gboolean use_static)
2276 if (GDK_WINDOW_DESTROYED (window) ||
2277 !WINDOW_IS_TOPLEVEL (window))
2280 /* FIXME: Implement */
2285 gdk_window_set_focus_on_map (GdkWindow *window,
2286 gboolean focus_on_map)
2288 GdkWindowObject *private;
2290 private = (GdkWindowObject *)window;
2292 private->focus_on_map = focus_on_map != FALSE;
2296 gdk_window_set_icon (GdkWindow *window,
2297 GdkWindow *icon_window,
2301 /* FIXME: Implement */
2305 gdk_window_set_icon_name (GdkWindow *window,
2308 /* FIXME: Implement */
2312 gdk_window_focus (GdkWindow *window,
2315 GdkWindowObject *private;
2316 GdkWindowImplQuartz *impl;
2318 private = (GdkWindowObject*) window;
2319 impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
2321 if (GDK_WINDOW_DESTROYED (window) ||
2322 !WINDOW_IS_TOPLEVEL (window))
2325 if (private->accept_focus && private->window_type != GDK_WINDOW_TEMP)
2327 GDK_QUARTZ_ALLOC_POOL;
2328 [impl->toplevel makeKeyAndOrderFront:impl->toplevel];
2329 clear_toplevel_order ();
2330 GDK_QUARTZ_RELEASE_POOL;
2335 gint window_type_hint_to_level (GdkWindowTypeHint hint)
2339 case GDK_WINDOW_TYPE_HINT_DOCK:
2340 case GDK_WINDOW_TYPE_HINT_UTILITY:
2341 return NSFloatingWindowLevel;
2343 case GDK_WINDOW_TYPE_HINT_MENU: /* Torn-off menu */
2344 case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU: /* Menu from menubar */
2345 return NSTornOffMenuWindowLevel;
2347 case GDK_WINDOW_TYPE_HINT_NOTIFICATION:
2348 case GDK_WINDOW_TYPE_HINT_TOOLTIP:
2349 return NSStatusWindowLevel;
2351 case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
2352 case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
2353 case GDK_WINDOW_TYPE_HINT_COMBO:
2354 case GDK_WINDOW_TYPE_HINT_DND:
2355 return NSPopUpMenuWindowLevel;
2357 case GDK_WINDOW_TYPE_HINT_NORMAL: /* Normal toplevel window */
2358 case GDK_WINDOW_TYPE_HINT_DIALOG: /* Dialog window */
2359 case GDK_WINDOW_TYPE_HINT_TOOLBAR: /* Window used to implement toolbars */
2360 case GDK_WINDOW_TYPE_HINT_DESKTOP: /* N/A */
2367 return NSNormalWindowLevel;
2371 window_type_hint_to_shadow (GdkWindowTypeHint hint)
2375 case GDK_WINDOW_TYPE_HINT_NORMAL: /* Normal toplevel window */
2376 case GDK_WINDOW_TYPE_HINT_DIALOG: /* Dialog window */
2377 case GDK_WINDOW_TYPE_HINT_DOCK:
2378 case GDK_WINDOW_TYPE_HINT_UTILITY:
2379 case GDK_WINDOW_TYPE_HINT_MENU: /* Torn-off menu */
2380 case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU: /* Menu from menubar */
2381 case GDK_WINDOW_TYPE_HINT_SPLASHSCREEN:
2382 case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
2383 case GDK_WINDOW_TYPE_HINT_COMBO:
2384 case GDK_WINDOW_TYPE_HINT_NOTIFICATION:
2385 case GDK_WINDOW_TYPE_HINT_TOOLTIP:
2388 case GDK_WINDOW_TYPE_HINT_TOOLBAR: /* Window used to implement toolbars */
2389 case GDK_WINDOW_TYPE_HINT_DESKTOP: /* N/A */
2390 case GDK_WINDOW_TYPE_HINT_DND:
2402 gdk_window_set_type_hint (GdkWindow *window,
2403 GdkWindowTypeHint hint)
2405 GdkWindowImplQuartz *impl;
2407 if (GDK_WINDOW_DESTROYED (window) ||
2408 !WINDOW_IS_TOPLEVEL (window))
2411 impl = GDK_WINDOW_IMPL_QUARTZ (((GdkWindowObject *) window)->impl);
2413 impl->type_hint = hint;
2415 /* Match the documentation, only do something if we're not mapped yet. */
2416 if (GDK_WINDOW_IS_MAPPED (window))
2419 [impl->toplevel setHasShadow: window_type_hint_to_shadow (hint)];
2420 [impl->toplevel setLevel: window_type_hint_to_level (hint)];
2424 gdk_window_get_type_hint (GdkWindow *window)
2426 if (GDK_WINDOW_DESTROYED (window) ||
2427 !WINDOW_IS_TOPLEVEL (window))
2428 return GDK_WINDOW_TYPE_HINT_NORMAL;
2430 return GDK_WINDOW_IMPL_QUARTZ (((GdkWindowObject *) window)->impl)->type_hint;
2434 gdk_window_set_modal_hint (GdkWindow *window,
2437 if (GDK_WINDOW_DESTROYED (window) ||
2438 !WINDOW_IS_TOPLEVEL (window))
2441 /* FIXME: Implement */
2445 gdk_window_set_skip_taskbar_hint (GdkWindow *window,
2446 gboolean skips_taskbar)
2448 if (GDK_WINDOW_DESTROYED (window) ||
2449 !WINDOW_IS_TOPLEVEL (window))
2452 /* FIXME: Implement */
2456 gdk_window_set_skip_pager_hint (GdkWindow *window,
2457 gboolean skips_pager)
2459 if (GDK_WINDOW_DESTROYED (window) ||
2460 !WINDOW_IS_TOPLEVEL (window))
2463 /* FIXME: Implement */
2467 gdk_window_begin_resize_drag (GdkWindow *window,
2474 GdkWindowObject *private;
2475 GdkWindowImplQuartz *impl;
2477 g_return_if_fail (GDK_IS_WINDOW (window));
2479 if (edge != GDK_WINDOW_EDGE_SOUTH_EAST)
2481 g_warning ("Resizing is only implemented for GDK_WINDOW_EDGE_SOUTH_EAST on Mac OS");
2485 if (GDK_WINDOW_DESTROYED (window))
2488 private = GDK_WINDOW_OBJECT (window);
2489 impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
2491 if (!impl->toplevel)
2493 g_warning ("Can't call gdk_window_begin_resize_drag on non-toplevel window");
2497 [(GdkQuartzWindow *)impl->toplevel beginManualResize];
2501 gdk_window_begin_move_drag (GdkWindow *window,
2507 GdkWindowObject *private;
2508 GdkWindowImplQuartz *impl;
2510 if (GDK_WINDOW_DESTROYED (window) ||
2511 !WINDOW_IS_TOPLEVEL (window))
2514 private = GDK_WINDOW_OBJECT (window);
2515 impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
2517 if (!impl->toplevel)
2519 g_warning ("Can't call gdk_window_begin_move_drag on non-toplevel window");
2523 [(GdkQuartzWindow *)impl->toplevel beginManualMove];
2527 gdk_window_set_icon_list (GdkWindow *window,
2530 /* FIXME: Implement */
2534 gdk_window_get_frame_extents (GdkWindow *window,
2537 GdkWindowObject *private;
2538 GdkWindow *toplevel;
2539 GdkWindowImplQuartz *impl;
2542 g_return_if_fail (rect != NULL);
2544 private = GDK_WINDOW_OBJECT (window);
2551 toplevel = gdk_window_get_toplevel (window);
2552 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (toplevel)->impl);
2554 ns_rect = [impl->toplevel frame];
2556 _gdk_quartz_window_xy_to_gdk_xy (ns_rect.origin.x,
2557 ns_rect.origin.y + ns_rect.size.height,
2558 &rect->x, &rect->y);
2560 rect->width = ns_rect.size.width;
2561 rect->height = ns_rect.size.height;
2565 gdk_window_set_decorations (GdkWindow *window,
2566 GdkWMDecoration decorations)
2568 GdkWindowImplQuartz *impl;
2569 NSUInteger old_mask, new_mask;
2572 if (GDK_WINDOW_DESTROYED (window) ||
2573 !WINDOW_IS_TOPLEVEL (window))
2576 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
2578 if (decorations == 0 || GDK_WINDOW_TYPE (window) == GDK_WINDOW_TEMP ||
2579 impl->type_hint == GDK_WINDOW_TYPE_HINT_SPLASHSCREEN )
2581 new_mask = NSBorderlessWindowMask;
2585 /* FIXME: Honor other GDK_DECOR_* flags. */
2586 new_mask = (NSTitledWindowMask | NSClosableWindowMask |
2587 NSMiniaturizableWindowMask | NSResizableWindowMask);
2590 GDK_QUARTZ_ALLOC_POOL;
2592 old_mask = [impl->toplevel styleMask];
2594 /* Note, there doesn't seem to be a way to change this without
2595 * recreating the toplevel. There might be bad side-effects of doing
2596 * that, but it seems alright.
2598 if (old_mask != new_mask)
2602 old_view = [impl->toplevel contentView];
2604 rect = [impl->toplevel frame];
2606 /* Properly update the size of the window when the titlebar is
2609 if (old_mask == NSBorderlessWindowMask &&
2610 new_mask != NSBorderlessWindowMask)
2612 rect = [NSWindow frameRectForContentRect:rect styleMask:new_mask];
2615 else if (old_mask != NSBorderlessWindowMask &&
2616 new_mask == NSBorderlessWindowMask)
2618 rect = [NSWindow contentRectForFrameRect:rect styleMask:old_mask];
2621 impl->toplevel = [impl->toplevel initWithContentRect:rect
2623 backing:NSBackingStoreBuffered
2626 [impl->toplevel setHasShadow: window_type_hint_to_shadow (impl->type_hint)];
2627 [impl->toplevel setLevel: window_type_hint_to_level (impl->type_hint)];
2629 [impl->toplevel setContentView:old_view];
2630 [impl->toplevel setFrame:rect display:YES];
2632 /* Invalidate the window shadow for non-opaque views that have shadow
2633 * enabled, to get the shadow shape updated.
2635 if (![old_view isOpaque] && [impl->toplevel hasShadow])
2636 [(GdkQuartzView*)old_view setNeedsInvalidateShadow:YES];
2639 GDK_QUARTZ_RELEASE_POOL;
2643 gdk_window_get_decorations (GdkWindow *window,
2644 GdkWMDecoration *decorations)
2646 GdkWindowImplQuartz *impl;
2648 if (GDK_WINDOW_DESTROYED (window) ||
2649 !WINDOW_IS_TOPLEVEL (window))
2652 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
2656 /* Borderless is 0, so we can't check it as a bit being set. */
2657 if ([impl->toplevel styleMask] == NSBorderlessWindowMask)
2663 /* FIXME: Honor the other GDK_DECOR_* flags. */
2664 *decorations = GDK_DECOR_ALL;
2672 gdk_window_set_functions (GdkWindow *window,
2673 GdkWMFunction functions)
2675 g_return_if_fail (GDK_IS_WINDOW (window));
2677 /* FIXME: Implement */
2681 _gdk_windowing_window_queue_antiexpose (GdkWindow *window,
2682 cairo_region_t *area)
2688 gdk_window_stick (GdkWindow *window)
2690 if (GDK_WINDOW_DESTROYED (window) ||
2691 !WINDOW_IS_TOPLEVEL (window))
2696 gdk_window_unstick (GdkWindow *window)
2698 if (GDK_WINDOW_DESTROYED (window) ||
2699 !WINDOW_IS_TOPLEVEL (window))
2704 gdk_window_maximize (GdkWindow *window)
2706 GdkWindowImplQuartz *impl;
2708 if (GDK_WINDOW_DESTROYED (window) ||
2709 !WINDOW_IS_TOPLEVEL (window))
2712 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
2714 if (GDK_WINDOW_IS_MAPPED (window))
2716 GDK_QUARTZ_ALLOC_POOL;
2718 if (impl->toplevel && ![impl->toplevel isZoomed])
2719 [impl->toplevel zoom:nil];
2721 GDK_QUARTZ_RELEASE_POOL;
2725 gdk_synthesize_window_state (window,
2727 GDK_WINDOW_STATE_MAXIMIZED);
2732 gdk_window_unmaximize (GdkWindow *window)
2734 GdkWindowImplQuartz *impl;
2736 if (GDK_WINDOW_DESTROYED (window) ||
2737 !WINDOW_IS_TOPLEVEL (window))
2740 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
2742 if (GDK_WINDOW_IS_MAPPED (window))
2744 GDK_QUARTZ_ALLOC_POOL;
2746 if (impl->toplevel && [impl->toplevel isZoomed])
2747 [impl->toplevel zoom:nil];
2749 GDK_QUARTZ_RELEASE_POOL;
2753 gdk_synthesize_window_state (window,
2754 GDK_WINDOW_STATE_MAXIMIZED,
2760 gdk_window_iconify (GdkWindow *window)
2762 GdkWindowImplQuartz *impl;
2764 if (GDK_WINDOW_DESTROYED (window) ||
2765 !WINDOW_IS_TOPLEVEL (window))
2768 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
2770 if (GDK_WINDOW_IS_MAPPED (window))
2772 GDK_QUARTZ_ALLOC_POOL;
2775 [impl->toplevel miniaturize:nil];
2777 GDK_QUARTZ_RELEASE_POOL;
2781 gdk_synthesize_window_state (window,
2783 GDK_WINDOW_STATE_ICONIFIED);
2788 gdk_window_deiconify (GdkWindow *window)
2790 GdkWindowImplQuartz *impl;
2792 if (GDK_WINDOW_DESTROYED (window) ||
2793 !WINDOW_IS_TOPLEVEL (window))
2796 impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);
2798 if (GDK_WINDOW_IS_MAPPED (window))
2800 GDK_QUARTZ_ALLOC_POOL;
2803 [impl->toplevel deminiaturize:nil];
2805 GDK_QUARTZ_RELEASE_POOL;
2809 gdk_synthesize_window_state (window,
2810 GDK_WINDOW_STATE_ICONIFIED,
2815 static FullscreenSavedGeometry *
2816 get_fullscreen_geometry (GdkWindow *window)
2818 return g_object_get_data (G_OBJECT (window), FULLSCREEN_DATA);
2822 gdk_window_fullscreen (GdkWindow *window)
2824 FullscreenSavedGeometry *geometry;
2825 GdkWindowObject *private = (GdkWindowObject *) window;
2828 if (GDK_WINDOW_DESTROYED (window) ||
2829 !WINDOW_IS_TOPLEVEL (window))
2832 geometry = get_fullscreen_geometry (window);
2835 geometry = g_new (FullscreenSavedGeometry, 1);
2837 geometry->x = private->x;
2838 geometry->y = private->y;
2839 geometry->width = private->width;
2840 geometry->height = private->height;
2842 if (!gdk_window_get_decorations (window, &geometry->decor))
2843 geometry->decor = GDK_DECOR_ALL;
2845 g_object_set_data_full (G_OBJECT (window),
2846 FULLSCREEN_DATA, geometry,
2849 gdk_window_set_decorations (window, 0);
2851 frame = [[NSScreen mainScreen] frame];
2852 move_resize_window_internal (window,
2854 frame.size.width, frame.size.height);
2857 SetSystemUIMode (kUIModeAllHidden, kUIOptionAutoShowMenuBar);
2859 gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_FULLSCREEN);
2863 gdk_window_unfullscreen (GdkWindow *window)
2865 FullscreenSavedGeometry *geometry;
2867 if (GDK_WINDOW_DESTROYED (window) ||
2868 !WINDOW_IS_TOPLEVEL (window))
2871 geometry = get_fullscreen_geometry (window);
2874 SetSystemUIMode (kUIModeNormal, 0);
2876 move_resize_window_internal (window,
2882 gdk_window_set_decorations (window, geometry->decor);
2884 g_object_set_data (G_OBJECT (window), FULLSCREEN_DATA, NULL);
2886 gdk_synthesize_window_state (window, GDK_WINDOW_STATE_FULLSCREEN, 0);
2891 gdk_window_set_keep_above (GdkWindow *window, gboolean setting)
2893 GdkWindowObject *private = (GdkWindowObject *) window;
2894 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
2897 g_return_if_fail (GDK_IS_WINDOW (window));
2899 if (GDK_WINDOW_DESTROYED (window) ||
2900 !WINDOW_IS_TOPLEVEL (window))
2903 level = window_type_hint_to_level (gdk_window_get_type_hint (window));
2905 /* Adjust normal window level by one if necessary. */
2906 [impl->toplevel setLevel: level + (setting ? 1 : 0)];
2910 gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
2912 GdkWindowObject *private = (GdkWindowObject *) window;
2913 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
2916 g_return_if_fail (GDK_IS_WINDOW (window));
2918 if (GDK_WINDOW_DESTROYED (window) ||
2919 !WINDOW_IS_TOPLEVEL (window))
2922 level = window_type_hint_to_level (gdk_window_get_type_hint (window));
2924 /* Adjust normal window level by one if necessary. */
2925 [impl->toplevel setLevel: level - (setting ? 1 : 0)];
2929 gdk_window_get_group (GdkWindow *window)
2931 g_return_val_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD, NULL);
2933 if (GDK_WINDOW_DESTROYED (window) ||
2934 !WINDOW_IS_TOPLEVEL (window))
2937 /* FIXME: Implement */
2943 gdk_window_set_group (GdkWindow *window,
2946 /* FIXME: Implement */
2950 gdk_window_foreign_new_for_display (GdkDisplay *display,
2951 GdkNativeWindow anid)
2953 /* Foreign windows aren't supported in Mac OS X */
2958 gdk_window_lookup (GdkNativeWindow anid)
2960 /* Foreign windows aren't supported in Mac OS X */
2965 gdk_window_lookup_for_display (GdkDisplay *display, GdkNativeWindow anid)
2967 /* Foreign windows aren't supported in Mac OS X */
2972 gdk_window_enable_synchronized_configure (GdkWindow *window)
2977 gdk_window_configure_finished (GdkWindow *window)
2982 gdk_window_destroy_notify (GdkWindow *window)
2984 check_grab_destroy (window);
2988 _gdk_windowing_window_beep (GdkWindow *window)
2990 g_return_if_fail (GDK_IS_WINDOW (window));
2992 gdk_display_beep (_gdk_display);
2996 gdk_window_set_opacity (GdkWindow *window,
2999 GdkWindowObject *private = (GdkWindowObject *) window;
3000 GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);
3002 g_return_if_fail (GDK_IS_WINDOW (window));
3003 g_return_if_fail (WINDOW_IS_TOPLEVEL (window));
3005 if (GDK_WINDOW_DESTROYED (window) ||
3006 !WINDOW_IS_TOPLEVEL (window))
3011 else if (opacity > 1)
3014 [impl->toplevel setAlphaValue: opacity];
3018 _gdk_windowing_window_set_composited (GdkWindow *window, gboolean composited)
3023 _gdk_windowing_get_shape_for_mask (GdkBitmap *mask)
3025 /* FIXME: implement */
3030 _gdk_windowing_window_get_shape (GdkWindow *window)
3032 /* FIXME: implement */
3037 _gdk_windowing_window_get_input_shape (GdkWindow *window)
3039 /* FIXME: implement */
3044 gdk_window_impl_iface_init (GdkWindowImplIface *iface)
3046 iface->show = gdk_window_quartz_show;
3047 iface->hide = gdk_window_quartz_hide;
3048 iface->withdraw = gdk_window_quartz_withdraw;
3049 iface->set_events = gdk_window_quartz_set_events;
3050 iface->get_events = gdk_window_quartz_get_events;
3051 iface->raise = gdk_window_quartz_raise;
3052 iface->lower = gdk_window_quartz_lower;
3053 iface->restack_toplevel = gdk_window_quartz_restack_toplevel;
3054 iface->move_resize = gdk_window_quartz_move_resize;
3055 iface->set_background = gdk_window_quartz_set_background;
3056 iface->set_back_pixmap = gdk_window_quartz_set_back_pixmap;
3057 iface->reparent = gdk_window_quartz_reparent;
3058 iface->set_device_cursor = gdk_window_quartz_set_device_cursor;
3059 iface->get_geometry = gdk_window_quartz_get_geometry;
3060 iface->get_root_coords = gdk_window_quartz_get_root_coords;
3061 iface->get_device_state = gdk_window_quartz_get_device_state;
3062 iface->get_deskrelative_origin = gdk_window_quartz_get_deskrelative_origin;
3063 iface->shape_combine_region = gdk_window_quartz_shape_combine_region;
3064 iface->input_shape_combine_region = gdk_window_quartz_input_shape_combine_region;
3065 iface->set_static_gravities = gdk_window_quartz_set_static_gravities;
3066 iface->queue_antiexpose = _gdk_quartz_window_queue_antiexpose;
3067 iface->translate = _gdk_quartz_window_translate;
3068 iface->destroy = _gdk_quartz_window_destroy;