win32: gdk3 resurrection

There are sure regressions but basic stuff seems to be working
again after all the API breakage done with comments like
"Win32 and Quartz need to be ported still."

gdk/gdk.symbols

@@ -350,13 +350,16 @@ gdk_visual_get_type G_GNUC_CONST
 gdk_visual_get_visual_type
 gdk_visual_type_get_type G_GNUC_CONST
 #ifdef GDK_WINDOWING_WIN32
-gdk_win32_drawable_get_handle
 gdk_win32_handle_table_lookup
 gdk_win32_icon_to_pixbuf_libgtk_only
 gdk_win32_pixbuf_to_hicon_libgtk_only
 gdk_win32_selection_add_targets
 gdk_win32_set_modal_dialog_libgtk_only
 gdk_win32_window_is_win32
+gdk_win32_window_get_handle
+gdk_win32_display_get_type
+gdk_win32_window_foreign_new_for_display
+gdk_win32_window_lookup_for_display
 #endif
 gdk_window_add_filter
 gdk_window_at_pointer
@@ -429,7 +432,9 @@ gdk_window_hide
 gdk_window_hints_get_type G_GNUC_CONST
 gdk_window_iconify
 gdk_window_impl_get_type G_GNUC_CONST
+#ifdef GDK_WINDOWING_X11
 gdk_window_impl_x11_get_type G_GNUC_CONST
+#endif
 gdk_window_input_shape_combine_region
 gdk_window_invalidate_maybe_recurse
 gdk_window_invalidate_rect
@@ -508,6 +513,7 @@ gdk_window_unstick
 gdk_window_withdraw
 gdk_wm_decoration_get_type G_GNUC_CONST
 gdk_wm_function_get_type G_GNUC_CONST
+#ifdef GDK_WINDOWING_X11
 gdk_x11_app_launch_context_get_type
 gdk_x11_atom_to_xatom
 gdk_x11_atom_to_xatom_for_display
@@ -570,3 +576,4 @@ gdk_x11_window_move_to_current_desktop
 gdk_x11_window_set_user_time
 gdk_x11_xatom_to_atom
 gdk_x11_xatom_to_atom_for_display
+#endif

gdk/gdkdisplaymanager.c

@@ -44,6 +44,9 @@
 #include "quartz/gdkquartzdisplaymanager.h"
 #endif
 
+#ifdef GDK_WINDOWING_WIN32
+#include "win32/gdkwin32.h"
+#endif
 
 /**
  * SECTION:gdkdisplaymanager
@@ -194,6 +197,11 @@ gdk_display_manager_get (void)
       if (backend == NULL || strcmp (backend, "quartz") == 0)
         manager = g_object_new (gdk_quartz_display_manager_get_type (), NULL);
       else
+#endif
+#ifdef GDK_WINDOWING_WIN32
+      if (backend == NULL || strcmp (backend, "win32") == 0)
+        manager = g_object_new (gdk_win32_display_manager_get_type (), NULL);
+      else
 #endif
       if (backend != NULL)
         g_error ("Unsupported GDK backend: %s", backend);

gdk/makefile.msc

@@ -19,8 +19,7 @@ WTKIT = $(TOP)\wtkit126
 
 # Nothing much configurable below
 # overwrite version?
-GTK_VER=2.0
+GTK_VER=3.0
-GDK_PIXBUF_VER=$(GTK_VER)
 
 !IFNDEF PERL
 PERL = perl
@@ -28,20 +27,19 @@ PERL = perl
 
 INCLUDES = -FImsvc_recommended_pragmas.h \
 	-I . -I .. \
-	$(GLIB_CFLAGS) $(PANGO_CFLAGS) $(CAIRO_CFLAGS) -I ../gdk-pixbuf \
+	$(GLIB_CFLAGS) $(PANGO_CFLAGS) $(CAIRO_CFLAGS) $(GDK_PIXBUF_CFLAGS) \
 
 DEFINES = \
-	-DHAVE_CONFIG_H -DGDK_ENABLE_BROKEN \
+	-DHAVE_CONFIG_H \
 	-DGDK_VERSION=\"$(GTK_VER)\" \
 	-DG_LOG_DOMAIN=\"Gdk\" \
 	-DGDK_COMPILATION -DG_LOG_DOMAIN=\"Gdk\"
 
 EXTRALIBS = \
 	$(WTKIT)\lib\i386\wntab32x.lib \
-	$(GLIB_LIBS) \
+	$(GLIB_LIBS) $(GDK_PIXBUF_LIBS) \
-	..\gdk-pixbuf\gdk_pixbuf-$(GDK_PIXBUF_VER).lib \
+	$(CAIRO_LIBS) $(CAIRO_GOBJECT_LIBS) \
-	$(PANGOWIN32_LIBS) $(PANGOCAIRO_LIBS) $(INTL_LIBS) $(CAIRO_LIBS) \
+	$(PANGOWIN32_LIBS) $(PANGOCAIRO_LIBS) $(INTL_LIBS)
-	$(PANGOCAIRO_LIBS)
 
 gdk-win32-backend :
 	cd win32
@@ -57,8 +55,8 @@ all: \
 	gdkmarshalers.c \
 	gdk-win32-backend \
 	libgdk-win32-$(GTK_VER)-0.dll \
-	testgdk.exe \
+#	testgdk.exe \
-	gdk-win32-$(GTK_VER)s.lib \
+#	gdk-win32-$(GTK_VER)s.lib \
 #	gdk-x11-$(GTK_VER).dll \
 
 gdk_OBJECTS = \
@@ -67,15 +65,14 @@ gdk_OBJECTS = \
 	gdkcairo.obj \
 	gdkcolor.obj \
 	gdkcursor.obj \
+	gdkdevice.obj \
+	gdkdevicemanager.obj \
 	gdkdisplay.obj \
 	gdkdisplaymanager.obj \
 	gdkdnd.obj \
-	gdkdraw.obj \
 	gdkenumtypes.obj \
 	gdkevents.obj \
-	gdkgc.obj \
 	gdkglobals.obj \
-	gdkwindowimpl.obj \
 	gdkkeynames.obj \
 	gdkkeys.obj \
 	gdkkeyuni.obj \
@@ -83,31 +80,43 @@ gdk_OBJECTS = \
 	gdkoffscreenwindow.obj \
 	gdkpango.obj \
 	gdkpixbuf-drawable.obj \
-	gdkpixbuf-render.obj \
 	gdkrectangle.obj \
+	gdkrgba.obj \
 	gdkscreen.obj \
 	gdkselection.obj \
 	gdkvisual.obj \
-	gdkwindow.obj
+	gdkwindow.obj \
+	gdkwindowimpl.obj \
 
-gdk_public_h_sources = \
+gdk_public_h_sources = 				\
-	gdk.h		\
+	gdk.h					\
-	gdkcolor.h	\
+	gdkapplaunchcontext.h			\
-	gdkcursor.h     \
+	gdkcairo.h				\
-	gdkdnd.h	\
+	gdkcolor.h				\
-	gdkdrawable.h	\
+	gdkcursor.h				\
-	gdkevents.h	\
+	gdkdevice.h				\
-	gdkgc.h		\
+	gdkdevicemanager.h			\
-	gdkkeysyms.h	\
+	gdkdisplay.h				\
-	gdkinput.h	\
+	gdkdisplaymanager.h			\
-	gdkkeys.h	\
+	gdkdnd.h				\
-	gdkpango.h	\
+	gdkevents.h				\
-	gdkpixbuf.h	\
+	gdkkeys.h				\
-	gdkproperty.h	\
+	gdkkeysyms.h				\
-	gdkselection.h	\
+	gdkkeysyms-compat.h			\
-	gdktypes.h	\
+	gdkmain.h				\
-	gdkvisual.h	\
+	gdkpango.h				\
-	gdkwindow.h	\
+	gdkpixbuf.h				\
+	gdkprivate.h				\
+	gdkproperty.h				\
+	gdkrectangle.h				\
+	gdkrgba.h				\
+	gdkscreen.h				\
+	gdkselection.h				\
+	gdktestutils.h				\
+	gdkthreads.h				\
+	gdktypes.h				\
+	gdkvisual.h				\
+	gdkwindow.h
 
 # private marshalers
 gdkmarshalers.h : gdkmarshalers.list
@@ -136,6 +145,7 @@ gdk.def: gdk.symbols
 		-DG_GNUC_CONST= \
 		gdk.symbols >> gdk.def
 
+# /force /verbose:lib 
 libgdk-win32-$(GTK_VER)-0.dll : $(gdk_OBJECTS) gdk.def win32\gdk-win32.lib
 	$(CC) $(CFLAGS) -LD -Fe$@ $(gdk_OBJECTS) win32\gdk-win32.lib $(EXTRALIBS) \
 	gdi32.lib user32.lib imm32.lib shell32.lib ole32.lib uuid.lib win32\gdk.res \

gdk/win32/gdkcursor-win32.c

@@ -24,6 +24,7 @@
 #include "gdkscreen.h"
 #include "gdkcursor.h"
 #include "gdkprivate-win32.h"
+#include "gdkwin32cursor.h"
 
 #ifdef __MINGW32__
 #include <w32api.h>
@@ -135,25 +136,47 @@ hcursor_from_type (GdkCursorType cursor_type)
   return rv;
 }
 
+struct _GdkWin32CursorClass
+{
+  GdkCursorClass cursor_class;
+};
+
+G_DEFINE_TYPE (GdkWin32Cursor, gdk_win32_cursor, GDK_TYPE_CURSOR)
+
+static void
+_gdk_win32_cursor_finalize (GObject *object)
+{
+  GdkWin32Cursor *private = GDK_WIN32_CURSOR (object);
+
+  if (GetCursor () == private->hcursor)
+    SetCursor (NULL);
+
+  if (!DestroyCursor (private->hcursor))
+    WIN32_API_FAILED ("DestroyCursor");
+
+  G_OBJECT_CLASS (gdk_win32_cursor_parent_class)->finalize (object);
+}
+
 static GdkCursor*
 cursor_new_from_hcursor (HCURSOR       hcursor,
 			 GdkCursorType cursor_type)
 {
-  GdkCursorPrivate *private;
+  GdkWin32Cursor *private;
   GdkCursor *cursor;
 
-  private = g_new (GdkCursorPrivate, 1);
+  private = g_object_new (GDK_TYPE_WIN32_CURSOR,
+                          "cursor-type", cursor_type,
+                          "display", _gdk_display,
+			  NULL);
   private->hcursor = hcursor;
   cursor = (GdkCursor*) private;
-  cursor->type = cursor_type;
-  cursor->ref_count = 1;
 
   return cursor;
 }
 
 GdkCursor*
-gdk_cursor_new_for_display (GdkDisplay   *display,
+_gdk_win32_display_get_cursor_for_type (GdkDisplay   *display,
-			    GdkCursorType cursor_type)
+					GdkCursorType cursor_type)
 {
   HCURSOR hcursor;
 
@@ -206,8 +229,8 @@ static struct {
 };
 
 GdkCursor*  
-gdk_cursor_new_from_name (GdkDisplay  *display,
+_gdk_win32_display_get_cursor_for_name (GdkDisplay  *display,
-			  const gchar *name)
+				        const gchar *name)
 {
   HCURSOR hcursor = NULL;
   int i;
@@ -229,26 +252,6 @@ gdk_cursor_new_from_name (GdkDisplay  *display,
   return NULL;
 }
 
-void
-_gdk_cursor_destroy (GdkCursor *cursor)
-{
-  GdkCursorPrivate *private;
-
-  g_return_if_fail (cursor != NULL);
-  private = (GdkCursorPrivate *) cursor;
-
-  GDK_NOTE (CURSOR, g_print ("_gdk_cursor_destroy: %p\n",
-			     (cursor->type == GDK_CURSOR_IS_PIXMAP) ? private->hcursor : 0));
-
-  if (GetCursor () == private->hcursor)
-    SetCursor (NULL);
-
-  if (!DestroyCursor (private->hcursor))
-    WIN32_API_FAILED ("DestroyCursor");
-
-  g_free (private);
-}
-
 GdkPixbuf *
 gdk_win32_icon_to_pixbuf_libgtk_only (HICON hicon)
 {
@@ -425,19 +428,19 @@ gdk_win32_icon_to_pixbuf_libgtk_only (HICON hicon)
   return pixbuf;
 }
 
-GdkPixbuf*  
+static GdkPixbuf *
-gdk_cursor_get_image (GdkCursor *cursor)
+_gdk_win32_cursor_get_image (GdkCursor *cursor)
 {
   g_return_val_if_fail (cursor != NULL, NULL);
 
-  return gdk_win32_icon_to_pixbuf_libgtk_only (((GdkCursorPrivate *) cursor)->hcursor);
+  return gdk_win32_icon_to_pixbuf_libgtk_only (((GdkWin32Cursor *) cursor)->hcursor);
 }
 
 GdkCursor *
-gdk_cursor_new_from_pixbuf (GdkDisplay *display, 
+_gdk_win32_display_get_cursor_for_pixbuf (GdkDisplay *display, 
-			    GdkPixbuf  *pixbuf,
+					  GdkPixbuf  *pixbuf,
-			    gint        x,
+					  gint        x,
-			    gint        y)
+					  gint        y)
 {
   HCURSOR hcursor;
 
@@ -452,8 +455,8 @@ gdk_cursor_new_from_pixbuf (GdkDisplay *display,
   return cursor_new_from_hcursor (hcursor, GDK_CURSOR_IS_PIXMAP);
 }
 
-gboolean 
+gboolean
-gdk_display_supports_cursor_alpha (GdkDisplay    *display)
+_gdk_win32_display_supports_cursor_alpha (GdkDisplay    *display)
 {
   g_return_val_if_fail (display == _gdk_display, FALSE);
 
@@ -461,25 +464,30 @@ gdk_display_supports_cursor_alpha (GdkDisplay    *display)
 }
 
 gboolean 
-gdk_display_supports_cursor_color (GdkDisplay    *display)
+_gdk_win32_display_supports_cursor_color (GdkDisplay    *display)
 {
   g_return_val_if_fail (display == _gdk_display, FALSE);
 
   return TRUE;
 }
 
-guint     
+void
-gdk_display_get_default_cursor_size (GdkDisplay    *display)
+_gdk_win32_display_get_default_cursor_size (GdkDisplay *display,
+					    guint       *width,
+					    guint       *height)
 {
-  g_return_val_if_fail (display == _gdk_display, 0);
+  g_return_if_fail (display == _gdk_display);
-  
+
-  return MIN (GetSystemMetrics (SM_CXCURSOR), GetSystemMetrics (SM_CYCURSOR));
+  if (width)
+    *width = GetSystemMetrics (SM_CXCURSOR);
+  if (height)
+    *height = GetSystemMetrics (SM_CYCURSOR);
 }
 
 void     
-gdk_display_get_maximal_cursor_size (GdkDisplay *display,
+_gdk_win32_display_get_maximal_cursor_size (GdkDisplay *display,
-				     guint       *width,
+					    guint       *width,
-				     guint       *height)
+					    guint       *height)
 {
   g_return_if_fail (display == _gdk_display);
   
@@ -812,3 +820,18 @@ gdk_win32_pixbuf_to_hicon_libgtk_only (GdkPixbuf *pixbuf)
 {
   return _gdk_win32_pixbuf_to_hicon (pixbuf);
 }
+
+static void
+gdk_win32_cursor_init (GdkWin32Cursor *cursor)
+{
+}
+static void
+gdk_win32_cursor_class_init(GdkWin32CursorClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkCursorClass *cursor_class = GDK_CURSOR_CLASS (klass);
+
+  object_class->finalize = _gdk_win32_cursor_finalize;
+  
+  cursor_class->get_image = _gdk_win32_cursor_get_image;
+}

gdk/win32/gdkdevice-win32.c

@@ -24,6 +24,7 @@
 #include <windowsx.h>
 #include <objbase.h>
 
+#include "gdkdisplayprivate.h"
 #include "gdkdevice-win32.h"
 #include "gdkwin32.h"
 
@@ -134,14 +135,14 @@ gdk_device_win32_set_window_cursor (GdkDevice *device,
                                     GdkWindow *window,
                                     GdkCursor *cursor)
 {
-  GdkCursorPrivate *cursor_private;
+  GdkWin32Cursor *cursor_private;
-  GdkWindowObject *parent_window;
+  GdkWindow *parent_window;
   GdkWindowImplWin32 *impl;
   HCURSOR hcursor;
   HCURSOR hprevcursor;
 
-  impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
+  impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
-  cursor_private = (GdkCursorPrivate*) cursor;
+  cursor_private = (GdkWin32Cursor*) cursor;
 
   hprevcursor = impl->hcursor;
 
@@ -164,13 +165,11 @@ gdk_device_win32_set_window_cursor (GdkDevice *device,
            * first ancestor that has cursor defined, and if so, set
            * new cursor.
            */
-          GdkWindowObject *curr_window_obj = GDK_WINDOW_OBJECT (curr_window);
+          while (curr_window && curr_window->impl &&
-
+                 !GDK_WINDOW_IMPL_WIN32 (curr_window->impl)->hcursor)
-          while (curr_window_obj &&
-                 !GDK_WINDOW_IMPL_WIN32 (curr_window_obj->impl)->hcursor)
             {
-              curr_window_obj = curr_window_obj->parent;
+              curr_window = curr_window->parent;
-              if (curr_window_obj == GDK_WINDOW_OBJECT (window))
+              if (curr_window == GDK_WINDOW (window))
                 {
                   SetCursor (hcursor);
                   break;
@@ -188,7 +187,7 @@ gdk_device_win32_set_window_cursor (GdkDevice *device,
     {
       /* Look for a suitable cursor to use instead */
       hcursor = NULL;
-      parent_window = GDK_WINDOW_OBJECT (window)->parent;
+      parent_window = GDK_WINDOW (window)->parent;
 
       while (hcursor == NULL)
         {
@@ -329,12 +328,19 @@ static void
 gdk_device_win32_ungrab (GdkDevice *device,
                          guint32    time_)
 {
+  GdkDeviceGrabInfo *info;
   GdkDisplay *display;
 
   display = gdk_device_get_display (device);
+  info = _gdk_display_get_last_device_grab (display, device);
+
+  if (info)
+    info->serial_end = 0;
 
   if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
     ReleaseCapture ();
+
+  _gdk_display_device_grab_update (display, device, NULL, 0);
 }
 
 static GdkWindow *

gdk/win32/gdkdevice-wintab.c

@@ -372,7 +372,7 @@ _gdk_input_check_extension_events (GdkDevice *device)
 
   for (l = input_windows; l; l = l->next)
     {
-      GdkWindowObject *window_private;
+      GdkWindow *window_private;
       GdkEventMask event_mask = 0;
 
       window_private = l->data;

gdk/win32/gdkdevicemanager-win32.c

@@ -29,6 +29,8 @@
 #include "gdkdeviceprivate.h"
 #include "gdkdevice-win32.h"
 #include "gdkdevice-wintab.h"
+#include "gdkwin32.h"
+#include "gdkdisplayprivate.h"
 
 #include <windows.h>
 #include <wintab.h>
@@ -860,7 +862,6 @@ _gdk_input_other_event (GdkEvent  *event,
                         GdkWindow *window)
 {
   GdkDisplay *display;
-  GdkWindowObject *obj;
   GdkDeviceWintab *device = NULL;
   GdkDeviceGrabInfo *last_grab;
   GdkEventMask masktest;
@@ -900,8 +901,6 @@ _gdk_input_other_event (GdkEvent  *event,
         return FALSE;
     }
 
-  obj = GDK_WINDOW_OBJECT (window);
-
   switch (msg->message)
     {
     case WT_PACKET:
@@ -928,7 +927,6 @@ _gdk_input_other_event (GdkEvent  *event,
           g_object_unref (window);
 
           window = g_object_ref (last_grab->window);
-          obj = GDK_WINDOW_OBJECT (window);
         }
 
       if (window == _gdk_root)
@@ -1006,12 +1004,12 @@ _gdk_input_other_event (GdkEvent  *event,
         {
           GDK_NOTE (EVENTS_OR_INPUT, g_print ("... not selected\n"));
 
-          if (obj->parent == GDK_WINDOW_OBJECT (_gdk_root))
+          if (window->parent == GDK_WINDOW (_gdk_root))
             return FALSE;
 
           /* It is not good to propagate the extended events up to the parent
            * if this window wants normal (not extended) motion/button events */
-          if (obj->event_mask & masktest)
+          if (window->event_mask & masktest)
             {
               GDK_NOTE (EVENTS_OR_INPUT,
                         g_print ("... wants ordinary event, ignoring this\n"));
@@ -1022,8 +1020,7 @@ _gdk_input_other_event (GdkEvent  *event,
           pt.y = y;
           ClientToScreen (GDK_WINDOW_HWND (window), &pt);
           g_object_unref (window);
-          window = (GdkWindow *) obj->parent;
+          window = window->parent;
-          obj = GDK_WINDOW_OBJECT (window);
           g_object_ref (window);
           ScreenToClient (GDK_WINDOW_HWND (window), &pt);
           x = pt.x;

gdk/win32/gdkdevicemanager-win32.h

@@ -20,7 +20,7 @@
 #ifndef __GDK_DEVICE_MANAGER_WIN32_H__
 #define __GDK_DEVICE_MANAGER_WIN32_H__
 
-#include <gdk/gdkdevicemanager.h>
+#include <gdk/gdkdevicemanagerprivate.h>
 
 G_BEGIN_DECLS
 

gdk/win32/gdkdisplay-win32.c

@@ -21,6 +21,10 @@
 #include "config.h"
 #include "gdk.h"
 #include "gdkprivate-win32.h"
+#include "gdkdisplayprivate.h"
+#include "gdkwin32display.h"
+#include "gdkwin32screen.h"
+#include "gdkwin32window.h"
 
 #define HAVE_MONITOR_INFO
 
@@ -36,8 +40,8 @@ _gdk_windowing_set_default_display (GdkDisplay *display)
   g_assert (display == NULL || _gdk_display == display);
 }
 
-gulong
+static gulong
-_gdk_windowing_window_get_next_serial (GdkDisplay *display)
+gdk_win32_display_get_next_serial (GdkDisplay *display)
 {
 	return 0;
 }
@@ -179,7 +183,7 @@ _gdk_monitor_init (void)
 }
 
 GdkDisplay *
-gdk_display_open (const gchar *display_name)
+_gdk_win32_display_open (const gchar *display_name)
 {
   GDK_NOTE (MISC, g_print ("gdk_display_open: %s\n", (display_name ? display_name : "NULL")));
 
@@ -199,8 +203,8 @@ gdk_display_open (const gchar *display_name)
       return NULL;
     }
 
-  _gdk_display = g_object_new (GDK_TYPE_DISPLAY, NULL);
+  _gdk_display = g_object_new (GDK_TYPE_WIN32_DISPLAY, NULL);
-  _gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
+  _gdk_screen = g_object_new (GDK_TYPE_WIN32_SCREEN, NULL);
 
   _gdk_monitor_init ();
   _gdk_visual_init ();
@@ -220,8 +224,20 @@ gdk_display_open (const gchar *display_name)
   return _gdk_display;
 }
 
-G_CONST_RETURN gchar *
+struct _GdkWin32Display
-gdk_display_get_name (GdkDisplay *display)
+{
+  GdkDisplay display;
+};
+
+struct _GdkWin32DisplayClass
+{
+  GdkDisplayClass display_class;
+};
+
+G_DEFINE_TYPE (GdkWin32Display, gdk_win32_display, GDK_TYPE_DISPLAY)
+
+static G_CONST_RETURN gchar *
+gdk_win32_display_get_name (GdkDisplay *display)
 {
   HDESK hdesk = GetThreadDesktop (GetCurrentThreadId ());
   char dummy;
@@ -277,24 +293,24 @@ gdk_display_get_name (GdkDisplay *display)
 				  window_station_name,
 				  desktop_name);
 
-  GDK_NOTE (MISC, g_print ("gdk_display_get_name: %s\n", display_name));
+  GDK_NOTE (MISC, g_print ("gdk_win32_display_get_name: %s\n", display_name));
 
   display_name_cache = display_name;
 
   return display_name_cache;
 }
 
-gint
+static gint
-gdk_display_get_n_screens (GdkDisplay *display)
+gdk_win32_display_get_n_screens (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
   
   return 1;
 }
 
-GdkScreen *
+static GdkScreen *
-gdk_display_get_screen (GdkDisplay *display,
+gdk_win32_display_get_screen (GdkDisplay *display,
-			gint        screen_num)
+			      gint        screen_num)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
   g_return_val_if_fail (screen_num == 0, NULL);
@@ -302,16 +318,16 @@ gdk_display_get_screen (GdkDisplay *display,
   return _gdk_screen;
 }
 
-GdkScreen *
+static GdkScreen *
-gdk_display_get_default_screen (GdkDisplay *display)
+gdk_win32_display_get_default_screen (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 
   return _gdk_screen;
 }
 
-GdkWindow *
+static GdkWindow *
-gdk_display_get_default_group (GdkDisplay *display)
+gdk_win32_display_get_default_group (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
 
@@ -320,30 +336,30 @@ gdk_display_get_default_group (GdkDisplay *display)
   return NULL;
 }
 
-gboolean 
+static gboolean
-gdk_display_supports_selection_notification (GdkDisplay *display)
+gdk_win32_display_supports_selection_notification (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
 
   return FALSE;
 }
 
-gboolean 
+static gboolean 
-gdk_display_request_selection_notification (GdkDisplay *display,
+gdk_win32_display_request_selection_notification (GdkDisplay *display,
                                             GdkAtom     selection)
 
 {
   return FALSE;
 }
 
-gboolean
+static gboolean
-gdk_display_supports_clipboard_persistence (GdkDisplay *display)
+gdk_win32_display_supports_clipboard_persistence (GdkDisplay *display)
 {
   return FALSE;
 }
 
-void
+static void
-gdk_display_store_clipboard (GdkDisplay    *display,
+gdk_win32_display_store_clipboard (GdkDisplay    *display,
 			     GdkWindow     *clipboard_window,
 			     guint32        time_,
 			     const GdkAtom *targets,
@@ -351,16 +367,16 @@ gdk_display_store_clipboard (GdkDisplay    *display,
 {
 }
 
-gboolean 
+static gboolean 
-gdk_display_supports_shapes (GdkDisplay *display)
+gdk_win32_display_supports_shapes (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
 
   return TRUE;
 }
 
-gboolean 
+static gboolean
-gdk_display_supports_input_shapes (GdkDisplay *display)
+gdk_win32_display_supports_input_shapes (GdkDisplay *display)
 {
   g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
 
@@ -371,8 +387,142 @@ gdk_display_supports_input_shapes (GdkDisplay *display)
   return FALSE;
 }
 
-gboolean
+static gboolean
-gdk_display_supports_composite (GdkDisplay *display)
+gdk_win32_display_supports_composite (GdkDisplay *display)
 {
   return FALSE;
 }
+
+static void
+gdk_win32_display_beep (GdkDisplay *display)
+{
+  g_return_if_fail (display == gdk_display_get_default());
+  if (!MessageBeep (-1))
+    Beep(1000, 50);
+}
+
+static void
+gdk_win32_display_flush (GdkDisplay * display)
+{
+  g_return_if_fail (display == _gdk_display);
+
+  GdiFlush ();
+}
+
+static void
+gdk_win32_display_dispose (GObject *object)
+{
+}
+
+static void
+gdk_win32_display_finalize (GObject *object)
+{
+}
+
+static void
+gdk_win32_display_init(GdkWin32Display *display)
+{
+}
+
+static void
+gdk_win32_display_before_process_all_updates (GdkDisplay  *display)
+{
+  /* nothing */
+}
+static void
+gdk_win32_display_after_process_all_updates (GdkDisplay  *display)
+{
+  /* nothing */
+}
+static void
+gdk_win32_display_notify_startup_complete (GdkDisplay  *display,
+                                           const gchar *startup_id)
+{
+  /* nothing */
+}
+static void
+gdk_win32_display_event_data_copy (GdkDisplay    *display,
+                                   const GdkEvent *src,
+                                   GdkEvent       *dst)
+{
+  /* nothing */
+}
+static void
+gdk_win32_display_event_data_free (GdkDisplay *display,
+                                   GdkEvent *event)
+{
+  /* nothing */
+}
+static void
+gdk_win32_display_push_error_trap (GdkDisplay *display)
+{
+  /* nothing */
+}
+static gint
+gdk_win32_display_pop_error_trap (GdkDisplay *display,
+				  gboolean    ignored)
+{
+  return 0;
+}
+static void
+gdk_win32_display_class_init (GdkWin32DisplayClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkDisplayClass *display_class = GDK_DISPLAY_CLASS (klass);
+
+  object_class->dispose = gdk_win32_display_dispose;
+  object_class->finalize = gdk_win32_display_finalize;
+
+  display_class->window_type = GDK_TYPE_WIN32_WINDOW;
+
+  display_class->get_name = gdk_win32_display_get_name;
+  display_class->get_n_screens = gdk_win32_display_get_n_screens;
+  display_class->get_screen = gdk_win32_display_get_screen;
+  display_class->get_default_screen = gdk_win32_display_get_default_screen;
+  display_class->beep = gdk_win32_display_beep;
+  display_class->sync = _gdk_win32_display_sync;
+  display_class->flush = gdk_win32_display_flush;
+  display_class->has_pending = _gdk_win32_display_has_pending;
+  display_class->queue_events = _gdk_win32_display_queue_events;
+  display_class->get_default_group = gdk_win32_display_get_default_group;
+
+  display_class->supports_selection_notification = gdk_win32_display_supports_selection_notification;
+  display_class->request_selection_notification = gdk_win32_display_request_selection_notification;
+  display_class->supports_clipboard_persistence = gdk_win32_display_supports_clipboard_persistence;
+  display_class->store_clipboard = gdk_win32_display_store_clipboard;
+  display_class->supports_shapes = gdk_win32_display_supports_shapes;
+  display_class->supports_input_shapes = gdk_win32_display_supports_input_shapes;
+  display_class->supports_composite = gdk_win32_display_supports_composite;
+
+  display_class->list_devices = _gdk_win32_display_list_devices;
+  display_class->send_client_message = _gdk_win32_display_send_client_message;
+  display_class->add_client_message_filter = _gdk_win32_display_add_client_message_filter;
+  //? display_class->get_app_launch_context = _gdk_win32_display_get_app_launch_context;
+  display_class->get_drag_protocol = _gdk_win32_display_get_drag_protocol;
+  display_class->get_cursor_for_type = _gdk_win32_display_get_cursor_for_type;
+  display_class->get_cursor_for_name = _gdk_win32_display_get_cursor_for_name;
+  display_class->get_cursor_for_pixbuf = _gdk_win32_display_get_cursor_for_pixbuf;
+  display_class->get_default_cursor_size = _gdk_win32_display_get_default_cursor_size;
+  display_class->get_maximal_cursor_size = _gdk_win32_display_get_maximal_cursor_size;
+  display_class->supports_cursor_alpha = _gdk_win32_display_supports_cursor_alpha;
+  display_class->supports_cursor_color = _gdk_win32_display_supports_cursor_color;
+
+  display_class->before_process_all_updates = gdk_win32_display_before_process_all_updates;
+  display_class->after_process_all_updates = gdk_win32_display_after_process_all_updates;
+  display_class->get_next_serial = gdk_win32_display_get_next_serial;
+  display_class->notify_startup_complete = gdk_win32_display_notify_startup_complete;
+  display_class->event_data_copy = gdk_win32_display_event_data_copy;
+  display_class->event_data_free = gdk_win32_display_event_data_free;
+  display_class->create_window_impl = _gdk_win32_display_create_window_impl;
+
+  display_class->get_keymap = _gdk_win32_display_get_keymap;
+  display_class->push_error_trap = gdk_win32_display_push_error_trap;
+  display_class->pop_error_trap = gdk_win32_display_pop_error_trap;
+  display_class->get_selection_owner = _gdk_win32_display_get_selection_owner;
+  display_class->set_selection_owner = _gdk_win32_display_set_selection_owner;
+  display_class->send_selection_notify = _gdk_win32_display_send_selection_notify;
+  display_class->get_selection_property = _gdk_win32_display_get_selection_property;
+  display_class->convert_selection = _gdk_win32_display_convert_selection;
+  display_class->text_property_to_utf8_list = _gdk_win32_display_text_property_to_utf8_list;
+  display_class->utf8_to_string_target = _gdk_win32_display_utf8_to_string_target;
+}

gdk/win32/gdkdnd-win32.c

@@ -76,6 +76,9 @@
 #include "gdkproperty.h"
 #include "gdkinternals.h"
 #include "gdkprivate-win32.h"
+#include "gdkwin32.h"
+#include "gdkwin32dnd.h"
+#include "gdk/gdkdndprivate.h"
 
 #include <ole2.h>
 
@@ -107,23 +110,29 @@ struct _GdkDragContextPrivateWin32 {
   guint drop_failed : 1;	/* Whether the drop was unsuccessful */
 };
 
-#define PRIVATE_DATA(context) ((GdkDragContextPrivateWin32 *) GDK_DRAG_CONTEXT (context)->windowing_data)
+#define PRIVATE_DATA(context) (GDK_WIN32_DRAG_CONTEXT (context)->windowing_data)
 
 static GList *contexts;
 static GdkDragContext *current_dest_drag = NULL;
 
-static void gdk_drag_context_init       (GdkDragContext      *dragcontext);
+struct _GdkWin32DragContext
-static void gdk_drag_context_class_init (GdkDragContextClass *klass);
+{
-static void gdk_drag_context_finalize   (GObject              *object);
+  GdkDragContext context;
+  
+  GdkDragContextPrivateWin32 *windowing_data;
+};
 
-static gpointer parent_class = NULL;
+struct _GdkWin32DragContextClass
+{
+  GdkDragContextClass parent_class;
+};
+
+G_DEFINE_TYPE (GdkWin32DragContext, gdk_win32_drag_context, GDK_TYPE_DRAG_CONTEXT)
 
 static gboolean use_ole2_dnd = FALSE;
 
-G_DEFINE_TYPE (GdkDragContext, gdk_drag_context, G_TYPE_OBJECT)
-
 static void
-gdk_drag_context_init (GdkDragContext *dragcontext)
+gdk_win32_drag_context_init (GdkWin32DragContext *dragcontext)
 {
   GdkDragContextPrivateWin32 *private;
 
@@ -148,19 +157,7 @@ gdk_drag_context_init (GdkDragContext *dragcontext)
 }
 
 static void
-gdk_drag_context_class_init (GdkDragContextClass *klass)
+gdk_win32_drag_context_finalize (GObject *object)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  parent_class = g_type_class_peek_parent (klass);
-
-  object_class->finalize = gdk_drag_context_finalize;
-
-  g_type_class_add_private (object_class, sizeof (GdkDragContextPrivateWin32));
-}
-
-static void
-gdk_drag_context_finalize (GObject *object)
 {
   GdkDragContext *context = GDK_DRAG_CONTEXT (object);
 
@@ -192,7 +189,7 @@ gdk_drag_context_finalize (GObject *object)
 	}
     }
 
-  G_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (gdk_win32_drag_context_parent_class)->finalize (object);
 }
 
 /* Drag Contexts */
@@ -1203,7 +1200,7 @@ target_context_new (GdkWindow *window)
   result->context->suggested_action = GDK_ACTION_MOVE;
   result->context->action = GDK_ACTION_MOVE;
 
-  private = result->context->windowing_data;
+  private = PRIVATE_DATA(result->context);
   private->iface = (IUnknown *) &result->idt;
   idroptarget_addref (&result->idt);
 
@@ -1239,7 +1236,7 @@ source_context_new (GdkWindow *window,
   result->context->dest_window = NULL;
   result->context->targets = g_list_copy (targets);
 
-  private = result->context->windowing_data;
+  private = PRIVATE_DATA(result->context);
   private->iface = (IUnknown *) &result->ids;
   idropsource_addref (&result->ids);
 
@@ -1819,8 +1816,9 @@ gdk_drag_do_leave (GdkDragContext *context,
 }
 
 GdkDragContext *
-gdk_drag_begin (GdkWindow *window,
+_gdk_win32_window_drag_begin (GdkWindow *window,
-		GList     *targets)
+			      GdkDevice *device,
+			      GList     *targets)
 {
   if (!use_ole2_dnd)
     {
@@ -1840,6 +1838,7 @@ gdk_drag_begin (GdkWindow *window,
 
       new_context->source_window = window;
       g_object_ref (window);
+      gdk_drag_context_set_device (new_context, device);
 
       new_context->targets = g_list_copy (targets);
       new_context->actions = 0;
@@ -1974,13 +1973,14 @@ _gdk_win32_dnd_do_dragdrop (void)
 }
 
 GdkNativeWindow
-gdk_drag_get_protocol_for_display (GdkDisplay      *display,
+_gdk_win32_display_get_drag_protocol (GdkDisplay      *display,
-				   GdkNativeWindow  xid,
+				      GdkNativeWindow  xid,
-				   GdkDragProtocol *protocol)
+				      GdkDragProtocol *protocol,
+				      guint           *version)
 {
   GdkWindow *window;
 
-  window = gdk_window_lookup (xid);
+  window = gdk_win32_window_lookup_for_display (display, xid);
   if (window &&
       gdk_window_get_window_type (window) != GDK_WINDOW_FOREIGN)
     {
@@ -1991,6 +1991,9 @@ gdk_drag_get_protocol_for_display (GdkDisplay      *display,
 	  else
 	    *protocol = GDK_DRAG_PROTO_LOCAL;
 
+	  /* even X11 code not always intializes it */
+	  *version = 0;
+
 	  return xid;
 	}
     }
@@ -1998,15 +2001,15 @@ gdk_drag_get_protocol_for_display (GdkDisplay      *display,
   return 0;
 }
 
-void
+static GdkWindow *
-gdk_drag_find_window_for_screen (GdkDragContext  *context,
+gdk_win32_drag_context_find_window (GdkDragContext  *context,
 				 GdkWindow       *drag_window,
 				 GdkScreen       *screen,
 				 gint             x_root,
 				 gint             y_root,
-				 GdkWindow      **dest_window,
 				 GdkDragProtocol *protocol)
 {
+  GdkWindow *dest_window;
   POINT pt;
   HWND hwnd;
 
@@ -2016,14 +2019,14 @@ gdk_drag_find_window_for_screen (GdkDragContext  *context,
   hwnd = WindowFromPoint (pt);
 
   if (hwnd == NULL)
-    *dest_window = NULL;
+    dest_window = NULL;
   else
     {
-      *dest_window = gdk_win32_handle_table_lookup (hwnd);
+      dest_window = gdk_win32_handle_table_lookup (hwnd);
-      if (*dest_window)
+      if (dest_window)
-	g_object_ref (*dest_window);
+	g_object_ref (dest_window);
       else
-	*dest_window = gdk_window_foreign_new_for_display (_gdk_display, hwnd);
+	dest_window = gdk_win32_window_foreign_new_for_display (_gdk_display, hwnd);
 
       if (use_ole2_dnd)
 	*protocol = GDK_DRAG_PROTO_OLE2;
@@ -2038,12 +2041,14 @@ gdk_drag_find_window_for_screen (GdkDragContext  *context,
 		     (drag_window ? GDK_WINDOW_HWND (drag_window) : NULL),
 		     x_root, y_root,
 		     hwnd,
-		     (*dest_window ? GDK_WINDOW_HWND (*dest_window) : NULL),
+		     (dest_window ? GDK_WINDOW_HWND (dest_window) : NULL),
 		     _gdk_win32_drag_protocol_to_string (*protocol)));
+
+  return dest_window;
 }
 
-gboolean
+static gboolean
-gdk_drag_motion (GdkDragContext *context,
+gdk_win32_drag_context_drag_motion (GdkDragContext *context,
 		 GdkWindow      *dest_window,
 		 GdkDragProtocol protocol,
 		 gint            x_root,
@@ -2181,8 +2186,8 @@ gdk_drag_motion (GdkDragContext *context,
   return FALSE;
 }
 
-void
+static void
-gdk_drag_drop (GdkDragContext *context,
+gdk_win32_drag_context_drag_drop (GdkDragContext *context,
 	       guint32         time)
 {
   g_return_if_fail (context != NULL);
@@ -2201,8 +2206,8 @@ gdk_drag_drop (GdkDragContext *context,
     }
 }
 
-void
+static void
-gdk_drag_abort (GdkDragContext *context,
+gdk_win32_drag_context_drag_abort (GdkDragContext *context,
 		guint32         time)
 {
   g_return_if_fail (context != NULL);
@@ -2215,8 +2220,8 @@ gdk_drag_abort (GdkDragContext *context,
 
 /* Destination side */
 
-void
+static void
-gdk_drag_status (GdkDragContext *context,
+gdk_win32_drag_context_drag_status (GdkDragContext *context,
 		 GdkDragAction   action,
 		 guint32         time)
 {
@@ -2270,8 +2275,8 @@ gdk_drag_status (GdkDragContext *context,
     }
 }
 
-void
+static void
-gdk_drop_reply (GdkDragContext *context,
+gdk_win32_drag_context_drop_reply (GdkDragContext *context,
 		gboolean        ok,
 		guint32         time)
 {
@@ -2287,8 +2292,8 @@ gdk_drop_reply (GdkDragContext *context,
       }
 }
 
-void
+static void
-gdk_drop_finish (GdkDragContext *context,
+gdk_win32_drag_context_drop_finish (GdkDragContext *context,
 		 gboolean        success,
 		 guint32         time)
 {
@@ -2357,7 +2362,7 @@ gdk_destroy_filter (GdkXEvent *xev,
 #endif
 
 void
-gdk_window_register_dnd (GdkWindow *window)
+_gdk_win32_window_register_dnd (GdkWindow *window)
 {
   target_drag_context *ctx;
   HRESULT hr;
@@ -2416,8 +2421,14 @@ gdk_window_register_dnd (GdkWindow *window)
     }
 }
 
-GdkAtom
+static gboolean
-gdk_drag_get_selection (GdkDragContext *context)
+gdk_win32_drag_context_drop_status (GdkDragContext *context)
+{
+  return ! PRIVATE_DATA (context)->drop_failed;
+}
+
+static GdkAtom
+gdk_win32_drag_context_get_selection (GdkDragContext *context)
 {
   switch (context->protocol)
     {
@@ -2432,15 +2443,25 @@ gdk_drag_get_selection (GdkDragContext *context)
     }
 }
 
-gboolean
+static void
-gdk_drag_drop_succeeded (GdkDragContext *context)
+gdk_win32_drag_context_class_init (GdkWin32DragContextClass *klass)
 {
-  GdkDragContextPrivateWin32 *private;
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkDragContextClass *context_class = GDK_DRAG_CONTEXT_CLASS (klass);
 
-  g_return_val_if_fail (context != NULL, FALSE);
+  gdk_win32_drag_context_parent_class = g_type_class_peek_parent (klass);
 
-  private = PRIVATE_DATA (context);
+  object_class->finalize = gdk_win32_drag_context_finalize;
 
-  /* FIXME: Can we set drop_failed when the drop has failed? */
+  context_class->find_window = gdk_win32_drag_context_find_window;
-  return !private->drop_failed;
+  context_class->drag_status = gdk_win32_drag_context_drag_status;
+  context_class->drag_motion = gdk_win32_drag_context_drag_motion;
+  context_class->drag_abort = gdk_win32_drag_context_drag_abort;
+  context_class->drag_drop = gdk_win32_drag_context_drag_drop;
+  context_class->drop_reply = gdk_win32_drag_context_drop_reply;
+  context_class->drop_finish = gdk_win32_drag_context_drop_finish;
+  context_class->drop_status = gdk_win32_drag_context_drop_status;
+  context_class->get_selection = gdk_win32_drag_context_get_selection;
+
+  g_type_class_add_private (object_class, sizeof (GdkDragContextPrivateWin32));
 }

gdk/win32/gdkdrawable-win32.c

@@ -1,222 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- * Copyright (C) 1998-2004 Tor Lillqvist
- * Copyright (C) 2001-2005 Hans Breuer
- *
- * 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 <math.h>
-#include <stdio.h>
-#include <glib.h>
-
-#include <pango/pangowin32.h>
-#include <cairo-win32.h>
-
-#include "gdkprivate-win32.h"
-
-static cairo_surface_t *gdk_win32_ref_cairo_surface (GdkDrawable *drawable);
-static cairo_surface_t *gdk_win32_create_cairo_surface (GdkDrawable *drawable,
-                                                        int          width,
-                                                        int          height);
-     
-static void gdk_drawable_impl_win32_finalize   (GObject *object);
-
-static const cairo_user_data_key_t gdk_win32_cairo_key;
-
-G_DEFINE_TYPE (GdkDrawableImplWin32,  _gdk_drawable_impl_win32, GDK_TYPE_DRAWABLE)
-
-
-static void
-_gdk_drawable_impl_win32_class_init (GdkDrawableImplWin32Class *klass)
-{
-  GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = gdk_drawable_impl_win32_finalize;
-
-  drawable_class->ref_cairo_surface = gdk_win32_ref_cairo_surface;
-  drawable_class->create_cairo_surface = gdk_win32_create_cairo_surface;
-}
-
-static void
-_gdk_drawable_impl_win32_init (GdkDrawableImplWin32 *impl)
-{
-}
-
-static void
-gdk_drawable_impl_win32_finalize (GObject *object)
-{
-  G_OBJECT_CLASS (_gdk_drawable_impl_win32_parent_class)->finalize (object);
-}
-
-/*****************************************************
- * Win32 specific implementations of generic functions *
- *****************************************************/
-
-/* Drawing
- */
-
-/**
- * _gdk_win32_drawable_acquire_dc
- * @drawable: a Win32 #GdkDrawable implementation
- * 
- * Gets a DC with the given drawable selected into
- * it.
- *
- * Return value: The DC, on success. Otherwise
- *  %NULL. If this function succeeded
- *  _gdk_win32_drawable_release_dc()  must be called
- *  release the DC when you are done using it.
- **/
-HDC 
-_gdk_win32_drawable_acquire_dc (GdkDrawable *drawable)
-{
-  GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
-  
-  if (GDK_IS_WINDOW_IMPL_WIN32 (drawable) &&
-      GDK_WINDOW_DESTROYED (impl->wrapper))
-    return NULL;
-
-  if (!impl->hdc)
-    {
-      impl->hdc = GetDC (impl->handle);
-      if (!impl->hdc)
-	WIN32_GDI_FAILED ("GetDC");
-    }
-
-  if (impl->hdc)
-    {
-      impl->hdc_count++;
-      return impl->hdc;
-    }
-  else
-    {
-      return NULL;
-    }
-}
-
-/**
- * _gdk_win32_drawable_release_dc
- * @drawable: a Win32 #GdkDrawable implementation
- * 
- * Releases the reference count for the DC
- * from _gdk_win32_drawable_acquire_dc()
- **/
-void
-_gdk_win32_drawable_release_dc (GdkDrawable *drawable)
-{
-  GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
-  
-  g_return_if_fail (impl->hdc_count > 0);
-
-  impl->hdc_count--;
-  if (impl->hdc_count == 0)
-    {
-      if (impl->saved_dc_bitmap)
-	{
-	  GDI_CALL (SelectObject, (impl->hdc, impl->saved_dc_bitmap));
-	  impl->saved_dc_bitmap = NULL;
-	}
-      
-      if (impl->hdc)
-	{
-	  GDI_CALL (ReleaseDC, (impl->handle, impl->hdc));
-	  impl->hdc = NULL;
-	}
-    }
-}
-
-static cairo_surface_t *
-gdk_win32_create_cairo_surface (GdkDrawable *drawable,
-				gint width,
-				gint height)
-{
-  /* width and height are determined from the DC */
-  return gdk_win32_ref_cairo_surface (drawable);
-}
-
-static void
-gdk_win32_cairo_surface_destroy (void *data)
-{
-  GdkDrawableImplWin32 *impl = data;
-
-  _gdk_win32_drawable_release_dc (GDK_DRAWABLE (impl));
-  impl->cairo_surface = NULL;
-}
-
-static cairo_surface_t *
-gdk_win32_ref_cairo_surface (GdkDrawable *drawable)
-{
-  GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
-
-  if (GDK_IS_WINDOW_IMPL_WIN32 (drawable) &&
-      GDK_WINDOW_DESTROYED (impl->wrapper))
-    return NULL;
-
-  if (!impl->cairo_surface)
-    {
-      HDC hdc = _gdk_win32_drawable_acquire_dc (drawable);
-      if (!hdc)
-	return NULL;
-
-      impl->cairo_surface = cairo_win32_surface_create (hdc);
-
-      cairo_surface_set_user_data (impl->cairo_surface, &gdk_win32_cairo_key,
-				   drawable, gdk_win32_cairo_surface_destroy);
-    }
-  else
-    cairo_surface_reference (impl->cairo_surface);
-
-  return impl->cairo_surface;
-}
-
-HGDIOBJ
-gdk_win32_drawable_get_handle (GdkDrawable *drawable)
-{
-  return GDK_DRAWABLE_HANDLE (drawable);
-}
-
-/**
- * _gdk_win32_drawable_finish
- * @drawable: a Win32 #GdkDrawable implementation
- * 
- * Releases any resources allocated internally for the drawable.
- * This is called when the drawable becomes unusable, i.e.
- * gdk_window_destroy() is called.
- **/
-void
-_gdk_win32_drawable_finish (GdkDrawable *drawable)
-{
-  GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (drawable);
-
-  if (impl->cairo_surface)
-    {
-      cairo_surface_finish (impl->cairo_surface);
-      cairo_surface_set_user_data (impl->cairo_surface, &gdk_win32_cairo_key, NULL, NULL);
-    }
-
-  g_assert (impl->hdc_count == 0);
-}
-

gdk/win32/gdkdrawable-win32.h

@@ -1,73 +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 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.
- */
-
-/*
- * Modified by the GTK+ Team and others 1997-1999.  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_DRAWABLE_WIN32_H__
-#define __GDK_DRAWABLE_WIN32_H__
-
-#include <gdk/gdkdrawable.h>
-#include <gdk/win32/gdkwin32.h>
-
-G_BEGIN_DECLS
-
-/* Drawable implementation for Win32
- */
-
-typedef struct _GdkDrawableImplWin32 GdkDrawableImplWin32;
-typedef struct _GdkDrawableImplWin32Class GdkDrawableImplWin32Class;
-
-#define GDK_TYPE_DRAWABLE_IMPL_WIN32              (_gdk_drawable_impl_win32_get_type ())
-#define GDK_DRAWABLE_IMPL_WIN32(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAWABLE_IMPL_WIN32, GdkDrawableImplWin32))
-#define GDK_DRAWABLE_IMPL_WIN32_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DRAWABLE_IMPL_WIN32, GdkDrawableImplWin32Class))
-#define GDK_IS_DRAWABLE_IMPL_WIN32(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAWABLE_IMPL_WIN32))
-#define GDK_IS_DRAWABLE_IMPL_WIN32_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DRAWABLE_IMPL_WIN32))
-#define GDK_DRAWABLE_IMPL_WIN32_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DRAWABLE_IMPL_WIN32, GdkDrawableImplWin32Class))
-
-struct _GdkDrawableImplWin32
-{
-  GdkDrawable parent_instance;
-  GdkDrawable *wrapper;
-  HANDLE handle;
-
-  guint hdc_count;
-  HDC hdc;
-  HBITMAP saved_dc_bitmap;	/* Original bitmap for dc */
-  cairo_surface_t *cairo_surface;
-};
- 
-struct _GdkDrawableImplWin32Class 
-{
-  GdkDrawableClass parent_class;
-};
-
-GType _gdk_drawable_impl_win32_get_type (void);
-
-HDC  _gdk_win32_drawable_acquire_dc (GdkDrawable *drawable);
-void _gdk_win32_drawable_release_dc (GdkDrawable *drawable);
-void _gdk_win32_drawable_finish     (GdkDrawable *drawable);
-
-G_END_DECLS
-
-#endif /* __GDK_DRAWABLE_WIN32_H__ */

gdk/win32/gdkevents-win32.c

@@ -46,11 +46,15 @@
 #include <glib/gprintf.h>
 
 #include "gdk.h"
+#include "gdkdisplayprivate.h"
 #include "gdkprivate-win32.h"
 #include "gdkkeysyms.h"
 #include "gdkdevicemanager-win32.h"
 #include "gdkdeviceprivate.h"
 #include "gdkdevice-wintab.h"
+#include "gdkwin32.h"
+#include "gdkwin32dnd.h"
+#include "gdkdndprivate.h"
 
 #include <windowsx.h>
 
@@ -390,10 +394,10 @@ _gdk_events_init (void)
 }
 
 gboolean
-gdk_events_pending (void)
+_gdk_win32_display_has_pending (GdkDisplay *display)
 {
   MSG msg;
-  return (_gdk_event_queue_find_first (_gdk_display) ||
+  return (_gdk_event_queue_find_first (display) ||
 	  (modal_win32_dialog == NULL &&
 	   PeekMessageW (&msg, NULL, 0, 0, PM_NOREMOVE)));
 }
@@ -449,15 +453,15 @@ _gdk_windowing_device_grab (GdkDevice    *device,
                             guint32	      time)
 {
   HCURSOR hcursor;
-  GdkCursorPrivate *cursor_private;
+  GdkWin32Cursor *cursor_private;
   gint return_val;
-  GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) native_window)->impl);
+  GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (native_window->impl);
 
   g_return_val_if_fail (window != NULL, 0);
   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
   g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
   
-  cursor_private = (GdkCursorPrivate*) cursor;
+  cursor_private = (GdkWin32Cursor*) cursor;
   
   if (!cursor)
     hcursor = NULL;
@@ -492,28 +496,6 @@ _gdk_windowing_device_grab (GdkDevice    *device,
   return return_val;
 }
 
-void
-gdk_device_ungrab (GdkDevice *device,
-                   guint32    time)
-{
-  GdkDeviceGrabInfo *info;
-  GdkDisplay *display;
-
-  g_return_if_fail (GDK_IS_DEVICE (device));
-
-  display = gdk_device_get_display (device);
-  info = _gdk_display_get_last_device_grab (display, device);
-
-  if (info)
-    {
-      info->serial_end = 0;
-      GDK_DEVICE_GET_CLASS (device)->ungrab (device, time);
-    }
-
-  _gdk_display_device_grab_update (display, device, 0);
-}
-
-
 static GdkWindow *
 find_window_for_mouse_event (GdkWindow* reported_window,
 			     MSG*       msg)
@@ -562,11 +544,11 @@ find_window_for_mouse_event (GdkWindow* reported_window,
   return other_window;
 }
 
-void 
+void
-gdk_display_add_client_message_filter (GdkDisplay   *display,
+_gdk_win32_display_add_client_message_filter (GdkDisplay   *display,
-				       GdkAtom       message_type,
+					      GdkAtom       message_type,
-				       GdkFilterFunc func,
+					      GdkFilterFunc func,
-				       gpointer      data)
+					      gpointer      data)
 {
   GdkClientFilter *filter = g_new (GdkClientFilter, 1);
 
@@ -1096,7 +1078,7 @@ apply_event_filters (GdkWindow  *window,
 static void
 show_window_recurse (GdkWindow *window, gboolean hide_window)
 {
-  GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
+  GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
   GSList *children = impl->transient_children;
   GdkWindow *child = NULL;
 
@@ -1119,9 +1101,9 @@ show_window_recurse (GdkWindow *window, gboolean hide_window)
 	{
 	  if (!hide_window)
 	    {
-	      if (GDK_WINDOW_OBJECT (window)->state & GDK_WINDOW_STATE_ICONIFIED)
+	      if (gdk_window_get_state (window) & GDK_WINDOW_STATE_ICONIFIED)
 		{
-		  if (GDK_WINDOW_OBJECT (window)->state & GDK_WINDOW_STATE_MAXIMIZED)
+		  if (gdk_window_get_state (window) & GDK_WINDOW_STATE_MAXIMIZED)
 		    {
 		      ShowWindow (GDK_WINDOW_HWND (window), SW_SHOWMAXIMIZED);
 		    }
@@ -1145,7 +1127,7 @@ static void
 do_show_window (GdkWindow *window, gboolean hide_window)
 {
   GdkWindow *tmp_window = NULL;
-  GdkWindowImplWin32 *tmp_impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
+  GdkWindowImplWin32 *tmp_impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
 
   if (!tmp_impl->changing_state)
     {
@@ -1153,7 +1135,7 @@ do_show_window (GdkWindow *window, gboolean hide_window)
       while (tmp_impl->transient_owner != NULL)
 	{
 	  tmp_window = tmp_impl->transient_owner;
-	  tmp_impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (tmp_window)->impl);
+	  tmp_impl = GDK_WINDOW_IMPL_WIN32 (tmp_window->impl);
 	}
 
       /* If we couldn't find one, use the window provided. */
@@ -1200,7 +1182,7 @@ synthesize_enter_or_leave_event (GdkWindow        *window,
   append_event (event);
   
   if (type == GDK_ENTER_NOTIFY &&
-      ((GdkWindowObject *) window)->extension_events != 0)
+      window->extension_events != 0)
     _gdk_device_wintab_update_window_coords (window);
 }
 			 
@@ -1226,7 +1208,7 @@ propagate (GdkWindow  **window,
        * device is used
        */
       if (check_extended &&
-	  ((GdkWindowObject *) grab_window)->extension_events != 0 &&
+	  grab_window->extension_events != 0 &&
 	  _gdk_input_ignore_core)
 	{
 	  GDK_NOTE (EVENTS, g_print (" (ignored for grabber)"));
@@ -1251,13 +1233,13 @@ propagate (GdkWindow  **window,
   while (TRUE)
     {
       if (check_extended &&
-	  ((GdkWindowObject *) *window)->extension_events != 0 &&
+	  (*window)->extension_events != 0 &&
 	  _gdk_input_ignore_core)
 	{
 	  GDK_NOTE (EVENTS, g_print (" (ignored)"));
 	  return FALSE;
 	}
-      if ((*doesnt_want_it) (((GdkWindowObject *) *window)->event_mask, msg))
+      if ((*doesnt_want_it) ((*window)->event_mask, msg))
 	{
 	  /* Owner doesn't want it, propagate to parent. */
 	  GdkWindow *parent = gdk_window_get_parent (*window);
@@ -1269,7 +1251,7 @@ propagate (GdkWindow  **window,
 		  /* Event source is grabbed with owner_events TRUE */
 
 		  if (check_extended &&
-		      ((GdkWindowObject *) grab_window)->extension_events != 0 &&
+		      grab_window->extension_events != 0 &&
 		      _gdk_input_ignore_core)
 		    {
 		      GDK_NOTE (EVENTS, g_print (" (ignored for grabber)"));
@@ -1329,7 +1311,6 @@ handle_configure_event (MSG       *msg,
 {
   RECT client_rect;
   POINT point;
-  GdkWindowObject *window_object;
 
   GetClientRect (msg->hwnd, &client_rect);
   point.x = client_rect.left; /* always 0 */
@@ -1343,17 +1324,15 @@ handle_configure_event (MSG       *msg,
       point.y += _gdk_offset_y;
     }
 
-  window_object = GDK_WINDOW_OBJECT (window);
+  window->width = client_rect.right - client_rect.left;
-
+  window->height = client_rect.bottom - client_rect.top;
-  window_object->width = client_rect.right - client_rect.left;
-  window_object->height = client_rect.bottom - client_rect.top;
   
-  window_object->x = point.x;
+  window->x = point.x;
-  window_object->y = point.y;
+  window->y = point.y;
 
   _gdk_window_update_size (window);
   
-  if (window_object->event_mask & GDK_STRUCTURE_MASK)
+  if (window->event_mask & GDK_STRUCTURE_MASK)
     {
       GdkEvent *event = gdk_event_new (GDK_CONFIGURE);
 
@@ -1601,7 +1580,7 @@ ensure_stacking_on_unminimize (MSG *msg)
       if (rover_gdkw)
 	{
 	  GdkWindowImplWin32 *rover_impl =
-	    (GdkWindowImplWin32 *)((GdkWindowObject *)rover_gdkw)->impl;
+	    GDK_WINDOW_IMPL_WIN32 (rover_gdkw->impl);
 
 	  if (GDK_WINDOW_IS_MAPPED (rover_gdkw) &&
 	      (rover_impl->type_hint == GDK_WINDOW_TYPE_HINT_UTILITY ||
@@ -1624,7 +1603,7 @@ static gboolean
 ensure_stacking_on_window_pos_changing (MSG       *msg,
 					GdkWindow *window)
 {
-  GdkWindowImplWin32 *impl = (GdkWindowImplWin32 *)((GdkWindowObject *) window)->impl;
+  GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
   WINDOWPOS *windowpos = (WINDOWPOS *) msg->lParam;
 
   if (GetActiveWindow () == msg->hwnd &&
@@ -1652,7 +1631,7 @@ ensure_stacking_on_window_pos_changing (MSG       *msg,
 	  if (rover_gdkw)
 	    {
 	      GdkWindowImplWin32 *rover_impl =
-		(GdkWindowImplWin32 *)((GdkWindowObject *)rover_gdkw)->impl;
+		GDK_WINDOW_IMPL_WIN32 (rover_gdkw->impl);
 
 	      if (GDK_WINDOW_IS_MAPPED (rover_gdkw) &&
 		  (rover_impl->type_hint == GDK_WINDOW_TYPE_HINT_UTILITY ||
@@ -1679,7 +1658,7 @@ static void
 ensure_stacking_on_activate_app (MSG       *msg,
 				 GdkWindow *window)
 {
-  GdkWindowImplWin32 *impl = (GdkWindowImplWin32 *)((GdkWindowObject *) window)->impl;
+  GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
 
   if (impl->type_hint == GDK_WINDOW_TYPE_HINT_UTILITY ||
       impl->type_hint == GDK_WINDOW_TYPE_HINT_DIALOG ||
@@ -1709,7 +1688,7 @@ ensure_stacking_on_activate_app (MSG       *msg,
 	  if (rover_gdkw)
 	    {
 	      GdkWindowImplWin32 *rover_impl =
-		(GdkWindowImplWin32 *)((GdkWindowObject *)rover_gdkw)->impl;
+		GDK_WINDOW_IMPL_WIN32 (rover_gdkw->impl);
 
 	      if (GDK_WINDOW_IS_MAPPED (rover_gdkw) &&
 		  (rover_impl->type_hint == GDK_WINDOW_TYPE_HINT_UTILITY ||
@@ -1829,11 +1808,11 @@ gdk_event_translate (MSG  *msg,
    */
 #define return GOTO_DONE_INSTEAD
   
-  if (!GDK_WINDOW_DESTROYED (window) && ((GdkWindowObject *) window)->filters)
+  if (!GDK_WINDOW_DESTROYED (window) && window->filters)
     {
       /* Apply per-window filters */
 
-      GdkFilterReturn result = apply_event_filters (window, msg, &((GdkWindowObject *) window)->filters);
+      GdkFilterReturn result = apply_event_filters (window, msg, &window->filters);
 
       if (result == GDK_FILTER_REMOVE || result == GDK_FILTER_TRANSLATE)
 	{
@@ -2009,7 +1988,7 @@ gdk_event_translate (MSG  *msg,
       
       build_key_event_state (event, key_state);
 
-      gdk_keymap_translate_keyboard_state (NULL,
+      gdk_keymap_translate_keyboard_state (_gdk_win32_display_get_keymap (_gdk_display),
 					   event->key.hardware_keycode,
 					   event->key.state,
 					   event->key.group,
@@ -2089,7 +2068,7 @@ gdk_event_translate (MSG  *msg,
 
       for (i = 0; i < ccount; i++)
 	{
-	  if (((GdkWindowObject *) window)->event_mask & GDK_KEY_PRESS_MASK)
+	  if (window->event_mask & GDK_KEY_PRESS_MASK)
 	    {
 	      /* Build a key press event */
 	      event = gdk_event_new (GDK_KEY_PRESS);
@@ -2100,7 +2079,7 @@ gdk_event_translate (MSG  *msg,
 	      append_event (event);
 	    }
 	  
-	  if (((GdkWindowObject *) window)->event_mask & GDK_KEY_RELEASE_MASK)
+	  if (window->event_mask & GDK_KEY_RELEASE_MASK)
 	    {
 	      /* Build a key release event.  */
 	      event = gdk_event_new (GDK_KEY_RELEASE);
@@ -2174,7 +2153,7 @@ gdk_event_translate (MSG  *msg,
 
       assign_object (&window, find_window_for_mouse_event (window, msg));
 #if 0
-      if (((GdkWindowObject *) window)->extension_events != 0 &&
+      if (window->extension_events != 0 &&
 	  _gdk_input_ignore_core)
 	{
 	  GDK_NOTE (EVENTS, g_print (" (ignored)"));
@@ -2244,7 +2223,7 @@ gdk_event_translate (MSG  *msg,
 			 GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
 #if 0 /* TODO_CSW? */
       if (current_toplevel != NULL &&
-	  (((GdkWindowObject *) current_toplevel)->event_mask & GDK_LEAVE_NOTIFY_MASK))
+	  (current_toplevel->event_mask & GDK_LEAVE_NOTIFY_MASK))
 	{
 	  synthesize_enter_or_leave_event (current_toplevel, msg,
 	                                   GDK_LEAVE_NOTIFY, GDK_CROSSING_NORMAL, GDK_NOTIFY_ANCESTOR);
@@ -2357,7 +2336,7 @@ gdk_event_translate (MSG  *msg,
 	 GdkWindow *tmp;
 
 	 if (gdk_window_get_window_type (window) == GDK_WINDOW_TEMP 
-	     || !((GdkWindowObject *)window)->accept_focus)
+	     || !window->accept_focus)
 	   {
 	     *ret_valp = MA_NOACTIVATE;
 	     return_val = TRUE;
@@ -2390,7 +2369,7 @@ gdk_event_translate (MSG  *msg,
 	  !keyboard_grab->owner_events)
 	break;
 
-      if (!(((GdkWindowObject *) window)->event_mask & GDK_FOCUS_CHANGE_MASK))
+      if (!(window->event_mask & GDK_FOCUS_CHANGE_MASK))
 	break;
 
       if (GDK_WINDOW_DESTROYED (window))
@@ -2433,7 +2412,7 @@ gdk_event_translate (MSG  *msg,
       if (grab_window != NULL && p_grab_cursor != NULL)
 	hcursor = p_grab_cursor;
       else if (!GDK_WINDOW_DESTROYED (window))
-	hcursor = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->hcursor;
+	hcursor = GDK_WINDOW_IMPL_WIN32 (window->impl)->hcursor;
       else
 	hcursor = NULL;
 
@@ -2456,7 +2435,7 @@ gdk_event_translate (MSG  *msg,
 				     (msg->lParam == SW_PARENTOPENING ? "PARENTOPENING" :
 				      "???")))))));
 
-      if (!(((GdkWindowObject *) window)->event_mask & GDK_STRUCTURE_MASK))
+      if (!(window->event_mask & GDK_STRUCTURE_MASK))
 	break;
 
       if (msg->lParam == SW_OTHERUNZOOM ||
@@ -2473,7 +2452,7 @@ gdk_event_translate (MSG  *msg,
 
       if (event->any.type == GDK_UNMAP)
 	{
-	  impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
+	  impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
 
 	  if (impl->transient_owner && GetForegroundWindow () == GDK_WINDOW_HWND (window))
 	    {
@@ -2539,7 +2518,7 @@ gdk_event_translate (MSG  *msg,
 	  GdkWindowState withdrawn_bit =
 	    IsWindowVisible (msg->hwnd) ? GDK_WINDOW_STATE_WITHDRAWN : 0;
 
-	  if (((GdkWindowObject *) window)->state & GDK_WINDOW_STATE_ICONIFIED)
+	  if (window->state & GDK_WINDOW_STATE_ICONIFIED)
 	    ensure_stacking_on_unminimize (msg);
 
 	  if (!GDK_WINDOW_DESTROYED (window))
@@ -2566,10 +2545,10 @@ gdk_event_translate (MSG  *msg,
 					   GDK_WINDOW_STATE_MAXIMIZED);
 	    }
 
-	  if (((GdkWindowObject *) window)->resize_count > 1)
+	  if (window->resize_count > 1)
-	    ((GdkWindowObject *) window)->resize_count -= 1;
+	    window->resize_count -= 1;
 	  
-	  if (((GdkWindowObject *) window)->extension_events != 0)
+	  if (window->extension_events != 0)
       _gdk_device_wintab_update_window_coords (window);
 
 	  return_val = TRUE;
@@ -2628,11 +2607,11 @@ gdk_event_translate (MSG  *msg,
 	 GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&
 	 !GDK_WINDOW_DESTROYED (window))
 	{
-	  if (((GdkWindowObject *) window)->event_mask & GDK_STRUCTURE_MASK)
+	  if (window->event_mask & GDK_STRUCTURE_MASK)
 	    {
 	      GDK_NOTE (EVENTS, g_print (" do magic"));
-	      if (((GdkWindowObject *) window)->resize_count > 1)
+	      if (window->resize_count > 1)
-		((GdkWindowObject *) window)->resize_count -= 1;
+		window->resize_count -= 1;
 
 	      handle_configure_event (msg, window);
 	      g_main_context_iteration (NULL, FALSE);
@@ -2664,7 +2643,7 @@ gdk_event_translate (MSG  *msg,
 				 _gdk_win32_rect_to_string (&rect),
 				 _gdk_win32_rect_to_string (drag)));
 
-      impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl);
+      impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
       orig_drag = *drag;
       if (impl->hint_flags & GDK_HINT_RESIZE_INC)
 	{
@@ -2867,7 +2846,7 @@ gdk_event_translate (MSG  *msg,
       if (GDK_WINDOW_DESTROYED (window))
 	break;
 
-      impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl);
+      impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
       mmi = (MINMAXINFO*) msg->lParam;
       GDK_NOTE (EVENTS, g_print (" (mintrack:%ldx%ld maxtrack:%ldx%ld "
 				 "maxpos:%+ld%+ld maxsize:%ldx%ld)",
@@ -2941,7 +2920,7 @@ gdk_event_translate (MSG  *msg,
 
       append_event (event);
 
-      impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
+      impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
 
       if (impl->transient_owner && GetForegroundWindow() == GDK_WINDOW_HWND (window))
 	{
@@ -3137,7 +3116,7 @@ done:
 }
 
 void
-_gdk_events_queue (GdkDisplay *display)
+_gdk_win32_display_queue_events (GdkDisplay *display)
 {
   MSG msg;
 
@@ -3205,7 +3184,7 @@ gdk_event_dispatch (GSource     *source,
  
   GDK_THREADS_ENTER ();
 
-  _gdk_events_queue (_gdk_display);
+  _gdk_win32_display_queue_events (_gdk_display);
   event = _gdk_event_unqueue (_gdk_display);
 
   if (event)
@@ -3254,9 +3233,9 @@ check_for_too_much_data (GdkEvent *event)
 }
 
 gboolean
-gdk_event_send_client_message_for_display (GdkDisplay     *display,
+_gdk_win32_display_send_client_message (GdkDisplay     *display,
-                                           GdkEvent       *event, 
+                                        GdkEvent       *event, 
-                                           GdkNativeWindow winid)
+                                        GdkNativeWindow winid)
 {
   check_for_too_much_data (event);
 
@@ -3266,7 +3245,7 @@ gdk_event_send_client_message_for_display (GdkDisplay     *display,
 }
 
 void
-gdk_screen_broadcast_client_message (GdkScreen *screen, 
+_gdk_win32_screen_broadcast_client_message (GdkScreen *screen, 
 				     GdkEvent  *event)
 {
   check_for_too_much_data (event);
@@ -3277,24 +3256,7 @@ gdk_screen_broadcast_client_message (GdkScreen *screen,
 }
 
 void
-gdk_flush (void)
+_gdk_win32_display_sync (GdkDisplay * display)
-{
-#if 0
-  MSG msg;
-
-  /* Process all messages currently available */
-  while (PeekMessageW (&msg, NULL, 0, 0, PM_REMOVE))
-    {
-      TranslateMessage (&msg);
-      DispatchMessageW (&msg);
-    }
-#endif
-
-  GdiFlush ();
-}
-
-void
-gdk_display_sync (GdkDisplay * display)
 {
   MSG msg;
 
@@ -3305,27 +3267,3 @@ gdk_display_sync (GdkDisplay * display)
     DispatchMessageW (&msg);
 }
 
-void
-gdk_display_flush (GdkDisplay * display)
-{
-  g_return_if_fail (display == _gdk_display);
-
-  /* Nothing */
-}
-
-gboolean
-gdk_net_wm_supports (GdkAtom property)
-{
-  return FALSE;
-}
-
-void
-_gdk_windowing_event_data_copy (const GdkEvent *src,
-                                GdkEvent       *dst)
-{
-}
-
-void
-_gdk_windowing_event_data_free (GdkEvent *event)
-{
-}

gdk/win32/gdkgeometry-win32.c

@@ -42,6 +42,7 @@
 #include "gdk.h"		/* For gdk_rectangle_intersect */
 #include "gdkinternals.h"
 #include "gdkprivate-win32.h"
+#include "gdkwin32.h"
 
 #define SIZE_LIMIT 32767
 
@@ -58,22 +59,20 @@ _gdk_window_move_resize_child (GdkWindow *window,
 			       gint       height)
 {
   GdkWindowImplWin32 *impl;
-  GdkWindowObject *obj;
   gboolean is_move;
   gboolean is_resize;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  obj = GDK_WINDOW_OBJECT (window);
+  impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
-  impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
 
-  is_move = (x - obj->x != 0) && (y - obj->y != 0);
+  is_move = (x - window->x != 0) && (y - window->y != 0);
-  is_resize = obj->width != width && obj->height != height;
+  is_resize = window->width != width && window->height != height;
   
   GDK_NOTE (MISC, g_print ("_gdk_window_move_resize_child: %s@%+d%+d %dx%d@%+d%+d\n",
-			   _gdk_win32_drawable_description (window),
+			   _gdk_win32_window_description (window),
-			   obj->x, obj->y, width, height, x, y));
+			   window->x, window->y, width, height, x, y));
 
   if (width > 65535 || height > 65535)
   {
@@ -85,10 +84,10 @@ _gdk_window_move_resize_child (GdkWindow *window,
       height = 65535;
   }
 
-  obj->x = x;
+  window->x = x;
-  obj->y = y;
+  window->y = y;
-  obj->width = width;
+  window->width = width;
-  obj->height = height;
+  window->height = height;
 
   _gdk_win32_window_tmp_unset_parent_bg (window);
   _gdk_win32_window_tmp_unset_bg (window, TRUE);
@@ -96,19 +95,18 @@ _gdk_window_move_resize_child (GdkWindow *window,
   GDK_NOTE (MISC, g_print ("... SetWindowPos(%p,NULL,%d,%d,%d,%d,"
 			   "NOACTIVATE|NOZORDER%s%s)\n",
 			   GDK_WINDOW_HWND (window),
-			   obj->x + obj->parent->abs_x, obj->y + obj->parent->abs_y, 
+			   window->x + window->parent->abs_x, window->y + window->parent->abs_y, 
 			   width, height,
 			   (is_move ? "" : "|NOMOVE"),
 			   (is_resize ? "" : "|NOSIZE")));
 
   API_CALL (SetWindowPos, (GDK_WINDOW_HWND (window), NULL,
-			   obj->x + obj->parent->abs_x, obj->y + obj->parent->abs_y, 
+			   window->x + window->parent->abs_x, window->y + window->parent->abs_y, 
 			   width, height,
 			   SWP_NOACTIVATE | SWP_NOZORDER | 
 			   (is_move ? 0 : SWP_NOMOVE) |
 			   (is_resize ? 0 : SWP_NOSIZE)));
 
-  //_gdk_win32_window_tmp_reset_parent_bg (window);
   _gdk_win32_window_tmp_reset_bg (window, TRUE);
 }
 
@@ -116,28 +114,24 @@ void
 _gdk_win32_window_tmp_unset_bg (GdkWindow *window,
 				gboolean recurse)
 {
-  GdkWindowObject *private;
-
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  private = (GdkWindowObject *)window;
+  if (window->input_only || window->destroyed ||
-
+      (window->window_type != GDK_WINDOW_ROOT &&
-  if (private->input_only || private->destroyed ||
-      (private->window_type != GDK_WINDOW_ROOT &&
        !GDK_WINDOW_IS_MAPPED (window)))
     return;
 
   if (_gdk_window_has_impl (window) &&
       GDK_WINDOW_IS_WIN32 (window) &&
-      private->window_type != GDK_WINDOW_ROOT &&
+      window->window_type != GDK_WINDOW_ROOT &&
-      private->window_type != GDK_WINDOW_FOREIGN)
+      window->window_type != GDK_WINDOW_FOREIGN)
     tmp_unset_bg (window);
 
   if (recurse)
     {
       GList *l;
 
-      for (l = private->children; l != NULL; l = l->next)
+      for (l = window->children; l != NULL; l = l->next)
 	_gdk_win32_window_tmp_unset_bg (l->data, TRUE);
     }
 }
@@ -146,10 +140,8 @@ static void
 tmp_unset_bg (GdkWindow *window)
 {
   GdkWindowImplWin32 *impl;
-  GdkWindowObject *obj;
 
-  obj = (GdkWindowObject *) window;
+  impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
-  impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
 
   impl->no_bg = TRUE;
 }
@@ -157,11 +149,9 @@ tmp_unset_bg (GdkWindow *window)
 static void
 tmp_reset_bg (GdkWindow *window)
 {
-  GdkWindowObject *obj;
   GdkWindowImplWin32 *impl;
 
-  obj = GDK_WINDOW_OBJECT (window);
+  impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
-  impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
 
   impl->no_bg = FALSE;
 }
@@ -169,12 +159,10 @@ tmp_reset_bg (GdkWindow *window)
 void
 _gdk_win32_window_tmp_unset_parent_bg (GdkWindow *window)
 {
-  GdkWindowObject *private = (GdkWindowObject*)window;
+  if (GDK_WINDOW_TYPE (window->parent) == GDK_WINDOW_ROOT)
-
-  if (GDK_WINDOW_TYPE (private->parent) == GDK_WINDOW_ROOT)
     return;
 
-  window = _gdk_window_get_impl_window ((GdkWindow*)private->parent);
+  window = _gdk_window_get_impl_window (window->parent);
   _gdk_win32_window_tmp_unset_bg (window, FALSE);
 }
 
@@ -182,18 +170,16 @@ void
 _gdk_win32_window_tmp_reset_bg (GdkWindow *window,
 				gboolean   recurse)
 {
-  GdkWindowObject *private = (GdkWindowObject*)window;
-
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (private->input_only || private->destroyed ||
+  if (window->input_only || window->destroyed ||
-      (private->window_type != GDK_WINDOW_ROOT && !GDK_WINDOW_IS_MAPPED (window)))
+      (window->window_type != GDK_WINDOW_ROOT && !GDK_WINDOW_IS_MAPPED (window)))
     return;
 
   if (_gdk_window_has_impl (window) &&
       GDK_WINDOW_IS_WIN32 (window) &&
-      private->window_type != GDK_WINDOW_ROOT &&
+      window->window_type != GDK_WINDOW_ROOT &&
-      private->window_type != GDK_WINDOW_FOREIGN)
+      window->window_type != GDK_WINDOW_FOREIGN)
     {
       tmp_reset_bg (window);
     }
@@ -202,79 +188,7 @@ _gdk_win32_window_tmp_reset_bg (GdkWindow *window,
     {
       GList *l;
 
-      for (l = private->children; l != NULL; l = l->next)
+      for (l = window->children; l != NULL; l = l->next)
 	_gdk_win32_window_tmp_reset_bg (l->data, TRUE);
     }
 }
-
-/*
-void
-_gdk_win32_window_tmp_reset_bg (GdkWindow *window)
-{
-  GdkWindowImplWin32 *impl;
-  GdkWindowObject *obj;
-
-  obj = (GdkWindowObject *) window;
-  impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
-
-  impl->no_bg = FALSE;
-}
-*/
-
-#if 0
-static cairo_region_t *
-gdk_window_clip_changed (GdkWindow    *window,
-			 GdkRectangle *old_clip,
-			 GdkRectangle *new_clip)
-{
-  GdkWindowImplWin32 *impl;
-  GdkWindowObject *obj;
-  cairo_region_t *old_clip_region;
-  cairo_region_t *new_clip_region;
-  
-  if (((GdkWindowObject *)window)->input_only)
-    return NULL;
-
-  obj = (GdkWindowObject *) window;
-  impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
-  
-  old_clip_region = cairo_region_create_rectangle (old_clip);
-  new_clip_region = cairo_region_create_rectangle (new_clip);
-
-  /* Trim invalid region of window to new clip rectangle
-   */
-  if (obj->update_area)
-    cairo_region_intersect (obj->update_area, new_clip_region);
-
-  /* Invalidate newly exposed portion of window
-   */
-  cairo_region_subtract (new_clip_region, old_clip_region);
-  if (!cairo_region_is_empty (new_clip_region))
-    gdk_window_tmp_unset_bg (window);
-  else
-    {
-      cairo_region_destroy (new_clip_region);
-      new_clip_region = NULL;
-    }
-
-  cairo_region_destroy (old_clip_region);
-
-  return new_clip_region;
-}
-#endif
-
-#if 0
-static void
-gdk_window_post_scroll (GdkWindow    *window,
-			cairo_region_t    *new_clip_region)
-{
-  GDK_NOTE (EVENTS,
-	    g_print ("gdk_window_clip_changed: invalidating region: %s\n",
-		     _gdk_win32_cairo_region_to_string (new_clip_region)));
-
-  gdk_window_invalidate_region (window, new_clip_region, FALSE);
-  g_print ("gdk_window_post_scroll\n");
-  cairo_region_destroy (new_clip_region);
-}
-
-#endif

gdk/win32/gdkim-win32.c

@@ -1,44 +0,0 @@
-/* GDK - The GIMP Drawing Kit
- * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
- * Copyright (C) 1998-2004 Tor Lillqvist
- *
- * 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 <string.h>
-#include <locale.h>
-
-#include "gdkinternals.h"
-#include "gdkwin32.h"
-
-gchar*
-gdk_set_locale (void)
-{
-  if (!setlocale (LC_ALL, ""))
-    g_warning ("locale not supported by C library");
-  
-  return g_win32_getlocale ();
-}

gdk/win32/gdkinput.c

@@ -34,7 +34,8 @@
 #include "config.h"
 
 #include "gdkdisplay.h"
-#include "gdkinput.h"
+#include "gdkdevice.h"
+#include "gdkdisplayprivate.h"
 
 #include "gdkprivate-win32.h"
 #include "gdkdevicemanager-win32.h"
@@ -47,11 +48,11 @@ GList            *_gdk_input_windows;
 GList *
 gdk_devices_list (void)
 {
-  return gdk_display_list_devices (_gdk_display);
+  return _gdk_win32_display_list_devices (_gdk_display);
 }
 
 GList *
-gdk_display_list_devices (GdkDisplay *dpy)
+_gdk_win32_display_list_devices (GdkDisplay *dpy)
 {
   g_return_val_if_fail (dpy == _gdk_display, NULL);
 
@@ -69,7 +70,6 @@ gdk_input_set_extension_events (GdkWindow *window, gint mask,
                                 GdkExtensionMode mode)
 {
   GdkDeviceManager *device_manager;
-  GdkWindowObject *window_private;
   GList *devices, *d;
 
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -80,8 +80,7 @@ gdk_input_set_extension_events (GdkWindow *window, gint mask,
   if (mode == GDK_EXTENSION_EVENTS_NONE)
     mask = 0;
 
-  window_private = (GdkWindowObject *) window;
+  window->extension_events = mask;
-  window_private->extension_events = mask;
 
   device_manager = gdk_display_get_device_manager (_gdk_display);
   devices = gdk_device_manager_list_devices (device_manager,

gdk/win32/gdkkeys-win32.c

@@ -35,9 +35,28 @@
 #include "gdkprivate-win32.h"
 #include "gdkinternals.h"
 #include "gdkkeysyms.h"
+#include "gdkkeysprivate.h"
+#include "gdkwin32keys.h"
 
 #include "config.h"
 
+struct _GdkWin32KeymapClass
+{
+  GdkKeymapClass parent_class;
+};
+
+struct _GdkWin32Keymap
+{
+  GdkKeymap parent_instance;
+};
+
+G_DEFINE_TYPE (GdkWin32Keymap, gdk_win32_keymap, GDK_TYPE_KEYMAP)
+
+static void
+gdk_win32_keymap_init (GdkWin32Keymap *keymap)
+{
+}
+
 guint _gdk_keymap_serial = 0;
 gboolean _gdk_keyboard_has_altgr = FALSE;
 guint _scancode_rshift = 0;
@@ -489,18 +508,18 @@ update_keymap (void)
 } 
 
 GdkKeymap*
-gdk_keymap_get_for_display (GdkDisplay *display)
+_gdk_win32_display_get_keymap (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);
+    default_keymap = g_object_new (gdk_win32_keymap_get_type (), NULL);
 
   return default_keymap;
 }
 
-PangoDirection
+static PangoDirection
-gdk_keymap_get_direction (GdkKeymap *keymap)
+gdk_win32_keymap_get_direction (GdkKeymap *keymap)
 {
   update_keymap ();
 
@@ -520,8 +539,8 @@ gdk_keymap_get_direction (GdkKeymap *keymap)
     }
 }
 
-gboolean
+static gboolean
-gdk_keymap_have_bidi_layouts (GdkKeymap *keymap)
+gdk_win32_keymap_have_bidi_layouts (GdkKeymap *keymap)
 {
   /* Should we check if the kayboard layouts switchable at the moment
    * cover both directionalities? What does the doc comment in
@@ -530,20 +549,20 @@ gdk_keymap_have_bidi_layouts (GdkKeymap *keymap)
   return FALSE;
 }
 
-gboolean
+static gboolean
-gdk_keymap_get_caps_lock_state (GdkKeymap *keymap)
+gdk_win32_keymap_get_caps_lock_state (GdkKeymap *keymap)
 {
   return ((GetKeyState (VK_CAPITAL) & 1) != 0);
 }
 
-gboolean
+static gboolean
-gdk_keymap_get_num_lock_state (GdkKeymap *keymap)
+gdk_win32_keymap_get_num_lock_state (GdkKeymap *keymap)
 {
   return ((GetKeyState (VK_NUMLOCK) & 1) != 0);
 }
 
-gboolean
+static gboolean
-gdk_keymap_get_entries_for_keyval (GdkKeymap     *keymap,
+gdk_win32_keymap_get_entries_for_keyval (GdkKeymap     *keymap,
                                    guint          keyval,
                                    GdkKeymapKey **keys,
                                    gint          *n_keys)
@@ -618,8 +637,8 @@ gdk_keymap_get_entries_for_keyval (GdkKeymap     *keymap,
   return *n_keys > 0;
 }
 
-gboolean
+static gboolean
-gdk_keymap_get_entries_for_keycode (GdkKeymap     *keymap,
+gdk_win32_keymap_get_entries_for_keycode (GdkKeymap     *keymap,
                                     guint          hardware_keycode,
                                     GdkKeymapKey **keys,
                                     guint        **keyvals,
@@ -712,8 +731,8 @@ gdk_keymap_get_entries_for_keycode (GdkKeymap     *keymap,
   return *n_entries > 0;
 }
 
-guint
+static guint
-gdk_keymap_lookup_key (GdkKeymap          *keymap,
+gdk_win32_keymap_lookup_key (GdkKeymap          *keymap,
                        const GdkKeymapKey *key)
 {
   guint sym;
@@ -741,8 +760,8 @@ gdk_keymap_lookup_key (GdkKeymap          *keymap,
     return sym;
 }
 
-gboolean
+static gboolean
-gdk_keymap_translate_keyboard_state (GdkKeymap       *keymap,
+gdk_win32_keymap_translate_keyboard_state (GdkKeymap       *keymap,
                                      guint            hardware_keycode,
                                      GdkModifierType  state,
                                      gint             group,
@@ -878,16 +897,41 @@ gdk_keymap_translate_keyboard_state (GdkKeymap       *keymap,
   return tmp_keyval != GDK_KEY_VoidSymbol;
 }
 
-void
+static void
-gdk_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
+gdk_win32_keymap_add_virtual_modifiers (GdkKeymap       *keymap,
                                   GdkModifierType *state)
 {
 }
 
-gboolean
+static gboolean
-gdk_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
+gdk_win32_keymap_map_virtual_modifiers (GdkKeymap       *keymap,
                                   GdkModifierType *state)
 {
   /* FIXME: Is this the right thing to do? */
   return TRUE;
 }
+
+static void
+gdk_win32_keymap_finalize (GObject *object)
+{
+}
+
+static void
+gdk_win32_keymap_class_init (GdkWin32KeymapClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkKeymapClass *keymap_class = GDK_KEYMAP_CLASS (klass);
+
+  object_class->finalize = gdk_win32_keymap_finalize;
+
+  keymap_class->get_direction = gdk_win32_keymap_get_direction;
+  keymap_class->have_bidi_layouts = gdk_win32_keymap_have_bidi_layouts;
+  keymap_class->get_caps_lock_state = gdk_win32_keymap_get_caps_lock_state;
+  keymap_class->get_num_lock_state = gdk_win32_keymap_get_num_lock_state;
+  keymap_class->get_entries_for_keyval = gdk_win32_keymap_get_entries_for_keyval;
+  keymap_class->get_entries_for_keycode = gdk_win32_keymap_get_entries_for_keycode;
+  keymap_class->lookup_key = gdk_win32_keymap_lookup_key;
+  keymap_class->translate_keyboard_state = gdk_win32_keymap_translate_keyboard_state;
+  keymap_class->add_virtual_modifiers = gdk_win32_keymap_add_virtual_modifiers;
+  keymap_class->map_virtual_modifiers = gdk_win32_keymap_map_virtual_modifiers;
+}

gdk/win32/gdkmain-win32.c

@@ -38,6 +38,7 @@
 #include "gdkinternals.h"
 #include "gdkintl.h"
 #include "gdkprivate-win32.h"
+#include "gdkwin32.h"
 
 #include <objbase.h>
 
@@ -64,7 +65,7 @@ const GOptionEntry _gdk_windowing_args[] = {
   { NULL }
 };
 
-int __stdcall
+BOOL WINAPI
 DllMain (HINSTANCE hinstDLL,
 	 DWORD     dwReason,
 	 LPVOID    reserved)
@@ -75,7 +76,7 @@ DllMain (HINSTANCE hinstDLL,
 }
 
 void
-_gdk_windowing_init (void)
+_gdk_win32_windowing_init (void)
 {
   gchar buf[10];
 
@@ -151,67 +152,6 @@ _gdk_other_api_failed (const gchar *where,
   g_warning ("%s: %s failed", where, api);
 }
 
-gint
-gdk_screen_get_width (GdkScreen *screen)
-{
-  return GDK_WINDOW_OBJECT (_gdk_root)->width;
-}
-
-gint
-gdk_screen_get_height (GdkScreen *screen)
-{
-  return GDK_WINDOW_OBJECT (_gdk_root)->height;
-}
-gint
-gdk_screen_get_width_mm (GdkScreen *screen)
-{
-  return (double) gdk_screen_get_width (screen) / GetDeviceCaps (_gdk_display_hdc, LOGPIXELSX) * 25.4;
-}
-
-gint
-gdk_screen_get_height_mm (GdkScreen *screen)
-{
-  return (double) gdk_screen_get_height (screen) / GetDeviceCaps (_gdk_display_hdc, LOGPIXELSY) * 25.4;
-}
-
-void
-gdk_display_beep (GdkDisplay *display)
-{
-  g_return_if_fail (display == gdk_display_get_default());
-  Beep(1000, 50);
-}
-
-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)
-{
-}
-
-void
-gdk_notify_startup_complete_with_id (const gchar* startup_id)
-{
-}
-
-void          
-gdk_window_set_startup_id (GdkWindow   *window,
-			   const gchar *startup_id)
-{
-}
 
 #ifdef G_ENABLE_DEBUG
 
@@ -1021,13 +961,13 @@ _gdk_win32_cairo_region_to_string (const cairo_region_t *rgn)
 }
 
 gchar *
-_gdk_win32_drawable_description (GdkDrawable *d)
+_gdk_win32_window_description (GdkWindow *d)
 {
-  g_return_val_if_fail (GDK_IS_DRAWABLE (d), NULL);
+  g_return_val_if_fail (GDK_IS_WINDOW (d), NULL);
 
   return static_printf ("%s:%p:%dx%dx%d",
 			G_OBJECT_TYPE_NAME (d),
-			GDK_DRAWABLE_HANDLE (d),
+			GDK_WINDOW_HWND (d),
 			gdk_window_get_width (GDK_WINDOW (d)),
                         gdk_window_get_height (GDK_WINDOW (d)),
                         gdk_visual_get_depth (gdk_window_get_visual (GDK_WINDOW (d))));

gdk/win32/gdkprivate-win32.h

@@ -36,6 +36,7 @@
 #endif
 
 #include <gdk/gdkprivate.h>
+#include <gdk/gdkcursorprivate.h>
 #include <gdk/win32/gdkwindow-win32.h>
 
 #include "gdkinternals.h"
@@ -103,16 +104,15 @@
 #define GDK_DEBUG_MISC_OR_COLORMAP (GDK_DEBUG_MISC|GDK_DEBUG_COLORMAP)
 #define GDK_DEBUG_MISC_OR_EVENTS (GDK_DEBUG_MISC|GDK_DEBUG_EVENTS)
 
-//#define GDK_WINDOW_SCREEN(win)         (_gdk_screen)
 GdkScreen *GDK_WINDOW_SCREEN(GObject *win);
 
-#define GDK_WINDOW_IS_WIN32(win)        (GDK_IS_WINDOW_IMPL_WIN32 (((GdkWindowObject *)win)->impl))
+#define GDK_WINDOW_IS_WIN32(win)        (GDK_IS_WINDOW_IMPL_WIN32 (win->impl))
 
 typedef struct _GdkColormapPrivateWin32 GdkColormapPrivateWin32;
-typedef struct _GdkCursorPrivate        GdkCursorPrivate;
+typedef struct _GdkWin32Cursor          GdkWin32Cursor;
 typedef struct _GdkWin32SingleFont      GdkWin32SingleFont;
 
-struct _GdkCursorPrivate
+struct _GdkWin32Cursor
 {
   GdkCursor cursor;
   HCURSOR hcursor;
@@ -126,11 +126,6 @@ struct _GdkWin32SingleFont
   FONTSIGNATURE fs;
 };
 
-struct _GdkVisualClass
-{
-  GObjectClass parent_class;
-};
-
 typedef enum {
   GDK_WIN32_PE_STATIC,
   GDK_WIN32_PE_AVAILABLE,
@@ -208,7 +203,7 @@ gchar *_gdk_win32_window_style_to_string (LONG style);
 gchar *_gdk_win32_window_exstyle_to_string (LONG style);
 gchar *_gdk_win32_window_pos_bits_to_string (UINT flags);
 gchar *_gdk_win32_drag_action_to_string (GdkDragAction actions);
-gchar *_gdk_win32_drawable_description (GdkDrawable *d);
+gchar *_gdk_win32_window_description (GdkWindow *d);
 
 gchar *_gdk_win32_rop2_to_string       (int          rop2);
 gchar *_gdk_win32_lbstyle_to_string    (UINT         brush_style);
@@ -371,7 +366,149 @@ HICON _gdk_win32_pixbuf_to_hcursor (GdkPixbuf *pixbuf,
 				    gint       y_hotspot);
 gboolean _gdk_win32_pixbuf_to_hicon_supports_alpha (void);
 
+/* GdkDisplay member functions */
+GdkNativeWindow _gdk_win32_display_get_drag_protocol (GdkDisplay      *display,
+						      GdkNativeWindow  xid,
+						      GdkDragProtocol *protocol,
+						      guint           *version);
+
+GdkCursor *_gdk_win32_display_get_cursor_for_type (GdkDisplay   *display,
+						   GdkCursorType cursor_type);
+GdkCursor *_gdk_win32_display_get_cursor_for_name (GdkDisplay  *display,
+						   const gchar *name);
+GdkCursor *_gdk_win32_display_get_cursor_for_pixbuf (GdkDisplay *display, 
+						     GdkPixbuf  *pixbuf,
+						     gint        x,
+						     gint        y);
+void     _gdk_win32_display_get_default_cursor_size (GdkDisplay  *display,
+						     guint       *width,
+						     guint       *height);
+void     _gdk_win32_display_get_maximal_cursor_size (GdkDisplay  *display,
+						     guint       *width,
+						     guint       *height);
+gboolean _gdk_win32_display_supports_cursor_alpha (GdkDisplay    *display);
+gboolean _gdk_win32_display_supports_cursor_color (GdkDisplay    *display);
+
+GList *_gdk_win32_display_list_devices (GdkDisplay *dpy);
+
+gboolean _gdk_win32_display_send_client_message   (GdkDisplay     *display,
+						   GdkEvent       *event,
+						   GdkNativeWindow winid);
+void _gdk_win32_display_add_client_message_filter (GdkDisplay   *display,
+						   GdkAtom       message_type,
+						   GdkFilterFunc func,
+						   gpointer      data);
+void _gdk_win32_display_sync (GdkDisplay * display);
+gboolean _gdk_win32_display_has_pending (GdkDisplay *display);
+void _gdk_win32_display_queue_events (GdkDisplay *display);
+
+gboolean _gdk_win32_selection_owner_set_for_display (GdkDisplay *display,
+						     GdkWindow  *owner,
+						     GdkAtom     selection,
+						     guint32     time,
+						     gboolean    send_event);
+GdkWindow *_gdk_win32_display_get_selection_owner   (GdkDisplay *display,
+						     GdkAtom     selection);
+gboolean   _gdk_win32_display_set_selection_owner   (GdkDisplay *display,
+						     GdkWindow  *owner,
+						     GdkAtom     selection,
+						     guint32     time,
+						     gboolean    send_event);
+void       _gdk_win32_display_send_selection_notify (GdkDisplay      *display,
+						     GdkNativeWindow  requestor,
+						     GdkAtom   	      selection,
+						     GdkAtom          target,
+						     GdkAtom          property,
+						     guint32          time);
+gint      _gdk_win32_display_get_selection_property (GdkDisplay *display,
+						     GdkWindow  *requestor,
+						     guchar    **data,
+						     GdkAtom    *ret_type,
+						     gint       *ret_format);
+void      _gdk_win32_display_convert_selection (GdkDisplay *display,
+						GdkWindow *requestor,
+						GdkAtom    selection,
+						GdkAtom    target,
+						guint32    time);
+gint      _gdk_win32_display_text_property_to_utf8_list (GdkDisplay    *display,
+							 GdkAtom        encoding,
+							 gint           format,
+							 const guchar  *text,
+							 gint           length,
+							 gchar       ***list);
+gchar     *_gdk_win32_display_utf8_to_string_target (GdkDisplay *display, const gchar *str);
+
+GdkKeymap *_gdk_win32_display_get_keymap (GdkDisplay *display);
+
+void       _gdk_win32_display_create_window_impl   (GdkDisplay    *display,
+                                                    GdkWindow     *window,
+                                                    GdkWindow     *real_parent,
+                                                    GdkScreen     *screen,
+                                                    GdkEventMask   event_mask,
+                                                    GdkWindowAttr *attributes,
+                                                    gint           attributes_mask);
+
+/* stray GdkWindowImplWin32 members */
+void _gdk_win32_window_register_dnd (GdkWindow *window);
+GdkDragContext *_gdk_win32_window_drag_begin (GdkWindow *window, GdkDevice *device, GList *targets);
+gboolean _gdk_win32_window_simulate_key (GdkWindow      *window,
+				  gint            x,
+				  gint            y,
+				  guint           keyval,
+				  GdkModifierType modifiers,
+				  GdkEventType    key_pressrelease);
+gboolean _gdk_win32_window_simulate_button (GdkWindow      *window,
+				     gint            x,
+				     gint            y,
+				     guint           button, /*1..3*/
+				     GdkModifierType modifiers,
+				     GdkEventType    button_pressrelease);
+
+gint _gdk_win32_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_win32_window_change_property (GdkWindow    *window,
+					GdkAtom       property,
+					GdkAtom       type,
+					gint          format,
+					GdkPropMode   mode,
+					const guchar *data,
+					gint          nelements);
+void _gdk_win32_window_delete_property (GdkWindow *window, GdkAtom    property);
+
+/* Stray GdkWin32Screen members */
+GdkVisual *_gdk_win32_screen_get_system_visual (GdkScreen *screen);
+void _gdk_win32_screen_broadcast_client_message (GdkScreen *screen, GdkEvent  *event);
+gboolean _gdk_win32_screen_get_setting (GdkScreen   *screen, const gchar *name, GValue *value);
+gint _gdk_win32_screen_visual_get_best_depth (GdkScreen *screen);
+GdkVisualType _gdk_win32_screen_visual_get_best_type (GdkScreen *screen);
+GdkVisual *_gdk_win32_screen_visual_get_best (GdkScreen *screen);
+GdkVisual *_gdk_win32_screen_visual_get_best_with_depth (GdkScreen *screen, gint depth);
+GdkVisual *_gdk_win32_screen_visual_get_best_with_type (GdkScreen *screen, GdkVisualType visual_type);
+GdkVisual *_gdk_win32_screen_visual_get_best_with_both (GdkScreen *screen, gint depth, GdkVisualType visual_type);
+void _gdk_win32_screen_query_depths  (GdkScreen *screen, gint **depths, gint  *count);
+void _gdk_win32_screen_query_visual_types (GdkScreen      *screen,
+				           GdkVisualType **visual_types,
+				           gint           *count);
+GList *_gdk_win32_screen_list_visuals (GdkScreen *screen);
+
+/* Distributed display manager implementation */
+GdkDisplay *_gdk_win32_display_open (const gchar *display_name);
+GdkAtom _gdk_win32_display_manager_atom_intern (GdkDisplayManager *manager,
+						const gchar *atom_name,
+						gint         only_if_exists);
+gchar *_gdk_win32_display_manager_get_atom_name (GdkDisplayManager *manager, 
+					         GdkAtom            atom);
+
 /* Initialization */
+void _gdk_win32_windowing_init (void);
 void _gdk_windowing_window_init (GdkScreen *screen);
 void _gdk_root_window_size_init (void);
 void _gdk_monitor_init(void);

gdk/win32/gdkproperty-win32.c

@@ -34,10 +34,12 @@
 #include "gdkproperty.h"
 #include "gdkselection.h"
 #include "gdkprivate-win32.h"
+#include "gdkwin32.h"
 
 GdkAtom
-gdk_atom_intern (const gchar *atom_name,
+_gdk_win32_display_manager_atom_intern (GdkDisplayManager *manager,
-		 gint         only_if_exists)
+					const gchar *atom_name,
+					gint         only_if_exists)
 {
   ATOM win32_atom;
   GdkAtom retval;
@@ -84,17 +86,9 @@ gdk_atom_intern (const gchar *atom_name,
   return retval;
 }
 
-GdkAtom
-gdk_atom_intern_static_string (const gchar *atom_name)
-{
-  /* on X11 this is supposed to save memory. On win32 there seems to be
-   * no way to make a difference ?
-   */
-  return gdk_atom_intern (atom_name, FALSE);
-}
-
 gchar *
-gdk_atom_name (GdkAtom atom)
+_gdk_win32_display_manager_get_atom_name (GdkDisplayManager *manager, 
+					  GdkAtom            atom)
 {
   ATOM win32_atom;
   gchar name[256];
@@ -122,7 +116,7 @@ gdk_atom_name (GdkAtom atom)
 }
 
 gint
-gdk_property_get (GdkWindow   *window,
+_gdk_win32_window_get_property (GdkWindow   *window,
 		  GdkAtom      property,
 		  GdkAtom      type,
 		  gulong       offset,
@@ -145,7 +139,7 @@ gdk_property_get (GdkWindow   *window,
 }
 
 void
-gdk_property_change (GdkWindow    *window,
+_gdk_win32_window_change_property (GdkWindow    *window,
 		     GdkAtom       property,
 		     GdkAtom       type,
 		     gint          format,
@@ -268,8 +262,8 @@ gdk_property_change (GdkWindow    *window,
 }
 
 void
-gdk_property_delete (GdkWindow *window,
+_gdk_win32_window_delete_property (GdkWindow *window,
-		     GdkAtom    property)
+				   GdkAtom    property)
 {
   gchar *prop_name;
 
@@ -354,7 +348,7 @@ gdk_property_delete (GdkWindow *window,
 
 */
 gboolean
-gdk_screen_get_setting (GdkScreen   *screen,
+_gdk_win32_screen_get_setting (GdkScreen   *screen,
                         const gchar *name,
                         GValue      *value)
 {

gdk/win32/gdkscreen-win32.c

@@ -20,37 +20,77 @@
 #include "config.h"
 #include "gdk.h"
 #include "gdkprivate-win32.h"
+#include "gdkscreenprivate.h"
+#include "gdkwin32screen.h"
 
-GdkDisplay *
+struct _GdkWin32Screen
-gdk_screen_get_display (GdkScreen *screen)
+{
+  GdkScreen parent_instance;
+};
+struct _GdkWin32ScreenClass
+{
+  GdkScreenClass parent_class;
+};
+G_DEFINE_TYPE (GdkWin32Screen, gdk_win32_screen, GDK_TYPE_SCREEN)
+static void
+gdk_win32_screen_init(GdkWin32Screen *display)
+{
+}
+
+static GdkDisplay *
+gdk_win32_screen_get_display (GdkScreen *screen)
 {
   return _gdk_display;
 }
 
-GdkWindow *
+static gint
-gdk_screen_get_root_window (GdkScreen *screen)
+gdk_win32_screen_get_width (GdkScreen *screen)
+{
+  return GDK_WINDOW (_gdk_root)->width;
+}
+
+static gint
+gdk_win32_screen_get_height (GdkScreen *screen)
+{
+  return GDK_WINDOW (_gdk_root)->height;
+}
+
+static gint
+gdk_win32_screen_get_width_mm (GdkScreen *screen)
+{
+  return (double) gdk_screen_get_width (screen) / GetDeviceCaps (_gdk_display_hdc, LOGPIXELSX) * 25.4;
+}
+
+static gint
+gdk_win32_screen_get_height_mm (GdkScreen *screen)
+{
+  return (double) gdk_screen_get_height (screen) / GetDeviceCaps (_gdk_display_hdc, LOGPIXELSY) * 25.4;
+}
+
+static GdkWindow *
+gdk_win32_screen_get_root_window (GdkScreen *screen)
 {
   return _gdk_root;
 }
 
-gint
+static gint
-gdk_screen_get_n_monitors (GdkScreen *screen)
+gdk_win32_screen_get_n_monitors (GdkScreen *screen)
 {
   g_return_val_if_fail (screen == _gdk_screen, 0);
 
   return _gdk_num_monitors;
 }
 
-gint
+static gint
-gdk_screen_get_primary_monitor (GdkScreen *screen)
+gdk_win32_screen_get_primary_monitor (GdkScreen *screen)
 {
   g_return_val_if_fail (screen == _gdk_screen, 0);
 
   return 0;
 }
 
-gint
+static gint
-gdk_screen_get_monitor_width_mm (GdkScreen *screen,
+gdk_win32_screen_get_monitor_width_mm (GdkScreen *screen,
                                  gint       num_monitor)
 {
   g_return_val_if_fail (screen == _gdk_screen, 0);
@@ -60,8 +100,8 @@ gdk_screen_get_monitor_width_mm (GdkScreen *screen,
   return _gdk_monitors[num_monitor].width_mm;
 }
 
-gint
+static gint
-gdk_screen_get_monitor_height_mm (GdkScreen *screen,
+gdk_win32_screen_get_monitor_height_mm (GdkScreen *screen,
                                   gint       num_monitor)
 {
   g_return_val_if_fail (screen == _gdk_screen, 0);
@@ -71,8 +111,8 @@ gdk_screen_get_monitor_height_mm (GdkScreen *screen,
   return _gdk_monitors[num_monitor].height_mm;
 }
 
-gchar *
+static gchar *
-gdk_screen_get_monitor_plug_name (GdkScreen *screen,
+gdk_win32_screen_get_monitor_plug_name (GdkScreen *screen,
                                   gint       num_monitor)
 {
   g_return_val_if_fail (screen == _gdk_screen, 0);
@@ -82,8 +122,8 @@ gdk_screen_get_monitor_plug_name (GdkScreen *screen,
   return g_strdup (_gdk_monitors[num_monitor].name);
 }
 
-void
+static void
-gdk_screen_get_monitor_geometry (GdkScreen    *screen, 
+gdk_win32_screen_get_monitor_geometry (GdkScreen    *screen, 
 				 gint          num_monitor,
 				 GdkRectangle *dest)
 {
@@ -94,16 +134,16 @@ gdk_screen_get_monitor_geometry (GdkScreen    *screen,
   *dest = _gdk_monitors[num_monitor].rect;
 }
 
-GdkVisual *
+static GdkVisual *
-gdk_screen_get_rgba_visual (GdkScreen *screen)
+gdk_win32_screen_get_rgba_visual (GdkScreen *screen)
 {
   g_return_val_if_fail (screen == _gdk_screen, NULL);
 
   return NULL;
 }
   
-gint
+static gint
-gdk_screen_get_number (GdkScreen *screen)
+gdk_win32_screen_get_number (GdkScreen *screen)
 {
   g_return_val_if_fail (screen == _gdk_screen, 0);  
   
@@ -120,32 +160,83 @@ _gdk_windowing_substitute_screen_number (const gchar *display_name,
   return g_strdup (display_name);
 }
 
-gchar *
+static gchar *
-gdk_screen_make_display_name (GdkScreen *screen)
+gdk_win32_screen_make_display_name (GdkScreen *screen)
 {
   return g_strdup (gdk_display_get_name (_gdk_display));
 }
 
-GdkWindow *
+static GdkWindow *
-gdk_screen_get_active_window (GdkScreen *screen)
+gdk_win32_screen_get_active_window (GdkScreen *screen)
 {
   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 
   return NULL;
 }
 
-GList *
+static GList *
-gdk_screen_get_window_stack (GdkScreen *screen)
+gdk_win32_screen_get_window_stack (GdkScreen *screen)
 {
   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 
   return NULL;
 }
 
-gboolean
+static gboolean
-gdk_screen_is_composited (GdkScreen *screen)
+gdk_win32_screen_is_composited (GdkScreen *screen)
 {
   g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
 
   return FALSE;
 }
+
+static void
+gdk_win32_screen_finalize (GObject *object)
+{
+}
+
+static void
+gdk_win32_screen_dispose (GObject *object)
+{
+}
+
+static void
+gdk_win32_screen_class_init (GdkWin32ScreenClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkScreenClass *screen_class = GDK_SCREEN_CLASS (klass);
+
+  object_class->dispose = gdk_win32_screen_dispose;
+  object_class->finalize = gdk_win32_screen_finalize;
+
+  screen_class->get_display = gdk_win32_screen_get_display;
+  screen_class->get_width = gdk_win32_screen_get_width;
+  screen_class->get_height = gdk_win32_screen_get_height;
+  screen_class->get_width_mm = gdk_win32_screen_get_width_mm;
+  screen_class->get_height_mm = gdk_win32_screen_get_height_mm;
+  screen_class->get_number = gdk_win32_screen_get_number;
+  screen_class->get_root_window = gdk_win32_screen_get_root_window;
+  screen_class->get_n_monitors = gdk_win32_screen_get_n_monitors;
+  screen_class->get_primary_monitor = gdk_win32_screen_get_primary_monitor;
+  screen_class->get_monitor_width_mm = gdk_win32_screen_get_monitor_width_mm;
+  screen_class->get_monitor_height_mm = gdk_win32_screen_get_monitor_height_mm;
+  screen_class->get_monitor_plug_name = gdk_win32_screen_get_monitor_plug_name;
+  screen_class->get_monitor_geometry = gdk_win32_screen_get_monitor_geometry;
+  screen_class->get_system_visual = _gdk_win32_screen_get_system_visual;
+  screen_class->get_rgba_visual = gdk_win32_screen_get_rgba_visual;
+  screen_class->is_composited = gdk_win32_screen_is_composited;
+  screen_class->make_display_name = gdk_win32_screen_make_display_name;
+  screen_class->get_active_window = gdk_win32_screen_get_active_window;
+  screen_class->get_window_stack = gdk_win32_screen_get_window_stack;
+  screen_class->broadcast_client_message = _gdk_win32_screen_broadcast_client_message;
+  screen_class->get_setting = _gdk_win32_screen_get_setting;
+  screen_class->visual_get_best_depth = _gdk_win32_screen_visual_get_best_depth;
+  screen_class->visual_get_best_type = _gdk_win32_screen_visual_get_best_type;
+  screen_class->visual_get_best = _gdk_win32_screen_visual_get_best;
+  screen_class->visual_get_best_with_depth = _gdk_win32_screen_visual_get_best_with_depth;
+  screen_class->visual_get_best_with_type = _gdk_win32_screen_visual_get_best_with_type;
+  screen_class->visual_get_best_with_both = _gdk_win32_screen_visual_get_best_with_both;
+  screen_class->query_depths = _gdk_win32_screen_query_depths;
+  screen_class->query_visual_types = _gdk_win32_screen_query_visual_types;
+  screen_class->list_visuals = _gdk_win32_screen_list_visuals;
+}

gdk/win32/gdkselection-win32.c

@@ -33,6 +33,7 @@
 #include "gdkselection.h"
 #include "gdkdisplay.h"
 #include "gdkprivate-win32.h"
+#include "gdkwin32.h"
 
 /* We emulate the GDK_SELECTION window properties of windows (as used
  * in the X11 backend) by using a hash table from window handles to
@@ -253,11 +254,11 @@ get_mapped_gdk_atom_name (GdkAtom gdk_target)
 }
 
 gboolean
-gdk_selection_owner_set_for_display (GdkDisplay *display,
+_gdk_win32_display_set_selection_owner (GdkDisplay *display,
-                                     GdkWindow  *owner,
+					GdkWindow  *owner,
-                                     GdkAtom     selection,
+					GdkAtom     selection,
-                                     guint32     time,
+					guint32     time,
-                                     gboolean    send_event)
+					gboolean    send_event)
 {
   HWND hwnd;
   GdkEvent tmp_event;
@@ -333,8 +334,8 @@ gdk_selection_owner_set_for_display (GdkDisplay *display,
 }
 
 GdkWindow*
-gdk_selection_owner_get_for_display (GdkDisplay *display,
+_gdk_win32_display_get_selection_owner (GdkDisplay *display,
-                                     GdkAtom     selection)
+                                        GdkAtom     selection)
 {
   GdkWindow *window;
 
@@ -351,7 +352,8 @@ gdk_selection_owner_get_for_display (GdkDisplay *display,
       return gdk_win32_handle_table_lookup ((GdkNativeWindow) owner);
     }
 
-  window = gdk_window_lookup ((GdkNativeWindow) g_hash_table_lookup (sel_owner_table, selection));
+  window = gdk_win32_window_lookup_for_display (display,
+                                                (GdkNativeWindow) g_hash_table_lookup (sel_owner_table, selection));
 
   GDK_NOTE (DND, {
       gchar *sel_name = gdk_atom_name (selection);
@@ -387,10 +389,11 @@ generate_selection_notify (GdkWindow *requestor,
 }
 
 void
-gdk_selection_convert (GdkWindow *requestor,
+_gdk_win32_display_convert_selection (GdkDisplay *display,
-		       GdkAtom    selection,
+				      GdkWindow *requestor,
-		       GdkAtom    target,
+				      GdkAtom    selection,
-		       guint32    time)
+				      GdkAtom    target,
+				      guint32    time)
 {
   HGLOBAL hdata;
   GdkAtom property = _gdk_selection;
@@ -804,10 +807,11 @@ gdk_selection_convert (GdkWindow *requestor,
 }
 
 gint
-gdk_selection_property_get (GdkWindow  *requestor,
+_gdk_win32_display_get_selection_property (GdkDisplay *display,
-			    guchar    **data,
+					   GdkWindow  *requestor,
-			    GdkAtom    *ret_type,
+					   guchar    **data,
-			    gint       *ret_format)
+					   GdkAtom    *ret_type,
+					   gint       *ret_format)
 {
   GdkSelProp *prop;
 
@@ -869,12 +873,12 @@ _gdk_selection_property_delete (GdkWindow *window)
 }
 
 void
-gdk_selection_send_notify_for_display (GdkDisplay      *display,
+_gdk_win32_display_send_selection_notify (GdkDisplay      *display,
-                                       GdkNativeWindow  requestor,
+					  GdkNativeWindow  requestor,
-                                       GdkAtom     	selection,
+					  GdkAtom     	selection,
-                                       GdkAtom     	target,
+					  GdkAtom     	target,
-                                       GdkAtom     	property,
+					  GdkAtom     	property,
-                                       guint32     	time)
+					  guint32     	time)
 {
   g_return_if_fail (display == _gdk_display);
 
@@ -1020,13 +1024,13 @@ make_list (const gchar  *text,
   return n_strings;
 }
 
-gint 
+gint
-gdk_text_property_to_utf8_list_for_display (GdkDisplay    *display,
+_gdk_win32_display_text_property_to_utf8_list (GdkDisplay    *display,
-                                            GdkAtom        encoding,
+					       GdkAtom        encoding,
-                                            gint           format,
+					       gint           format,
-                                            const guchar  *text,
+					       const guchar  *text,
-                                            gint           length,
+					       gint           length,
-                                            gchar       ***list)
+					       gchar       ***list)
 {
   g_return_val_if_fail (text != NULL, 0);
   g_return_val_if_fail (length >= 0, 0);
@@ -1086,7 +1090,8 @@ gdk_string_to_compound_text_for_display (GdkDisplay  *display,
 }
 
 gchar *
-gdk_utf8_to_string_target (const gchar *str)
+_gdk_win32_display_utf8_to_string_target (GdkDisplay *display,
+					  const gchar *str)
 {
   return _gdk_utf8_to_string_target_internal (str, strlen (str));
 }

gdk/win32/gdkspawn-win32.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/win32/gdktestutils-win32.c

@@ -22,13 +22,8 @@
 #include <win32/gdkwin32.h>
 
 
-void
-gdk_test_render_sync (GdkWindow *window)
-{
-}
-
 gboolean
-gdk_test_simulate_key (GdkWindow      *window,
+_gdk_win32_window_simulate_key (GdkWindow      *window,
                        gint            x,
                        gint            y,
                        guint           keyval,
@@ -41,7 +36,7 @@ gdk_test_simulate_key (GdkWindow      *window,
 }
 
 gboolean
-gdk_test_simulate_button (GdkWindow      *window,
+_gdk_win32_window_simulate_button (GdkWindow      *window,
                           gint            x,
                           gint            y,
                           guint           button, /*1..3*/

gdk/win32/gdkvisual-win32.c

@@ -31,6 +31,7 @@
 #include "gdkvisual.h"
 #include "gdkscreen.h" /* gdk_screen_get_default() */
 #include "gdkprivate-win32.h"
+#include "gdkvisualprivate.h"
 
 static void  gdk_visual_decompose_mask (gulong     mask,
 					gint      *shift,
@@ -42,46 +43,6 @@ static gint available_depths[1];
 
 static GdkVisualType available_types[1];
 
-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;
-}
-
 void
 _gdk_visual_init (void)
 {
@@ -102,6 +63,7 @@ _gdk_visual_init (void)
   gint map_entries = 0;
 
   system_visual = g_object_new (GDK_TYPE_VISUAL, NULL);
+  system_visual->screen = gdk_screen_get_default();
 
   GDK_NOTE (COLORMAP, g_print ("BITSPIXEL=%d NUMCOLORS=%d\n",
 			       bitspixel, numcolors));
@@ -290,31 +252,31 @@ _gdk_visual_init (void)
 }
 
 gint
-gdk_visual_get_best_depth (void)
+_gdk_win32_screen_visual_get_best_depth (GdkScreen *screen)
 {
   return available_depths[0];
 }
 
 GdkVisualType
-gdk_visual_get_best_type (void)
+_gdk_win32_screen_visual_get_best_type (GdkScreen *screen)
 {
   return available_types[0];
 }
 
 GdkVisual*
-gdk_screen_get_system_visual (GdkScreen *screen)
+_gdk_win32_screen_get_system_visual (GdkScreen *screen)
 {
   return system_visual;
 }
 
 GdkVisual*
-gdk_visual_get_best (void)
+_gdk_win32_screen_visual_get_best (GdkScreen *screen)
 {
   return ((GdkVisual*) system_visual);
 }
 
 GdkVisual*
-gdk_visual_get_best_with_depth (gint depth)
+_gdk_win32_screen_visual_get_best_with_depth (GdkScreen *screen, gint depth)
 {
   if (depth == system_visual->depth)
     return (GdkVisual*) system_visual;
@@ -323,7 +285,7 @@ gdk_visual_get_best_with_depth (gint depth)
 }
 
 GdkVisual*
-gdk_visual_get_best_with_type (GdkVisualType visual_type)
+_gdk_win32_screen_visual_get_best_with_type (GdkScreen *screen, GdkVisualType visual_type)
 {
   if (visual_type == system_visual->type)
     return system_visual;
@@ -332,8 +294,9 @@ gdk_visual_get_best_with_type (GdkVisualType visual_type)
 }
 
 GdkVisual*
-gdk_visual_get_best_with_both (gint          depth,
+_gdk_win32_screen_visual_get_best_with_both (GdkScreen    *screen,
-			       GdkVisualType visual_type)
+					     gint          depth,
+					     GdkVisualType visual_type)
 {
   if ((depth == system_visual->depth) && (visual_type == system_visual->type))
     return system_visual;
@@ -342,35 +305,29 @@ gdk_visual_get_best_with_both (gint          depth,
 }
 
 void
-gdk_query_depths  (gint **depths,
+_gdk_win32_screen_query_depths  (GdkScreen *screen,
-		   gint  *count)
+				 gint **depths,
+				 gint  *count)
 {
   *count = 1;
   *depths = available_depths;
 }
 
 void
-gdk_query_visual_types (GdkVisualType **visual_types,
+_gdk_win32_screen_query_visual_types (GdkScreen      *screen,
-			gint           *count)
+				      GdkVisualType **visual_types,
+				      gint           *count)
 {
   *count = 1;
   *visual_types = available_types;
 }
 
 GList*
-gdk_screen_list_visuals (GdkScreen *screen)
+_gdk_win32_screen_list_visuals (GdkScreen *screen)
 {
   return g_list_append (NULL, (gpointer) system_visual);
 }
 
-GdkScreen *
-gdk_visual_get_screen (GdkVisual *visual)
-{
-  g_return_val_if_fail (GDK_IS_VISUAL (visual), NULL);
-
-  return gdk_screen_get_default ();
-}
-
 static void
 gdk_visual_decompose_mask (gulong  mask,
 			   gint   *shift,

gdk/win32/gdkwin32.h

@@ -27,6 +27,18 @@
 #ifndef __GDK_WIN32_H__
 #define __GDK_WIN32_H__
 
+#define __GDKWIN32_H_INSIDE__
+
+#include <gdk/win32/gdkwin32cursor.h>
+#include <gdk/win32/gdkwin32display.h>
+#include <gdk/win32/gdkwin32displaymanager.h>
+#include <gdk/win32/gdkwin32dnd.h>
+#include <gdk/win32/gdkwin32keys.h>
+#include <gdk/win32/gdkwin32screen.h>
+#include <gdk/win32/gdkwin32window.h>
+
+#undef __GDKWIN32_H_INSIDE__
+
 #include <gdk/gdkprivate.h>
 
 #ifndef STRICT
@@ -41,19 +53,13 @@ G_BEGIN_DECLS
 
 #include "gdkprivate-win32.h"
 
-#define GDK_WINDOW_HWND(win)          (GDK_DRAWABLE_IMPL_WIN32(((GdkWindowObject *)win)->impl)->handle)
+#define GDK_WINDOW_HWND(win)          (GDK_WINDOW_IMPL_WIN32(win->impl)->handle)
-#define GDK_DRAWABLE_IMPL_WIN32_HANDLE(d) (((GdkDrawableImplWin32 *) d)->handle)
-#define GDK_DRAWABLE_HANDLE(win)      (GDK_IS_WINDOW (win) ? GDK_WINDOW_HWND (win) : (GDK_IS_DRAWABLE_IMPL_WIN32 (win) ? GDK_DRAWABLE_IMPL_WIN32_HANDLE (win) : 0))
 #else
 /* definition for exported 'internals' go here */
-#define GDK_WINDOW_HWND(d) (gdk_win32_drawable_get_handle (d))
+#define GDK_WINDOW_HWND(d) (gdk_win32_window_get_handle (d))
 
 #endif
 
-#define GDK_ROOT_WINDOW()             ((guint32) HWND_DESKTOP)
-#define GDK_DISPLAY()                 NULL
-
-
 /* These need to be here so gtkstatusicon.c can pick them up if needed. */
 #ifndef WM_XBUTTONDOWN
 #define WM_XBUTTONDOWN 0x020B
@@ -77,9 +83,8 @@ gboolean      gdk_win32_window_is_win32 (GdkWindow *window);
 
 /* Return the Gdk* for a particular HANDLE */
 gpointer      gdk_win32_handle_table_lookup (GdkNativeWindow handle);
-
+/* Translate from window to Windows handle */
-/* Translate from drawable to Windows handle */
+HGDIOBJ       gdk_win32_window_get_handle (GdkWindow *window);
-HGDIOBJ       gdk_win32_drawable_get_handle (GdkDrawable *drawable);
 
 void          gdk_win32_selection_add_targets (GdkWindow  *owner,
 					       GdkAtom     selection,

gdk/win32/gdkwin32cursor.h

@@ -0,0 +1,56 @@
+/* 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/. 
+ */
+
+#if !defined (__GDKWIN32_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdkwin32.h> can be included directly."
+#endif
+
+#ifndef __GDK_WIN32_CURSOR_H__
+#define __GDK_WIN32_CURSOR_H__
+
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_WIN32_CURSOR              (gdk_win32_cursor_get_type ())
+#define GDK_WIN32_CURSOR(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WIN32_CURSOR, GdkWin32Cursor))
+#define GDK_WIN32_CURSOR_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WIN32_CURSOR, GdkWin32CursorClass))
+#define GDK_IS_WIN32_CURSOR(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WIN32_CURSOR))
+#define GDK_IS_WIN32_CURSOR_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WIN32_CURSOR))
+#define GDK_WIN32_CURSOR_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WIN32_CURSOR, GdkWin32CursorClass))
+
+#ifdef GDK_COMPILATION
+typedef struct _GdkWin32Cursor GdkWin32Cursor;
+#else
+typedef GdkCursor GdkWin32Cursor;
+#endif
+typedef struct _GdkWin32CursorClass GdkWin32CursorClass;
+
+GType    gdk_win32_cursor_get_type          (void);
+
+G_END_DECLS
+
+#endif /* __GDK_WIN32_CURSOR_H__ */

gdk/win32/gdkwin32display.h

@@ -0,0 +1,56 @@
+/* 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/. 
+ */
+
+#if !defined (__GDKWIN32_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdkwin32.h> can be included directly."
+#endif
+
+#ifndef __GDK_WIN32_DISPLAY_H__
+#define __GDK_WIN32_DISPLAY_H__
+
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#ifdef GDK_COMPILATION
+typedef struct _GdkWin32Display GdkWin32Display;
+#else
+typedef GdkDisplay GdkWin32Display;
+#endif
+typedef struct _GdkWin32DisplayClass GdkWin32DisplayClass;
+
+#define GDK_TYPE_WIN32_DISPLAY              (gdk_win32_display_get_type())
+#define GDK_WIN32_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WIN32_DISPLAY, GdkWin32Display))
+#define GDK_WIN32_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WIN32_DISPLAY, GdkWin32DisplayClass))
+#define GDK_IS_WIN32_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WIN32_DISPLAY))
+#define GDK_IS_WIN32_DISPLAY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WIN32_DISPLAY))
+#define GDK_WIN32_DISPLAY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WIN32_DISPLAY, GdkWin32DisplayClass))
+
+GType      gdk_win32_display_get_type            (void);
+
+G_END_DECLS
+
+#endif /* __GDK_WIN32_DISPLAY_H__ */

gdk/win32/gdkwin32displaymanager.h

@@ -0,0 +1,49 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 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.
+ */
+
+#if !defined (__GDKWIN32_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdkwin32.h> can be included directly."
+#endif
+
+#ifndef __GDK_WIN32_DISPLAY_MANAGER_H__
+#define __GDK_WIN32_DISPLAY_MANAGER_H__
+
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#ifdef GDK_COMPILATION
+typedef struct _GdkWin32DisplayManager GdkWin32DisplayManager;
+#else
+typedef GdkDisplayManager GdkWin32DisplayManager;
+#endif
+typedef struct _GdkWin32DisplayManagerClass GdkWin32DisplayManagerClass;
+
+#define GDK_TYPE_WIN32_DISPLAY_MANAGER              (gdk_win32_display_manager_get_type())
+#define GDK_WIN32_DISPLAY_MANAGER(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WIN32_DISPLAY_MANAGER, GdkWin32DisplayManager))
+#define GDK_WIN32_DISPLAY_MANAGER_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WIN32_DISPLAY_MANAGER, GdkWin32DisplayManagerClass))
+#define GDK_IS_WIN32_DISPLAY_MANAGER(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WIN32_DISPLAY_MANAGER))
+#define GDK_IS_WIN32_DISPLAY_MANAGER_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WIN32_DISPLAY_MANAGER))
+#define GDK_WIN32_DISPLAY_MANAGER_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WIN32_DISPLAY_MANAGER, GdkWin32DisplayManagerClass))
+
+GType      gdk_win32_display_manager_get_type            (void);
+
+G_END_DECLS
+
+#endif /* __GDK_WIN32_DISPLAY_MANAGER_H__ */

gdk/win32/gdkwin32dnd.h

@@ -0,0 +1,49 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 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.
+ */
+
+#if !defined (__GDKWIN32_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdkwin32.h> can be included directly."
+#endif
+
+#ifndef __GDK_WIN32_DND_H__
+#define __GDK_WIN32_DND_H__
+
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_WIN32_DRAG_CONTEXT              (gdk_win32_drag_context_get_type ())
+#define GDK_WIN32_DRAG_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WIN32_DRAG_CONTEXT, GdkWin32DragContext))
+#define GDK_WIN32_DRAG_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WIN32_DRAG_CONTEXT, GdkWin32DragContextClass))
+#define GDK_IS_WIN32_DRAG_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WIN32_DRAG_CONTEXT))
+#define GDK_IS_WIN32_DRAG_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WIN32_DRAG_CONTEXT))
+#define GDK_WIN32_DRAG_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WIN32_DRAG_CONTEXT, GdkWin32DragContextClass))
+
+#ifdef GDK_COMPILATION
+typedef struct _GdkWin32DragContext GdkWin32DragContext;
+#else
+typedef GdkDragContext GdkWin32DragContext;
+#endif
+typedef struct _GdkWin32DragContextClass GdkWin32DragContextClass;
+
+GType    gdk_win32_drag_context_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GDK_WIN32_DRAG_CONTEXT_H__ */

gdk/win32/gdkwin32keys.h

@@ -0,0 +1,49 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 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.
+ */
+
+#if !defined (__GDKWIN32_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdkwin32.h> can be included directly."
+#endif
+
+#ifndef __GDK_WIN32_KEYS_H__
+#define __GDK_WIN32_KEYS_H__
+
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#ifdef GDK_COMPILATION
+typedef struct _GdkWin32Keymap GdkWin32Keymap;
+#else
+typedef GdkKeymap GdkWin32Keymap;
+#endif
+typedef struct _GdkWin32KeymapClass GdkWin32KeymapClass;
+
+#define GDK_TYPE_WIN32_KEYMAP              (gdk_win32_keymap_get_type())
+#define GDK_WIN32_KEYMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WIN32_KEYMAP, GdkWin32Keymap))
+#define GDK_WIN32_KEYMAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WIN32_KEYMAP, GdkWin32KeymapClass))
+#define GDK_IS_WIN32_KEYMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WIN32_KEYMAP))
+#define GDK_IS_WIN32_KEYMAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WIN32_KEYMAP))
+#define GDK_WIN32_KEYMAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WIN32_KEYMAP, GdkWin32KeymapClass))
+
+GType gdk_win32_keymap_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GDK_WIN32_KEYMAP_H__ */

gdk/win32/gdkwin32screen.h

@@ -0,0 +1,56 @@
+/* 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/. 
+ */
+
+#if !defined (__GDKWIN32_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdkwin32.h> can be included directly."
+#endif
+
+#ifndef __GDK_WIN32_SCREEN_H__
+#define __GDK_WIN32_SCREEN_H__
+
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_WIN32_SCREEN              (gdk_win32_screen_get_type ())
+#define GDK_WIN32_SCREEN(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WIN32_SCREEN, GdkWin32Screen))
+#define GDK_WIN32_SCREEN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WIN32_SCREEN, GdkWin32ScreenClass))
+#define GDK_IS_WIN32_SCREEN(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WIN32_SCREEN))
+#define GDK_IS_WIN32_SCREEN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WIN32_SCREEN))
+#define GDK_WIN32_SCREEN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WIN32_SCREEN, GdkWin32ScreenClass))
+
+#ifdef GDK_COMPILATION
+typedef struct _GdkWin32Screen GdkWin32Screen;
+#else
+typedef GdkScreen GdkWin32Screen;
+#endif
+typedef struct _GdkWin32ScreenClass GdkWin32ScreenClass;
+
+GType    gdk_win32_screen_get_type          (void);
+
+G_END_DECLS
+
+#endif /* __GDK_WIN32_SCREEN_H__ */

gdk/win32/gdkwin32window.h

@@ -0,0 +1,56 @@
+/* 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/. 
+ */
+
+#if !defined (__GDKWIN32_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdkwin32.h> can be included directly."
+#endif
+
+#ifndef __GDK_WIN32_WINDOW_H__
+#define __GDK_WIN32_WINDOW_H__
+
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_WIN32_WINDOW              (gdk_win32_window_get_type ())
+#define GDK_WIN32_WINDOW(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WIN32_WINDOW, GdkWin32Window))
+#define GDK_WIN32_WINDOW_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WIN32_WINDOW, GdkWin32WindowClass))
+#define GDK_IS_WIN32_WINDOW(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WIN32_WINDOW))
+#define GDK_IS_WIN32_WINDOW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WIN32_WINDOW))
+#define GDK_WIN32_WINDOW_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WIN32_WINDOW, GdkWin32WindowClass))
+
+#ifdef GDK_COMPILATION
+typedef struct _GdkWin32Window GdkWin32Window;
+#else
+typedef GdkWindow GdkWin32Window;
+#endif
+typedef struct _GdkWin32WindowClass GdkWin32WindowClass;
+
+GType    gdk_win32_window_get_type          (void);
+
+G_END_DECLS
+
+#endif /* __GDK_X11_WINDOW_H__ */

gdk/win32/gdkwindow-win32.h

@@ -27,32 +27,14 @@
 #ifndef __GDK_WINDOW_WIN32_H__
 #define __GDK_WINDOW_WIN32_H__
 
-#include <gdk/win32/gdkdrawable-win32.h>
+#include "gdk/win32/gdkprivate-win32.h"
+#include "gdk/gdkwindowimpl.h"
+#include "gdk/gdkcursor.h"
+
+#include <windows.h>
 
 G_BEGIN_DECLS
 
-typedef struct _GdkWin32PositionInfo    GdkWin32PositionInfo;
-
-#if 0
-struct _GdkWin32PositionInfo
-{
-  gint x;
-  gint y;
-  gint width;
-  gint height;
-  gint x_offset;		/* Offsets to add to Win32 coordinates */
-  gint y_offset;		/* within window to get GDK coodinates */
-  guint big : 1;
-  guint mapped : 1;
-  guint no_bg : 1;	        /* Set when the window background
-				 * is temporarily unset during resizing
-				 * and scaling
-				 */
-  GdkRectangle clip_rect;	/* visible rectangle of window */
-};
-#endif
-
-
 /* Window implementation for Win32
  */
 
@@ -68,7 +50,10 @@ typedef struct _GdkWindowImplWin32Class GdkWindowImplWin32Class;
 
 struct _GdkWindowImplWin32
 {
-  GdkDrawableImplWin32 parent_instance;
+  GdkWindowImpl parent_instance;
+
+  GdkWindow *wrapper;
+  HANDLE handle;
 
   gint8 toplevel_window_type;
 
@@ -90,11 +75,16 @@ struct _GdkWindowImplWin32
   gboolean   changing_state;
 
   guint no_bg : 1;
+
+  cairo_surface_t *cairo_surface;
+  HDC              hdc;
+  int              hdc_count;
+  HBITMAP          saved_dc_bitmap; /* Original bitmap for dc */
 };
  
 struct _GdkWindowImplWin32Class 
 {
-  GdkDrawableImplWin32Class parent_class;
+  GdkWindowImplClass parent_class;
 };
 
 GType _gdk_window_impl_win32_get_type (void);

gdk/win32/makefile.msc

@@ -14,7 +14,7 @@ TOP = ../../..
 WTKIT = $(TOP)\wtkit126
 !ENDIF
 
-GTK_VER=2.0
+GTK_VER=3.0
 
 DEFINES = \
 	-DHAVE_CONFIG_H -DINSIDE_GDK_WIN32 -DGDK_VERSION=\"$(GTK_VER)\" \
@@ -22,7 +22,7 @@ DEFINES = \
 
 INCLUDES = -FImsvc_recommended_pragmas.h \
 	-I. -I.. -I..\.. $(GLIB_CFLAGS) $(PANGO_CFLAGS) $(CAIRO_CFLAGS) \
-	-I$(WTKIT)\include -I$(GLIB) \
+	$(GDK_PIXBUF_CFLAGS) -I$(WTKIT)\include -I$(GLIB) \
 
 all: \
 	..\..\config.h	\
@@ -31,25 +31,22 @@ all: \
 	gdk.res
 
 gdk_win32_OBJECTS = \
-	gdkapplaunchcontext-win32.obj \
 	gdkcursor-win32.obj \
+	gdkdevice-win32.obj \
+	gdkdevice-wintab.obj \
+	gdkdevicemanager-win32.obj \
 	gdkdnd-win32.obj \
 	gdkdisplay-win32.obj \
-	gdkdrawable-win32.obj \
+	gdkdisplaymanager-win32.obj \
 	gdkevents-win32.obj \
-	gdkgc-win32.obj \
 	gdkgeometry-win32.obj \
 	gdkglobals-win32.obj \
-	gdkim-win32.obj \
 	gdkinput.obj \
-	gdkinput-win32.obj \
 	gdkkeys-win32.obj \
 	gdkmain-win32.obj \
 	gdkproperty-win32.obj \
-#	gdkregion-win32.obj \
 	gdkscreen-win32.obj \
 	gdkselection-win32.obj \
-	gdkspawn-win32.obj \
 	gdktestutils-win32.obj \
 	gdkvisual-win32.obj \
 	gdkwin32id.obj \