quartz: rename GdkDeviceManagerCore -> GdkQuartzDeviceManagerCore

These have been removed since the implementation was just
a straight wrapper around g_spawn.

gdk/Makefile.am

@@ -16,6 +16,7 @@ CLEANFILES =
 EXTRA_DIST += 			\
 	keynames.txt		\
 	keyname-table.h		\
+	gdkkeynames.c		\
 	gen-keyname-table.pl	\
 	gdkconfig.h.win32	\
 	gdkkeysyms-update.pl	\
@@ -155,17 +156,23 @@ common_sources = 		\
 	gdkmarshalers.h
 
 libgdk_3_0_la_SOURCES = $(common_sources)
-libgdk_3_0_la_LIBADD = x11/libgdk-x11.la $(GDK_DEP_LIBS)
+libgdk_3_0_la_LIBADD = $(GDK_DEP_LIBS)
 libgdk_3_0_la_LDFLAGS = $(LDADD)
 
-libgdk_quartz_3_0_la_SOURCES = $(common_sources) gdkkeynames.c
-libgdk_quartz_3_0_la_LIBADD = quartz/libgdk-quartz.la $(GDK_DEP_LIBS)
-libgdk_quartz_3_0_la_LDFLAGS = $(LDADD)
+if USE_X11
+libgdk_3_0_la_LIBADD += x11/libgdk-x11.la
+endif # USE_X11
 
-libgdk_win32_3_0_la_SOURCES = $(common_sources) gdkkeynames.c
-libgdk_win32_3_0_la_LIBADD = win32/libgdk-win32.la $(GDK_DEP_LIBS)
-libgdk_win32_3_0_la_DEPENDENCIES = win32/libgdk-win32.la win32/rc/gdk-win32-res.o gdk.def
-libgdk_win32_3_0_la_LDFLAGS = -Wl,win32/rc/gdk-win32-res.o -export-symbols $(srcdir)/gdk.def $(LDADD)
+if USE_QUARTZ
+libgdk_3_0_la_LIBADD += quartz/libgdk-quartz.la
+endif # USE_QUARTZ
+
+if USE_WIN32
+libgdk_3_0_la_SOURCES += gdkkeynames.c
+libgdk_3_0_la_LIBADD += win32/libgdk-win32.la
+libgdk_3_0_la_DEPENDENCIES = win32/libgdk-win32.la win32/rc/gdk-win32-res.o gdk.def
+libgdk_3_0_la_LDFLAGS += -Wl,win32/rc/gdk-win32-res.o -export-symbols $(srcdir)/gdk.def
+endif # USE_WIN32
 
 if HAVE_INTROSPECTION
 

gdk/gdkdisplaymanager.c

@@ -36,6 +36,10 @@
 #include "x11/gdkx.h"
 #endif
 
+#ifdef GDK_WINDOWING_QUARTZ
+#include "quartz/gdkdisplaymanager-quartz.h"
+#endif
+
 
 /**
  * SECTION:gdkdisplaymanager
@@ -176,6 +180,11 @@ gdk_display_manager_get (void)
       if (backend == NULL || strcmp (backend, "x11") == 0)
         manager = g_object_new (gdk_x11_display_manager_get_type (), NULL);
       else
+#endif
+#ifdef GDK_WINDOWING_QUARTZ
+      if (backend == NULL || strcmp (backend, "quartz") == 0)
+        manager = g_object_new (gdk_quartz_display_manager_get_type (), NULL);
+      else
 #endif
       if (backend != NULL)
         g_error ("Unsupported GDK backend: %s", backend);

gdk/gdkkeynames.c

@@ -45,8 +45,8 @@ gdk_keys_keyval_compare (const void *pkey, const void *pbase)
   return (*(int *) pkey) - ((gdk_key *) pbase)->keyval;
 }
 
-gchar*
-gdk_keyval_name (guint keyval)
+static gchar*
+_gdk_keyval_name (guint keyval)
 {
   static gchar buf[100];
   gdk_key *found;
@@ -86,8 +86,8 @@ gdk_keys_name_compare (const void *pkey, const void *pbase)
 		 (const char *) (keynames + ((const gdk_key *) pbase)->offset));
 }
 
-guint
-gdk_keyval_from_name (const gchar *keyval_name)
+static guint
+_gdk_keyval_from_name (const gchar *keyval_name)
 {
   gdk_key *found;
 

gdk/quartz/GdkQuartzWindow.c

@@ -22,7 +22,7 @@
 #include "gdkwindow-quartz.h"
 #include "gdkprivate-quartz.h"
 
-@implementation GdkQuartzWindow
+@implementation GdkQuartzNSWindow
 
 -(BOOL)windowShouldClose:(id)sender
 {
@@ -441,7 +441,7 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)
 {
   g_assert (current_context != NULL);
 
-  GDK_DRAG_CONTEXT_PRIVATE (current_context)->dragging_info = sender;
+  GDK_QUARTZ_DRAG_CONTEXT (current_context)->dragging_info = sender;
   current_context->suggested_action = drag_operation_to_drag_action ([sender draggingSourceOperationMask]);
   current_context->actions = current_context->suggested_action;
 }
@@ -455,7 +455,7 @@ update_context_from_dragging_info (id <NSDraggingInfo> sender)
   if (current_context)
     g_object_unref (current_context);
   
-  current_context = gdk_drag_context_new ();
+  current_context = g_object_new (GDK_TYPE_QUARTZ_DRAG_CONTEXT, NULL);
   update_context_from_dragging_info (sender);
 
   window = [[self contentView] gdkWindow];

gdk/quartz/GdkQuartzWindow.h

@@ -22,7 +22,7 @@
 #import <Foundation/Foundation.h>
 #include <glib.h>
 
-@interface GdkQuartzWindow : NSWindow {
+@interface GdkQuartzNSWindow : NSWindow {
   BOOL    inMove;
   BOOL    inShowOrHide;
 

gdk/quartz/Makefile.am

@@ -22,17 +22,21 @@ libgdk_quartz_la_SOURCES =    	\
 	GdkQuartzWindow.c	\
 	GdkQuartzWindow.h	\
 	gdkcursor-quartz.c	\
-	gdkdevice-core.c	\
-	gdkdevicemanager-core.c	\
+	gdkcursor-quartz.h	\
+	gdkdevice-core-quartz.c	\
+	gdkdevice-core-quartz.h	\
+	gdkdevicemanager-core-quartz.c	\
+	gdkdevicemanager-core-quartz.h	\
 	gdkdisplay-quartz.c	\
+	gdkdisplay-quartz.h	\
+	gdkdisplaymanager-quartz.c	\
+	gdkdisplaymanager-quartz.h	\
 	gdkdnd-quartz.c		\
+	gdkdnd-quartz.h		\
 	gdkevents-quartz.c	\
 	gdkeventloop-quartz.c	\
 	gdkgeometry-quartz.c	\
 	gdkglobals-quartz.c	\
-	gdkim-quartz.c		\
-	gdkinput.c		\
-	gdkinputprivate.h	\
 	gdkkeys-quartz.c	\
 	gdkmain-quartz.c	\
 	gdkprivate-quartz.h	\
@@ -41,7 +45,6 @@ libgdk_quartz_la_SOURCES =    	\
 	gdkscreen-quartz.c	\
 	gdkscreen-quartz.h	\
 	gdkselection-quartz.c	\
-	gdkspawn-quartz.c	\
 	gdktestutils-quartz.c	\
 	gdkvisual-quartz.c	\
 	gdkwindow-quartz.c	\

gdk/quartz/gdkcursor-quartz.c

@@ -22,6 +22,7 @@
 
 #include "gdkdisplay.h"
 #include "gdkcursor.h"
+#include "gdkcursor-quartz.h"
 #include "gdkprivate-quartz.h"
 
 #include "xcursors.h"
@@ -32,17 +33,15 @@ static GdkCursor *
 gdk_quartz_cursor_new_from_nscursor (NSCursor      *nscursor,
                                      GdkCursorType  cursor_type)
 {
-  GdkCursorPrivate *private;
-  GdkCursor *cursor;
+  GdkQuartzCursor *private;
 
-  private = g_new (GdkCursorPrivate, 1);
+  private = g_object_new (GDK_TYPE_QUARTZ_CURSOR,
+                          "cursor-type", cursor_type,
+                          "display", _gdk_display,
+                          NULL);
   private->nscursor = nscursor;
 
-  cursor = (GdkCursor *)private;
-  cursor->type = cursor_type;
-  cursor->ref_count = 1;
-
-  return cursor;
+  return GDK_CURSOR (private);
 }
 
 static GdkCursor *
@@ -175,14 +174,14 @@ create_builtin_cursor (GdkCursorType cursor_type)
 }
 
 GdkCursor*
-gdk_cursor_new_for_display (GdkDisplay    *display,
-			    GdkCursorType  cursor_type)
+_gdk_quartz_display_get_cursor_for_type (GdkDisplay    *display,
+                                         GdkCursorType  cursor_type)
 {
   NSCursor *nscursor;
 
   g_return_val_if_fail (display == gdk_display_get_default (), NULL);
 
-  switch (cursor_type) 
+  switch (cursor_type)
     {
     case GDK_XTERM:
       nscursor = [NSCursor IBeamCursor];
@@ -303,21 +302,16 @@ _gdk_quartz_pixbuf_to_ns_image (GdkPixbuf *pixbuf)
 }
 
 GdkCursor *
-gdk_cursor_new_from_pixbuf (GdkDisplay *display, 
-			    GdkPixbuf  *pixbuf,
-			    gint        x,
-			    gint        y)
+_gdk_quartz_display_get_cursor_for_pixbuf (GdkDisplay *display,
+                                           GdkPixbuf  *pixbuf,
+                                           gint        x,
+                                           gint        y)
 {
   NSImage *image;
   NSCursor *nscursor;
   GdkCursor *cursor;
   gboolean has_alpha;
 
-  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
-  g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
-  g_return_val_if_fail (0 <= x && x < gdk_pixbuf_get_width (pixbuf), NULL);
-  g_return_val_if_fail (0 <= y && y < gdk_pixbuf_get_height (pixbuf), NULL);
-
   GDK_QUARTZ_ALLOC_POOL;
 
   has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
@@ -332,67 +326,79 @@ gdk_cursor_new_from_pixbuf (GdkDisplay *display,
   return cursor;
 }
 
-GdkCursor*  
-gdk_cursor_new_from_name (GdkDisplay  *display,  
-			  const gchar *name)
+GdkCursor*
+_gdk_quartz_display_get_cursor_for_name (GdkDisplay  *display,
+                                         const gchar *name)
 {
   /* FIXME: Implement */
   return NULL;
 }
 
+G_DEFINE_TYPE (GdkQuartzCursor, gdk_quartz_cursor, GDK_TYPE_CURSOR)
+
+static GdkPixbuf *gdk_quartz_cursor_get_image (GdkCursor *cursor);
+
+static void
+gdk_quartz_cursor_finalize (GObject *object)
+{
+  GdkQuartzCursor *private = GDK_QUARTZ_CURSOR (object);
+
+  if (private->nscursor)
+    [private->nscursor release];
+  private->nscursor = NULL;
+}
+
+static void
+gdk_quartz_cursor_class_init (GdkQuartzCursorClass *quartz_cursor_class)
+{
+  GdkCursorClass *cursor_class = GDK_CURSOR_CLASS (quartz_cursor_class);
+  GObjectClass *object_class = G_OBJECT_CLASS (quartz_cursor_class);
+
+  object_class->finalize = gdk_quartz_cursor_finalize;
+
+  cursor_class->get_image = gdk_quartz_cursor_get_image;
+}
+
+static void
+gdk_quartz_cursor_init (GdkQuartzCursor *cursor)
+{
+}
+
+
+gboolean
+_gdk_quartz_display_supports_cursor_alpha (GdkDisplay *display)
+{
+  return TRUE;
+}
+
+gboolean
+_gdk_quartz_display_supports_cursor_color (GdkDisplay *display)
+{
+  return TRUE;
+}
+
 void
-_gdk_cursor_destroy (GdkCursor *cursor)
+_gdk_quartz_display_get_default_cursor_size (GdkDisplay *display,
+                                             guint      *width,
+                                             guint      *height)
 {
-  GdkCursorPrivate *private;
-
-  g_return_if_fail (cursor != NULL);
-  g_return_if_fail (cursor->ref_count == 0);
-
-  private = (GdkCursorPrivate *)cursor;
-  [private->nscursor release];
-  
-  g_free (private);
-}
-
-gboolean 
-gdk_display_supports_cursor_alpha (GdkDisplay *display)
-{
-  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
-
-  return TRUE;
-}
-
-gboolean 
-gdk_display_supports_cursor_color (GdkDisplay *display)
-{
-  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
-
-  return TRUE;
-}
-
-guint     
-gdk_display_get_default_cursor_size (GdkDisplay *display)
-{
-  g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
-
   /* Mac OS X doesn't have the notion of a default size */
-  return 32;
+  *width = 32;
+  *height = 32;
 }
 
-void     
-gdk_display_get_maximal_cursor_size (GdkDisplay *display,
-				     guint       *width,
-				     guint       *height)
+void
+_gdk_quartz_display_get_maximal_cursor_size (GdkDisplay *display,
+                                             guint       *width,
+                                             guint       *height)
 {
-  g_return_if_fail (GDK_IS_DISPLAY (display));
-
   /* Cursor sizes in Mac OS X can be arbitrarily large */
   *width = 65536;
   *height = 65536;
 }
 
-GdkPixbuf *
-gdk_cursor_get_image (GdkCursor *cursor)
+static GdkPixbuf *
+gdk_quartz_cursor_get_image (GdkCursor *cursor)
 {
   /* FIXME: Implement */
   return NULL;

gdk/quartz/gdkcursor-quartz.h

@@ -0,0 +1,57 @@
+/* gdkcursor-quartz.h
+ *
+ * Copyright (C) 2005-2007  Imendio AB
+ * Copyright (C) 2010 Kristian Rietveld  <kris@gtk.org>
+ *
+ * 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.
+ */
+
+#ifndef __GDK_QUARTZ_CURSOR_H__
+#define __GDK_QUARTZ_CURSOR_H__
+
+#include <gdk/gdk.h>
+#include <gdk/quartz/gdkquartz.h>
+#include "gdkcursorprivate.h"
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_QUARTZ_CURSOR              (gdk_quartz_cursor_get_type ())
+#define GDK_QUARTZ_CURSOR(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_QUARTZ_CURSOR, GdkQuartzCursor))
+#define GDK_QUARTZ_CURSOR_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_QUARTZ_CURSOR, GdkQuartzCursorClass))
+#define GDK_IS_QUARTZ_CURSOR(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_QUARTZ_CURSOR))
+#define GDK_IS_QUARTZ_CURSOR_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_QUARTZ_CURSOR))
+#define GDK_QUARTZ_CURSOR_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_QUARTZ_CURSOR, GdkQuartzCursorClass))
+
+typedef struct _GdkQuartzCursor GdkQuartzCursor;
+typedef struct _GdkQuartzCursorClass GdkQuartzCursorClass;
+
+struct _GdkQuartzCursor
+{
+  GdkCursor cursor;
+
+  NSCursor *nscursor;
+};
+
+struct _GdkQuartzCursorClass
+{
+  GdkCursorClass cursor_class;
+};
+
+GType gdk_quartz_cursor_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GDK_QUARTZ_CURSOR_H__ */

gdk/quartz/gdkdevice-core-quartz.c

@@ -0,0 +1,366 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ * Copyright (C) 2010 Kristian Rietveld <kris@gtk.org>
+ *
+ * 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 <gdk/gdkdisplayprivate.h>
+
+#import "GdkQuartzView.h"
+#include "gdkwindow-quartz.h"
+#include "gdkcursor-quartz.h"
+#include "gdkprivate-quartz.h"
+#include "gdkdevice-core-quartz.h"
+
+static gboolean gdk_quartz_device_core_get_history (GdkDevice      *device,
+                                                    GdkWindow      *window,
+                                                    guint32         start,
+                                                    guint32         stop,
+                                                    GdkTimeCoord ***events,
+                                                    gint           *n_events);
+static void gdk_quartz_device_core_get_state (GdkDevice       *device,
+                                              GdkWindow       *window,
+                                              gdouble         *axes,
+                                              GdkModifierType *mask);
+static void gdk_quartz_device_core_set_window_cursor (GdkDevice *device,
+                                                      GdkWindow *window,
+                                                      GdkCursor *cursor);
+static void gdk_quartz_device_core_warp (GdkDevice *device,
+                                         GdkScreen *screen,
+                                         gint       x,
+                                         gint       y);
+static gboolean gdk_quartz_device_core_query_state (GdkDevice        *device,
+                                                    GdkWindow        *window,
+                                                    GdkWindow       **root_window,
+                                                    GdkWindow       **child_window,
+                                                    gint             *root_x,
+                                                    gint             *root_y,
+                                                    gint             *win_x,
+                                                    gint             *win_y,
+                                                    GdkModifierType  *mask);
+static GdkGrabStatus gdk_quartz_device_core_grab   (GdkDevice     *device,
+                                                    GdkWindow     *window,
+                                                    gboolean       owner_events,
+                                                    GdkEventMask   event_mask,
+                                                    GdkWindow     *confine_to,
+                                                    GdkCursor     *cursor,
+                                                    guint32        time_);
+static void          gdk_quartz_device_core_ungrab (GdkDevice     *device,
+                                                    guint32        time_);
+static GdkWindow * gdk_quartz_device_core_window_at_position (GdkDevice       *device,
+                                                              gint            *win_x,
+                                                              gint            *win_y,
+                                                              GdkModifierType *mask,
+                                                              gboolean         get_toplevel);
+static void      gdk_quartz_device_core_select_window_events (GdkDevice       *device,
+                                                              GdkWindow       *window,
+                                                              GdkEventMask     event_mask);
+
+
+G_DEFINE_TYPE (GdkQuartzDeviceCore, gdk_quartz_device_core, GDK_TYPE_DEVICE)
+
+static void
+gdk_quartz_device_core_class_init (GdkQuartzDeviceCoreClass *klass)
+{
+  GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
+
+  device_class->get_history = gdk_quartz_device_core_get_history;
+  device_class->get_state = gdk_quartz_device_core_get_state;
+  device_class->set_window_cursor = gdk_quartz_device_core_set_window_cursor;
+  device_class->warp = gdk_quartz_device_core_warp;
+  device_class->query_state = gdk_quartz_device_core_query_state;
+  device_class->grab = gdk_quartz_device_core_grab;
+  device_class->ungrab = gdk_quartz_device_core_ungrab;
+  device_class->window_at_position = gdk_quartz_device_core_window_at_position;
+  device_class->select_window_events = gdk_quartz_device_core_select_window_events;
+}
+
+static void
+gdk_quartz_device_core_init (GdkQuartzDeviceCore *quartz_device_core)
+{
+  GdkDevice *device;
+
+  device = GDK_DEVICE (quartz_device_core);
+
+  _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
+  _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
+}
+
+static gboolean
+gdk_quartz_device_core_get_history (GdkDevice      *device,
+                                    GdkWindow      *window,
+                                    guint32         start,
+                                    guint32         stop,
+                                    GdkTimeCoord ***events,
+                                    gint           *n_events)
+{
+  return FALSE;
+}
+
+static void
+gdk_quartz_device_core_get_state (GdkDevice       *device,
+                                  GdkWindow       *window,
+                                  gdouble         *axes,
+                                  GdkModifierType *mask)
+{
+  gint x_int, y_int;
+
+  gdk_window_get_pointer (window, &x_int, &y_int, mask);
+
+  if (axes)
+    {
+      axes[0] = x_int;
+      axes[1] = y_int;
+    }
+}
+
+static void
+translate_coords_to_child_coords (GdkWindow *parent,
+                                  GdkWindow *child,
+                                  gint      *x,
+                                  gint      *y)
+{
+  GdkWindow *current = child;
+
+  if (child == parent)
+    return;
+
+  while (current != parent)
+    {
+      gint tmp_x, tmp_y;
+
+      gdk_window_get_origin (current, &tmp_x, &tmp_y);
+
+      *x -= tmp_x;
+      *y -= tmp_y;
+
+      current = gdk_window_get_effective_parent (current);
+    }
+}
+
+static void
+gdk_quartz_device_core_set_window_cursor (GdkDevice *device,
+                                          GdkWindow *window,
+                                          GdkCursor *cursor)
+{
+  GdkQuartzCursor *cursor_private;
+  NSCursor *nscursor;
+
+  cursor_private = (GdkQuartzCursor *) cursor;
+
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+
+  if (!cursor)
+    nscursor = [NSCursor arrowCursor];
+  else
+    nscursor = cursor_private->nscursor;
+
+  [nscursor set];
+}
+
+static void
+gdk_quartz_device_core_warp (GdkDevice *device,
+                             GdkScreen *screen,
+                             gint       x,
+                             gint       y)
+{
+  CGDisplayMoveCursorToPoint (CGMainDisplayID (), CGPointMake (x, y));
+}
+
+static GdkWindow *
+gdk_quartz_device_core_query_state_helper (GdkWindow       *window,
+                                           GdkDevice       *device,
+                                           gint            *x,
+                                           gint            *y,
+                                           GdkModifierType *mask)
+{
+  GdkWindow *toplevel;
+  NSPoint point;
+  gint x_tmp, y_tmp;
+  GdkWindow *found_window;
+
+  g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
+
+  if (GDK_WINDOW_DESTROYED (window))
+    {
+      *x = 0;
+      *y = 0;
+      *mask = 0;
+      return NULL;
+    }
+
+  toplevel = gdk_window_get_effective_toplevel (window);
+
+  *mask = _gdk_quartz_events_get_current_event_mask ();
+
+  /* Get the y coordinate, needs to be flipped. */
+  if (window == _gdk_root)
+    {
+      point = [NSEvent mouseLocation];
+      _gdk_quartz_window_nspoint_to_gdk_xy (point, &x_tmp, &y_tmp);
+    }
+  else
+    {
+      GdkWindowImplQuartz *impl;
+      NSWindow *nswindow;
+
+      impl = GDK_WINDOW_IMPL_QUARTZ (toplevel->impl);
+      nswindow = impl->toplevel;
+
+      point = [nswindow mouseLocationOutsideOfEventStream];
+
+      x_tmp = point.x;
+      y_tmp = toplevel->height - point.y;
+
+      window = toplevel;
+    }
+
+  found_window = _gdk_quartz_window_find_child (window, x_tmp, y_tmp,
+                                                FALSE);
+
+  if (found_window == _gdk_root)
+    found_window = NULL;
+  else if (found_window)
+    translate_coords_to_child_coords (window, found_window,
+                                      &x_tmp, &y_tmp);
+
+  if (x)
+    *x = x_tmp;
+
+  if (y)
+    *y = y_tmp;
+
+  return found_window;
+}
+
+static gboolean
+gdk_quartz_device_core_query_state (GdkDevice        *device,
+                                    GdkWindow        *window,
+                                    GdkWindow       **root_window,
+                                    GdkWindow       **child_window,
+                                    gint             *root_x,
+                                    gint             *root_y,
+                                    gint             *win_x,
+                                    gint             *win_y,
+                                    GdkModifierType  *mask)
+{
+  GdkDisplay *display;
+  GdkWindow *found_window;
+  NSPoint point;
+  gint x_tmp, y_tmp;
+
+  found_window = gdk_quartz_device_core_query_state_helper (window, device,
+                                                            win_x, win_y,
+                                                            mask);
+  if (!found_window)
+    return FALSE;
+
+  display = gdk_window_get_display (window);
+
+  if (root_window)
+    *root_window = _gdk_root;
+
+  if (child_window)
+    *child_window = found_window;
+
+  point = [NSEvent mouseLocation];
+  _gdk_quartz_window_nspoint_to_gdk_xy (point, &x_tmp, &y_tmp);
+
+  if (root_x)
+    *root_x = x_tmp;
+
+  if (root_y)
+    *root_y = y_tmp;
+
+  return TRUE;
+}
+
+static GdkGrabStatus
+gdk_quartz_device_core_grab (GdkDevice    *device,
+                             GdkWindow    *window,
+                             gboolean      owner_events,
+                             GdkEventMask  event_mask,
+                             GdkWindow    *confine_to,
+                             GdkCursor    *cursor,
+                             guint32       time_)
+{
+  /* Should remain empty */
+  return GDK_GRAB_SUCCESS;
+}
+
+static void
+gdk_quartz_device_core_ungrab (GdkDevice *device,
+                               guint32    time_)
+{
+  GdkDeviceGrabInfo *grab;
+
+  grab = _gdk_display_get_last_device_grab (_gdk_display, device);
+  if (grab)
+    grab->serial_end = 0;
+
+  _gdk_display_device_grab_update (_gdk_display, device, NULL, 0);
+}
+
+static GdkWindow *
+gdk_quartz_device_core_window_at_position (GdkDevice       *device,
+                                           gint            *win_x,
+                                           gint            *win_y,
+                                           GdkModifierType *mask,
+                                           gboolean         get_toplevel)
+{
+  GdkDisplay *display;
+  GdkScreen *screen;
+  GdkWindow *found_window;
+  NSPoint point;
+  gint x_tmp, y_tmp;
+
+  display = gdk_device_get_display (device);
+  screen = gdk_display_get_default_screen (display);
+
+  /* Get mouse coordinates, find window under the mouse pointer */
+  point = [NSEvent mouseLocation];
+  _gdk_quartz_window_nspoint_to_gdk_xy (point, &x_tmp, &y_tmp);
+
+  found_window = _gdk_quartz_window_find_child (_gdk_root, x_tmp, y_tmp,
+                                                get_toplevel);
+
+  if (found_window)
+    translate_coords_to_child_coords (_gdk_root, found_window,
+                                      &x_tmp, &y_tmp);
+
+  if (win_x)
+    *win_x = found_window ? x_tmp : -1;
+
+  if (win_y)
+    *win_y = found_window ? y_tmp : -1;
+
+  if (mask)
+    *mask = _gdk_quartz_events_get_current_event_mask ();
+
+  return found_window;
+}
+
+static void
+gdk_quartz_device_core_select_window_events (GdkDevice    *device,
+                                             GdkWindow    *window,
+                                             GdkEventMask  event_mask)
+{
+  /* The mask is set in the common code. */
+}

gdk/quartz/gdkdevice-core-quartz.h

@@ -0,0 +1,51 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * 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.
+ */
+
+#ifndef __GDK_QUARTZ_DEVICE_CORE_H__
+#define __GDK_QUARTZ_DEVICE_CORE_H__
+
+#include <gdk/gdkdeviceprivate.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_QUARTZ_DEVICE_CORE         (gdk_quartz_device_core_get_type ())
+#define GDK_QUARTZ_DEVICE_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_QUARTZ_DEVICE_CORE, GdkQuartzDeviceCore))
+#define GDK_QUARTZ_DEVICE_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_QUARTZ_DEVICE_CORE, GdkQuartzDeviceCoreClass))
+#define GDK_IS_QUARTZ_DEVICE_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_QUARTZ_DEVICE_CORE))
+#define GDK_IS_QUARTZ_DEVICE_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_QUARTZ_DEVICE_CORE))
+#define GDK_QUARTZ_DEVICE_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_QUARTZ_DEVICE_CORE, GdkQuartzDeviceCoreClass))
+
+typedef struct _GdkQuartzDeviceCore GdkQuartzDeviceCore;
+typedef struct _GdkQuartzDeviceCoreClass GdkQuartzDeviceCoreClass;
+
+struct _GdkQuartzDeviceCore
+{
+  GdkDevice parent_instance;
+};
+
+struct _GdkQuartzDeviceCoreClass
+{
+  GdkDeviceClass parent_class;
+};
+
+GType gdk_quartz_device_core_get_type (void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* __GDK_QUARTZ_DEVICE_CORE_H__ */

gdk/quartz/gdkdevice-core.c

@@ -1,354 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
- * Copyright (C) 2010 Kristian Rietveld <kris@gtk.org>
- *
- * 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"
-
-#import "GdkQuartzView.h"
-#include "gdkwindow-quartz.h"
-#include "gdkprivate-quartz.h"
-#include "gdkdevice-core.h"
-
-static gboolean gdk_device_core_get_history (GdkDevice      *device,
-                                             GdkWindow      *window,
-                                             guint32         start,
-                                             guint32         stop,
-                                             GdkTimeCoord ***events,
-                                             gint           *n_events);
-static void gdk_device_core_get_state (GdkDevice       *device,
-                                       GdkWindow       *window,
-                                       gdouble         *axes,
-                                       GdkModifierType *mask);
-static void gdk_device_core_set_window_cursor (GdkDevice *device,
-                                               GdkWindow *window,
-                                               GdkCursor *cursor);
-static void gdk_device_core_warp (GdkDevice *device,
-                                  GdkScreen *screen,
-                                  gint       x,
-                                  gint       y);
-static gboolean gdk_device_core_query_state (GdkDevice        *device,
-                                             GdkWindow        *window,
-                                             GdkWindow       **root_window,
-                                             GdkWindow       **child_window,
-                                             gint             *root_x,
-                                             gint             *root_y,
-                                             gint             *win_x,
-                                             gint             *win_y,
-                                             GdkModifierType  *mask);
-static GdkGrabStatus gdk_device_core_grab   (GdkDevice     *device,
-                                             GdkWindow     *window,
-                                             gboolean       owner_events,
-                                             GdkEventMask   event_mask,
-                                             GdkWindow     *confine_to,
-                                             GdkCursor     *cursor,
-                                             guint32        time_);
-static void          gdk_device_core_ungrab (GdkDevice     *device,
-                                             guint32        time_);
-static GdkWindow * gdk_device_core_window_at_position (GdkDevice       *device,
-                                                       gint            *win_x,
-                                                       gint            *win_y,
-                                                       GdkModifierType *mask,
-                                                       gboolean         get_toplevel);
-static void      gdk_device_core_select_window_events (GdkDevice       *device,
-                                                       GdkWindow       *window,
-                                                       GdkEventMask     event_mask);
-
-
-G_DEFINE_TYPE (GdkDeviceCore, gdk_device_core, GDK_TYPE_DEVICE)
-
-static void
-gdk_device_core_class_init (GdkDeviceCoreClass *klass)
-{
-  GdkDeviceClass *device_class = GDK_DEVICE_CLASS (klass);
-
-  device_class->get_history = gdk_device_core_get_history;
-  device_class->get_state = gdk_device_core_get_state;
-  device_class->set_window_cursor = gdk_device_core_set_window_cursor;
-  device_class->warp = gdk_device_core_warp;
-  device_class->query_state = gdk_device_core_query_state;
-  device_class->grab = gdk_device_core_grab;
-  device_class->ungrab = gdk_device_core_ungrab;
-  device_class->window_at_position = gdk_device_core_window_at_position;
-  device_class->select_window_events = gdk_device_core_select_window_events;
-}
-
-static void
-gdk_device_core_init (GdkDeviceCore *device_core)
-{
-  GdkDevice *device;
-
-  device = GDK_DEVICE (device_core);
-
-  _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_X, 0, 0, 1);
-  _gdk_device_add_axis (device, GDK_NONE, GDK_AXIS_Y, 0, 0, 1);
-}
-
-static gboolean
-gdk_device_core_get_history (GdkDevice      *device,
-                             GdkWindow      *window,
-                             guint32         start,
-                             guint32         stop,
-                             GdkTimeCoord ***events,
-                             gint           *n_events)
-{
-  return FALSE;
-}
-
-static void
-gdk_device_core_get_state (GdkDevice       *device,
-                           GdkWindow       *window,
-                           gdouble         *axes,
-                           GdkModifierType *mask)
-{
-  gint x_int, y_int;
-
-  gdk_window_get_pointer (window, &x_int, &y_int, mask);
-
-  if (axes)
-    {
-      axes[0] = x_int;
-      axes[1] = y_int;
-    }
-}
-
-static void
-translate_coords_to_child_coords (GdkWindow *parent,
-                                  GdkWindow *child,
-                                  gint      *x,
-                                  gint      *y)
-{
-  GdkWindow *current = child;
-
-  if (child == parent)
-    return;
-
-  while (current != parent)
-    {
-      gint tmp_x, tmp_y;
-
-      gdk_window_get_origin (current, &tmp_x, &tmp_y);
-
-      *x -= tmp_x;
-      *y -= tmp_y;
-
-      current = gdk_window_get_effective_parent (current);
-    }
-}
-
-static void
-gdk_device_core_set_window_cursor (GdkDevice *device,
-                                   GdkWindow *window,
-                                   GdkCursor *cursor)
-{
-  GdkCursorPrivate *cursor_private;
-  NSCursor *nscursor;
-
-  cursor_private = (GdkCursorPrivate*) cursor;
-
-  if (GDK_WINDOW_DESTROYED (window))
-    return;
-
-  if (!cursor)
-    nscursor = [NSCursor arrowCursor];
-  else
-    nscursor = cursor_private->nscursor;
-
-  [nscursor set];
-}
-
-static void
-gdk_device_core_warp (GdkDevice *device,
-                      GdkScreen *screen,
-                      gint       x,
-                      gint       y)
-{
-  CGDisplayMoveCursorToPoint (CGMainDisplayID (), CGPointMake (x, y));
-}
-
-static GdkWindow *
-gdk_device_core_query_state_helper (GdkWindow       *window,
-                                    GdkDevice       *device,
-                                    gint            *x,
-                                    gint            *y,
-                                    GdkModifierType *mask)
-{
-  GdkWindow *toplevel;
-  NSPoint point;
-  gint x_tmp, y_tmp;
-  GdkWindow *found_window;
-
-  g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
-
-  if (GDK_WINDOW_DESTROYED (window))
-    {
-      *x = 0;
-      *y = 0;
-      *mask = 0;
-      return NULL;
-    }
-
-  toplevel = gdk_window_get_effective_toplevel (window);
-
-  *mask = _gdk_quartz_events_get_current_event_mask ();
-
-  /* Get the y coordinate, needs to be flipped. */
-  if (window == _gdk_root)
-    {
-      point = [NSEvent mouseLocation];
-      _gdk_quartz_window_nspoint_to_gdk_xy (point, &x_tmp, &y_tmp);
-    }
-  else
-    {
-      GdkWindowImplQuartz *impl;
-      NSWindow *nswindow;
-
-      impl = GDK_WINDOW_IMPL_QUARTZ (toplevel->impl);
-      nswindow = impl->toplevel;
-
-      point = [nswindow mouseLocationOutsideOfEventStream];
-
-      x_tmp = point.x;
-      y_tmp = toplevel->height - point.y;
-
-      window = toplevel;
-    }
-
-  found_window = _gdk_quartz_window_find_child (window, x_tmp, y_tmp,
-                                                FALSE);
-
-  if (found_window == _gdk_root)
-    found_window = NULL;
-  else if (found_window)
-    translate_coords_to_child_coords (window, found_window,
-                                      &x_tmp, &y_tmp);
-
-  *x = x_tmp;
-  *y = y_tmp;
-
-  return found_window;
-}
-
-static gboolean
-gdk_device_core_query_state (GdkDevice        *device,
-                             GdkWindow        *window,
-                             GdkWindow       **root_window,
-                             GdkWindow       **child_window,
-                             gint             *root_x,
-                             gint             *root_y,
-                             gint             *win_x,
-                             gint             *win_y,
-                             GdkModifierType  *mask)
-{
-  GdkDisplay *display;
-  GdkWindow *found_window;
-  NSPoint point;
-  gint x_tmp, y_tmp;
-
-  found_window = gdk_device_core_query_state_helper (window, device,
-                                                     win_x, win_y,
-                                                     mask);
-  if (!found_window)
-    return FALSE;
-
-  display = gdk_window_get_display (window);
-
-  if (root_window)
-    *root_window = _gdk_root;
-
-  if (child_window)
-    *child_window = found_window;
-
-  point = [NSEvent mouseLocation];
-  _gdk_quartz_window_nspoint_to_gdk_xy (point, &x_tmp, &y_tmp);
-
-  if (root_x)
-    *root_x = x_tmp;
-
-  if (root_y)
-    *root_y = y_tmp;
-
-  return TRUE;
-}
-
-static GdkGrabStatus
-gdk_device_core_grab (GdkDevice    *device,
-                      GdkWindow    *window,
-                      gboolean      owner_events,
-                      GdkEventMask  event_mask,
-                      GdkWindow    *confine_to,
-                      GdkCursor    *cursor,
-                      guint32       time_)
-{
-  /* Should remain empty */
-  return GDK_GRAB_SUCCESS;
-}
-
-static void
-gdk_device_core_ungrab (GdkDevice *device,
-                        guint32    time_)
-{
-  /* Should remain empty */
-}
-
-static GdkWindow *
-gdk_device_core_window_at_position (GdkDevice       *device,
-                                    gint            *win_x,
-                                    gint            *win_y,
-                                    GdkModifierType *mask,
-                                    gboolean         get_toplevel)
-{
-  GdkDisplay *display;
-  GdkScreen *screen;
-  GdkWindow *found_window;
-  NSPoint point;
-  gint x_tmp, y_tmp;
-
-  display = gdk_device_get_display (device);
-  screen = gdk_display_get_default_screen (display);
-
-  /* Get mouse coordinates, find window under the mouse pointer */
-  point = [NSEvent mouseLocation];
-  _gdk_quartz_window_nspoint_to_gdk_xy (point, &x_tmp, &y_tmp);
-
-  found_window = _gdk_quartz_window_find_child (_gdk_root, x_tmp, y_tmp,
-                                                get_toplevel);
-
-  if (found_window)
-    translate_coords_to_child_coords (_gdk_root, found_window,
-                                      &x_tmp, &y_tmp);
-
-  if (win_x)
-    *win_x = found_window ? x_tmp : -1;
-
-  if (win_y)
-    *win_y = found_window ? y_tmp : -1;
-
-  if (mask)
-    *mask = _gdk_quartz_events_get_current_event_mask ();
-
-  return found_window;
-}
-
-static void
-gdk_device_core_select_window_events (GdkDevice    *device,
-                                      GdkWindow    *window,
-                                      GdkEventMask  event_mask)
-{
-  /* The mask is set in the common code. */
-}

gdk/quartz/gdkdevice-core.h

@@ -1,51 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
- *
- * 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.
- */
-
-#ifndef __GDK_DEVICE_CORE_H__
-#define __GDK_DEVICE_CORE_H__
-
-#include <gdk/gdkdeviceprivate.h>
-
-G_BEGIN_DECLS
-
-#define GDK_TYPE_DEVICE_CORE         (gdk_device_core_get_type ())
-#define GDK_DEVICE_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCore))
-#define GDK_DEVICE_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
-#define GDK_IS_DEVICE_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_CORE))
-#define GDK_IS_DEVICE_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_CORE))
-#define GDK_DEVICE_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_CORE, GdkDeviceCoreClass))
-
-typedef struct _GdkDeviceCore GdkDeviceCore;
-typedef struct _GdkDeviceCoreClass GdkDeviceCoreClass;
-
-struct _GdkDeviceCore
-{
-  GdkDevice parent_instance;
-};
-
-struct _GdkDeviceCoreClass
-{
-  GdkDeviceClass parent_class;
-};
-
-GType gdk_device_core_get_type (void) G_GNUC_CONST;
-
-G_END_DECLS
-
-#endif /* __GDK_DEVICE_CORE_H__ */

gdk/quartz/gdkdevicemanager-core-quartz.c

@@ -21,41 +21,41 @@
 
 #include <gdk/gdktypes.h>
 #include <gdk/gdkdevicemanager.h>
-#include "gdkdevicemanager-core.h"
-#include "gdkdevice-core.h"
+#include "gdkdevicemanager-core-quartz.h"
+#include "gdkdevice-core-quartz.h"
 #include "gdkkeysyms.h"
 
 
 #define HAS_FOCUS(toplevel)                           \
   ((toplevel)->has_focus || (toplevel)->has_pointer_focus)
 
-static void    gdk_device_manager_core_finalize    (GObject *object);
-static void    gdk_device_manager_core_constructed (GObject *object);
+static void    gdk_quartz_device_manager_core_finalize    (GObject *object);
+static void    gdk_quartz_device_manager_core_constructed (GObject *object);
 
-static GList * gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
-                                                     GdkDeviceType     type);
-static GdkDevice * gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager);
+static GList * gdk_quartz_device_manager_core_list_devices (GdkDeviceManager *device_manager,
+                                                            GdkDeviceType     type);
+static GdkDevice * gdk_quartz_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager);
 
 
-G_DEFINE_TYPE (GdkDeviceManagerCore, gdk_device_manager_core, GDK_TYPE_DEVICE_MANAGER)
+G_DEFINE_TYPE (GdkQuartzDeviceManagerCore, gdk_quartz_device_manager_core, GDK_TYPE_DEVICE_MANAGER)
 
 static void
-gdk_device_manager_core_class_init (GdkDeviceManagerCoreClass *klass)
+gdk_quartz_device_manager_core_class_init (GdkQuartzDeviceManagerCoreClass *klass)
 {
   GdkDeviceManagerClass *device_manager_class = GDK_DEVICE_MANAGER_CLASS (klass);
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  object_class->finalize = gdk_device_manager_core_finalize;
-  object_class->constructed = gdk_device_manager_core_constructed;
-  device_manager_class->list_devices = gdk_device_manager_core_list_devices;
-  device_manager_class->get_client_pointer = gdk_device_manager_core_get_client_pointer;
+  object_class->finalize = gdk_quartz_device_manager_core_finalize;
+  object_class->constructed = gdk_quartz_device_manager_core_constructed;
+  device_manager_class->list_devices = gdk_quartz_device_manager_core_list_devices;
+  device_manager_class->get_client_pointer = gdk_quartz_device_manager_core_get_client_pointer;
 }
 
 static GdkDevice *
 create_core_pointer (GdkDeviceManager *device_manager,
                      GdkDisplay       *display)
 {
-  return g_object_new (GDK_TYPE_DEVICE_CORE,
+  return g_object_new (GDK_TYPE_QUARTZ_DEVICE_CORE,
                        "name", "Core Pointer",
                        "type", GDK_DEVICE_TYPE_MASTER,
                        "input-source", GDK_SOURCE_MOUSE,
@@ -70,7 +70,7 @@ static GdkDevice *
 create_core_keyboard (GdkDeviceManager *device_manager,
                       GdkDisplay       *display)
 {
-  return g_object_new (GDK_TYPE_DEVICE_CORE,
+  return g_object_new (GDK_TYPE_QUARTZ_DEVICE_CORE,
                        "name", "Core Keyboard",
                        "type", GDK_DEVICE_TYPE_MASTER,
                        "input-source", GDK_SOURCE_KEYBOARD,
@@ -82,30 +82,30 @@ create_core_keyboard (GdkDeviceManager *device_manager,
 }
 
 static void
-gdk_device_manager_core_init (GdkDeviceManagerCore *device_manager)
+gdk_quartz_device_manager_core_init (GdkQuartzDeviceManagerCore *device_manager)
 {
 }
 
 static void
-gdk_device_manager_core_finalize (GObject *object)
+gdk_quartz_device_manager_core_finalize (GObject *object)
 {
-  GdkDeviceManagerCore *device_manager_core;
+  GdkQuartzDeviceManagerCore *quartz_device_manager_core;
 
-  device_manager_core = GDK_DEVICE_MANAGER_CORE (object);
+  quartz_device_manager_core = GDK_QUARTZ_DEVICE_MANAGER_CORE (object);
 
-  g_object_unref (device_manager_core->core_pointer);
-  g_object_unref (device_manager_core->core_keyboard);
+  g_object_unref (quartz_device_manager_core->core_pointer);
+  g_object_unref (quartz_device_manager_core->core_keyboard);
 
-  G_OBJECT_CLASS (gdk_device_manager_core_parent_class)->finalize (object);
+  G_OBJECT_CLASS (gdk_quartz_device_manager_core_parent_class)->finalize (object);
 }
 
 static void
-gdk_device_manager_core_constructed (GObject *object)
+gdk_quartz_device_manager_core_constructed (GObject *object)
 {
-  GdkDeviceManagerCore *device_manager;
+  GdkQuartzDeviceManagerCore *device_manager;
   GdkDisplay *display;
 
-  device_manager = GDK_DEVICE_MANAGER_CORE (object);
+  device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (object);
   display = gdk_device_manager_get_display (GDK_DEVICE_MANAGER (object));
   device_manager->core_pointer = create_core_pointer (GDK_DEVICE_MANAGER (device_manager), display);
   device_manager->core_keyboard = create_core_keyboard (GDK_DEVICE_MANAGER (device_manager), display);
@@ -115,27 +115,27 @@ gdk_device_manager_core_constructed (GObject *object)
 }
 
 static GList *
-gdk_device_manager_core_list_devices (GdkDeviceManager *device_manager,
-                                      GdkDeviceType     type)
+gdk_quartz_device_manager_core_list_devices (GdkDeviceManager *device_manager,
+                                             GdkDeviceType     type)
 {
-  GdkDeviceManagerCore *device_manager_core;
+  GdkQuartzDeviceManagerCore *quartz_device_manager_core;
   GList *devices = NULL;
 
   if (type == GDK_DEVICE_TYPE_MASTER)
     {
-      device_manager_core = (GdkDeviceManagerCore *) device_manager;
-      devices = g_list_prepend (devices, device_manager_core->core_keyboard);
-      devices = g_list_prepend (devices, device_manager_core->core_pointer);
+      quartz_device_manager_core = (GdkQuartzDeviceManagerCore *) device_manager;
+      devices = g_list_prepend (devices, quartz_device_manager_core->core_keyboard);
+      devices = g_list_prepend (devices, quartz_device_manager_core->core_pointer);
     }
 
   return devices;
 }
 
 static GdkDevice *
-gdk_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
+gdk_quartz_device_manager_core_get_client_pointer (GdkDeviceManager *device_manager)
 {
-  GdkDeviceManagerCore *device_manager_core;
+  GdkQuartzDeviceManagerCore *quartz_device_manager_core;
 
-  device_manager_core = (GdkDeviceManagerCore *) device_manager;
-  return device_manager_core->core_pointer;
+  quartz_device_manager_core = (GdkQuartzDeviceManagerCore *) device_manager;
+  return quartz_device_manager_core->core_pointer;
 }

gdk/quartz/gdkdevicemanager-core-quartz.h

@@ -0,0 +1,54 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
+ *
+ * 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.
+ */
+
+#ifndef __GDK_QUARTZ_DEVICE_MANAGER_CORE_H__
+#define __GDK_QUARTZ_DEVICE_MANAGER_CORE_H__
+
+#include <gdk/gdkdevicemanagerprivate.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_QUARTZ_DEVICE_MANAGER_CORE         (gdk_quartz_device_manager_core_get_type ())
+#define GDK_QUARTZ_DEVICE_MANAGER_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_QUARTZ_DEVICE_MANAGER_CORE, GdkQuartzDeviceManagerCore))
+#define GDK_QUARTZ_DEVICE_MANAGER_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_QUARTZ_DEVICE_MANAGER_CORE, GdkQuartzDeviceManagerCoreClass))
+#define GDK_IS_QUARTZ_DEVICE_MANAGER_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_QUARTZ_DEVICE_MANAGER_CORE))
+#define GDK_IS_QUARTZ_DEVICE_MANAGER_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_QUARTZ_DEVICE_MANAGER_CORE))
+#define GDK_QUARTZ_DEVICE_MANAGER_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_QUARTZ_DEVICE_MANAGER_CORE, GdkQuartzDeviceManagerCoreClass))
+
+typedef struct _GdkQuartzDeviceManagerCore GdkQuartzDeviceManagerCore;
+typedef struct _GdkQuartzDeviceManagerCoreClass GdkQuartzDeviceManagerCoreClass;
+
+struct _GdkQuartzDeviceManagerCore
+{
+  GdkDeviceManager parent_object;
+  GdkDevice *core_pointer;
+  GdkDevice *core_keyboard;
+};
+
+struct _GdkQuartzDeviceManagerCoreClass
+{
+  GdkDeviceManagerClass parent_class;
+};
+
+GType gdk_quartz_device_manager_core_get_type (void) G_GNUC_CONST;
+
+
+G_END_DECLS
+
+#endif /* __GDK_QUARTZ_DEVICE_MANAGER_CORE_H__ */

gdk/quartz/gdkdevicemanager-core.h

@@ -1,54 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 2009 Carlos Garnacho <carlosg@gnome.org>
- *
- * 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.
- */
-
-#ifndef __GDK_DEVICE_MANAGER_CORE_H__
-#define __GDK_DEVICE_MANAGER_CORE_H__
-
-#include <gdk/gdkdevicemanager.h>
-
-G_BEGIN_DECLS
-
-#define GDK_TYPE_DEVICE_MANAGER_CORE         (gdk_device_manager_core_get_type ())
-#define GDK_DEVICE_MANAGER_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCore))
-#define GDK_DEVICE_MANAGER_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
-#define GDK_IS_DEVICE_MANAGER_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_MANAGER_CORE))
-#define GDK_IS_DEVICE_MANAGER_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_DEVICE_MANAGER_CORE))
-#define GDK_DEVICE_MANAGER_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_DEVICE_MANAGER_CORE, GdkDeviceManagerCoreClass))
-
-typedef struct _GdkDeviceManagerCore GdkDeviceManagerCore;
-typedef struct _GdkDeviceManagerCoreClass GdkDeviceManagerCoreClass;
-
-struct _GdkDeviceManagerCore
-{
-  GdkDeviceManager parent_object;
-  GdkDevice *core_pointer;
-  GdkDevice *core_keyboard;
-};
-
-struct _GdkDeviceManagerCoreClass
-{
-  GdkDeviceManagerClass parent_class;
-};
-
-GType gdk_device_manager_core_get_type (void) G_GNUC_CONST;
-
-
-G_END_DECLS
-
-#endif /* __GDK_DEVICE_MANAGER_CORE_H__ */

gdk/quartz/gdkdisplay-quartz.c

@@ -23,10 +23,12 @@
 #include "gdk.h"
 #include "gdkprivate-quartz.h"
 #include "gdkscreen-quartz.h"
-#include "gdkdevicemanager-core.h"
+#include "gdkwindow-quartz.h"
+#include "gdkdisplay-quartz.h"
+#include "gdkdevicemanager-core-quartz.h"
 
-GdkWindow *
-gdk_display_get_default_group (GdkDisplay *display)
+static GdkWindow *
+gdk_quartz_display_get_default_group (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 
@@ -35,22 +37,66 @@ gdk_display_get_default_group (GdkDisplay *display)
   return NULL;
 }
 
-void
-_gdk_windowing_set_default_display (GdkDisplay *display)
-{
-  g_assert (display == NULL || _gdk_display == display);
-}
-
 GdkDeviceManager *
 _gdk_device_manager_new (GdkDisplay *display)
 {
-  return g_object_new (GDK_TYPE_DEVICE_MANAGER_CORE,
+  return g_object_new (GDK_TYPE_QUARTZ_DEVICE_MANAGER_CORE,
                        "display", display,
                        NULL);
 }
 
+static void
+gdk_quartz_display_init_input (GdkDisplay *display)
+{
+  GdkQuartzDisplay *display_quartz;
+  GdkDeviceManager *device_manager;
+  GList *list, *l;
+
+  display_quartz = GDK_QUARTZ_DISPLAY (display);
+  device_manager = gdk_display_get_device_manager (_gdk_display);
+
+  /* For backwards compabitility, just add floating devices that are
+   * not keyboards.
+   */
+  list = gdk_device_manager_list_devices (device_manager,
+                                          GDK_DEVICE_TYPE_FLOATING);
+  for (l = list; l; l = l->next)
+    {
+      GdkDevice *device = l->data;
+
+      if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
+        continue;
+
+      display_quartz->input_devices = g_list_prepend (display_quartz->input_devices,
+                                                      g_object_ref (l->data));
+    }
+
+  g_list_free (list);
+
+  /* Now set "core" pointer to the first master device that is a pointer. */
+  list = gdk_device_manager_list_devices (device_manager,
+                                          GDK_DEVICE_TYPE_MASTER);
+
+  for (l = list; l; l = l->next)
+    {
+      GdkDevice *device = list->data;
+
+      if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
+        continue;
+
+      display->core_pointer = device;
+      break;
+    }
+
+  /* Add the core pointer to the devices list */
+  display_quartz->input_devices = g_list_prepend (display_quartz->input_devices,
+                                                  g_object_ref (display->core_pointer));
+
+  g_list_free (list);
+}
+
 GdkDisplay *
-gdk_display_open (const gchar *display_name)
+_gdk_quartz_display_open (const gchar *display_name)
 {
   if (_gdk_display != NULL)
     return NULL;
@@ -58,22 +104,22 @@ gdk_display_open (const gchar *display_name)
   /* Initialize application */
   [NSApplication sharedApplication];
 
-  _gdk_display = g_object_new (GDK_TYPE_DISPLAY, NULL);
+  _gdk_display = g_object_new (_gdk_quartz_display_get_type (), NULL);
   _gdk_display->device_manager = _gdk_device_manager_new (_gdk_display);
 
-  _gdk_visual_init ();
+  _gdk_screen = _gdk_quartz_screen_new ();
 
-  _gdk_screen = _gdk_screen_quartz_new ();
+  _gdk_quartz_screen_init_visuals (_gdk_screen);
 
   _gdk_windowing_window_init ();
 
-  _gdk_events_init ();
+  _gdk_quartz_events_init ();
 
-  _gdk_input_init ();
+  gdk_quartz_display_init_input (_gdk_display);
 
 #if 0
   /* FIXME: Remove the #if 0 when we have these functions */
-  _gdk_dnd_init ();
+  _gdk_quartz_dnd_init ();
 #endif
 
   g_signal_emit_by_name (gdk_display_manager_get (),
@@ -82,8 +128,8 @@ gdk_display_open (const gchar *display_name)
   return _gdk_display;
 }
 
-G_CONST_RETURN gchar *
-gdk_display_get_name (GdkDisplay *display)
+static const gchar *
+gdk_quartz_display_get_name (GdkDisplay *display)
 {
   static gchar *display_name = NULL;
 
@@ -97,17 +143,17 @@ gdk_display_get_name (GdkDisplay *display)
   return display_name;
 }
 
-int
-gdk_display_get_n_screens (GdkDisplay *display)
+static gint
+gdk_quartz_display_get_n_screens (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
 
   return 1;
 }
 
-GdkScreen *
-gdk_display_get_screen (GdkDisplay *display,
-			gint        screen_num)
+static GdkScreen *
+gdk_quartz_display_get_screen (GdkDisplay *display,
+                               gint        screen_num)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
   g_return_val_if_fail (screen_num == 0, NULL);
@@ -115,22 +161,22 @@ gdk_display_get_screen (GdkDisplay *display,
   return _gdk_screen;
 }
 
-GdkScreen *
-gdk_display_get_default_screen (GdkDisplay *display)
+static GdkScreen *
+gdk_quartz_display_get_default_screen (GdkDisplay *display)
 {
   return _gdk_screen;
 }
 
-void
-gdk_display_beep (GdkDisplay *display)
+static void
+gdk_quartz_display_beep (GdkDisplay *display)
 {
   g_return_if_fail (GDK_IS_DISPLAY (display));
 
   NSBeep();
 }
 
-gboolean 
-gdk_display_supports_selection_notification (GdkDisplay *display)
+static gboolean
+gdk_quartz_display_supports_selection_notification (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
 
@@ -138,56 +184,154 @@ gdk_display_supports_selection_notification (GdkDisplay *display)
   return FALSE;
 }
 
-gboolean 
-gdk_display_request_selection_notification (GdkDisplay *display,
-                                            GdkAtom     selection)
+static gboolean
+gdk_quartz_display_request_selection_notification (GdkDisplay *display,
+                                                   GdkAtom     selection)
 
 {
   /* FIXME: Implement */
   return FALSE;
 }
 
-gboolean
-gdk_display_supports_clipboard_persistence (GdkDisplay *display)
+static gboolean
+gdk_quartz_display_supports_clipboard_persistence (GdkDisplay *display)
 {
   /* FIXME: Implement */
   return FALSE;
 }
 
-gboolean 
-gdk_display_supports_shapes (GdkDisplay *display)
+static gboolean
+gdk_quartz_display_supports_shapes (GdkDisplay *display)
 {
   /* FIXME: Implement */
   return FALSE;
 }
 
-gboolean 
-gdk_display_supports_input_shapes (GdkDisplay *display)
+static gboolean
+gdk_quartz_display_supports_input_shapes (GdkDisplay *display)
 {
   /* FIXME: Implement */
   return FALSE;
 }
 
-void
-gdk_display_store_clipboard (GdkDisplay    *display,
-			     GdkWindow     *clipboard_window,
-			     guint32        time_,
-			     const GdkAtom *targets,
-			     gint           n_targets)
+static void
+gdk_quartz_display_store_clipboard (GdkDisplay    *display,
+                                    GdkWindow     *clipboard_window,
+                                    guint32        time_,
+                                    const GdkAtom *targets,
+                                    gint           n_targets)
 {
   /* FIXME: Implement */
 }
 
 
-gboolean
-gdk_display_supports_composite (GdkDisplay *display)
+static gboolean
+gdk_quartz_display_supports_composite (GdkDisplay *display)
 {
   /* FIXME: Implement */
   return FALSE;
 }
 
+static GList *
+_gdk_quartz_display_list_devices (GdkDisplay *display)
+{
+  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
+
+  return GDK_QUARTZ_DISPLAY (display)->input_devices;
+}
+
 gulong
-_gdk_windowing_window_get_next_serial (GdkDisplay *display)
+_gdk_quartz_display_get_next_serial (GdkDisplay *display)
 {
   return 0;
 }
+
+G_DEFINE_TYPE (GdkQuartzDisplay, _gdk_quartz_display, GDK_TYPE_DISPLAY)
+
+static void
+_gdk_quartz_display_init (GdkQuartzDisplay *display)
+{
+  _gdk_quartz_display_manager_add_display (gdk_display_manager_get (),
+                                           GDK_DISPLAY_OBJECT (display));
+}
+
+static void
+_gdk_quartz_display_dispose (GObject *object)
+{
+  GdkQuartzDisplay *display_quartz = GDK_QUARTZ_DISPLAY (object);
+
+  _gdk_quartz_display_manager_remove_display (gdk_display_manager_get (),
+                                              GDK_DISPLAY_OBJECT (object));
+
+  g_list_foreach (display_quartz->input_devices,
+                  (GFunc) g_object_run_dispose, NULL);
+
+  G_OBJECT_CLASS (_gdk_quartz_display_parent_class)->dispose (object);
+}
+
+static void
+_gdk_quartz_display_finalize (GObject *object)
+{
+  GdkQuartzDisplay *display_quartz = GDK_QUARTZ_DISPLAY (object);
+
+  g_list_foreach (display_quartz->input_devices, (GFunc) g_object_unref, NULL);
+  g_list_free (display_quartz->input_devices);
+
+  G_OBJECT_CLASS (_gdk_quartz_display_parent_class)->finalize (object);
+}
+
+static void
+_gdk_quartz_display_class_init (GdkQuartzDisplayClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GdkDisplayClass *display_class = GDK_DISPLAY_CLASS (class);
+
+  object_class->finalize = _gdk_quartz_display_finalize;
+
+  display_class->window_type = GDK_TYPE_QUARTZ_WINDOW;
+
+  display_class->get_name = gdk_quartz_display_get_name;
+  display_class->get_n_screens = gdk_quartz_display_get_n_screens;
+  display_class->get_screen = gdk_quartz_display_get_screen;
+  display_class->get_default_screen = gdk_quartz_display_get_default_screen;
+  display_class->beep = gdk_quartz_display_beep;
+  display_class->sync = _gdk_quartz_display_sync;
+  display_class->flush = _gdk_quartz_display_flush;
+  display_class->queue_events = _gdk_quartz_display_queue_events;
+  display_class->has_pending = _gdk_quartz_display_has_pending;
+  display_class->get_default_group = gdk_quartz_display_get_default_group;
+  display_class->supports_selection_notification = gdk_quartz_display_supports_selection_notification;
+  display_class->request_selection_notification = gdk_quartz_display_request_selection_notification;
+  display_class->supports_clipboard_persistence = gdk_quartz_display_supports_clipboard_persistence;
+  display_class->store_clipboard = gdk_quartz_display_store_clipboard;
+  display_class->supports_shapes = gdk_quartz_display_supports_shapes;
+  display_class->supports_input_shapes = gdk_quartz_display_supports_input_shapes;
+  display_class->supports_composite = gdk_quartz_display_supports_composite;
+  display_class->list_devices = _gdk_quartz_display_list_devices;
+  display_class->send_client_message = _gdk_quartz_display_send_client_message;
+  display_class->add_client_message_filter = _gdk_quartz_display_add_client_message_filter;
+  display_class->get_drag_protocol = _gdk_quartz_display_get_drag_protocol;
+  display_class->get_cursor_for_type = _gdk_quartz_display_get_cursor_for_type;
+  display_class->get_cursor_for_name = _gdk_quartz_display_get_cursor_for_name;
+  display_class->get_cursor_for_pixbuf = _gdk_quartz_display_get_cursor_for_pixbuf;
+  display_class->get_default_cursor_size = _gdk_quartz_display_get_default_cursor_size;
+  display_class->get_maximal_cursor_size = _gdk_quartz_display_get_maximal_cursor_size;
+  display_class->supports_cursor_alpha = _gdk_quartz_display_supports_cursor_alpha;
+  display_class->supports_cursor_color = _gdk_quartz_display_supports_cursor_color;
+
+  display_class->before_process_all_updates = _gdk_quartz_display_before_process_all_updates;
+  display_class->after_process_all_updates = _gdk_quartz_display_after_process_all_updates;
+  display_class->get_next_serial = _gdk_quartz_display_get_next_serial;
+  display_class->notify_startup_complete = _gdk_quartz_display_notify_startup_complete;
+  display_class->event_data_copy = _gdk_quartz_display_event_data_copy;
+  display_class->event_data_free = _gdk_quartz_display_event_data_free;
+  display_class->create_window_impl = _gdk_quartz_display_create_window_impl;
+  display_class->get_keymap = _gdk_quartz_display_get_keymap;
+  display_class->get_selection_owner = _gdk_quartz_display_get_selection_owner;
+  display_class->set_selection_owner = _gdk_quartz_display_set_selection_owner;
+  display_class->send_selection_notify = _gdk_quartz_display_send_selection_notify;
+  display_class->get_selection_property = _gdk_quartz_display_get_selection_property;
+  display_class->convert_selection = _gdk_quartz_display_convert_selection;
+  display_class->text_property_to_utf8_list = _gdk_quartz_display_text_property_to_utf8_list;
+  display_class->utf8_to_string_target = _gdk_quartz_display_utf8_to_string_target;
+}

gdk/quartz/gdkdisplay-quartz.h

@@ -0,0 +1,56 @@
+/* gdkdisplay-quartz.h
+ *
+ * Copyright (C) 2005-2007  Imendio AB
+ * Copyright (C) 2010 Kristian Rietveld  <kris@gtk.org>
+ *
+ * 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.
+ */
+
+#ifndef __GDK_QUARTZ_DISPLAY_H__
+#define __GDK_QUARTZ_DISPLAY_H__
+
+#include <gdk/gdk.h>
+#include "gdkdisplayprivate.h"
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_QUARTZ_DISPLAY              (_gdk_quartz_display_get_type ())
+#define GDK_QUARTZ_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_QUARTZ_DISPLAY, GdkQuartzDisplay))
+#define GDK_QUARTZ_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_QUARTZ_DISPLAY, GdkQuartzDisplayClass))
+#define GDK_IS_QUARTZ_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_QUARTZ_DISPLAY))
+#define GDK_IS_QUARTZ_DISPLAY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_QUARTZ_DISPLAY))
+#define GDK_QUARTZ_DISPLAY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_QUARTZ_DISPLAY, GdkQuartzDisplayClass))
+
+typedef struct _GdkQuartzDisplay GdkQuartzDisplay;
+typedef struct _GdkQuartzDisplayClass GdkQuartzDisplayClass;
+
+struct _GdkQuartzDisplay
+{
+  GdkDisplay display;
+
+  GList *input_devices;
+};
+
+struct _GdkQuartzDisplayClass
+{
+  GdkDisplayClass display_class;
+};
+
+GType _gdk_quartz_display_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GDK_QUARTZ_DISPLAY_H__ */

gdk/quartz/gdkdisplaymanager-quartz.c

@@ -0,0 +1,169 @@
+/* GDK - The GIMP Drawing Kit
+ * gdkdisplaymanager-quartz.c
+ *
+ * Copyright (C) 2005 Imendio AB
+ * Copyright 2010 Red Hat, Inc.
+ *
+ * Author: Matthias clasen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library 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 <dlfcn.h>
+#include <ApplicationServices/ApplicationServices.h>
+
+#include "gdkdisplay-quartz.h"
+#include "gdkdisplaymanager-quartz.h"
+#include "gdkprivate-quartz.h"
+
+#include "gdkdisplaymanagerprivate.h"
+#include "gdkinternals.h"
+
+
+G_DEFINE_TYPE (GdkQuartzDisplayManager, gdk_quartz_display_manager, GDK_TYPE_DISPLAY_MANAGER)
+
+static GdkDisplay *
+gdk_quartz_display_manager_open_display (GdkDisplayManager *manager,
+                                         const gchar       *name)
+{
+  return _gdk_quartz_display_open (name);
+}
+
+static GSList *
+gdk_quartz_display_manager_list_displays (GdkDisplayManager *manager)
+{
+  GdkQuartzDisplayManager *manager_quartz = GDK_QUARTZ_DISPLAY_MANAGER (manager);
+
+  return g_slist_copy (manager_quartz->displays);
+}
+
+static GdkDisplay *
+gdk_quartz_display_manager_get_default_display (GdkDisplayManager *manager)
+{
+  return GDK_QUARTZ_DISPLAY_MANAGER (manager)->default_display;
+}
+
+static void
+gdk_quartz_display_manager_set_default_display (GdkDisplayManager *manager,
+                                                GdkDisplay        *display)
+{
+  GdkQuartzDisplayManager *manager_quartz = GDK_QUARTZ_DISPLAY_MANAGER (manager);
+
+  manager_quartz->default_display = display;
+}
+
+#include "../gdkkeynames.c"
+
+static gchar *
+gdk_quartz_display_manager_get_keyval_name (GdkDisplayManager *manager,
+                                            guint              keyval)
+{
+  return _gdk_keyval_name (keyval);
+}
+
+static guint
+gdk_quartz_display_manager_lookup_keyval (GdkDisplayManager *manager,
+                                          const gchar       *name)
+{
+  return _gdk_keyval_from_name (name);
+}
+
+static void
+gdk_quartz_display_manager_keyval_convert_case (GdkDisplayManager *manager,
+                                                guint              symbol,
+                                                guint             *lower,
+                                                guint             *upper)
+{
+  /* FIXME implement this */
+  if (lower)
+    *lower = symbol;
+  if (upper)
+    *upper = symbol;
+}
+
+static void
+gdk_quartz_display_manager_init (GdkQuartzDisplayManager *manager)
+{
+  ProcessSerialNumber psn = { 0, kCurrentProcess };
+  void (*_gtk_quartz_framework_init_ptr) (void);
+
+  /* Make the current process a foreground application, i.e. an app
+   * with a user interface, in case we're not running from a .app bundle
+   */
+  TransformProcessType (&psn, kProcessTransformToForegroundApplication);
+
+  /* Initialize GTK+ framework if there is one. */
+  _gtk_quartz_framework_init_ptr = dlsym (RTLD_DEFAULT, "_gtk_quartz_framework_init");
+  if (_gtk_quartz_framework_init_ptr)
+    _gtk_quartz_framework_init_ptr ();
+}
+
+static void
+gdk_quartz_display_manager_finalize (GObject *object)
+{
+  g_error ("A GdkQuartzDisplayManager object was finalized. This should not happen");
+  G_OBJECT_CLASS (gdk_quartz_display_manager_parent_class)->finalize (object);
+}
+
+static void
+gdk_quartz_display_manager_class_init (GdkQuartzDisplayManagerClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GdkDisplayManagerClass *manager_class = GDK_DISPLAY_MANAGER_CLASS (class);
+
+  object_class->finalize = gdk_quartz_display_manager_finalize;
+
+  manager_class->open_display = gdk_quartz_display_manager_open_display;
+  manager_class->list_displays = gdk_quartz_display_manager_list_displays;
+  manager_class->set_default_display = gdk_quartz_display_manager_set_default_display;
+  manager_class->get_default_display = gdk_quartz_display_manager_get_default_display;
+  manager_class->atom_intern = _gdk_quartz_display_manager_atom_intern;
+  manager_class->get_atom_name = _gdk_quartz_display_manager_get_atom_name;
+  manager_class->lookup_keyval = gdk_quartz_display_manager_lookup_keyval;
+  manager_class->get_keyval_name = gdk_quartz_display_manager_get_keyval_name;
+  manager_class->keyval_convert_case = gdk_quartz_display_manager_keyval_convert_case;
+}
+
+void
+_gdk_quartz_display_manager_add_display (GdkDisplayManager *manager,
+                                         GdkDisplay        *display)
+{
+  GdkQuartzDisplayManager *manager_quartz = GDK_QUARTZ_DISPLAY_MANAGER (manager);
+
+  if (manager_quartz->displays == NULL)
+    gdk_display_manager_set_default_display (manager, display);
+
+  manager_quartz->displays = g_slist_prepend (manager_quartz->displays, display);
+}
+
+void
+_gdk_quartz_display_manager_remove_display (GdkDisplayManager *manager,
+                                            GdkDisplay        *display)
+{
+  GdkQuartzDisplayManager *manager_quartz = GDK_QUARTZ_DISPLAY_MANAGER (manager);
+
+  manager_quartz->displays = g_slist_remove (manager_quartz->displays, display);
+
+  if (manager_quartz->default_display == display)
+    {
+      if (manager_quartz->displays)
+        gdk_display_manager_set_default_display (manager, manager_quartz->displays->data);
+      else
+        gdk_display_manager_set_default_display (manager, NULL);
+    }
+}

gdk/quartz/gdkdisplaymanager-quartz.h

@@ -0,0 +1,48 @@
+/* gdkdisplaymanager-quartz.h
+ *
+ * Copyright (C) 2005-2007  Imendio AB
+ * Copyright 2010 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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.
+ */
+
+#ifndef __GDK_QUARTZ_DISPLAYMANAGER_H__
+#define __GDK_QUARTZ_DISPLAYMANAGER_H__
+
+#include <gdk/gdk.h>
+#include <gdk/gdkdisplaymanagerprivate.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_QUARTZ_DISPLAY_MANAGER    (gdk_quartz_display_manager_get_type ())
+#define GDK_QUARTZ_DISPLAY_MANAGER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_QUARTZ_DISPLAY_MANAGER, GdkQuartzDisplayManager))
+
+typedef struct _GdkQuartzDisplayManager GdkQuartzDisplayManager;
+typedef struct _GdkDisplayManagerClass GdkQuartzDisplayManagerClass;
+
+struct _GdkQuartzDisplayManager
+{
+  GdkDisplayManager parent;
+
+  GdkDisplay *default_display;
+  GSList *displays;
+};
+
+GType gdk_quartz_display_manager_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GDK_QUARTZ_DISPLAYMANAGER_H__ */

gdk/quartz/gdkdnd-quartz.c

@@ -19,73 +19,11 @@
  */
 
 #include "gdkdnd.h"
+#include "gdkdnd-quartz.h"
 #include "gdkprivate-quartz.h"
 
-static gpointer parent_class = NULL;
+G_DEFINE_TYPE (GdkQuartzDragContext, gdk_quartz_drag_context, GDK_TYPE_DRAG_CONTEXT)
 
-static void
-gdk_drag_context_finalize (GObject *object)
-{
-  GdkDragContext *context = GDK_DRAG_CONTEXT (object);
-  GdkDragContextPrivate *private = GDK_DRAG_CONTEXT_PRIVATE (context);
- 
-  g_free (private);
-  
-  G_OBJECT_CLASS (parent_class)->finalize (object);
-}
-
-static void
-gdk_drag_context_init (GdkDragContext *dragcontext)
-{
-  GdkDragContextPrivate *priv = g_new0 (GdkDragContextPrivate, 1);
-
-  dragcontext->windowing_data = priv;
-}
-
-static void
-gdk_drag_context_class_init (GdkDragContextClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  
-  parent_class = g_type_class_peek_parent (klass);
-
-  object_class->finalize = gdk_drag_context_finalize;
-}
-
-GType
-gdk_drag_context_get_type (void)
-{
-  static GType object_type = 0;
-
-  if (!object_type)
-    {
-      const GTypeInfo object_info =
-      {
-        sizeof (GdkDragContextClass),
-        (GBaseInitFunc) NULL,
-        (GBaseFinalizeFunc) NULL,
-        (GClassInitFunc) gdk_drag_context_class_init,
-        NULL,           /* class_finalize */
-        NULL,           /* class_data */
-        sizeof (GdkDragContext),
-        0,              /* n_preallocs */
-        (GInstanceInitFunc) gdk_drag_context_init,
-      };
-      
-      object_type = g_type_register_static (G_TYPE_OBJECT,
-                                            "GdkDragContext",
-                                            &object_info,
-					    0);
-    }
-  
-  return object_type;
-}
-
-GdkDragContext *
-gdk_drag_context_new (void)
-{
-  return (GdkDragContext *)g_object_new (gdk_drag_context_get_type (), NULL);
-}
 
 GdkDragContext *_gdk_quartz_drag_source_context = NULL;
 
@@ -95,117 +33,114 @@ gdk_quartz_drag_source_context ()
   return _gdk_quartz_drag_source_context;
 }
 
-GdkDragContext * 
-gdk_drag_begin (GdkWindow     *window,
-		GList         *targets)
+GdkDragContext *
+_gdk_quartz_window_drag_begin (GdkWindow *window,
+                               GdkDevice *device,
+                               GList     *targets)
 {
-  GdkDeviceManager *device_manager;
+  GdkDragContext *context;
 
   g_assert (_gdk_quartz_drag_source_context == NULL);
-  
+
   /* Create fake context */
-  _gdk_quartz_drag_source_context = gdk_drag_context_new ();
+  _gdk_quartz_drag_source_context = g_object_new (GDK_TYPE_QUARTZ_DRAG_CONTEXT,
+                                                  NULL);
   _gdk_quartz_drag_source_context->is_source = TRUE;
 
-  device_manager = gdk_display_get_device_manager (gdk_display_get_default ());
-  gdk_drag_context_set_device (_gdk_quartz_drag_source_context,
-                               gdk_device_manager_get_client_pointer (device_manager));
+  gdk_drag_context_set_device (context, device);
 
-  return _gdk_quartz_drag_source_context;
+  return context;
 }
 
-gboolean        
-gdk_drag_motion (GdkDragContext *context,
-		 GdkWindow      *dest_window,
-		 GdkDragProtocol protocol,
-		 gint            x_root, 
-		 gint            y_root,
-		 GdkDragAction   suggested_action,
-		 GdkDragAction   possible_actions,
-		 guint32         time)
+static gboolean
+gdk_quartz_drag_context_drag_motion (GdkDragContext  *context,
+                                     GdkWindow       *dest_window,
+                                     GdkDragProtocol  protocol,
+                                     gint             x_root,
+                                     gint             y_root,
+                                     GdkDragAction    suggested_action,
+                                     GdkDragAction    possible_actions,
+                                     guint32          time)
 {
   /* FIXME: Implement */
   return FALSE;
 }
 
-guint32
-gdk_drag_get_protocol_for_display (GdkDisplay      *display,
-				   guint32          xid,
-				   GdkDragProtocol *protocol)
+GdkNativeWindow
+_gdk_quartz_display_get_drag_protocol (GdkDisplay      *display,
+                                       GdkNativeWindow  xid,
+                                       GdkDragProtocol *protocol,
+                                       guint           *version)
 {
   /* FIXME: Implement */
   return 0;
 }
 
-void
-gdk_drag_find_window_for_screen (GdkDragContext  *context,
-				 GdkWindow       *drag_window,
-				 GdkScreen       *screen,
-				 gint             x_root,
-				 gint             y_root,
-				 GdkWindow      **dest_window,
-				 GdkDragProtocol *protocol)
+static GdkWindow *
+gdk_quartz_drag_context_find_window (GdkDragContext  *context,
+                                     GdkWindow       *drag_window,
+                                     GdkScreen       *screen,
+                                     gint             x_root,
+                                     gint             y_root,
+                                     GdkDragProtocol *protocol)
+{
+  /* FIXME: Implement */
+  return NULL;
+}
+
+static void
+gdk_quartz_drag_context_drag_drop (GdkDragContext *context,
+                                   guint32         time)
 {
   /* FIXME: Implement */
 }
 
-void
-gdk_drag_drop (GdkDragContext *context,
-	       guint32         time)
+static void
+gdk_quartz_drag_context_drag_abort (GdkDragContext *context,
+                                    guint32         time)
 {
   /* FIXME: Implement */
 }
 
-void
-gdk_drag_abort (GdkDragContext *context,
-		guint32         time)
-{
-  g_return_if_fail (context != NULL);
-  
-  /* FIXME: Implement */
-}
-
-void             
-gdk_drag_status (GdkDragContext   *context,
-		 GdkDragAction     action,
-		 guint32           time)
+static void
+gdk_quartz_drag_context_drag_status (GdkDragContext *context,
+                                     GdkDragAction   action,
+                                     guint32         time)
 {
   context->action = action;
 }
 
-void 
-gdk_drop_reply (GdkDragContext   *context,
-		gboolean          ok,
-		guint32           time)
-{
-  g_return_if_fail (context != NULL);
-
-  /* FIXME: Implement */
-}
-
-void             
-gdk_drop_finish (GdkDragContext   *context,
-		 gboolean          success,
-		 guint32           time)
+static void
+gdk_quartz_drag_context_drop_reply (GdkDragContext *context,
+                                    gboolean        ok,
+                                    guint32         time)
 {
   /* FIXME: Implement */
 }
 
-void            
-gdk_window_register_dnd (GdkWindow *window)
+static void
+gdk_quartz_drag_context_drop_finish (GdkDragContext *context,
+                                     gboolean        success,
+                                     guint32         time)
 {
   /* FIXME: Implement */
 }
 
-GdkAtom       
-gdk_drag_get_selection (GdkDragContext *context)
+void
+_gdk_quartz_window_register_dnd (GdkWindow *window)
+{
+  /* FIXME: Implement */
+}
+
+static GdkAtom
+gdk_quartz_drag_context_get_selection (GdkDragContext *context)
 {
   /* FIXME: Implement */
   return GDK_NONE;
 }
 
-gboolean 
-gdk_drag_drop_succeeded (GdkDragContext *context)
+static gboolean
+gdk_quartz_drag_context_drop_status (GdkDragContext *context)
 {
   /* FIXME: Implement */
   return FALSE;
@@ -214,5 +149,35 @@ gdk_drag_drop_succeeded (GdkDragContext *context)
 id
 gdk_quartz_drag_context_get_dragging_info_libgtk_only (GdkDragContext *context)
 {
-  return GDK_DRAG_CONTEXT_PRIVATE (context)->dragging_info;
+  return GDK_QUARTZ_DRAG_CONTEXT (context)->dragging_info;
+}
+
+static void
+gdk_quartz_drag_context_init (GdkQuartzDragContext *context)
+{
+}
+
+static void
+gdk_quartz_drag_context_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (gdk_quartz_drag_context_parent_class)->finalize (object);
+}
+
+static void
+gdk_drag_context_class_init (GdkDragContextClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkDragContextClass *context_class = GDK_DRAG_CONTEXT_CLASS (klass);
+
+  object_class->finalize = gdk_quartz_drag_context_finalize;
+
+  context_class->find_window = gdk_quartz_drag_context_find_window;
+  context_class->drag_status = gdk_quartz_drag_context_drag_status;
+  context_class->drag_motion = gdk_quartz_drag_context_drag_motion;
+  context_class->drag_abort = gdk_quartz_drag_context_drag_abort;
+  context_class->drag_drop = gdk_quartz_drag_context_drag_drop;
+  context_class->drop_reply = gdk_quartz_drag_context_drop_reply;
+  context_class->drop_finish = gdk_quartz_drag_context_drop_finish;
+  context_class->drop_status = gdk_quartz_drag_context_drop_status;
+  context_class->get_selection = gdk_quartz_drag_context_get_selection;
 }

gdk/quartz/gdkdnd-quartz.h

@@ -0,0 +1,57 @@
+/* gdkdnd-quartz.h
+ *
+ * Copyright (C) 2010 Kristian Rietveld  <kris@gtk.org>
+ *
+ * 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.
+ */
+
+#ifndef __GDK_QUARTZ_DND_H__
+#define __GDK_QUARTZ_DND_H__
+
+#include <gdk/gdk.h>
+#include <gdk/quartz/gdkquartz.h>
+#include <gdk/gdkdndprivate.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_QUARTZ_DRAG_CONTEXT              (gdk_quartz_drag_context_get_type ())
+#define GDK_QUARTZ_DRAG_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_QUARTZ_DRAG_CONTEXT, GdkQuartzDragContext))
+#define GDK_QUARTZ_DRAG_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_QUARTZ_DRAG_CONTEXT, GdkQuartzDragContextClass))
+#define GDK_IS_QUARTZ_DRAG_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_QUARTZ_DRAG_CONTEXT))
+#define GDK_IS_QUARTZ_DRAG_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_QUARTZ_DRAG_CONTEXT))
+#define GDK_QUARTZ_DRAG_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_QUARTZ_DRAG_CONTEXT, GdkQuartzDragContextClass))
+
+typedef struct _GdkQuartzDragContext GdkQuartzDragContext;
+typedef struct _GdkQuartzDragContextClass GdkQuartzDragContextClass;
+
+struct _GdkQuartzDragContext
+{
+  GdkDragContext context;
+
+  id <NSDraggingInfo> dragging_info;
+  GdkDevice *device;
+};
+
+struct _GdkQuartzDragContextClass
+{
+  GdkDragContextClass context_class;
+};
+
+GType gdk_quartz_drag_context_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GDK_QUARTZ_DRAG_CONTEXT_H__ */

gdk/quartz/gdkeventloop-quartz.c

@@ -664,7 +664,7 @@ gdk_event_dispatch (GSource     *source,
 
   GDK_THREADS_ENTER ();
 
-  _gdk_events_queue (_gdk_display);
+  _gdk_quartz_display_queue_events (_gdk_display);
 
   event = _gdk_event_unqueue (_gdk_display);
 

gdk/quartz/gdkevents-quartz.c

@@ -31,8 +31,9 @@
 
 #include "gdkscreen.h"
 #include "gdkkeysyms.h"
+#include "gdkdisplay-quartz.h"
 #include "gdkprivate-quartz.h"
-#include "gdkdevicemanager-core.h"
+#include "gdkdevicemanager-core-quartz.h"
 
 #define GRIP_WIDTH 15
 #define GRIP_HEIGHT 15
@@ -60,7 +61,7 @@ gdk_quartz_event_get_nsevent (GdkEvent *event)
 }
 
 void
-_gdk_events_init (void)
+_gdk_quartz_events_init (void)
 {
   _gdk_quartz_event_loop_init ();
 
@@ -68,53 +69,10 @@ _gdk_events_init (void)
 }
 
 gboolean
-gdk_events_pending (void)
+_gdk_quartz_display_has_pending (GdkDisplay *display)
 {
-  return (_gdk_event_queue_find_first (_gdk_display) ||
-	  (_gdk_quartz_event_loop_check_pending ()));
-}
-
-void
-gdk_device_ungrab (GdkDevice *device,
-                   guint32    time_)
-{
-  GdkDeviceGrabInfo *grab;
-
-  grab = _gdk_display_get_last_device_grab (_gdk_display, device);
-  if (grab)
-    grab->serial_end = 0;
-
-  _gdk_display_device_grab_update (_gdk_display, device, 0);
-}
-
-GdkGrabStatus
-_gdk_windowing_device_grab (GdkDevice    *device,
-                            GdkWindow    *window,
-                            GdkWindow    *native,
-                            gboolean      owner_events,
-                            GdkEventMask  event_mask,
-                            GdkWindow    *confine_to,
-                            GdkCursor    *cursor,
-                            guint32       time)
-{
-  g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
-  g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
-
-  if (!window || GDK_WINDOW_DESTROYED (window))
-    return GDK_GRAB_NOT_VIEWABLE;
-
-  _gdk_display_add_device_grab (_gdk_display,
-                                device,
-                                window,
-                                native,
-                                GDK_OWNERSHIP_NONE,
-                                owner_events,
-                                event_mask,
-                                0,
-                                time,
-                                FALSE);
-
-  return GDK_GRAB_SUCCESS;
+  return (_gdk_event_queue_find_first (display) ||
+         (_gdk_quartz_event_loop_check_pending ()));
 }
 
 static void
@@ -137,7 +95,7 @@ break_all_grabs (guint32 time)
           grab->implicit_ungrab = TRUE;
         }
 
-      _gdk_display_device_grab_update (_gdk_display, l->data, 0);
+      _gdk_display_device_grab_update (_gdk_display, l->data, NULL, 0);
     }
 
   g_list_free (list);
@@ -354,13 +312,13 @@ create_focus_event (GdkWindow *window,
 		    gboolean   in)
 {
   GdkEvent *event;
-  GdkDeviceManagerCore *device_manager;
+  GdkQuartzDeviceManagerCore *device_manager;
 
   event = gdk_event_new (GDK_FOCUS_CHANGE);
   event->focus_change.window = window;
   event->focus_change.in = in;
 
-  device_manager = GDK_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
+  device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
   gdk_event_set_device (event, device_manager->core_keyboard);
 
   return event;
@@ -421,7 +379,7 @@ _gdk_quartz_events_update_focus_window (GdkWindow *window,
   if (got_focus && window == current_keyboard_window)
     return;
 
-  /* FIXME: Don't do this when grabbed? Or make GdkQuartzWindow
+  /* FIXME: Don't do this when grabbed? Or make GdkQuartzNSWindow
    * disallow it in the first place instead?
    */
   
@@ -942,7 +900,7 @@ fill_key_event (GdkWindow    *window,
                 GdkEventType  type)
 {
   GdkEventPrivate *priv;
-  GdkDeviceManagerCore *device_manager;
+  GdkQuartzDeviceManagerCore *device_manager;
   gchar buf[7];
   gunichar c = 0;
 
@@ -957,7 +915,7 @@ fill_key_event (GdkWindow    *window,
   event->key.group = ([nsevent modifierFlags] & NSAlternateKeyMask) ? 1 : 0;
   event->key.keyval = GDK_KEY_VoidSymbol;
 
-  device_manager = GDK_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
+  device_manager = GDK_QUARTZ_DEVICE_MANAGER_CORE (_gdk_display->device_manager);
   gdk_event_set_device (event, device_manager->core_keyboard);
   
   gdk_keymap_translate_keyboard_state (NULL,
@@ -1182,7 +1140,7 @@ gdk_event_translate (GdkEvent *event,
    * dragged. This is a workaround for the window getting events for
    * the window title.
    */
-  if ([(GdkQuartzWindow *)nswindow isInMove])
+  if ([(GdkQuartzNSWindow *)nswindow isInMove])
     {
       break_all_grabs (get_time_from_ns_event (nsevent));
       return FALSE;
@@ -1339,7 +1297,7 @@ gdk_event_translate (GdkEvent *event,
 }
 
 void
-_gdk_events_queue (GdkDisplay *display)
+_gdk_quartz_display_queue_events (GdkDisplay *display)
 {  
   NSEvent *nsevent;
 
@@ -1379,52 +1337,46 @@ _gdk_events_queue (GdkDisplay *display)
 }
 
 void
-gdk_flush (void)
+_gdk_quartz_display_add_client_message_filter (GdkDisplay   *display,
+                                               GdkAtom       message_type,
+                                               GdkFilterFunc func,
+                                               gpointer      data)
 {
   /* Not supported. */
 }
 
 void
-gdk_display_add_client_message_filter (GdkDisplay   *display,
-				       GdkAtom       message_type,
-				       GdkFilterFunc func,
-				       gpointer      data)
+_gdk_quartz_display_sync (GdkDisplay *display)
 {
   /* Not supported. */
 }
 
 void
-gdk_display_sync (GdkDisplay *display)
-{
-  /* Not supported. */
-}
-
-void
-gdk_display_flush (GdkDisplay *display)
+_gdk_quartz_display_flush (GdkDisplay *display)
 {
   /* Not supported. */
 }
 
 gboolean
-gdk_event_send_client_message_for_display (GdkDisplay      *display,
-					   GdkEvent        *event,
-					   GdkNativeWindow  winid)
+_gdk_quartz_display_send_client_message (GdkDisplay      *display,
+                                         GdkEvent        *event,
+                                         GdkNativeWindow  winid)
 {
   /* Not supported. */
   return FALSE;
 }
 
 void
-gdk_screen_broadcast_client_message (GdkScreen *screen,
-				     GdkEvent  *event)
+_gdk_quartz_screen_broadcast_client_message (GdkScreen *screen,
+                                             GdkEvent  *event)
 {
   /* Not supported. */
 }
 
 gboolean
-gdk_screen_get_setting (GdkScreen   *screen,
-			const gchar *name,
-			GValue      *value)
+_gdk_quartz_screen_get_setting (GdkScreen   *screen,
+                                const gchar *name,
+                                GValue      *value)
 {
   if (strcmp (name, "gtk-double-click-time") == 0)
     {
@@ -1481,8 +1433,9 @@ gdk_screen_get_setting (GdkScreen   *screen,
 }
 
 void
-_gdk_windowing_event_data_copy (const GdkEvent *src,
-                                GdkEvent       *dst)
+_gdk_quartz_display_event_data_copy (GdkDisplay     *display,
+                                     const GdkEvent *src,
+                                     GdkEvent       *dst)
 {
   GdkEventPrivate *priv_src = (GdkEventPrivate *) src;
   GdkEventPrivate *priv_dst = (GdkEventPrivate *) dst;
@@ -1495,7 +1448,8 @@ _gdk_windowing_event_data_copy (const GdkEvent *src,
 }
 
 void
-_gdk_windowing_event_data_free (GdkEvent *event)
+_gdk_quartz_display_event_data_free (GdkDisplay *display,
+                                     GdkEvent   *event)
 {
   GdkEventPrivate *priv = (GdkEventPrivate *) event;
 

gdk/quartz/gdkim-quartz.c

@@ -1,41 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- *
- * 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.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
- * file for a list of people on the GTK+ Team.  See the ChangeLog
- * files for a list of changes.  These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
- */
-
-#include "config.h"
-
-#include <locale.h>
-
-#include "gdkinternals.h"
-#include "gdkprivate-quartz.h"
-
-gchar*
-gdk_set_locale (void)
-{
-  if (!setlocale (LC_ALL,""))
-    g_warning ("locale not supported by C library");
-  
-  return setlocale (LC_ALL, NULL);
-}

gdk/quartz/gdkinput-old.c

@@ -1,68 +0,0 @@
-/* gdkinput.c
- *
- * Copyright (C) 2005 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 "gdkinput.h"
-
-GType
-gdk_device_get_type (void)
-{
-  static GType object_type = 0;
-
-  if (!object_type)
-    {
-      const GTypeInfo object_info =
-      {
-        sizeof (GdkDeviceClass),
-        (GBaseInitFunc) NULL,
-        (GBaseFinalizeFunc) NULL,
-        (GClassInitFunc) NULL,
-        NULL,           /* class_finalize */
-        NULL,           /* class_data */
-        sizeof (GdkDevicePrivate),
-        0,              /* n_preallocs */
-        (GInstanceInitFunc) NULL,
-      };
-      
-      object_type = g_type_register_static (G_TYPE_OBJECT,
-                                            "GdkDevice",
-                                            &object_info, 0);
-    }
-  
-  return object_type;
-}
-
-void
-gdk_device_set_key (GdkDevice      *device,
-		    guint           index,
-		    guint           keyval,
-		    GdkModifierType modifiers)
-{
-  /* FIXME: Implement */
-}
-
-gboolean
-gdk_device_get_axis (GdkDevice *device, gdouble *axes, GdkAxisUse use, gdouble *value)
-{
-  /* FIXME: Implement */
-  return FALSE;
-}
-

gdk/quartz/gdkinput.c

@@ -1,285 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- *
- * 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.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
- * file for a list of people on the GTK+ Team.  See the ChangeLog
- * files for a list of changes.  These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
- */
-
-#include "config.h"
-#include <stdlib.h>
-
-#include "gdkprivate-quartz.h"
-#include "gdkinput.h"
-#include "gdkprivate.h"
-#include "gdkinputprivate.h"
-#include <gdkdevice.h>
-#include <gdkdeviceprivate.h>
-
-/* Addition used for extension_events mask */
-#define GDK_ALL_DEVICES_MASK (1<<30)
-
-GdkDevice *_gdk_core_pointer = NULL;
-
-/* Global variables  */
-
-gchar            *_gdk_input_gxid_host;
-gint              _gdk_input_gxid_port;
-gint              _gdk_input_ignore_core;
-GList            *_gdk_input_windows;
-GList            *_gdk_input_devices;
-
-
-GList *
-gdk_devices_list (void)
-{
-  return _gdk_input_devices;
-}
-
-GList *
-gdk_display_list_devices (GdkDisplay *dpy)
-{
-  return _gdk_input_devices;
-}
-
-static void
-_gdk_input_select_device_events (GdkWindow *impl_window,
-                                 GdkDevice *device)
-{
-  guint event_mask;
-  GdkWindow *w;
-  GdkInputWindow *iw;
-  GdkInputMode mode;
-  gboolean has_cursor;
-  GdkDeviceType type;
-  GList *l;
-
-  event_mask = 0;
-  iw = impl_window->input_window;
-
-  g_object_get (device,
-                "type", &type,
-                "input-mode", &mode,
-                "has-cursor", &has_cursor,
-                NULL);
-
-  if (iw == NULL ||
-      mode == GDK_MODE_DISABLED ||
-      type == GDK_DEVICE_TYPE_MASTER)
-    return;
-
-  for (l = _gdk_input_windows; l != NULL; l = l->next)
-    {
-      w = l->data;
-
-      if (has_cursor || (w->extension_events & GDK_ALL_DEVICES_MASK))
-        {
-          event_mask = w->extension_events;
-
-          if (event_mask)
-            event_mask |= GDK_PROXIMITY_OUT_MASK
-                | GDK_BUTTON_PRESS_MASK
-                | GDK_BUTTON_RELEASE_MASK;
-
-          gdk_window_set_device_events ((GdkWindow *) w, device, event_mask);
-        }
-    }
-}
-
-gint
-_gdk_input_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
-{
-  return TRUE;
-}
-
-gint
-_gdk_input_disable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
-{
-  return TRUE;
-}
-
-
-GdkInputWindow *
-_gdk_input_window_find(GdkWindow *window)
-{
-  GList *tmp_list;
-
-  for (tmp_list=_gdk_input_windows; tmp_list; tmp_list=tmp_list->next)
-    if (((GdkInputWindow *)(tmp_list->data))->window == window)
-      return (GdkInputWindow *)(tmp_list->data);
-
-  return NULL;      /* Not found */
-}
-
-/* FIXME: this routine currently needs to be called between creation
-   and the corresponding configure event (because it doesn't get the
-   root_relative_geometry).  This should work with
-   gtk_window_set_extension_events, but will likely fail in other
-   cases */
-
-void
-gdk_input_set_extension_events (GdkWindow        *window,
-                                gint              mask,
-                                GdkExtensionMode  mode)
-{
-  GList *tmp_list;
-  GdkInputWindow *iw;
-  GdkWindow *impl_window;
-
-  g_return_if_fail (window != NULL);
-  g_return_if_fail (GDK_WINDOW_IS_QUARTZ (window));
-
-  impl_window = (GdkWindow *)_gdk_window_get_impl_window (window);
-
-  if (mode == GDK_EXTENSION_EVENTS_NONE)
-    mask = 0;
-
-  if (mask != 0)
-    {
-      iw = g_new (GdkInputWindow, 1);
-
-      iw->window = window;
-      iw->mode = mode;
-
-      iw->obscuring = NULL;
-      iw->num_obscuring = 0;
-      iw->grabbed = FALSE;
-
-      _gdk_input_windows = g_list_append (_gdk_input_windows, iw);
-      window->extension_events = mask;
-
-      /* Add enter window events to the event mask */
-      /* FIXME, this is not needed for XINPUT_NONE */
-      gdk_window_set_events (window,
-                             gdk_window_get_events (window) | 
-                             GDK_ENTER_NOTIFY_MASK);
-    }
-  else
-    {
-      iw = _gdk_input_window_find (window);
-      if (iw)
-        {
-          _gdk_input_windows = g_list_remove (_gdk_input_windows,iw);
-          g_free (iw);
-        }
-
-      window->extension_events = 0;
-    }
-
-  for (tmp_list = _gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
-    {
-      GdkDevice *dev = tmp_list->data;
-
-      _gdk_input_select_device_events (GDK_WINDOW (impl_window), dev);
-    }
-}
-
-void
-_gdk_input_window_destroy (GdkWindow *window)
-{
-  GdkInputWindow *input_window;
-
-  input_window = _gdk_input_window_find (window);
-  g_return_if_fail (input_window != NULL);
-
-  _gdk_input_windows = g_list_remove (_gdk_input_windows,input_window);
-  g_free (input_window);
-}
-
-void
-_gdk_input_check_extension_events (GdkDevice *device)
-{
-}
-
-void
-_gdk_input_init (void)
-{
-  GdkDeviceManager *device_manager;
-  GList *list, *l;
-
-  device_manager = gdk_display_get_device_manager (_gdk_display);
-
-  /* For backward compatibility, just add floating devices that are
-   * not keyboards.
-   */
-  list = gdk_device_manager_list_devices (device_manager,
-                                          GDK_DEVICE_TYPE_FLOATING);
-  for (l = list; l; l = l->next)
-    {
-      GdkDevice *device = l->data;
-
-      if (gdk_device_get_source(device) == GDK_SOURCE_KEYBOARD)
-        continue;
-
-      _gdk_input_devices = g_list_prepend (_gdk_input_devices, l->data);
-    }
-
-  g_list_free (list);
-
-  /* Now set "core" pointer to the first master device that is a pointer.
-   */
-  list = gdk_device_manager_list_devices (device_manager,
-                                          GDK_DEVICE_TYPE_MASTER);
-
-  for (l = list; l; l = l->next)
-    {
-      GdkDevice *device = list->data;
-
-      if (gdk_device_get_source(device) != GDK_SOURCE_MOUSE)
-        continue;
-
-      _gdk_display->core_pointer = device;
-      break;
-    }
-
-  g_list_free (list);
-
-  /* Add the core pointer to the devices list */
-  _gdk_input_devices = g_list_prepend (_gdk_input_devices,
-                                       _gdk_display->core_pointer);
-
-  _gdk_input_ignore_core = FALSE;
-}
-
-void
-_gdk_input_exit (void)
-{
-  GList *tmp_list;
-  GdkDevicePrivate *gdkdev;
-
-  for (tmp_list = _gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
-    {
-      gdkdev = (GdkDevicePrivate *)(tmp_list->data);
-      if (gdkdev != (GdkDevicePrivate *)_gdk_core_pointer)
-	{
-	  gdk_device_set_mode ((GdkDevice *)gdkdev, GDK_MODE_DISABLED);
-	  g_object_unref(gdkdev);
-	}
-    }
-
-  g_list_free (_gdk_input_devices);
-
-  for (tmp_list = _gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
-    {
-      g_free (tmp_list->data);
-    }
-  g_list_free (_gdk_input_windows);
-}

gdk/quartz/gdkinputprivate.h

@@ -1,149 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- *
- * 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.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
- * file for a list of people on the GTK+ Team.  See the ChangeLog
- * files for a list of changes.  These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
- */
-
-#ifndef __GDK_INPUTPRIVATE_H__
-#define __GDK_INPUTPRIVATE_H__
-
-#include "config.h"
-#include "gdkinput.h"
-#include "gdkevents.h"
-#include "gdkquartz.h"
-
-typedef struct _GdkAxisInfo    GdkAxisInfo;
-typedef struct _GdkInputVTable GdkInputVTable;
-
-struct _GdkInputVTable {
-  gint (*set_mode) (guint32 deviceid, GdkInputMode mode);
-  void (*set_axes) (guint32 deviceid, GdkAxisUse *axes);
-  void (*set_key)  (guint32 deviceid,
-		    guint   index,
-		    guint   keyval,
-		    GdkModifierType modifiers);
-	
-  GdkTimeCoord* (*motion_events) (GdkWindow *window,
-				  guint32 deviceid,
-				  guint32 start,
-				  guint32 stop,
-				  gint *nevents_return);
-  void (*get_pointer)   (GdkWindow       *window,
-			 guint32	  deviceid,
-			 gdouble         *x,
-			 gdouble         *y,
-			 gdouble         *pressure,
-			 gdouble         *xtilt,
-			 gdouble         *ytilt,
-			 GdkModifierType *mask);
-  gint (*grab_pointer) (GdkWindow *     window,
-			gint            owner_events,
-			GdkEventMask    event_mask,
-			GdkWindow *     confine_to,
-			guint32         time);
-  void (*ungrab_pointer) (guint32 time);
-
-  void (*configure_event) (GdkEventConfigure *event, GdkWindow *window);
-  void (*enter_event) (GdkEventCrossing *event, GdkWindow *window);
-  gint (*other_event) (GdkEvent *event, GdkWindow *window);
-  /* Handle an unidentified event. Returns TRUE if handled, FALSE
-     otherwise */
-  gint (*window_none_event) (GdkEvent *event);
-  gint (*enable_window) (GdkWindow *window, GdkDevicePrivate *gdkdev);
-  gint (*disable_window) (GdkWindow *window, GdkDevicePrivate *gdkdev);
-};
-
-/* information about a device axis */
-struct _GdkAxisInfo
-{
-  /* reported x resolution */
-  gint xresolution;
-
-  /* reported x minimum/maximum values */
-  gint xmin_value, xmax_value;
-
-  /* calibrated resolution (for aspect ration) - only relative values
-     between axes used */
-  gint resolution;
-  
-  /* calibrated minimum/maximum values */
-  gint min_value, max_value;
-};
-
-#define GDK_INPUT_NUM_EVENTC 6
-
-struct _GdkDevicePrivate {
-  GdkDevice  info;
-};
-
-struct _GdkInputWindow
-{
-  /* gdk window */
-  GdkWindow *window;
-
-  /* Extension mode (GDK_EXTENSION_EVENTS_ALL/CURSOR) */
-  GdkExtensionMode mode;
-
-  /* position relative to root window */
-  gint root_x;
-  gint root_y;
-
-  /* rectangles relative to window of windows obscuring this one */
-  GdkRectangle *obscuring;
-  gint num_obscuring;
-
-  /* Is there a pointer grab for this window ? */
-  gint grabbed;
-};
-
-/* Global data */
-
-extern const GdkDevice gdk_input_core_info;
-extern GdkDevice *_gdk_core_pointer;
-extern GList *_gdk_input_devices;
-extern GList *_gdk_input_windows;
-
-extern GdkInputVTable gdk_input_vtable;
-/* information about network port and host for gxid daemon */
-extern gchar           *_gdk_input_gxid_host;
-extern gint             _gdk_input_gxid_port;
-extern gint             _gdk_input_ignore_core;
-
-/* Function declarations */
-
-GdkInputWindow *   _gdk_input_window_find    (GdkWindow        *window);
-void               _gdk_input_window_destroy (GdkWindow        *window);
-void               _gdk_input_init           (void);
-void               _gdk_input_exit           (void);
-gint               _gdk_input_enable_window  (GdkWindow        *window,
-					      GdkDevicePrivate *gdkdev);
-gint               _gdk_input_disable_window (GdkWindow        *window,
-					      GdkDevicePrivate *gdkdev);
-void               _gdk_init_input_core      (void);
-
-void               _gdk_input_window_crossing (GdkWindow       *window,
-                                               gboolean         enter);
-
-void _gdk_input_exit           (void);
-
-#endif /* __GDK_INPUTPRIVATE_H__ */

gdk/quartz/gdkkeys-quartz.c

@@ -54,6 +54,7 @@
 #include <Carbon/Carbon.h>
 #include <AppKit/NSEvent.h>
 #include "gdk.h"
+#include "gdkkeysprivate.h"
 #include "gdkkeysyms.h"
 
 #define NUM_KEYCODES 128
@@ -61,6 +62,38 @@
 
 static GdkKeymap *default_keymap = NULL;
 
+
+#define GDK_TYPE_QUARTZ_KEYMAP              (gdk_quartz_keymap_get_type ())
+#define GDK_QUARTZ_KEYMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_QUARTZ_KEYMAP, GdkQuartzKeymap))
+#define GDK_QUARTZ_KEYMAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_QUARTZ_KEYMAP, GdkQuartzKeymapClass))
+#define GDK_IS_QUARTZ_KEYMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_QUARTZ_KEYMAP))
+#define GDK_IS_QUARTZ_KEYMAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_QUARTZ_KEYMAP))
+#define GDK_QUARTZ_KEYMAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_QUARTZ_KEYMAP, GdkQuartzKeymapClass))
+
+typedef struct _GdkQuartzKeymap GdkQuartzKeymap;
+typedef struct _GdkQuartzKeymapClass GdkQuartzKeymapClass;
+
+struct _GdkQuartzKeymap
+{
+  GdkKeymap keymap;
+};
+
+struct _GdkQuartzKeymapClass
+{
+  GdkKeymapClass keymap_class;
+};
+
+G_DEFINE_TYPE (GdkQuartzKeymap, _gdk_quartz_keymap, GDK_TYPE_KEYMAP)
+
+GdkKeymap *
+_gdk_quartz_display_get_keymap (GdkDisplay *display)
+{
+  if (default_keymap == NULL)
+    default_keymap = g_object_new (_gdk_quartz_keymap_get_type (), NULL);
+
+  return default_keymap;
+}
+
 /* Note: we could check only if building against the 10.5 SDK instead, but
  * that would make non-xml layouts not work in 32-bit which would be a quite
  * bad regression. This way, old unsupported layouts will just not work in
@@ -420,58 +453,42 @@ maybe_update_keymap (void)
     }
 }
 
-GdkKeymap *
-gdk_keymap_get_for_display (GdkDisplay *display)
-{
-  g_return_val_if_fail (display == gdk_display_get_default (), NULL);
-
-  if (default_keymap == NULL)
-    default_keymap = g_object_new (gdk_keymap_get_type (), NULL);
-
-  return default_keymap;
-}
-
-PangoDirection
-gdk_keymap_get_direction (GdkKeymap *keymap)
+static PangoDirection
+gdk_quartz_keymap_get_direction (GdkKeymap *keymap)
 {
   return PANGO_DIRECTION_NEUTRAL;
 }
 
-gboolean
-gdk_keymap_have_bidi_layouts (GdkKeymap *keymap)
+static gboolean
+gdk_quartz_keymap_have_bidi_layouts (GdkKeymap *keymap)
 {
   /* FIXME: Can we implement this? */
   return FALSE;
 }
 
-gboolean
-gdk_keymap_get_caps_lock_state (GdkKeymap *keymap)
+static gboolean
+gdk_quartz_keymap_get_caps_lock_state (GdkKeymap *keymap)
 {
   /* FIXME: Implement this. */
   return FALSE;
 }
 
-gboolean
-gdk_keymap_get_num_lock_state (GdkKeymap *keymap)
+static gboolean
+gdk_quartz_keymap_get_num_lock_state (GdkKeymap *keymap)
 {
   /* FIXME: Implement this. */
   return FALSE;
 }
 
-gboolean
-gdk_keymap_get_entries_for_keyval (GdkKeymap     *keymap,
-                                   guint          keyval,
-                                   GdkKeymapKey **keys,
-                                   gint          *n_keys)
+static gboolean
+gdk_quartz_keymap_get_entries_for_keyval (GdkKeymap     *keymap,
+                                          guint          keyval,
+                                          GdkKeymapKey **keys,
+                                          gint          *n_keys)
 {
   GArray *keys_array;
   int i;
 
-  g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);
-  g_return_val_if_fail (keys != NULL, FALSE);
-  g_return_val_if_fail (n_keys != NULL, FALSE);
-  g_return_val_if_fail (keyval != 0, FALSE);
-
   maybe_update_keymap ();
 
   *n_keys = 0;
@@ -498,20 +515,17 @@ gdk_keymap_get_entries_for_keyval (GdkKeymap     *keymap,
   return *n_keys > 0;;
 }
 
-gboolean
-gdk_keymap_get_entries_for_keycode (GdkKeymap     *keymap,
-                                    guint          hardware_keycode,
-                                    GdkKeymapKey **keys,
-                                    guint        **keyvals,
-                                    gint          *n_entries)
+static gboolean
+gdk_quartz_keymap_get_entries_for_keycode (GdkKeymap     *keymap,
+                                           guint          hardware_keycode,
+                                           GdkKeymapKey **keys,
+                                           guint        **keyvals,
+                                           gint          *n_entries)
 {
   GArray *keys_array, *keyvals_array;
   int i;
   guint *p;
 
-  g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);
-  g_return_val_if_fail (n_entries != NULL, FALSE);
-
   maybe_update_keymap ();
 
   *n_entries = 0;
@@ -562,14 +576,10 @@ gdk_keymap_get_entries_for_keycode (GdkKeymap     *keymap,
   return *n_entries > 0;
 }
 
-guint
-gdk_keymap_lookup_key (GdkKeymap          *keymap,
-                       const GdkKeymapKey *key)
+static guint
+gdk_quartz_keymap_lookup_key (GdkKeymap          *keymap,
+                              const GdkKeymapKey *key)
 {
-  g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), 0);
-  g_return_val_if_fail (key != NULL, 0);
-  g_return_val_if_fail (key->group < 4, 0);
-
   /* FIXME: Implement */
 
   return 0;
@@ -609,23 +619,20 @@ translate_keysym (guint           hardware_keycode,
   return tmp_keyval;
 }
 
-gboolean
-gdk_keymap_translate_keyboard_state (GdkKeymap       *keymap,
-                                     guint            hardware_keycode,
-                                     GdkModifierType  state,
-                                     gint             group,
-                                     guint           *keyval,
-                                     gint            *effective_group,
-                                     gint            *level,
-                                     GdkModifierType *consumed_modifiers)
+static gboolean
+gdk_quartz_keymap_translate_keyboard_state (GdkKeymap       *keymap,
+                                            guint            hardware_keycode,
+                                            GdkModifierType  state,
+                                            gint             group,
+                                            guint           *keyval,
+                                            gint            *effective_group,
+                                            gint            *level,
+                                            GdkModifierType *consumed_modifiers)
 {
   guint tmp_keyval;
   GdkModifierType bit;
   guint tmp_modifiers = 0;
 
-  g_return_val_if_fail (keymap == NULL || GDK_IS_KEYMAP (keymap), FALSE);
-  g_return_val_if_fail (group >= 0 && group <= 1, FALSE);
-  
   maybe_update_keymap ();
 
   if (keyval)
@@ -659,16 +666,16 @@ gdk_keymap_translate_keyboard_state (GdkKeymap       *keymap,
   return TRUE;
 }
 
-void
-gdk_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
-                                  GdkModifierType *state)
+static void
+gdk_quartz_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
+                                         GdkModifierType *state)
 {
   /* FIXME: For now, we've mimiced the Windows backend. */
 }
 
-gboolean
-gdk_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
-                                  GdkModifierType *state)
+static gboolean
+gdk_quartz_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
+                                         GdkModifierType *state)
 {
   /* FIXME: For now, we've mimiced the Windows backend. */
   return TRUE;
@@ -733,3 +740,34 @@ _gdk_quartz_keys_is_modifier (guint keycode)
 
   return FALSE;
 }
+
+static void
+_gdk_quartz_keymap_init (GdkQuartzKeymap *keymap)
+{
+}
+
+static void
+_gdk_quartz_keymap_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (_gdk_quartz_keymap_parent_class)->finalize (object);
+}
+
+static void
+_gdk_quartz_keymap_class_init (GdkQuartzKeymapClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkKeymapClass *keymap_class = GDK_KEYMAP_CLASS (klass);
+
+  object_class->finalize = _gdk_quartz_keymap_finalize;
+
+  keymap_class->get_direction = gdk_quartz_keymap_get_direction;
+  keymap_class->have_bidi_layouts = gdk_quartz_keymap_have_bidi_layouts;
+  keymap_class->get_caps_lock_state = gdk_quartz_keymap_get_caps_lock_state;
+  keymap_class->get_num_lock_state = gdk_quartz_keymap_get_num_lock_state;
+  keymap_class->get_entries_for_keyval = gdk_quartz_keymap_get_entries_for_keyval;
+  keymap_class->get_entries_for_keycode = gdk_quartz_keymap_get_entries_for_keycode;
+  keymap_class->lookup_key = gdk_quartz_keymap_lookup_key;
+  keymap_class->translate_keyboard_state = gdk_quartz_keymap_translate_keyboard_state;
+  keymap_class->add_virtual_modifiers = gdk_quartz_keymap_add_virtual_modifiers;
+  keymap_class->map_virtual_modifiers = gdk_quartz_keymap_map_virtual_modifiers;
+}

gdk/quartz/gdkmain-quartz.c

@@ -19,10 +19,8 @@
  */
 
 #include "config.h"
-#include <dlfcn.h>
 
 #include "gdk.h"
-#include <ApplicationServices/ApplicationServices.h>
 
 const GOptionEntry _gdk_windowing_args[] = {
   { NULL }
@@ -31,51 +29,18 @@ const GOptionEntry _gdk_windowing_args[] = {
 void
 _gdk_windowing_init (void)
 {
-  ProcessSerialNumber psn = { 0, kCurrentProcess };
-  void (*_gtk_quartz_framework_init_ptr) (void);
-
-  /* Make the current process a foreground application, i.e. an app
-   * with a user interface, in case we're not running from a .app bundle
-   */
-  TransformProcessType (&psn, kProcessTransformToForegroundApplication);
-
-  /* Initialize GTK+ framework if there is one. */
-  _gtk_quartz_framework_init_ptr = dlsym (RTLD_DEFAULT, "_gtk_quartz_framework_init");
-  if (_gtk_quartz_framework_init_ptr)
-    _gtk_quartz_framework_init_ptr ();
 }
 
 void
-gdk_error_trap_push (void)
-{
-}
-
-gint
-gdk_error_trap_pop (void)
-{
-  return 0;
-}
-
-void
-gdk_error_trap_pop_ignored (void)
-{
-}
-
-void
-gdk_notify_startup_complete (void)
+_gdk_quartz_display_notify_startup_complete (GdkDisplay  *display,
+                                             const gchar *startup_id)
 {
   /* FIXME: Implement? */
 }
 
 void
-gdk_notify_startup_complete_with_id (const gchar* startup_id)
-{
-  /* FIXME: Implement? */
-}
-
-void          
-gdk_window_set_startup_id (GdkWindow   *window,
-			   const gchar *startup_id)
+_gdk_quartz_window_set_startup_id (GdkWindow   *window,
+                                   const gchar *startup_id)
 {
   /* FIXME: Implement? */
 }

gdk/quartz/gdkprivate-quartz.h

@@ -26,6 +26,7 @@
 
 #include <gdk/gdkprivate.h>
 #include <gdk/quartz/gdkwindow-quartz.h>
+#include <gdk/quartz/gdkdnd-quartz.h>
 #include <gdk/quartz/gdkquartz.h>
 
 #include <gdk/gdk.h>
@@ -34,28 +35,6 @@
 
 #include "config.h"
 
-#define GDK_DRAG_CONTEXT_PRIVATE(context) ((GdkDragContextPrivate *) GDK_DRAG_CONTEXT (context)->windowing_data)
-
-typedef struct _GdkCursorPrivate GdkCursorPrivate;
-typedef struct _GdkDragContextPrivate GdkDragContextPrivate;
-
-struct _GdkVisualClass
-{
-  GObjectClass parent_class;
-};
-
-struct _GdkCursorPrivate
-{
-  GdkCursor cursor;
-  NSCursor *nscursor;
-};
-
-struct _GdkDragContextPrivate
-{
-  id <NSDraggingInfo> dragging_info;
-  GdkDevice *device;
-};
-
 extern GdkDisplay *_gdk_display;
 extern GdkScreen *_gdk_screen;
 extern GdkWindow *_gdk_root;
@@ -67,9 +46,8 @@ extern GdkDragContext *_gdk_quartz_drag_source_context;
 /* Initialization */
 void _gdk_windowing_update_window_sizes     (GdkScreen *screen);
 void _gdk_windowing_window_init             (void);
-void _gdk_events_init                       (void);
-void _gdk_visual_init                       (void);
-void _gdk_input_init                        (void);
+void _gdk_quartz_events_init                (void);
+void _gdk_quartz_input_init                 (void);
 void _gdk_quartz_event_loop_init            (void);
 
 /* GC */
@@ -141,4 +119,177 @@ void        _gdk_quartz_window_translate   (GdkWindow       *window,
 gboolean    _gdk_quartz_window_queue_antiexpose  (GdkWindow *window,
                                                   cairo_region_t *area);
 
+void        _gdk_quartz_window_set_startup_id    (GdkWindow   *window,
+                                                  const gchar *startup_id);
+void        _gdk_quartz_window_register_dnd      (GdkWindow   *window);
+GdkDragContext * _gdk_quartz_window_drag_begin   (GdkWindow   *window,
+                                                  GdkDevice   *device,
+                                                  GList       *targets);
+
+
+void     _gdk_quartz_display_sync         (GdkDisplay *display);
+void     _gdk_quartz_display_flush        (GdkDisplay *display);
+void     _gdk_quartz_display_queue_events (GdkDisplay *display);
+gboolean _gdk_quartz_display_has_pending  (GdkDisplay *display);
+
+GdkCursor *_gdk_quartz_display_get_cursor_for_type     (GdkDisplay    *display,
+                                                        GdkCursorType  type);
+GdkCursor *_gdk_quartz_display_get_cursor_for_name     (GdkDisplay    *display,
+                                                        const gchar   *name);
+GdkCursor *_gdk_quartz_display_get_cursor_for_pixbuf   (GdkDisplay    *display,
+                                                        GdkPixbuf     *pixbuf,
+                                                        gint           x,
+                                                        gint           y);
+gboolean   _gdk_quartz_display_supports_cursor_alpha   (GdkDisplay    *display);
+gboolean   _gdk_quartz_display_supports_cursor_color   (GdkDisplay    *display);
+void       _gdk_quartz_display_get_default_cursor_size (GdkDisplay *display,
+                                                        guint      *width,
+                                                        guint      *height);
+void       _gdk_quartz_display_get_maximal_cursor_size (GdkDisplay *display,
+                                                        guint      *width,
+                                                        guint      *height);
+void       _gdk_quartz_display_before_process_all_updates (GdkDisplay *display);
+void       _gdk_quartz_display_after_process_all_updates  (GdkDisplay *display);
+void       _gdk_quartz_display_notify_startup_complete    (GdkDisplay *display,
+                                                           const gchar *id);
+void       _gdk_quartz_display_event_data_copy (GdkDisplay     *display,
+                                                const GdkEvent *src,
+                                                GdkEvent       *dst);
+void       _gdk_quartz_display_event_data_free (GdkDisplay     *display,
+                                                GdkEvent       *event);
+void       _gdk_quartz_display_create_window_impl (GdkDisplay    *display,
+                                                   GdkWindow     *window,
+                                                   GdkWindow     *real_parent,
+                                                   GdkScreen     *screen,
+                                                   GdkEventMask   event_mask,
+                                                   GdkWindowAttr *attributes,
+                                                   gint           attributes_mask);
+GdkKeymap * _gdk_quartz_display_get_keymap (GdkDisplay *display);
+
+
+GdkDisplay *    _gdk_quartz_display_open (const gchar *name);
+
+GdkNativeWindow _gdk_quartz_display_get_drag_protocol     (GdkDisplay      *display,
+                                                           GdkNativeWindow  xid,
+                                                           GdkDragProtocol *protocol,
+                                                           guint           *version);
+
+
+gboolean    _gdk_quartz_display_send_client_message       (GdkDisplay      *display,
+                                                           GdkEvent        *event,
+                                                           GdkNativeWindow  winid);
+void        _gdk_quartz_display_add_client_message_filter (GdkDisplay      *display,
+                                                           GdkAtom          message_type,
+                                                           GdkFilterFunc    func,
+                                                           gpointer         data);
+
+GdkVisual *   _gdk_quartz_screen_get_rgba_visual            (GdkScreen      *screen);
+GdkVisual *   _gdk_quartz_screen_get_system_visual          (GdkScreen      *screen);
+gint          _gdk_quartz_screen_visual_get_best_depth      (GdkScreen      *screen);
+GdkVisualType _gdk_quartz_screen_visual_get_best_type       (GdkScreen      *screen);
+GdkVisual *   _gdk_quartz_screen_get_system_visual          (GdkScreen      *screen);
+GdkVisual*    _gdk_quartz_screen_visual_get_best            (GdkScreen      *screen);
+GdkVisual*    _gdk_quartz_screen_visual_get_best_with_depth (GdkScreen      *screen,
+                                                             gint            depth);
+GdkVisual*    _gdk_quartz_screen_visual_get_best_with_type  (GdkScreen      *screen,
+                                                             GdkVisualType   visual_type);
+GdkVisual*    _gdk_quartz_screen_visual_get_best_with_both  (GdkScreen      *screen,
+                                                             gint            depth,
+                                                             GdkVisualType   visual_type);
+void          _gdk_quartz_screen_query_depths               (GdkScreen      *screen,
+                                                             gint          **depths,
+                                                             gint           *count);
+void          _gdk_quartz_screen_query_visual_types         (GdkScreen      *screen,
+                                                             GdkVisualType **visual_types,
+                                                             gint           *count);
+void          _gdk_quartz_screen_init_visuals               (GdkScreen      *screen);
+GList *       _gdk_quartz_screen_list_visuals               (GdkScreen      *screen);
+
+
+void        _gdk_quartz_screen_broadcast_client_message (GdkScreen   *screen,
+                                                         GdkEvent    *event);
+gboolean    _gdk_quartz_screen_get_setting              (GdkScreen   *screen,
+                                                         const gchar *name,
+                                                         GValue      *value);
+
+GdkScreen  *_gdk_quartz_screen_new                      (void);
+
+GdkAtom _gdk_quartz_display_manager_atom_intern   (GdkDisplayManager *manager,
+                                                   const gchar       *atom_name,
+                                                   gboolean           copy_name);
+gchar * _gdk_quartz_display_manager_get_atom_name (GdkDisplayManager *manager,
+                                                   GdkAtom            atom);
+
+void    _gdk_quartz_display_manager_add_display    (GdkDisplayManager *manager,
+                                                    GdkDisplay        *display);
+void    _gdk_quartz_display_manager_remove_display (GdkDisplayManager *manager,
+                                                    GdkDisplay        *display);
+
+void     _gdk_quartz_window_sync_rendering    (GdkWindow       *window);
+gboolean _gdk_quartz_window_simulate_key      (GdkWindow       *window,
+                                               gint             x,
+                                               gint             y,
+                                               guint            keyval,
+                                               GdkModifierType  modifiers,
+                                               GdkEventType     key_pressrelease);
+gboolean _gdk_quartz_window_simulate_button   (GdkWindow       *window,
+                                               gint             x,
+                                               gint             y,
+                                               guint            button,
+                                               GdkModifierType  modifiers,
+                                               GdkEventType     button_pressrelease);
+
+gboolean _gdk_quartz_window_get_property      (GdkWindow    *window,
+                                               GdkAtom       property,
+                                               GdkAtom       type,
+                                               gulong        offset,
+                                               gulong        length,
+                                               gint          pdelete,
+                                               GdkAtom      *actual_property_type,
+                                               gint         *actual_format_type,
+                                               gint         *actual_length,
+                                               guchar      **data);
+void     _gdk_quartz_window_change_property   (GdkWindow    *window,
+                                               GdkAtom       property,
+                                               GdkAtom       type,
+                                               gint          format,
+                                               GdkPropMode   mode,
+                                               const guchar *data,
+                                               gint          nelements);
+void     _gdk_quartz_window_delete_property   (GdkWindow    *window,
+                                               GdkAtom       property);
+
+gboolean    _gdk_quartz_display_set_selection_owner (GdkDisplay *display,
+                                                     GdkWindow  *owner,
+                                                     GdkAtom     selection,
+                                                     guint32     time,
+                                                     gboolean    send_event);
+GdkWindow * _gdk_quartz_display_get_selection_owner (GdkDisplay *display,
+                                                     GdkAtom     selection);
+void        _gdk_quartz_display_send_selection_notify (GdkDisplay       *display,
+                                                       GdkNativeWindow  requestor,
+                                                       GdkAtom          selection,
+                                                       GdkAtom          target,
+                                                       GdkAtom          property,
+                                                       guint32          time);
+gint        _gdk_quartz_display_get_selection_property (GdkDisplay     *display,
+                                                        GdkWindow      *requestor,
+                                                        guchar        **data,
+                                                        GdkAtom        *ret_type,
+                                                        gint           *ret_format);
+void        _gdk_quartz_display_convert_selection      (GdkDisplay     *display,
+                                                        GdkWindow      *requestor,
+                                                        GdkAtom         selection,
+                                                        GdkAtom         target,
+                                                        guint32         time);
+gint        _gdk_quartz_display_text_property_to_utf8_list (GdkDisplay     *display,
+                                                            GdkAtom         encoding,
+                                                            gint            format,
+                                                            const guchar   *text,
+                                                            gint            length,
+                                                            gchar        ***list);
+gchar *     _gdk_quartz_display_utf8_to_string_target      (GdkDisplay     *displayt,
+                                                            const gchar    *str);
+
+
 #endif /* __GDK_PRIVATE_QUARTZ_H__ */

gdk/quartz/gdkproperty-quartz.c

@@ -151,61 +151,56 @@ intern_atom_internal (const gchar *atom_name, gboolean allocate)
 }
 
 GdkAtom
-gdk_atom_intern (const gchar *atom_name,
-		 gboolean     only_if_exists)
+_gdk_quartz_display_manager_atom_intern (GdkDisplayManager *manager,
+                                         const gchar       *atom_name,
+                                         gboolean           copy_name)
 {
-  return intern_atom_internal (atom_name, TRUE);
+  return intern_atom_internal (atom_name, copy_name);
 }
 
-GdkAtom
-gdk_atom_intern_static_string (const gchar *atom_name)
-{
-  return intern_atom_internal (atom_name, FALSE);
-}
-
-
 gchar *
-gdk_atom_name (GdkAtom atom)
+_gdk_quartz_display_manager_get_atom_name (GdkDisplayManager *manager,
+                                           GdkAtom            atom)
 {
   ensure_atom_tables ();
-    
+
   if (GPOINTER_TO_INT (atom) >= atoms_to_names->len)
     return NULL;
-    
+
   return g_strdup (g_ptr_array_index (atoms_to_names, GPOINTER_TO_INT (atom)));
 }
 
 void
-gdk_property_delete (GdkWindow *window,
-		     GdkAtom    property)
+_gdk_quartz_window_delete_property (GdkWindow *window,
+                                    GdkAtom    property)
 {
   /* FIXME: Implement */
 }
 
 gint
-gdk_property_get (GdkWindow   *window,
-		  GdkAtom      property,
-		  GdkAtom      type,
-		  gulong       offset,
-		  gulong       length,
-		  gint         pdelete,
-		  GdkAtom     *actual_property_type,
-		  gint        *actual_format_type,
-		  gint        *actual_length,
-		  guchar     **data)
+_gdk_quartz_window_get_property (GdkWindow   *window,
+                                 GdkAtom      property,
+                                 GdkAtom      type,
+                                 gulong       offset,
+                                 gulong       length,
+                                 gint         pdelete,
+                                 GdkAtom     *actual_property_type,
+                                 gint        *actual_format_type,
+                                 gint        *actual_length,
+                                 guchar     **data)
 {
   /* FIXME: Implement */
   return 0;
 }
 
 void
-gdk_property_change (GdkWindow   *window,
-		     GdkAtom      property,
-		     GdkAtom      type,
-		     gint         format,
-		     GdkPropMode  mode,
-		     const guchar *data,
-		     gint         nelements)
+_gdk_quartz_window_change_property (GdkWindow   *window,
+                                    GdkAtom      property,
+                                    GdkAtom      type,
+                                    gint         format,
+                                    GdkPropMode  mode,
+                                    const guchar *data,
+                                    gint         nelements)
 {
   /* FIXME: Implement */
 }

gdk/quartz/gdkscreen-quartz.c

@@ -1,7 +1,7 @@
 /* gdkscreen-quartz.c
  *
  * Copyright (C) 2005 Imendio AB
- * Copyright (C) 2009  Kristian Rietveld  <kris@gtk.org>
+ * Copyright (C) 2009,2010  Kristian Rietveld  <kris@gtk.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -48,7 +48,7 @@
  * all monitors in the root window.  Once that size is known, we iterate
  * over the monitors and translate their Cocoa position to a position
  * in the root window of the GdkScreen.  This happens below in the
- * function gdk_screen_quartz_calculate_layout().
+ * function gdk_quartz_screen_calculate_layout().
  *
  * A Cocoa coordinate is always relative to the origin of the monitor
  * coordinate space.  Such coordinates are mapped to their respective
@@ -59,47 +59,38 @@
  * but GDK coordinates can *not*!
  */
 
-static void  gdk_screen_quartz_dispose          (GObject         *object);
-static void  gdk_screen_quartz_finalize         (GObject         *object);
-static void  gdk_screen_quartz_calculate_layout (GdkScreenQuartz *screen);
+static void  gdk_quartz_screen_dispose          (GObject         *object);
+static void  gdk_quartz_screen_finalize         (GObject         *object);
+static void  gdk_quartz_screen_calculate_layout (GdkQuartzScreen *screen);
 
 static void display_reconfiguration_callback (CGDirectDisplayID            display,
                                               CGDisplayChangeSummaryFlags  flags,
                                               void                        *userInfo);
 
-G_DEFINE_TYPE (GdkScreenQuartz, _gdk_screen_quartz, GDK_TYPE_SCREEN);
+G_DEFINE_TYPE (GdkQuartzScreen, _gdk_quartz_screen, GDK_TYPE_SCREEN);
 
 static void
-_gdk_screen_quartz_class_init (GdkScreenQuartzClass *klass)
+_gdk_quartz_screen_init (GdkQuartzScreen *quartz_screen)
 {
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->dispose = gdk_screen_quartz_dispose;
-  object_class->finalize = gdk_screen_quartz_finalize;
-}
-
-static void
-_gdk_screen_quartz_init (GdkScreenQuartz *screen_quartz)
-{
-  GdkScreen *screen = GDK_SCREEN (screen_quartz);
+  GdkScreen *screen = GDK_SCREEN (quartz_screen);
   NSScreen *nsscreen;
 
   nsscreen = [[NSScreen screens] objectAtIndex:0];
   gdk_screen_set_resolution (screen,
                              72.0 * [nsscreen userSpaceScaleFactor]);
 
-  gdk_screen_quartz_calculate_layout (screen_quartz);
+  gdk_quartz_screen_calculate_layout (quartz_screen);
 
   CGDisplayRegisterReconfigurationCallback (display_reconfiguration_callback,
                                             screen);
 
-  screen_quartz->emit_monitors_changed = FALSE;
+  quartz_screen->emit_monitors_changed = FALSE;
 }
 
 static void
-gdk_screen_quartz_dispose (GObject *object)
+gdk_quartz_screen_dispose (GObject *object)
 {
-  GdkScreenQuartz *screen = GDK_SCREEN_QUARTZ (object);
+  GdkQuartzScreen *screen = GDK_QUARTZ_SCREEN (object);
 
   if (screen->screen_changed_id)
     {
@@ -110,11 +101,11 @@ gdk_screen_quartz_dispose (GObject *object)
   CGDisplayRemoveReconfigurationCallback (display_reconfiguration_callback,
                                           screen);
 
-  G_OBJECT_CLASS (_gdk_screen_quartz_parent_class)->dispose (object);
+  G_OBJECT_CLASS (_gdk_quartz_screen_parent_class)->dispose (object);
 }
 
 static void
-gdk_screen_quartz_screen_rects_free (GdkScreenQuartz *screen)
+gdk_quartz_screen_screen_rects_free (GdkQuartzScreen *screen)
 {
   screen->n_screens = 0;
 
@@ -126,16 +117,16 @@ gdk_screen_quartz_screen_rects_free (GdkScreenQuartz *screen)
 }
 
 static void
-gdk_screen_quartz_finalize (GObject *object)
+gdk_quartz_screen_finalize (GObject *object)
 {
-  GdkScreenQuartz *screen = GDK_SCREEN_QUARTZ (object);
+  GdkQuartzScreen *screen = GDK_QUARTZ_SCREEN (object);
 
-  gdk_screen_quartz_screen_rects_free (screen);
+  gdk_quartz_screen_screen_rects_free (screen);
 }
 
 
 static void
-gdk_screen_quartz_calculate_layout (GdkScreenQuartz *screen)
+gdk_quartz_screen_calculate_layout (GdkQuartzScreen *screen)
 {
   NSArray *array;
   int i;
@@ -143,7 +134,7 @@ gdk_screen_quartz_calculate_layout (GdkScreenQuartz *screen)
 
   GDK_QUARTZ_ALLOC_POOL;
 
-  gdk_screen_quartz_screen_rects_free (screen);
+  gdk_quartz_screen_screen_rects_free (screen);
 
   array = [NSScreen screens];
 
@@ -194,14 +185,14 @@ gdk_screen_quartz_calculate_layout (GdkScreenQuartz *screen)
 
 
 static void
-process_display_reconfiguration (GdkScreenQuartz *screen)
+process_display_reconfiguration (GdkQuartzScreen *screen)
 {
   int width, height;
 
   width = gdk_screen_get_width (GDK_SCREEN (screen));
   height = gdk_screen_get_height (GDK_SCREEN (screen));
 
-  gdk_screen_quartz_calculate_layout (GDK_SCREEN_QUARTZ (screen));
+  gdk_quartz_screen_calculate_layout (GDK_QUARTZ_SCREEN (screen));
 
   _gdk_windowing_update_window_sizes (GDK_SCREEN (screen));
 
@@ -219,7 +210,7 @@ process_display_reconfiguration (GdkScreenQuartz *screen)
 static gboolean
 screen_changed_idle (gpointer data)
 {
-  GdkScreenQuartz *screen = data;
+  GdkQuartzScreen *screen = data;
 
   process_display_reconfiguration (data);
 
@@ -233,7 +224,7 @@ display_reconfiguration_callback (CGDirectDisplayID            display,
                                   CGDisplayChangeSummaryFlags  flags,
                                   void                        *userInfo)
 {
-  GdkScreenQuartz *screen = userInfo;
+  GdkQuartzScreen *screen = userInfo;
 
   if (flags & kCGDisplayBeginConfigurationFlag)
     {
@@ -264,33 +255,27 @@ display_reconfiguration_callback (CGDirectDisplayID            display,
 }
 
 GdkScreen *
-_gdk_screen_quartz_new (void)
+_gdk_quartz_screen_new (void)
 {
-  return g_object_new (GDK_TYPE_SCREEN_QUARTZ, NULL);
+  return g_object_new (GDK_TYPE_QUARTZ_SCREEN, NULL);
 }
 
-GdkDisplay *
-gdk_screen_get_display (GdkScreen *screen)
+static GdkDisplay *
+gdk_quartz_screen_get_display (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
-
   return _gdk_display;
 }
 
 
-GdkWindow *
-gdk_screen_get_root_window (GdkScreen *screen)
+static GdkWindow *
+gdk_quartz_screen_get_root_window (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
-
   return _gdk_root;
 }
 
-gint
-gdk_screen_get_number (GdkScreen *screen)
+static gint
+gdk_quartz_screen_get_number (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
   return 0;
 }
 
@@ -304,20 +289,16 @@ _gdk_windowing_substitute_screen_number (const gchar *display_name,
   return g_strdup (display_name);
 }
 
-gint
-gdk_screen_get_width (GdkScreen *screen)
+static gint
+gdk_quartz_screen_get_width (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
-  return GDK_SCREEN_QUARTZ (screen)->width;
+  return GDK_QUARTZ_SCREEN (screen)->width;
 }
 
-gint
-gdk_screen_get_height (GdkScreen *screen)
+static gint
+gdk_quartz_screen_get_height (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
-  return GDK_SCREEN_QUARTZ (screen)->height;
+  return GDK_QUARTZ_SCREEN (screen)->height;
 }
 
 static gint
@@ -352,110 +333,125 @@ get_nsscreen_for_monitor (gint monitor_num)
   return screen;
 }
 
-gint
-gdk_screen_get_width_mm (GdkScreen *screen)
+static gint
+gdk_quartz_screen_get_width_mm (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
   return get_mm_from_pixels (get_nsscreen_for_monitor (0),
-                             GDK_SCREEN_QUARTZ (screen)->width);
+                             GDK_QUARTZ_SCREEN (screen)->width);
 }
 
-gint
-gdk_screen_get_height_mm (GdkScreen *screen)
+static gint
+gdk_quartz_screen_get_height_mm (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
   return get_mm_from_pixels (get_nsscreen_for_monitor (0),
-                             GDK_SCREEN_QUARTZ (screen)->height);
+                             GDK_QUARTZ_SCREEN (screen)->height);
 }
 
-gint
-gdk_screen_get_n_monitors (GdkScreen *screen)
+static gint
+gdk_quartz_screen_get_n_monitors (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
-  return GDK_SCREEN_QUARTZ (screen)->n_screens;
+  return GDK_QUARTZ_SCREEN (screen)->n_screens;
 }
 
-gint
-gdk_screen_get_primary_monitor (GdkScreen *screen)
+static gint
+gdk_quartz_screen_get_primary_monitor (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
   return 0;
 }
 
-gint
-gdk_screen_get_monitor_width_mm	(GdkScreen *screen,
-				 gint       monitor_num)
+static gint
+gdk_quartz_screen_get_monitor_width_mm (GdkScreen *screen,
+                                        gint       monitor_num)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-  g_return_val_if_fail (monitor_num < gdk_screen_get_n_monitors (screen), 0);
-  g_return_val_if_fail (monitor_num >= 0, 0);
-
   return get_mm_from_pixels (get_nsscreen_for_monitor (monitor_num),
-                             GDK_SCREEN_QUARTZ (screen)->screen_rects[monitor_num].width);
+                             GDK_QUARTZ_SCREEN (screen)->screen_rects[monitor_num].width);
 }
 
-gint
-gdk_screen_get_monitor_height_mm (GdkScreen *screen,
-                                  gint       monitor_num)
+static gint
+gdk_quartz_screen_get_monitor_height_mm (GdkScreen *screen,
+                                         gint       monitor_num)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-  g_return_val_if_fail (monitor_num < gdk_screen_get_n_monitors (screen), 0);
-  g_return_val_if_fail (monitor_num >= 0, 0);
-
   return get_mm_from_pixels (get_nsscreen_for_monitor (monitor_num),
-                             GDK_SCREEN_QUARTZ (screen)->screen_rects[monitor_num].height);
+                             GDK_QUARTZ_SCREEN (screen)->screen_rects[monitor_num].height);
 }
 
-gchar *
-gdk_screen_get_monitor_plug_name (GdkScreen *screen,
-				  gint       monitor_num)
+static gchar *
+gdk_quartz_screen_get_monitor_plug_name (GdkScreen *screen,
+                                         gint       monitor_num)
 {
   /* FIXME: Is there some useful name we could use here? */
   return NULL;
 }
 
-void
-gdk_screen_get_monitor_geometry (GdkScreen    *screen, 
-				 gint          monitor_num,
-				 GdkRectangle *dest)
+static void
+gdk_quartz_screen_get_monitor_geometry (GdkScreen    *screen,
+                                        gint          monitor_num,
+                                        GdkRectangle *dest)
 {
-  g_return_if_fail (GDK_IS_SCREEN (screen));
-  g_return_if_fail (monitor_num < gdk_screen_get_n_monitors (screen));
-  g_return_if_fail (monitor_num >= 0);
-
-  *dest = GDK_SCREEN_QUARTZ (screen)->screen_rects[monitor_num];
+  *dest = GDK_QUARTZ_SCREEN (screen)->screen_rects[monitor_num];
 }
 
-gchar *
-gdk_screen_make_display_name (GdkScreen *screen)
+static gchar *
+gdk_quartz_screen_make_display_name (GdkScreen *screen)
 {
   return g_strdup (gdk_display_get_name (_gdk_display));
 }
 
-GdkWindow *
-gdk_screen_get_active_window (GdkScreen *screen)
+static GdkWindow *
+gdk_quartz_screen_get_active_window (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
-
   return NULL;
 }
 
-GList *
-gdk_screen_get_window_stack (GdkScreen *screen)
+static GList *
+gdk_quartz_screen_get_window_stack (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
-
   return NULL;
 }
 
-gboolean
-gdk_screen_is_composited (GdkScreen *screen)
+static gboolean
+gdk_quartz_screen_is_composited (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
-
   return TRUE;
 }
+
+static void
+_gdk_quartz_screen_class_init (GdkQuartzScreenClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkScreenClass *screen_class = GDK_SCREEN_CLASS (klass);
+
+  object_class->dispose = gdk_quartz_screen_dispose;
+  object_class->finalize = gdk_quartz_screen_finalize;
+
+  screen_class->get_display = gdk_quartz_screen_get_display;
+  screen_class->get_width = gdk_quartz_screen_get_width;
+  screen_class->get_height = gdk_quartz_screen_get_height;
+  screen_class->get_width_mm = gdk_quartz_screen_get_width_mm;
+  screen_class->get_height_mm = gdk_quartz_screen_get_height_mm;
+  screen_class->get_number = gdk_quartz_screen_get_number;
+  screen_class->get_root_window = gdk_quartz_screen_get_root_window;
+  screen_class->get_n_monitors = gdk_quartz_screen_get_n_monitors;
+  screen_class->get_primary_monitor = gdk_quartz_screen_get_primary_monitor;
+  screen_class->get_monitor_width_mm = gdk_quartz_screen_get_monitor_width_mm;
+  screen_class->get_monitor_height_mm = gdk_quartz_screen_get_monitor_height_mm;
+  screen_class->get_monitor_plug_name = gdk_quartz_screen_get_monitor_plug_name;
+  screen_class->get_monitor_geometry = gdk_quartz_screen_get_monitor_geometry;
+  screen_class->is_composited = gdk_quartz_screen_is_composited;
+  screen_class->make_display_name = gdk_quartz_screen_make_display_name;
+  screen_class->get_active_window = gdk_quartz_screen_get_active_window;
+  screen_class->get_window_stack = gdk_quartz_screen_get_window_stack;
+  screen_class->broadcast_client_message = _gdk_quartz_screen_broadcast_client_message;
+  screen_class->get_setting = _gdk_quartz_screen_get_setting;
+  screen_class->get_rgba_visual = _gdk_quartz_screen_get_rgba_visual;
+  screen_class->get_system_visual = _gdk_quartz_screen_get_system_visual;
+  screen_class->visual_get_best_depth = _gdk_quartz_screen_visual_get_best_depth;
+  screen_class->visual_get_best_type = _gdk_quartz_screen_visual_get_best_type;
+  screen_class->visual_get_best = _gdk_quartz_screen_visual_get_best;
+  screen_class->visual_get_best_with_depth = _gdk_quartz_screen_visual_get_best_with_depth;
+  screen_class->visual_get_best_with_type = _gdk_quartz_screen_visual_get_best_with_type;
+  screen_class->visual_get_best_with_both = _gdk_quartz_screen_visual_get_best_with_both;
+  screen_class->query_depths = _gdk_quartz_screen_query_depths;
+  screen_class->query_visual_types = _gdk_quartz_screen_query_visual_types;
+  screen_class->list_visuals = _gdk_quartz_screen_list_visuals;
+}

gdk/quartz/gdkscreen-quartz.h

@@ -1,6 +1,6 @@
 /* gdkscreen-quartz.h
  *
- * Copyright (C) 2009  Kristian Rietveld  <kris@gtk.org>
+ * Copyright (C) 2009, 2010  Kristian Rietveld  <kris@gtk.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -18,22 +18,24 @@
  * Boston, MA 02111-1307, USA.
  */
 
-#ifndef __GDK_SCREEN_QUARTZ_H__
-#define __GDK_SCREEN_QUARTZ_H__
+#ifndef __GDK_QUARTZ_SCREEN_H__
+#define __GDK_QUARTZ_SCREEN_H__
 
 G_BEGIN_DECLS
 
-typedef struct _GdkScreenQuartz GdkScreenQuartz;
-typedef struct _GdkScreenQuartzClass GdkScreenQuartzClass;
+#include <gdk/gdkscreenprivate.h>
 
-#define GDK_TYPE_SCREEN_QUARTZ              (_gdk_screen_quartz_get_type ())
-#define GDK_SCREEN_QUARTZ(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_SCREEN_QUARTZ, GdkScreenQuartz))
-#define GDK_SCREEN_QUARTZ_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_SCREEN_QUARTZ, GdkScreenQuartzClass))
-#define GDK_IS_SCREEN_QUARTZ(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_SCREEN_QUARTZ))
-#define GDK_IS_SCREEN_QUARTZ_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_SCREEN_QUARTZ))
-#define GDK_SCREEN_QUARTZ_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_SCREEN_QUARTZ, GdkScreenQuartzClass))
+typedef struct _GdkQuartzScreen GdkQuartzScreen;
+typedef struct _GdkQuartzScreenClass GdkQuartzScreenClass;
 
-struct _GdkScreenQuartz
+#define GDK_TYPE_QUARTZ_SCREEN              (_gdk_quartz_screen_get_type ())
+#define GDK_QUARTZ_SCREEN(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_QUARTZ_SCREEN, GdkQuartzScreen))
+#define GDK_QUARTZ_SCREEN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_QUARTZ_SCREEN, GdkQuartzScreenClass))
+#define GDK_IS_QUARTZ_SCREEN(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_QUARTZ_SCREEN))
+#define GDK_IS_QUARTZ_SCREEN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_QUARTZ_SCREEN))
+#define GDK_QUARTZ_SCREEN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_QUARTZ_SCREEN, GdkQuartzScreenClass))
+
+struct _GdkQuartzScreen
 {
   GdkScreen parent_instance;
 
@@ -54,14 +56,14 @@ struct _GdkScreenQuartz
   guint emit_monitors_changed : 1;
 };
 
-struct _GdkScreenQuartzClass
+struct _GdkQuartzScreenClass
 {
   GdkScreenClass parent_class;
 };
 
-GType      _gdk_screen_quartz_get_type (void);
-GdkScreen *_gdk_screen_quartz_new      (void);
+GType      _gdk_quartz_screen_get_type (void);
+GdkScreen *_gdk_quartz_screen_new      (void);
 
 G_END_DECLS
 
-#endif /* _GDK_SCREEN_QUARTZ_H_ */
+#endif /* _GDK_QUARTZ_SCREEN_H_ */

gdk/quartz/gdkselection-quartz.c

@@ -26,111 +26,64 @@
 #include "gdkproperty.h"
 
 gboolean
-gdk_selection_owner_set_for_display (GdkDisplay *display,
-				     GdkWindow  *owner,
-				     GdkAtom     selection,
-				     guint32     time,
-				     gint        send_event)
+_gdk_quartz_display_set_selection_owner (GdkDisplay *display,
+                                         GdkWindow  *owner,
+                                         GdkAtom     selection,
+                                         guint32     time,
+                                         gint        send_event)
 {
   /* FIXME: Implement */
   return TRUE;
 }
 
 GdkWindow*
-gdk_selection_owner_get_for_display (GdkDisplay *display,
-				     GdkAtom     selection)
+_gdk_quartz_display_get_selection_owner (GdkDisplay *display,
+                                         GdkAtom     selection)
 {
   /* FIXME: Implement */
   return NULL;
 }
 
 void
-gdk_selection_convert (GdkWindow *requestor,
-		       GdkAtom    selection,
-		       GdkAtom    target,
-		       guint32    time)
+_gdk_quartz_display_convert_selection (GdkDisplay *display,
+                                       GdkWindow  *requestor,
+                                       GdkAtom     selection,
+                                       GdkAtom     target,
+                                       guint32     time)
 {
   /* FIXME: Implement */
 }
 
 gint
-gdk_selection_property_get (GdkWindow  *requestor,
-			    guchar    **data,
-			    GdkAtom    *ret_type,
-			    gint       *ret_format)
+_gdk_quartz_display_get_selection_property (GdkDisplay *display,
+                                            GdkWindow  *requestor,
+                                            guchar    **data,
+                                            GdkAtom    *ret_type,
+                                            gint       *ret_format)
 {
   /* FIXME: Implement */
   return 0;
 }
 
 void
-gdk_selection_send_notify_for_display (GdkDisplay *display,
-				       guint32     requestor,
-				       GdkAtom     selection,
-				       GdkAtom     target,
-				       GdkAtom     property,
-				       guint32     time)
-{
-  /* FIXME: Implement */
-}
-
-gint
-gdk_text_property_to_text_list_for_display (GdkDisplay   *display,
-					    GdkAtom       encoding,
-					    gint          format, 
-					    const guchar *text,
-					    gint          length,
-					    gchar      ***list)
-{
-  /* FIXME: Implement */
-  return 0;
-}
-
-gint
-gdk_string_to_compound_text_for_display (GdkDisplay  *display,
-					 const gchar *str,
-					 GdkAtom     *encoding,
-					 gint        *format,
-					 guchar     **ctext,
-					 gint        *length)
-{
-  /* FIXME: Implement */
-  return 0;
-}
-
-void gdk_free_compound_text (guchar *ctext)
+_gdk_quartz_display_send_selection_notify (GdkDisplay      *display,
+                                           GdkNativeWindow  requestor,
+                                           GdkAtom          selection,
+                                           GdkAtom          target,
+                                           GdkAtom          property,
+                                           guint32          time)
 {
   /* FIXME: Implement */
 }
 
 gchar *
-gdk_utf8_to_string_target (const gchar *str)
+_gdk_quartz_display_utf8_to_string_target (GdkDisplay  *display,
+                                           const gchar *str)
 {
   /* FIXME: Implement */
   return NULL;
 }
 
-gboolean
-gdk_utf8_to_compound_text_for_display (GdkDisplay  *display,
-				       const gchar *str,
-				       GdkAtom     *encoding,
-				       gint        *format,
-				       guchar     **ctext,
-				       gint        *length)
-{
-  /* FIXME: Implement */
-  return 0;
-}
-
-void
-gdk_free_text_list (gchar **list)
-{
-  g_return_if_fail (list != NULL);
-
-  g_free (*list);
-  g_free (list);
-}
-
 static gint
 make_list (const gchar  *text,
 	   gint          length,
@@ -200,13 +153,13 @@ make_list (const gchar  *text,
   return n_strings;
 }
 
-gint 
-gdk_text_property_to_utf8_list_for_display (GdkDisplay    *display,
-					    GdkAtom        encoding,
-					    gint           format,
-					    const guchar  *text,
-					    gint           length,
-					    gchar       ***list)
+gint
+_gdk_quartz_display_text_property_to_utf8_list (GdkDisplay    *display,
+                                                GdkAtom        encoding,
+                                                gint           format,
+                                                const guchar  *text,
+                                                gint           length,
+                                                gchar       ***list)
 {
   g_return_val_if_fail (text != NULL, 0);
   g_return_val_if_fail (length >= 0, 0);

gdk/quartz/gdkspawn-quartz.c

@@ -1,106 +0,0 @@
-/*
- * Copyright (C) 2003 Sun Microsystems Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library 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.
- *
- * Authors: Mark McLoughlin <mark@skynet.ie>
- */
-
-#include "config.h"
-
-#include "gdkspawn.h"
-
-#include <glib.h>
-#include <gdk/gdk.h>
-
-gboolean
-gdk_spawn_on_screen (GdkScreen             *screen,
-		     const gchar           *working_directory,
-		     gchar                **argv,
-		     gchar                **envp,
-		     GSpawnFlags            flags,
-		     GSpawnChildSetupFunc   child_setup,
-		     gpointer               user_data,
-		     GPid                  *child_pid,
-		     GError               **error)
-{
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
-  g_assert (sizeof(GPid) == sizeof(int));
-
-  return g_spawn_async (working_directory,
-			argv,
-			envp,
-			flags,
-			child_setup,
-			user_data,
-			child_pid,
-			error);
-}
-
-gboolean
-gdk_spawn_on_screen_with_pipes (GdkScreen            *screen,
-				const gchar          *working_directory,
-				gchar               **argv,
-				gchar               **envp,
-				GSpawnFlags           flags,
-				GSpawnChildSetupFunc  child_setup,
-				gpointer              user_data,
-				GPid                 *child_pid,
-				gint                 *standard_input,
-				gint                 *standard_output,
-				gint                 *standard_error,
-				GError              **error)
-{
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
-  g_assert (sizeof(GPid) == sizeof(int));
-
-  return g_spawn_async_with_pipes (working_directory,
-				   argv,
-				   envp,
-				   flags,
-				   child_setup,
-				   user_data,
-				   child_pid,
-				   standard_input,
-				   standard_output,
-				   standard_error,
-				   error);
-}
-
-gboolean
-gdk_spawn_command_line_on_screen (GdkScreen    *screen,
-				  const gchar  *command_line,
-				  GError      **error)
-{
-  gchar    **argv = NULL;
-  gboolean   retval;
-
-  g_return_val_if_fail (command_line != NULL, FALSE);
-
-  if (!g_shell_parse_argv (command_line,
-			   NULL, &argv,
-			   error))
-    return FALSE;
-
-  retval = gdk_spawn_on_screen (screen,
-				NULL, argv, NULL,
-				G_SPAWN_SEARCH_PATH,
-				NULL, NULL, NULL,
-				error);
-  g_strfreev (argv);
-
-  return retval;
-}

gdk/quartz/gdktestutils-quartz.c

@@ -22,54 +22,19 @@
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkinternals.h>
 
-/**
- * gdk_test_render_sync
- * @window: a mapped GdkWindow
- *
- * This function retrives a pixel from @window to force the windowing
- * system to carry out any pending rendering commands.
- * This function is intended to be used to syncronize with rendering
- * pipelines, to benchmark windowing system rendering operations.
- **/
 void
-gdk_test_render_sync (GdkWindow *window)
+_gdk_quartz_window_sync_rendering (GdkWindow *window)
 {
   /* FIXME: Find out if there is a way to implement this on quartz. */
 }
 
-/**
- * gdk_test_simulate_key
- * @window: Gdk window to simulate a key event for.
- * @x:      x coordinate within @window for the key event.
- * @y:      y coordinate within @window for the key event.
- * @keyval: A Gdk keyboard value.
- * @modifiers: Keyboard modifiers the event is setup with.
- * @key_pressrelease: either %GDK_KEY_PRESS or %GDK_KEY_RELEASE
- *
- * This function is intended to be used in Gtk+ test programs.
- * If (@x,@y) are > (-1,-1), it will warp the mouse pointer to
- * the given (@x,@y) corrdinates within @window and simulate a
- * key press or release event.
- * When the mouse pointer is warped to the target location, use
- * of this function outside of test programs that run in their
- * own virtual windowing system (e.g. Xvfb) is not recommended.
- * If (@x,@y) are passed as (-1,-1), the mouse pointer will not
- * be warped and @window origin will be used as mouse pointer
- * location for the event.
- * Also, gtk_test_simulate_key() is a fairly low level function,
- * for most testing purposes, gtk_test_widget_send_key() is the
- * right function to call which will generate a key press event
- * followed by its accompanying key release event.
- *
- * Returns: wether all actions neccessary for a key event simulation were carried out successfully.
- **/
 gboolean
-gdk_test_simulate_key (GdkWindow      *window,
-                       gint            x,
-                       gint            y,
-                       guint           keyval,
-                       GdkModifierType modifiers,
-                       GdkEventType    key_pressrelease)
+_gdk_quartz_window_simulate_key (GdkWindow      *window,
+                                 gint            x,
+                                 gint            y,
+                                 guint           keyval,
+                                 GdkModifierType modifiers,
+                                 GdkEventType    key_pressrelease)
 {
   g_return_val_if_fail (key_pressrelease == GDK_KEY_PRESS || key_pressrelease == GDK_KEY_RELEASE, FALSE);
   g_return_val_if_fail (window != NULL, FALSE);
@@ -82,36 +47,13 @@ gdk_test_simulate_key (GdkWindow      *window,
   return FALSE;
 }
 
-/**
- * gdk_test_simulate_button
- * @window: Gdk window to simulate a button event for.
- * @x:      x coordinate within @window for the button event.
- * @y:      y coordinate within @window for the button event.
- * @button: Number of the pointer button for the event, usually 1, 2 or 3.
- * @modifiers: Keyboard modifiers the event is setup with.
- * @button_pressrelease: either %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE
- *
- * This function is intended to be used in Gtk+ test programs.
- * It will warp the mouse pointer to the given (@x,@y) corrdinates
- * within @window and simulate a button press or release event.
- * Because the mouse pointer needs to be warped to the target
- * location, use of this function outside of test programs that
- * run in their own virtual windowing system (e.g. Xvfb) is not
- * recommended.
- * Also, gtk_test_simulate_button() is a fairly low level function,
- * for most testing purposes, gtk_test_widget_click() is the right
- * function to call which will generate a button press event followed
- * by its accompanying button release event.
- *
- * Returns: wether all actions neccessary for a button event simulation were carried out successfully.
- **/
 gboolean
-gdk_test_simulate_button (GdkWindow      *window,
-                          gint            x,
-                          gint            y,
-                          guint           button, /*1..3*/
-                          GdkModifierType modifiers,
-                          GdkEventType    button_pressrelease)
+_gdk_quartz_window_simulate_button (GdkWindow      *window,
+                                    gint            x,
+                                    gint            y,
+                                    guint           button, /*1..3*/
+                                    GdkModifierType modifiers,
+                                    GdkEventType    button_pressrelease)
 {
   g_return_val_if_fail (button_pressrelease == GDK_BUTTON_PRESS || button_pressrelease == GDK_BUTTON_RELEASE, FALSE);
   g_return_val_if_fail (window != NULL, FALSE);

gdk/quartz/gdkvisual-quartz.c

@@ -20,53 +20,36 @@
 
 #include "config.h"
 
-#include "gdkvisual.h"
+#include "gdkvisualprivate.h"
 #include "gdkprivate-quartz.h"
 
+GType _gdk_quartz_visual_get_type (void);
+
+#define GDK_TYPE_QUARTZ_VISUAL              (_gdk_quartz_visual_get_type ())
+#define GDK_QUARTZ_VISUAL(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_QUARTZ_VISUAL, GdkQuartzVisual))
+#define GDK_QUARTZ_VISUAL_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_QUARTZ_VISUAL, GdkQuartzVisualClass))
+#define GDK_IS_QUARTZ_VISUAL(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_QUARTZ_VISUAL))
+#define GDK_IS_QUARTZ_VISUAL_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_QUARTZ_VISUAL))
+#define GDK_QUARTZ_VISUAL_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_QUARTZ_VISUAL, GdkQuartzVisualClass))
+
+typedef struct _GdkQuartzVisual GdkQuartzVisual;
+typedef struct _GdkQuartzVisualClass GdkQuartzVisualClass;
+
+struct _GdkQuartzVisual
+{
+  GdkVisual visual;
+};
+
+struct _GdkQuartzVisualClass
+{
+  GdkVisualClass visual_class;
+};
+
+
 static GdkVisual *system_visual;
 static GdkVisual *rgba_visual;
 static GdkVisual *gray_visual;
 
-static void
-gdk_visual_finalize (GObject *object)
-{
-  g_error ("A GdkVisual object was finalized. This should not happen");
-}
-
-static void
-gdk_visual_class_init (GObjectClass *class)
-{
-  class->finalize = gdk_visual_finalize;
-}
-
-GType
-gdk_visual_get_type (void)
-{
-  static GType object_type = 0;
-
-  if (!object_type)
-    {
-      const GTypeInfo object_info =
-      {
-        sizeof (GdkVisualClass),
-        (GBaseInitFunc) NULL,
-        (GBaseFinalizeFunc) NULL,
-        (GClassInitFunc) gdk_visual_class_init,
-        NULL,           /* class_finalize */
-        NULL,           /* class_data */
-        sizeof (GdkVisual),
-        0,              /* n_preallocs */
-        (GInstanceInitFunc) NULL,
-      };
-      
-      object_type = g_type_register_static (G_TYPE_OBJECT,
-                                            "GdkVisual",
-                                            &object_info, 0);
-    }
-  
-  return object_type;
-}
-
 static void
 gdk_visual_decompose_mask (gulong  mask,
 			   gint   *shift,
@@ -89,14 +72,17 @@ gdk_visual_decompose_mask (gulong  mask,
 }
 
 static GdkVisual *
-create_standard_visual (gint depth)
+create_standard_visual (GdkScreen *screen,
+                        gint       depth)
 {
-  GdkVisual *visual = g_object_new (GDK_TYPE_VISUAL, NULL);
+  GdkVisual *visual = g_object_new (GDK_TYPE_QUARTZ_VISUAL, NULL);
+
+  visual->screen = screen;
 
   visual->depth = depth;
   visual->byte_order = GDK_MSB_FIRST; /* FIXME: Should this be different on intel macs? */
   visual->colormap_size = 0;
-  
+
   visual->type = GDK_VISUAL_TRUE_COLOR;
 
   visual->red_mask = 0xff0000;
@@ -117,9 +103,11 @@ create_standard_visual (gint depth)
 }
 
 static GdkVisual *
-create_gray_visual (void)
+create_gray_visual (GdkScreen *screen)
 {
-  GdkVisual *visual = g_object_new (GDK_TYPE_VISUAL, NULL);
+  GdkVisual *visual = g_object_new (GDK_TYPE_QUARTZ_VISUAL, NULL);
+
+  visual->screen = screen;
 
   visual->depth = 1;
   visual->byte_order = GDK_MSB_FIRST;
@@ -130,49 +118,53 @@ create_gray_visual (void)
   return visual;
 }
 
-void
-_gdk_visual_init (void)
+
+G_DEFINE_TYPE (GdkQuartzVisual, _gdk_quartz_visual, GDK_TYPE_VISUAL)
+
+static void
+_gdk_quartz_visual_init (GdkQuartzVisual *quartz_visual)
+{
+}
+
+static void
+_gdk_quartz_visual_class_init (GdkQuartzVisualClass *class)
 {
-  system_visual = create_standard_visual (24);
-  rgba_visual = create_standard_visual (32);
-  gray_visual = create_gray_visual ();
 }
 
 /* We prefer the system visual for now ... */
 gint
-gdk_visual_get_best_depth (void)
+_gdk_quartz_screen_visual_get_best_depth (GdkScreen *screen)
 {
   return system_visual->depth;
 }
 
 GdkVisualType
-gdk_visual_get_best_type (void)
+_gdk_quartz_screen_visual_get_best_type (GdkScreen *screen)
 {
   return system_visual->type;
 }
 
 GdkVisual *
-gdk_screen_get_rgba_visual (GdkScreen *screen)
+_gdk_quartz_screen_get_rgba_visual (GdkScreen *screen)
 {
-  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
-
   return rgba_visual;
 }
 
 GdkVisual*
-gdk_screen_get_system_visual (GdkScreen *screen)
+_gdk_quartz_screen_get_system_visual (GdkScreen *screen)
 {
   return system_visual;
 }
 
 GdkVisual*
-gdk_visual_get_best (void)
+_gdk_quartz_screen_visual_get_best (GdkScreen *screen)
 {
   return system_visual;
 }
 
 GdkVisual*
-gdk_visual_get_best_with_depth (gint depth)
+_gdk_quartz_screen_visual_get_best_with_depth (GdkScreen *screen,
+                                               gint       depth)
 {
   GdkVisual *visual = NULL;
 
@@ -198,7 +190,8 @@ gdk_visual_get_best_with_depth (gint depth)
 }
 
 GdkVisual*
-gdk_visual_get_best_with_type (GdkVisualType visual_type)
+_gdk_quartz_screen_visual_get_best_with_type (GdkScreen     *screen,
+                                              GdkVisualType  visual_type)
 {
   if (system_visual->type == visual_type)
     return system_visual;
@@ -209,8 +202,9 @@ gdk_visual_get_best_with_type (GdkVisualType visual_type)
 }
 
 GdkVisual*
-gdk_visual_get_best_with_both (gint          depth,
-			       GdkVisualType visual_type)
+_gdk_quartz_screen_visual_get_best_with_both (GdkScreen     *screen,
+                                              gint           depth,
+                                              GdkVisualType  visual_type)
 {
   if (system_visual->depth == depth
       && system_visual->type == visual_type)
@@ -227,23 +221,33 @@ gdk_visual_get_best_with_both (gint          depth,
 
 /* For these, we also prefer the system visual */
 void
-gdk_query_depths  (gint **depths,
-		   gint  *count)
+_gdk_quartz_screen_query_depths  (GdkScreen  *screen,
+                                  gint      **depths,
+                                  gint       *count)
 {
   *count = 1;
   *depths = &system_visual->depth;
 }
 
 void
-gdk_query_visual_types (GdkVisualType **visual_types,
-			gint           *count)
+_gdk_quartz_screen_query_visual_types (GdkScreen      *screen,
+                                       GdkVisualType **visual_types,
+                                       gint           *count)
 {
   *count = 1;
   *visual_types = &system_visual->type;
 }
 
+void
+_gdk_quartz_screen_init_visuals (GdkScreen *screen)
+{
+  system_visual = create_standard_visual (screen, 24);
+  rgba_visual = create_standard_visual (screen, 32);
+  gray_visual = create_gray_visual (screen);
+}
+
 GList*
-gdk_screen_list_visuals (GdkScreen *screen)
+_gdk_quartz_screen_list_visuals (GdkScreen *screen)
 {
   GList *visuals = NULL;
 
@@ -253,12 +257,3 @@ gdk_screen_list_visuals (GdkScreen *screen)
 
   return visuals;
 }
-
-GdkScreen *
-gdk_visual_get_screen (GdkVisual *visual)
-{
-  g_return_val_if_fail (GDK_IS_VISUAL (visual), NULL);
-
-  return gdk_screen_get_default ();
-}
-

gdk/quartz/gdkwindow-quartz.c

@@ -24,10 +24,11 @@
 
 #include "gdk.h"
 #include "gdkdeviceprivate.h"
+#include "gdkdisplayprivate.h"
 #include "gdkwindowimpl.h"
 #include "gdkprivate-quartz.h"
 #include "gdkscreen-quartz.h"
-#include "gdkinputprivate.h"
+#include "gdkcursor-quartz.h"
 
 #include <sys/time.h>
 #include <cairo-quartz.h>
@@ -62,6 +63,37 @@ static FullscreenSavedGeometry *get_fullscreen_geometry (GdkWindow *window);
    GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \
    GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
 
+/*
+ * GdkQuartzWindow
+ */
+
+struct _GdkQuartzWindow
+{
+  GdkWindow parent;
+};
+
+struct _GdkQuartzWindowClass
+{
+  GdkWindowClass parent_class;
+};
+
+G_DEFINE_TYPE (GdkQuartzWindow, gdk_quartz_window, GDK_TYPE_WINDOW);
+
+static void
+gdk_quartz_window_class_init (GdkQuartzWindowClass *quartz_window_class)
+{
+}
+
+static void
+gdk_quartz_window_init (GdkQuartzWindow *quartz_window)
+{
+}
+
+
+/*
+ * GdkQuartzWindowImpl
+ */
+
 NSView *
 gdk_quartz_window_get_nsview (GdkWindow *window)
 {
@@ -424,8 +456,8 @@ _gdk_quartz_window_set_needs_display_in_region (GdkWindow    *window,
 }
 
 void
-_gdk_windowing_window_process_updates_recurse (GdkWindow *window,
-                                               cairo_region_t *region)
+_gdk_quartz_window_process_updates_recurse (GdkWindow *window,
+                                            cairo_region_t *region)
 {
   /* Make sure to only flush each toplevel at most once if we're called
    * from process_all_updates.
@@ -467,7 +499,7 @@ _gdk_windowing_window_process_updates_recurse (GdkWindow *window,
 }
 
 void
-_gdk_windowing_before_process_all_updates (void)
+_gdk_quartz_display_before_process_all_updates (GdkDisplay *display)
 {
   in_process_all_updates = TRUE;
 
@@ -475,7 +507,7 @@ _gdk_windowing_before_process_all_updates (void)
 }
 
 void
-_gdk_windowing_after_process_all_updates (void)
+_gdk_quartz_display_after_process_all_updates (GdkDisplay *display)
 {
   GSList *old_update_nswindows = update_nswindows;
   GSList *tmp_list = update_nswindows;
@@ -649,7 +681,7 @@ _gdk_quartz_window_gdk_xy_to_xy (gint  gdk_x,
                                  gint *ns_x,
                                  gint *ns_y)
 {
-  GdkScreenQuartz *screen_quartz = GDK_SCREEN_QUARTZ (_gdk_screen);
+  GdkQuartzScreen *screen_quartz = GDK_QUARTZ_SCREEN (_gdk_screen);
 
   if (ns_y)
     *ns_y = screen_quartz->height - gdk_y + screen_quartz->min_y;
@@ -664,7 +696,7 @@ _gdk_quartz_window_xy_to_gdk_xy (gint  ns_x,
                                  gint *gdk_x,
                                  gint *gdk_y)
 {
-  GdkScreenQuartz *screen_quartz = GDK_SCREEN_QUARTZ (_gdk_screen);
+  GdkQuartzScreen *screen_quartz = GDK_QUARTZ_SCREEN (_gdk_screen);
 
   if (gdk_y)
     *gdk_y = screen_quartz->height - ns_y + screen_quartz->min_y;
@@ -843,12 +875,13 @@ get_nsscreen_for_point (gint x, gint y)
 }
 
 void
-_gdk_window_impl_new (GdkWindow     *window,
-		      GdkWindow     *real_parent,
-		      GdkScreen     *screen,
-		      GdkEventMask   event_mask,
-		      GdkWindowAttr *attributes,
-		      gint           attributes_mask)
+_gdk_quartz_display_create_window_impl (GdkDisplay    *display,
+                                        GdkWindow     *window,
+                                        GdkWindow     *real_parent,
+                                        GdkScreen     *screen,
+                                        GdkEventMask   event_mask,
+                                        GdkWindowAttr *attributes,
+                                        gint           attributes_mask)
 {
   GdkWindowImplQuartz *impl;
   GdkWindowImplQuartz *parent_impl;
@@ -925,11 +958,11 @@ _gdk_window_impl_new (GdkWindow     *window,
                           NSResizableWindowMask);
           }
 
-	impl->toplevel = [[GdkQuartzWindow alloc] initWithContentRect:content_rect 
-			                                    styleMask:style_mask
-			                                      backing:NSBackingStoreBuffered
-			                                        defer:NO
-                                                                screen:screen];
+	impl->toplevel = [[GdkQuartzNSWindow alloc] initWithContentRect:content_rect 
+			                                      styleMask:style_mask
+			                                        backing:NSBackingStoreBuffered
+			                                          defer:NO
+                                                                  screen:screen];
 
 	if (attributes_mask & GDK_WA_TITLE)
 	  title = attributes->title;
@@ -1144,7 +1177,7 @@ gdk_window_quartz_show (GdkWindow *window, gboolean already_mapped)
       make_key = (window->accept_focus && focus_on_map &&
                   window->window_type != GDK_WINDOW_TEMP);
 
-      [(GdkQuartzWindow*)impl->toplevel showAndMakeKey:make_key];
+      [(GdkQuartzNSWindow*)impl->toplevel showAndMakeKey:make_key];
       clear_toplevel_order ();
 
       _gdk_quartz_events_send_map_event (window);
@@ -1241,7 +1274,7 @@ gdk_window_quartz_hide (GdkWindow *window)
       if (impl->transient_for)
         _gdk_quartz_window_detach_from_parent (window);
 
-      [(GdkQuartzWindow*)impl->toplevel hide];
+      [(GdkQuartzNSWindow*)impl->toplevel hide];
     }
   else if (impl->view)
     {
@@ -1638,10 +1671,10 @@ gdk_window_quartz_set_device_cursor (GdkWindow *window,
                                      GdkDevice *device,
                                      GdkCursor *cursor)
 {
-  GdkCursorPrivate *cursor_private;
+  GdkQuartzCursor *cursor_private;
   NSCursor *nscursor;
 
-  cursor_private = (GdkCursorPrivate *)cursor;
+  cursor_private = (GdkQuartzCursor *)cursor;
 
   if (GDK_WINDOW_DESTROYED (window))
     return;
@@ -1789,10 +1822,10 @@ gdk_window_quartz_get_root_coords (GdkWindow *window,
   return TRUE;
 }
 
-void
-gdk_window_get_root_origin (GdkWindow *window,
-			    gint      *x,
-			    gint      *y)
+static void
+gdk_quartz_window_get_root_origin (GdkWindow *window,
+                                   gint      *x,
+                                   gint      *y)
 {
   GdkRectangle rect;
 
@@ -1897,15 +1930,6 @@ _gdk_windowing_get_device_state (GdkDisplay       *display,
   gdk_window_quartz_get_device_state_helper (_gdk_root, device, x, y, mask);
 }
 
-void
-gdk_display_warp_pointer (GdkDisplay *display,
-			  GdkScreen  *screen,
-			  gint        x,
-			  gint        y)
-{
-  CGDisplayMoveCursorToPoint (CGMainDisplayID (), CGPointMake (x, y));
-}
-
 /* Returns coordinates relative to the found window. */
 GdkWindow *
 _gdk_windowing_window_at_pointer (GdkDisplay      *display,
@@ -2000,9 +2024,9 @@ gdk_window_quartz_set_events (GdkWindow       *window,
   /* The mask is set in the common code. */
 }
 
-void
-gdk_window_set_urgency_hint (GdkWindow *window,
-			     gboolean   urgent)
+static void
+gdk_quartz_window_set_urgency_hint (GdkWindow *window,
+                                    gboolean   urgent)
 {
   if (GDK_WINDOW_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL (window))
@@ -2011,10 +2035,10 @@ gdk_window_set_urgency_hint (GdkWindow *window,
   /* FIXME: Implement */
 }
 
-void 
-gdk_window_set_geometry_hints (GdkWindow         *window,
-			       const GdkGeometry *geometry,
-			       GdkWindowHints     geom_mask)
+static void
+gdk_quartz_window_set_geometry_hints (GdkWindow         *window,
+                                      const GdkGeometry *geometry,
+                                      GdkWindowHints     geom_mask)
 {
   GdkWindowImplQuartz *impl;
 
@@ -2089,9 +2113,9 @@ gdk_window_set_geometry_hints (GdkWindow         *window,
     }
 }
 
-void
-gdk_window_set_title (GdkWindow   *window,
-		      const gchar *title)
+static void
+gdk_quartz_window_set_title (GdkWindow   *window,
+                             const gchar *title)
 {
   GdkWindowImplQuartz *impl;
 
@@ -2111,9 +2135,9 @@ gdk_window_set_title (GdkWindow   *window,
     }
 }
 
-void          
-gdk_window_set_role (GdkWindow   *window,
-		     const gchar *role)
+static void
+gdk_quartz_window_set_role (GdkWindow   *window,
+                            const gchar *role)
 {
   if (GDK_WINDOW_DESTROYED (window) ||
       WINDOW_IS_TOPLEVEL (window))
@@ -2122,9 +2146,9 @@ gdk_window_set_role (GdkWindow   *window,
   /* FIXME: Implement */
 }
 
-void
-gdk_window_set_transient_for (GdkWindow *window, 
-			      GdkWindow *parent)
+static void
+gdk_quartz_window_set_transient_for (GdkWindow *window,
+                                     GdkWindow *parent)
 {
   GdkWindowImplQuartz *window_impl;
   GdkWindowImplQuartz *parent_impl;
@@ -2193,16 +2217,16 @@ gdk_window_quartz_input_shape_combine_region (GdkWindow       *window,
   /* FIXME: Implement */
 }
 
-void
-gdk_window_set_override_redirect (GdkWindow *window,
-				  gboolean override_redirect)
+static void
+gdk_quartz_window_set_override_redirect (GdkWindow *window,
+                                         gboolean override_redirect)
 {
   /* FIXME: Implement */
 }
 
-void
-gdk_window_set_accept_focus (GdkWindow *window,
-			     gboolean accept_focus)
+static void
+gdk_quartz_window_set_accept_focus (GdkWindow *window,
+                                    gboolean accept_focus)
 {
   window->accept_focus = accept_focus != FALSE;
 }
@@ -2219,23 +2243,23 @@ gdk_window_quartz_set_static_gravities (GdkWindow *window,
   return FALSE;
 }
 
-void
-gdk_window_set_focus_on_map (GdkWindow *window,
-			     gboolean focus_on_map)
+static void
+gdk_quartz_window_set_focus_on_map (GdkWindow *window,
+                                    gboolean focus_on_map)
 {
   window->focus_on_map = focus_on_map != FALSE;
 }
 
-void          
-gdk_window_set_icon_name (GdkWindow   *window, 
-			  const gchar *name)
+static void
+gdk_quartz_window_set_icon_name (GdkWindow   *window,
+                                 const gchar *name)
 {
   /* FIXME: Implement */
 }
 
-void
-gdk_window_focus (GdkWindow *window,
-                  guint32    timestamp)
+static void
+gdk_quartz_window_focus (GdkWindow *window,
+                         guint32    timestamp)
 {
   GdkWindowImplQuartz *impl;
 	
@@ -2321,9 +2345,9 @@ window_type_hint_to_shadow (GdkWindowTypeHint hint)
 }
 
 
-void
-gdk_window_set_type_hint (GdkWindow        *window,
-			  GdkWindowTypeHint hint)
+static void
+gdk_quartz_window_set_type_hint (GdkWindow        *window,
+                                 GdkWindowTypeHint hint)
 {
   GdkWindowImplQuartz *impl;
   
@@ -2343,8 +2367,8 @@ gdk_window_set_type_hint (GdkWindow        *window,
   [impl->toplevel setLevel: window_type_hint_to_level (hint)];
 }
 
-GdkWindowTypeHint
-gdk_window_get_type_hint (GdkWindow *window)
+static GdkWindowTypeHint
+gdk_quartz_window_get_type_hint (GdkWindow *window)
 {
   if (GDK_WINDOW_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL (window))
@@ -2353,9 +2377,9 @@ gdk_window_get_type_hint (GdkWindow *window)
   return GDK_WINDOW_IMPL_QUARTZ (window->impl)->type_hint;
 }
 
-void
-gdk_window_set_modal_hint (GdkWindow *window,
-			   gboolean   modal)
+static void
+gdk_quartz_window_set_modal_hint (GdkWindow *window,
+                                  gboolean   modal)
 {
   if (GDK_WINDOW_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL (window))
@@ -2364,9 +2388,9 @@ gdk_window_set_modal_hint (GdkWindow *window,
   /* FIXME: Implement */
 }
 
-void
-gdk_window_set_skip_taskbar_hint (GdkWindow *window,
-				  gboolean   skips_taskbar)
+static void
+gdk_quartz_window_set_skip_taskbar_hint (GdkWindow *window,
+                                         gboolean   skips_taskbar)
 {
   if (GDK_WINDOW_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL (window))
@@ -2375,9 +2399,9 @@ gdk_window_set_skip_taskbar_hint (GdkWindow *window,
   /* FIXME: Implement */
 }
 
-void
-gdk_window_set_skip_pager_hint (GdkWindow *window,
-				gboolean   skips_pager)
+static void
+gdk_quartz_window_set_skip_pager_hint (GdkWindow *window,
+                                       gboolean   skips_pager)
 {
   if (GDK_WINDOW_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL (window))
@@ -2386,13 +2410,13 @@ gdk_window_set_skip_pager_hint (GdkWindow *window,
   /* FIXME: Implement */
 }
 
-void
-gdk_window_begin_resize_drag (GdkWindow     *window,
-                              GdkWindowEdge  edge,
-                              gint           button,
-                              gint           root_x,
-                              gint           root_y,
-                              guint32        timestamp)
+static void
+gdk_quartz_window_begin_resize_drag (GdkWindow     *window,
+                                     GdkWindowEdge  edge,
+                                     gint           button,
+                                     gint           root_x,
+                                     gint           root_y,
+                                     guint32        timestamp)
 {
   GdkWindowImplQuartz *impl;
 
@@ -2415,15 +2439,15 @@ gdk_window_begin_resize_drag (GdkWindow     *window,
       return;
     }
 
-  [(GdkQuartzWindow *)impl->toplevel beginManualResize];
+  [(GdkQuartzNSWindow *)impl->toplevel beginManualResize];
 }
 
-void
-gdk_window_begin_move_drag (GdkWindow *window,
-                            gint       button,
-                            gint       root_x,
-                            gint       root_y,
-                            guint32    timestamp)
+static void
+gdk_quartz_window_begin_move_drag (GdkWindow *window,
+                                   gint       button,
+                                   gint       root_x,
+                                   gint       root_y,
+                                   guint32    timestamp)
 {
   GdkWindowImplQuartz *impl;
 
@@ -2439,19 +2463,19 @@ gdk_window_begin_move_drag (GdkWindow *window,
       return;
     }
 
-  [(GdkQuartzWindow *)impl->toplevel beginManualMove];
+  [(GdkQuartzNSWindow *)impl->toplevel beginManualMove];
 }
 
-void
-gdk_window_set_icon_list (GdkWindow *window,
-			  GList     *pixbufs)
+static void
+gdk_quartz_window_set_icon_list (GdkWindow *window,
+                                 GList     *pixbufs)
 {
   /* FIXME: Implement */
 }
 
-void
-gdk_window_get_frame_extents (GdkWindow    *window,
-                              GdkRectangle *rect)
+static void
+gdk_quartz_window_get_frame_extents (GdkWindow    *window,
+                                     GdkRectangle *rect)
 {
   GdkWindow *toplevel;
   GdkWindowImplQuartz *impl;
@@ -2478,9 +2502,9 @@ gdk_window_get_frame_extents (GdkWindow    *window,
   rect->height = ns_rect.size.height;
 }
 
-void
-gdk_window_set_decorations (GdkWindow       *window,
-			    GdkWMDecoration  decorations)
+static void
+gdk_quartz_window_set_decorations (GdkWindow       *window,
+                                   GdkWMDecoration  decorations)
 {
   GdkWindowImplQuartz *impl;
   NSUInteger old_mask, new_mask;
@@ -2556,9 +2580,9 @@ gdk_window_set_decorations (GdkWindow       *window,
   GDK_QUARTZ_RELEASE_POOL;
 }
 
-gboolean
-gdk_window_get_decorations (GdkWindow       *window,
-			    GdkWMDecoration *decorations)
+static gboolean
+gdk_quartz_window_get_decorations (GdkWindow       *window,
+                                   GdkWMDecoration *decorations)
 {
   GdkWindowImplQuartz *impl;
 
@@ -2585,9 +2609,9 @@ gdk_window_get_decorations (GdkWindow       *window,
   return TRUE;
 }
 
-void
-gdk_window_set_functions (GdkWindow    *window,
-			  GdkWMFunction functions)
+static void
+gdk_quartz_window_set_functions (GdkWindow    *window,
+                                 GdkWMFunction functions)
 {
   g_return_if_fail (GDK_IS_WINDOW (window));
 
@@ -2601,24 +2625,24 @@ _gdk_windowing_window_queue_antiexpose (GdkWindow  *window,
   return FALSE;
 }
 
-void
-gdk_window_stick (GdkWindow *window)
+static void
+gdk_quartz_window_stick (GdkWindow *window)
 {
   if (GDK_WINDOW_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL (window))
     return;
 }
 
-void
-gdk_window_unstick (GdkWindow *window)
+static void
+gdk_quartz_window_unstick (GdkWindow *window)
 {
   if (GDK_WINDOW_DESTROYED (window) ||
       !WINDOW_IS_TOPLEVEL (window))
     return;
 }
 
-void
-gdk_window_maximize (GdkWindow *window)
+static void
+gdk_quartz_window_maximize (GdkWindow *window)
 {
   GdkWindowImplQuartz *impl;
 
@@ -2645,8 +2669,8 @@ gdk_window_maximize (GdkWindow *window)
     }
 }
 
-void
-gdk_window_unmaximize (GdkWindow *window)
+static void
+gdk_quartz_window_unmaximize (GdkWindow *window)
 {
   GdkWindowImplQuartz *impl;
 
@@ -2673,8 +2697,8 @@ gdk_window_unmaximize (GdkWindow *window)
     }
 }
 
-void
-gdk_window_iconify (GdkWindow *window)
+static void
+gdk_quartz_window_iconify (GdkWindow *window)
 {
   GdkWindowImplQuartz *impl;
 
@@ -2701,8 +2725,8 @@ gdk_window_iconify (GdkWindow *window)
     }
 }
 
-void
-gdk_window_deiconify (GdkWindow *window)
+static void
+gdk_quartz_window_deiconify (GdkWindow *window)
 {
   GdkWindowImplQuartz *impl;
 
@@ -2735,8 +2759,8 @@ get_fullscreen_geometry (GdkWindow *window)
   return g_object_get_data (G_OBJECT (window), FULLSCREEN_DATA);
 }
 
-void
-gdk_window_fullscreen (GdkWindow *window)
+static void
+gdk_quartz_window_fullscreen (GdkWindow *window)
 {
   FullscreenSavedGeometry *geometry;
   NSRect frame;
@@ -2775,8 +2799,8 @@ gdk_window_fullscreen (GdkWindow *window)
   gdk_synthesize_window_state (window, 0, GDK_WINDOW_STATE_FULLSCREEN);
 }
 
-void
-gdk_window_unfullscreen (GdkWindow *window)
+static void
+gdk_quartz_window_unfullscreen (GdkWindow *window)
 {
   FullscreenSavedGeometry *geometry;
 
@@ -2803,8 +2827,9 @@ gdk_window_unfullscreen (GdkWindow *window)
     }
 }
 
-void
-gdk_window_set_keep_above (GdkWindow *window, gboolean setting)
+static void
+gdk_quartz_window_set_keep_above (GdkWindow *window,
+                                  gboolean   setting)
 {
   GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
   gint level;
@@ -2821,8 +2846,9 @@ gdk_window_set_keep_above (GdkWindow *window, gboolean setting)
   [impl->toplevel setLevel: level + (setting ? 1 : 0)];
 }
 
-void
-gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
+static void
+gdk_quartz_window_set_keep_below (GdkWindow *window,
+                                  gboolean   setting)
 {
   GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
   gint level;
@@ -2839,8 +2865,8 @@ gdk_window_set_keep_below (GdkWindow *window, gboolean setting)
   [impl->toplevel setLevel: level - (setting ? 1 : 0)];
 }
 
-GdkWindow *
-gdk_window_get_group (GdkWindow *window)
+static GdkWindow *
+gdk_quartz_window_get_group (GdkWindow *window)
 {
   g_return_val_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD, NULL);
 
@@ -2853,47 +2879,32 @@ gdk_window_get_group (GdkWindow *window)
   return NULL;
 }
 
-void          
-gdk_window_set_group (GdkWindow *window, 
-		      GdkWindow *leader)
+static void
+gdk_quartz_window_set_group (GdkWindow *window,
+                             GdkWindow *leader)
 {
   /* FIXME: Implement */	
 }
 
-GdkWindow*
-gdk_window_foreign_new_for_display (GdkDisplay      *display,
-				    GdkNativeWindow  anid)
-{
-  /* Foreign windows aren't supported in Mac OS X */
-  return NULL;
-}
-
-GdkWindow *
-gdk_window_lookup_for_display (GdkDisplay *display, GdkNativeWindow anid)
-{
-  /* Foreign windows aren't supported in Mac OS X */
-  return NULL;
-}
-
-void
-gdk_window_enable_synchronized_configure (GdkWindow *window)
+static void
+gdk_quartz_window_enable_synchronized_configure (GdkWindow *window)
 {
 }
 
-void
-gdk_window_configure_finished (GdkWindow *window)
+static void
+gdk_quartz_window_configure_finished (GdkWindow *window)
 {
 }
 
-void
-gdk_window_destroy_notify (GdkWindow *window)
+static void
+gdk_quartz_window_destroy_notify (GdkWindow *window)
 {
   check_grab_destroy (window);
 }
 
-void
-gdk_window_set_opacity (GdkWindow *window,
-			gdouble    opacity)
+static void
+gdk_quartz_window_set_opacity (GdkWindow *window,
+                               gdouble    opacity)
 {
   GdkWindowImplQuartz *impl = GDK_WINDOW_IMPL_QUARTZ (window->impl);
 
@@ -2965,6 +2976,58 @@ gdk_window_impl_quartz_class_init (GdkWindowImplQuartzClass *klass)
   impl_class->get_shape = gdk_quartz_window_get_shape;
   impl_class->get_input_shape = gdk_quartz_window_get_input_shape;
 
+  impl_class->focus = gdk_quartz_window_focus;
+  impl_class->set_type_hint = gdk_quartz_window_set_type_hint;
+  impl_class->get_type_hint = gdk_quartz_window_get_type_hint;
+  impl_class->set_modal_hint = gdk_quartz_window_set_modal_hint;
+  impl_class->set_skip_taskbar_hint = gdk_quartz_window_set_skip_taskbar_hint;
+  impl_class->set_skip_pager_hint = gdk_quartz_window_set_skip_pager_hint;
+  impl_class->set_urgency_hint = gdk_quartz_window_set_urgency_hint;
+  impl_class->set_geometry_hints = gdk_quartz_window_set_geometry_hints;
+  impl_class->set_title = gdk_quartz_window_set_title;
+  impl_class->set_role = gdk_quartz_window_set_role;
+  impl_class->set_startup_id = _gdk_quartz_window_set_startup_id;
+  impl_class->set_transient_for = gdk_quartz_window_set_transient_for;
+  impl_class->get_root_origin = gdk_quartz_window_get_root_origin;
+  impl_class->get_frame_extents = gdk_quartz_window_get_frame_extents;
+  impl_class->set_override_redirect = gdk_quartz_window_set_override_redirect;
+  impl_class->set_accept_focus = gdk_quartz_window_set_accept_focus;
+  impl_class->set_focus_on_map = gdk_quartz_window_set_focus_on_map;
+  impl_class->set_icon_list = gdk_quartz_window_set_icon_list;
+  impl_class->set_icon_name = gdk_quartz_window_set_icon_name;
+  impl_class->iconify = gdk_quartz_window_iconify;
+  impl_class->deiconify = gdk_quartz_window_deiconify;
+  impl_class->stick = gdk_quartz_window_stick;
+  impl_class->unstick = gdk_quartz_window_unstick;
+  impl_class->maximize = gdk_quartz_window_maximize;
+  impl_class->unmaximize = gdk_quartz_window_unmaximize;
+  impl_class->fullscreen = gdk_quartz_window_fullscreen;
+  impl_class->unfullscreen = gdk_quartz_window_unfullscreen;
+  impl_class->set_keep_above = gdk_quartz_window_set_keep_above;
+  impl_class->set_keep_below = gdk_quartz_window_set_keep_below;
+  impl_class->get_group = gdk_quartz_window_get_group;
+  impl_class->set_group = gdk_quartz_window_set_group;
+  impl_class->set_decorations = gdk_quartz_window_set_decorations;
+  impl_class->get_decorations = gdk_quartz_window_get_decorations;
+  impl_class->set_functions = gdk_quartz_window_set_functions;
+  impl_class->set_functions = gdk_quartz_window_set_functions;
+  impl_class->begin_resize_drag = gdk_quartz_window_begin_resize_drag;
+  impl_class->begin_move_drag = gdk_quartz_window_begin_move_drag;
+  impl_class->enable_synchronized_configure = gdk_quartz_window_enable_synchronized_configure;
+  impl_class->configure_finished = gdk_quartz_window_configure_finished;
+  impl_class->set_opacity = gdk_quartz_window_set_opacity;
+  impl_class->destroy_notify = gdk_quartz_window_destroy_notify;
+  impl_class->register_dnd = _gdk_quartz_window_register_dnd;
+  impl_class->drag_begin = _gdk_quartz_window_drag_begin;
+  impl_class->process_updates_recurse = _gdk_quartz_window_process_updates_recurse;
+  impl_class->sync_rendering = _gdk_quartz_window_sync_rendering;
+  impl_class->simulate_key = _gdk_quartz_window_simulate_key;
+  impl_class->simulate_button = _gdk_quartz_window_simulate_button;
+  impl_class->get_property = _gdk_quartz_window_get_property;
+  impl_class->change_property = _gdk_quartz_window_change_property;
+  impl_class->delete_property = _gdk_quartz_window_delete_property;
+
+
   impl_quartz_class->get_context = gdk_window_impl_quartz_get_context;
   impl_quartz_class->release_context = gdk_window_impl_quartz_release_context;
 }

gdk/quartz/gdkwindow-quartz.h

@@ -27,6 +27,19 @@
 
 G_BEGIN_DECLS
 
+#define GDK_TYPE_QUARTZ_WINDOW              (gdk_quartz_window_get_type ())
+#define GDK_QUARTZ_WINDOW(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_QUARTZ_WINDOW, GdkQuartzWindow))
+#define GDK_QUARTZ_WINDOW_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_QUARTZ_WINDOW, GdkQuartzWindowClass))
+#define GDK_IS_QUARTZ_WINDOW(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_QUARTZ_WINDOW))
+#define GDK_IS_QUARTZ_WINDOW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_QUARTZ_WINDOW))
+#define GDK_QUARTZ_WINDOW_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_QUARTZ_WINDOW, GdkQuartzWindowClass))
+
+typedef struct _GdkQuartzWindow GdkQuartzWindow;
+typedef struct _GdkQuartzWindowClass GdkQuartzWindowClass;
+
+GType gdk_quartz_window_get_type (void);
+
+
 /* Window implementation for Quartz
  */
 

gdk/x11/gdkdisplay-x11.c

@@ -1187,17 +1187,6 @@ set_sm_client_id (GdkDisplay  *display,
                      gdk_x11_get_xatom_by_name_for_display (display, "SM_CLIENT_ID"));
 }
 
-/**
- * gdk_display_open:
- * @display_name: the name of the display to open
- *
- * Opens a display.
- *
- * Return value: (transfer none): a #GdkDisplay, or %NULL if the display
- *               could not be opened.
- *
- * Since: 2.2
- */
 GdkDisplay *
 _gdk_x11_display_open (const gchar *display_name)
 {

gtk/gtkclipboard-quartz.c

@@ -31,6 +31,7 @@
 #include "gtkmarshalers.h"
 #include "gtkintl.h"
 #include "gtktextbuffer.h"
+#include "gtkselectionprivate.h"
 #include "gtkquartz.h"
 
 
@@ -252,7 +253,7 @@ gtk_clipboard_get_for_display (GdkDisplay *display,
 			       GdkAtom     selection)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
-  g_return_val_if_fail (!display->closed, NULL);
+  g_return_val_if_fail (!gdk_display_is_closed (display), NULL);
 
   return clipboard_peek (display, selection, FALSE);
 }

gtk/gtkdnd-quartz.c

@@ -43,6 +43,7 @@
 #include "gtkintl.h"
 #include "gtkquartz.h"
 #include "gdk/quartz/gdkquartz.h"
+#include "gtkselectionprivate.h"
 
 typedef struct _GtkDragSourceSite GtkDragSourceSite;
 typedef struct _GtkDragSourceInfo GtkDragSourceInfo;
@@ -229,7 +230,7 @@ gtk_drag_get_data (GtkWidget      *widget,
     {
       gtk_drag_finish (context, 
 		       (selection_data->length >= 0),
-		       (context->action == GDK_ACTION_MOVE),
+		       (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE),
 		       time);
     }      
 }
@@ -807,8 +808,8 @@ gtk_drag_dest_motion (GtkWidget	     *widget,
 
   if (site->track_motion || site->flags & GTK_DEST_DEFAULT_MOTION)
     {
-      if (context->suggested_action & site->actions)
-	action = context->suggested_action;
+      if (gdk_drag_context_get_suggested_action (context) & site->actions)
+	action = gdk_drag_context_get_suggested_action (context);
       
       if (action && gtk_drag_dest_find_target (widget, context, NULL))
 	{
@@ -1001,7 +1002,6 @@ gtk_drag_dest_find_target (GtkWidget      *widget,
 
   g_return_val_if_fail (GTK_IS_WIDGET (widget), GDK_NONE);
   g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), GDK_NONE);
-  g_return_val_if_fail (!context->is_source, GDK_NONE);
 
   dragging_info = gdk_quartz_drag_context_get_dragging_info_libgtk_only (context);
   pasteboard = [dragging_info draggingPasteboard];
@@ -1110,7 +1110,6 @@ gtk_drag_begin_internal (GtkWidget         *widget,
   NSWindow *nswindow;
 
   context = gdk_drag_begin (NULL, NULL);
-  context->is_source = TRUE;
 
   info = gtk_drag_get_source_info (context, TRUE);
   
@@ -1545,7 +1544,6 @@ gtk_drag_set_icon_widget (GdkDragContext    *context,
 			  gint               hot_y)
 {
   g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
-  g_return_if_fail (context->is_source);
   g_return_if_fail (GTK_IS_WIDGET (widget));
 
   g_warning ("gtk_drag_set_icon_widget is not supported on Mac OS X");
@@ -1565,7 +1563,7 @@ set_icon_stock_pixbuf (GdkDragContext    *context,
   if (stock_id)
     {
       pixbuf = gtk_widget_render_icon_pixbuf (info->widget, stock_id,
-				              GTK_ICON_SIZE_DND, NULL);
+				              GTK_ICON_SIZE_DND);
 
       if (!pixbuf)
 	{
@@ -1600,7 +1598,6 @@ gtk_drag_set_icon_pixbuf  (GdkDragContext *context,
 			   gint            hot_y)
 {
   g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
-  g_return_if_fail (context->is_source);
   g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
 
   set_icon_stock_pixbuf (context, NULL, pixbuf, hot_x, hot_y);
@@ -1624,7 +1621,6 @@ gtk_drag_set_icon_stock  (GdkDragContext *context,
 {
 
   g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
-  g_return_if_fail (context->is_source);
   g_return_if_fail (stock_id != NULL);
 
   set_icon_stock_pixbuf (context, stock_id, NULL, hot_x, hot_y);
@@ -1692,7 +1688,6 @@ gtk_drag_set_icon_surface (GdkDragContext  *context,
   double x_offset, y_offset;
 
   g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
-  g_return_if_fail (context->is_source);
   g_return_if_fail (surface != NULL);
 
   _gtk_cairo_surface_extents (surface, &extents);
@@ -1734,10 +1729,9 @@ gtk_drag_set_icon_name (GdkDragContext *context,
   gint width, height, icon_size;
 
   g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
-  g_return_if_fail (context->is_source);
   g_return_if_fail (icon_name != NULL);
 
-  screen = gdk_window_get_screen (context->source_window);
+  screen = gdk_window_get_screen (gdk_drag_context_get_source_window (context));
   g_return_if_fail (screen != NULL);
 
   settings = gtk_settings_get_for_screen (screen);
@@ -1770,7 +1764,6 @@ void
 gtk_drag_set_icon_default (GdkDragContext    *context)
 {
   g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
-  g_return_if_fail (context->is_source);
 
   gtk_drag_set_icon_stock (context, GTK_STOCK_DND, -2, -2);
 }

gtk/gtkquartz.c

@@ -21,6 +21,7 @@
 #include "config.h"
 
 #include "gtkquartz.h"
+#include "gtkselectionprivate.h"
 #include <gdk/quartz/gdkquartz.h>
 
 NSImage *