/* gdkwindow-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, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <Carbon/Carbon.h>

#include "gdk.h"

#include "gdkwindowimpl.h"

#include "gdkprivate-quartz.h"

#include "gdkscreen-quartz.h"

#include "gdkinputprivate.h"

static gpointer parent_class;

static GSList   *update_nswindows;

static gboolean  in_process_all_updates = FALSE;

static GSList *main_window_stack;

#define FULLSCREEN_DATA "fullscreen-data"

typedef struct

{

  gint            x, y;

  gint            width, height;

  GdkWMDecoration decor;

} FullscreenSavedGeometry;

static void update_toplevel_order (void);

static void clear_toplevel_order  (void);

static FullscreenSavedGeometry *get_fullscreen_geometry (GdkWindow *window);

#define WINDOW_IS_TOPLEVEL(window)		     \

  (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&   \

   GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \

   GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)

static void gdk_window_impl_iface_init (GdkWindowImplIface *iface);

gboolean

gdk_quartz_window_is_quartz (GdkWindow *window)

{

  return GDK_WINDOW_IS_QUARTZ (window);

}

NSView *

gdk_quartz_window_get_nsview (GdkWindow *window)

{

  GdkWindowObject *private = (GdkWindowObject *)window;

  g_return_val_if_fail (GDK_WINDOW_IS_QUARTZ (window), NULL);

  if (GDK_WINDOW_DESTROYED (window))

    return NULL;

  return ((GdkWindowImplQuartz *)private->impl)->view;

}

NSWindow *

gdk_quartz_window_get_nswindow (GdkWindow *window)

{

  GdkWindowObject *private = (GdkWindowObject *)window;

  if (GDK_WINDOW_DESTROYED (window))

    return NULL;

  return ((GdkWindowImplQuartz *)private->impl)->toplevel;

}

static CGContextRef

gdk_window_impl_quartz_get_context (GdkDrawable *drawable,

				    gboolean     antialias)

{

  GdkDrawableImplQuartz *drawable_impl = GDK_DRAWABLE_IMPL_QUARTZ (drawable);

  GdkWindowImplQuartz *window_impl = GDK_WINDOW_IMPL_QUARTZ (drawable);

  CGContextRef cg_context;

  if (GDK_WINDOW_DESTROYED (drawable_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 (window_impl->in_paint_rect_count == 0)

    {

      if (![window_impl->view lockFocusIfCanDraw])

        return NULL;

    }

  cg_context = [[NSGraphicsContext currentContext] graphicsPort];

  CGContextSaveGState (cg_context);

  CGContextSetAllowsAntialiasing (cg_context, antialias);

  /* We'll emulate the clipping caused by double buffering here */

  if (window_impl->begin_paint_count != 0)

    {

      CGRect rect;

      CGRect *cg_rects;

      GdkRectangle *rects;

      gint n_rects, i;

      gdk_region_get_rectangles (window_impl->paint_clip_region,

                                 &rects, &n_rects);

      if (n_rects == 1)

        cg_rects = ▭

      else

        cg_rects = g_new (CGRect, n_rects);

      for (i = 0; i < n_rects; i++)

        {

          cg_rects[i].origin.x = rects[i].x;

          cg_rects[i].origin.y = rects[i].y;

          cg_rects[i].size.width = rects[i].width;

          cg_rects[i].size.height = rects[i].height;

        }

      CGContextClipToRects (cg_context, cg_rects, n_rects);

      g_free (rects);

      if (cg_rects != &rect)

        g_free (cg_rects);

    }

  return cg_context;

}

static void

check_grab_unmap (GdkWindow *window)

{

  GdkDisplay *display = gdk_drawable_get_display (window);

  _gdk_display_end_pointer_grab (display, 0, window, TRUE);

  if (display->keyboard_grab.window)

    {

      GdkWindowObject *private = GDK_WINDOW_OBJECT (window);

      GdkWindowObject *tmp = GDK_WINDOW_OBJECT (display->keyboard_grab.window);

      while (tmp && tmp != private)

	tmp = tmp->parent;

      if (tmp)

	_gdk_display_unset_has_keyboard_grab (display, TRUE);

    }

}

static void

check_grab_destroy (GdkWindow *window)

{

  GdkDisplay *display = gdk_drawable_get_display (window);

  GdkPointerGrabInfo *grab;

  /* Make sure there is no lasting grab in this native window */

  grab = _gdk_display_get_last_pointer_grab (display);

  if (grab && grab->native_window == window)

    {

      /* Serials are always 0 in quartz, but for clarity: */

      grab->serial_end = grab->serial_start;

      grab->implicit_ungrab = TRUE;

    }

  if (window == display->keyboard_grab.native_window &&

      display->keyboard_grab.window != NULL)

    _gdk_display_unset_has_keyboard_grab (display, TRUE);

}

static void

gdk_window_impl_quartz_finalize (GObject *object)

{

  GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (object);

  check_grab_destroy (GDK_DRAWABLE_IMPL_QUARTZ (object)->wrapper);

  if (impl->paint_clip_region)

    gdk_region_destroy (impl->paint_clip_region);

  if (impl->transient_for)

    g_object_unref (impl->transient_for);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

gdk_window_impl_quartz_class_init (GdkWindowImplQuartzClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  GdkDrawableImplQuartzClass *drawable_quartz_class = GDK_DRAWABLE_IMPL_QUARTZ_CLASS (klass);

  parent_class = g_type_class_peek_parent (klass);

  object_class->finalize = gdk_window_impl_quartz_finalize;

  drawable_quartz_class->get_context = gdk_window_impl_quartz_get_context;

}

static void

gdk_window_impl_quartz_init (GdkWindowImplQuartz *impl)

{

  impl->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;

}

static void

gdk_window_impl_quartz_begin_paint_region (GdkPaintable    *paintable,

                                           GdkWindow       *window,

					   const GdkRegion *region)

{

  GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (paintable);

  GdkWindowObject *private = (GdkWindowObject*)window;

  int n_rects;

  GdkRectangle *rects = NULL;

  GdkPixmap *bg_pixmap;

  GdkRegion *clipped_and_offset_region;

  gboolean free_clipped_and_offset_region = TRUE;

  bg_pixmap = private->bg_pixmap;

  clipped_and_offset_region = gdk_region_copy (region);

  gdk_region_intersect (clipped_and_offset_region,

                        private->clip_region_with_children);

  gdk_region_offset (clipped_and_offset_region,

                     private->abs_x, private->abs_y);

  if (impl->begin_paint_count == 0)

    {

      impl->paint_clip_region = clipped_and_offset_region;

      free_clipped_and_offset_region = FALSE;

    }

  else

    gdk_region_union (impl->paint_clip_region, clipped_and_offset_region);

  impl->begin_paint_count++;

  if (bg_pixmap == GDK_NO_BG)

    goto done;

  gdk_region_get_rectangles (clipped_and_offset_region, &rects, &n_rects);

  if (n_rects == 0)

    goto done;

  if (bg_pixmap == NULL)

    {

      CGContextRef cg_context;

      CGColorRef color;

      gint i;

      cg_context = gdk_quartz_drawable_get_context (GDK_DRAWABLE (impl), FALSE);

      color = _gdk_quartz_colormap_get_cgcolor_from_pixel (window,

                                                           private->bg_color.pixel);

      CGContextSetFillColorWithColor (cg_context, color);

      CGColorRelease (color);

      for (i = 0; i < n_rects; i++)

        {

          CGContextFillRect (cg_context,

                             CGRectMake (rects[i].x, rects[i].y,

                                         rects[i].width, rects[i].height));

        }

      gdk_quartz_drawable_release_context (GDK_DRAWABLE (impl), cg_context);

    }

  else

    {

      int x, y;

      int x_offset, y_offset;

      int width, height;

      GdkGC *gc;

      x_offset = y_offset = 0;

      while (window && bg_pixmap == GDK_PARENT_RELATIVE_BG)

        {

          /* If this window should have the same background as the parent,

           * fetch the parent. (And if the same goes for the parent, fetch

           * the grandparent, etc.)

           */

          x_offset += ((GdkWindowObject *) window)->x;

          y_offset += ((GdkWindowObject *) window)->y;

          window = GDK_WINDOW (((GdkWindowObject *) window)->parent);

          bg_pixmap = ((GdkWindowObject *) window)->bg_pixmap;

        }

      if (bg_pixmap == NULL || bg_pixmap == GDK_NO_BG || bg_pixmap == GDK_PARENT_RELATIVE_BG)

        {

          /* Parent relative background but the parent doesn't have a

           * pixmap.

           */ 

          goto done;

        }

      /* Note: There should be a CG API to draw tiled images, we might

       * want to look into that for this. 

       */

      gc = gdk_gc_new (GDK_DRAWABLE (impl));

      gdk_drawable_get_size (GDK_DRAWABLE (bg_pixmap), &width, &height);

      x = -x_offset;

      while (x < (rects[0].x + rects[0].width))

        {

          if (x + width >= rects[0].x)

	    {

              y = -y_offset;

              while (y < (rects[0].y + rects[0].height))

                {

                  if (y + height >= rects[0].y)

                    gdk_draw_drawable (GDK_DRAWABLE (impl), gc, bg_pixmap, 0, 0, x, y, width, height);

                  y += height;

                }

            }

          x += width;

        }

      g_object_unref (gc);

    }

 done:

  if (free_clipped_and_offset_region)

    gdk_region_destroy (clipped_and_offset_region);

  g_free (rects);

}

static void

gdk_window_impl_quartz_end_paint (GdkPaintable *paintable)

{

  GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (paintable);

  impl->begin_paint_count--;

  if (impl->begin_paint_count == 0)

    {

      gdk_region_destroy (impl->paint_clip_region);

      impl->paint_clip_region = NULL;

    }

}

void

_gdk_quartz_window_set_needs_display_in_rect (GdkWindow    *window,

                                              GdkRectangle *rect)

{

  GdkWindowObject *private;

  GdkWindowImplQuartz *impl;

  private = GDK_WINDOW_OBJECT (window);

  impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);

  if (!impl->needs_display_region)

    impl->needs_display_region = gdk_region_new ();

  gdk_region_union_with_rect (impl->needs_display_region, rect);

  [impl->view setNeedsDisplayInRect:NSMakeRect (rect->x, rect->y,

                                                rect->width, rect->height)];

}

void

_gdk_quartz_window_set_needs_display_in_region (GdkWindow    *window,

                                                GdkRegion    *region)

{

  GdkWindowObject *private;

  GdkWindowImplQuartz *impl;

  int i, n_rects;

  GdkRectangle *rects;

  private = GDK_WINDOW_OBJECT (window);

  impl = GDK_WINDOW_IMPL_QUARTZ (private->impl);

  if (!impl->needs_display_region)

    impl->needs_display_region = gdk_region_new ();

  gdk_region_union (impl->needs_display_region, region);

  gdk_region_get_rectangles (region, &rects, &n_rects);

  for (i = 0; i < n_rects; i++)

    [impl->view setNeedsDisplayInRect:NSMakeRect (rects[i].x, rects[i].y,

                                                  rects[i].width,

                                                  rects[i].height)];

  g_free (rects);

}

void

_gdk_windowing_window_process_updates_recurse (GdkWindow *window,

                                               GdkRegion *region)

{

  /* Make sure to only flush each toplevel at most once if we're called

   * from process_all_updates.

   */

  if (in_process_all_updates)

    {

      GdkWindow *toplevel;

      toplevel = gdk_window_get_effective_toplevel (window);

      if (toplevel && WINDOW_IS_TOPLEVEL (toplevel))

        {

          GdkWindowObject *toplevel_private;

          GdkWindowImplQuartz *toplevel_impl;

          NSWindow *nswindow;

          toplevel_private = (GdkWindowObject *)toplevel;

          toplevel_impl = (GdkWindowImplQuartz *)toplevel_private->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 (WINDOW_IS_TOPLEVEL (window))

    _gdk_quartz_window_set_needs_display_in_region (window, region);

  else

    _gdk_window_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.

   */

}

void

_gdk_windowing_before_process_all_updates (void)

{

  in_process_all_updates = TRUE;

  NSDisableScreenUpdates ();

}

void

_gdk_windowing_after_process_all_updates (void)

{

  GSList *old_update_nswindows = update_nswindows;

  GSList *tmp_list = update_nswindows;

  update_nswindows = NULL;

  while (tmp_list)

    {

      NSWindow *nswindow = tmp_list->data;

      [[nswindow contentView] displayIfNeeded];

      _gdk_quartz_drawable_flush (NULL);

      [nswindow enableFlushWindow];

      [nswindow flushWindow];

      [nswindow release];

      tmp_list = tmp_list->next;

    }

  g_slist_free (old_update_nswindows);

  in_process_all_updates = FALSE;

  NSEnableScreenUpdates ();

}

static void

gdk_window_impl_quartz_paintable_init (GdkPaintableIface *iface)

{

  iface->begin_paint_region = gdk_window_impl_quartz_begin_paint_region;

  iface->end_paint = gdk_window_impl_quartz_end_paint;

}

GType

_gdk_window_impl_quartz_get_type (void)

{

  static GType object_type = 0;

  if (!object_type)

    {

      const GTypeInfo object_info =

	{

	  sizeof (GdkWindowImplQuartzClass),

	  (GBaseInitFunc) NULL,

	  (GBaseFinalizeFunc) NULL,

	  (GClassInitFunc) gdk_window_impl_quartz_class_init,

	  NULL,           /* class_finalize */

	  NULL,           /* class_data */

	  sizeof (GdkWindowImplQuartz),

	  0,              /* n_preallocs */

	  (GInstanceInitFunc) gdk_window_impl_quartz_init,

	};

      const GInterfaceInfo paintable_info = 

	{

	  (GInterfaceInitFunc) gdk_window_impl_quartz_paintable_init,

	  NULL,

	  NULL

	};

      const GInterfaceInfo window_impl_info = 

	{

	  (GInterfaceInitFunc) gdk_window_impl_iface_init,

	  NULL,

	  NULL

	};

      object_type = g_type_register_static (GDK_TYPE_DRAWABLE_IMPL_QUARTZ,

                                            "GdkWindowImplQuartz",

                                            &object_info, 0);

      g_type_add_interface_static (object_type,

				   GDK_TYPE_PAINTABLE,

				   &paintable_info);

      g_type_add_interface_static (object_type,

				   GDK_TYPE_WINDOW_IMPL,

				   &window_impl_info);

    }

  return object_type;

}

GType

_gdk_window_impl_get_type (void)

{

  return _gdk_window_impl_quartz_get_type ();

}

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 (GdkWindow *child_window,

				     gint       child_x,

				     gint       child_y,

				     GdkWindow *ancestor_window, 

				     gint      *ancestor_x, 

				     gint      *ancestor_y)

{

  GdkWindowObject *child_private = GDK_WINDOW_OBJECT (child_window);

  GdkWindowObject *ancestor_private = GDK_WINDOW_OBJECT (ancestor_window);

  while (child_private != ancestor_private)

    {

      child_x += child_private->x;

      child_y += child_private->y;

      child_private = child_private->parent;

    }

  *ancestor_x = child_x;

  *ancestor_y = child_y;

}

void

_gdk_quartz_window_debug_highlight (GdkWindow *window, gint number)

{

  GdkWindowObject *private = GDK_WINDOW_OBJECT (window);

  gint x, y;

  gint gx, gy;

  GdkWindow *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_window_get_effective_toplevel (window);

  get_ancestor_coordinates_from_child (window, 0, 0, toplevel, &x, &y);

  gdk_window_get_origin (toplevel, &tx, &ty;;

  x += tx;

  y += ty;

  _gdk_quartz_window_gdk_xy_to_xy (x, y + private->height,

                                   &gx, &gy;;

  rect = NSMakeRect (gx, gy, private->width, private->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_window_is_ancestor (GdkWindow *ancestor,

                                GdkWindow *window)

{

  if (ancestor == NULL || window == NULL)

    return FALSE;

  return (gdk_window_get_parent (window) == ancestor ||

          _gdk_quartz_window_is_ancestor (ancestor, 

                                          gdk_window_get_parent (window)));

}

/* See notes on top of gdkscreen-quartz.c */

void

_gdk_quartz_window_gdk_xy_to_xy (gint  gdk_x,

                                 gint  gdk_y,

                                 gint *ns_x,

                                 gint *ns_y)

{

  GdkScreenQuartz *screen_quartz = GDK_SCREEN_QUARTZ (_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_window_xy_to_gdk_xy (gint  ns_x,

                                 gint  ns_y,

                                 gint *gdk_x,

                                 gint *gdk_y)

{

  GdkScreenQuartz *screen_quartz = GDK_SCREEN_QUARTZ (_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_window_nspoint_to_gdk_xy (NSPoint  point,

                                      gint    *x,

                                      gint    *y)

{

  _gdk_quartz_window_xy_to_gdk_xy (point.x, point.y,

                                   x, y);

}

static GdkWindow *

find_child_window_helper (GdkWindow *window,

			  gint       x,

			  gint       y,

			  gint       x_offset,

			  gint       y_offset)

{

  GdkWindowImplQuartz *impl;

  GList *l;

  impl = GDK_WINDOW_IMPL_QUARTZ (GDK_WINDOW_OBJECT (window)->impl);

  if (window == _gdk_root)

    update_toplevel_order ();

  for (l = impl->sorted_children; l; l = l->next)

    {

      GdkWindowObject *child_private = l->data;

      GdkWindowImplQuartz *child_impl = GDK_WINDOW_IMPL_QUARTZ (child_private->impl);

      int temp_x, temp_y;

      if (!GDK_WINDOW_IS_MAPPED (child_private))

	continue;

      temp_x = x_offset + child_private->x;

      temp_y = y_offset + child_private->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_private->width && y < temp_y)

            {

              /* The root means "unknown" i.e. a window not managed by

               * GDK.

               */

              return (GdkWindow *)_gdk_root;

            }

        }

      if (x >= temp_x && y >= temp_y &&

	  x < temp_x + child_private->width && y < temp_y + child_private->height)

	{

	  /* Look for child windows. */

	  return find_child_window_helper (l->data,

					   x, y,

					   temp_x, temp_y);

	}

    }

  return window;

}

/* Given a GdkWindow 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.

 */

GdkWindow *

_gdk_quartz_window_find_child (GdkWindow *window,

			       gint       x,

			       gint       y)

{

  GdkWindowObject *private = GDK_WINDOW_OBJECT (window);

  if (x >= 0 && y >= 0 && x < private->width && y < private->height)

    return find_child_window_helper (window, x, y, 0, 0);

  return NULL;

}

void

_gdk_quartz_window_did_become_main (GdkWindow *window)

{

  main_window_stack = g_slist_remove (main_window_stack, window);

  if (GDK_WINDOW_OBJECT (window)->window_type != GDK_WINDOW_TEMP)

    main_window_stack = g_slist_prepend (main_window_stack, window);

  clear_toplevel_order ();

}

void

_gdk_quartz_window_did_resign_main (GdkWindow *window)

{

  GdkWindow *new_window = NULL;

  if (main_window_stack)

    new_window = main_window_stack->data;

  else

    {

      GList *toplevels;

      toplevels = gdk_window_get_toplevels ();

      if (toplevels)

        new_window = toplevels->data;

      g_list_free (toplevels);

    }

  if (new_window &&

      new_window != window &&

      GDK_WINDOW_IS_MAPPED (new_window) &&

      WINDOW_IS_TOPLEVEL (new_window))

    {

      GdkWindowObject *private = (GdkWindowObject *) new_window;

      GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (private->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;