Intermediate commit.

4 files changed, 510 insertions, 782 deletions

diff --git a/gdk/win32/gdkfont-win32.c b/gdk/win32/gdkfont-win32.c
index 3cee42da86..cc9c7016b0 100644
--- a/gdk/win32/gdkfont-win32.c
+++ b/gdk/win32/gdkfont-win32.c
@@ -30,7 +30,7 @@
 #include <ctype.h>
 
 #include "gdkfont.h"
-#include "gdkx.h"
+#include "gdkwin32.h"
 
 static GHashTable *font_name_hash = NULL;
 static GHashTable *fontset_name_hash = NULL;
@@ -40,7 +40,7 @@ gdk_font_hash_insert (GdkFontType  type,
 		      GdkFont     *font,
 		      const gchar *font_name)
 {
-  GdkFontPrivate *private = (GdkFontPrivate *) font;
+  GdkFontPrivateWin32 *private = (GdkFontPrivateWin32 *) font;
   GHashTable **hashp = (type == GDK_FONT_FONT) ?
     &font_name_hash : &fontset_name_hash;
 
@@ -55,7 +55,7 @@ static void
 gdk_font_hash_remove (GdkFontType type,
 		      GdkFont    *font)
 {
-  GdkFontPrivate *private = (GdkFontPrivate *) font;
+  GdkFontPrivateWin32 *private = (GdkFontPrivateWin32 *) font;
   GSList *tmp_list;
   GHashTable *hash = (type == GDK_FONT_FONT) ?
     font_name_hash : fontset_name_hash;
@@ -254,7 +254,7 @@ logfont_to_xlfd (const LOGFONT *lfp,
 gchar *
 gdk_font_xlfd_create (GdkFont *font)
 {
-  GdkFontPrivate *private;
+  GdkFontPrivateWin32 *private;
   GdkWin32SingleFont *singlefont;
   GSList *list;
   GString *string;
@@ -263,7 +263,7 @@ gdk_font_xlfd_create (GdkFont *font)
 
   g_return_val_if_fail (font != NULL, NULL);
 
-  private = (GdkFontPrivate *) font;
+  private = (GdkFontPrivateWin32 *) font;
 
   list = private->fonts;
   string = g_string_new ("");
@@ -351,7 +351,7 @@ pattern_match (const gchar *pattern,
   return FALSE;
 }
 
-int CALLBACK
+static int CALLBACK
 InnerEnumFontFamExProc (const LOGFONT    *lfp,
 			const TEXTMETRIC *metrics,
 			DWORD	          fontType,
@@ -388,7 +388,7 @@ InnerEnumFontFamExProc (const LOGFONT    *lfp,
   return 1;
 }
 
-int CALLBACK
+static int CALLBACK
 EnumFontFamExProc (const LOGFONT    *lfp,
 		   const TEXTMETRIC *metrics,
 		   DWORD             fontType,
@@ -756,7 +756,7 @@ GdkFont*
 gdk_font_load (const gchar *font_name)
 {
   GdkFont *font;
-  GdkFontPrivate *private;
+  GdkFontPrivateWin32 *private;
   GdkWin32SingleFont *singlefont;
   HGDIOBJ oldfont;
   HANDLE *f;
@@ -770,10 +770,10 @@ gdk_font_load (const gchar *font_name)
 
   singlefont = gdk_font_load_internal (font_name);
 
-  private = g_new (GdkFontPrivate, 1);
+  private = g_new (GdkFontPrivateWin32, 1);
   font = (GdkFont*) private;
 
-  private->ref_count = 1;
+  private->base.ref_count = 1;
   private->names = NULL;
   private->fonts = g_slist_append (NULL, singlefont);
 
@@ -805,7 +805,7 @@ GdkFont*
 gdk_fontset_load (gchar *fontset_name)
 {
   GdkFont *font;
-  GdkFontPrivate *private;
+  GdkFontPrivateWin32 *private;
   GdkWin32SingleFont *singlefont;
   HGDIOBJ oldfont;
   HANDLE *f;
@@ -826,10 +826,10 @@ gdk_fontset_load (gchar *fontset_name)
 
   g_return_val_if_fail (*s, NULL);
 
-  private = g_new (GdkFontPrivate, 1);
+  private = g_new (GdkFontPrivateWin32, 1);
   font = (GdkFont*) private;
 
-  private->ref_count = 1;
+  private->base.ref_count = 1;
   private->names = NULL;
   private->fonts = NULL;
 
@@ -883,81 +883,51 @@ gdk_fontset_load (gchar *fontset_name)
   return font;
 }
 
-GdkFont*
-gdk_font_ref (GdkFont *font)
-{
-  GdkFontPrivate *private;
-
-  g_return_val_if_fail (font != NULL, NULL);
-
-  private = (GdkFontPrivate*) font;
-  private->ref_count += 1;
-
-  GDK_NOTE (MISC,
-	    g_print ("gdk_font_ref %#x %d\n",
-		     ((GdkWin32SingleFont *) private->fonts->data)->xfont,
-		     private->ref_count));
-  return font;
-}
-
 void
-gdk_font_unref (GdkFont *font)
+_gdk_font_destroy (GdkFont *font)
 {
-  GdkFontPrivate *private;
+  GdkFontPrivateWin32 *private = (GdkFontPrivateWin32 *) font;
   GdkWin32SingleFont *singlefont;
   GSList *list;
-  private = (GdkFontPrivate*) font;
-
-  g_return_if_fail (font != NULL);
-  g_return_if_fail (private->ref_count > 0);
-
-  private->ref_count -= 1;
 
   singlefont = (GdkWin32SingleFont *) private->fonts->data;
-  GDK_NOTE (MISC, g_print ("gdk_font_unref %#x %d%s\n",
-			   singlefont->xfont, private->ref_count,
-			   (private->ref_count == 0 ? " freeing" : "")));
+  GDK_NOTE (MISC, g_print ("_gdk_font_destroy %#x\n",
+			   singlefont->xfont));
 
-  if (private->ref_count == 0)
+  gdk_font_hash_remove (font->type, font);
+  
+  switch (font->type)
     {
-      gdk_font_hash_remove (font->type, font);
+    case GDK_FONT_FONT:
+      DeleteObject (singlefont->xfont);
+      break;
       
-      switch (font->type)
+    case GDK_FONT_FONTSET:
+      list = private->fonts;
+      while (list)
 	{
-	case GDK_FONT_FONT:
+	  singlefont = (GdkWin32SingleFont *) list->data;
 	  DeleteObject (singlefont->xfont);
-	  break;
-
-	case GDK_FONT_FONTSET:
-	  list = private->fonts;
-	  while (list)
-	    {
-	      singlefont = (GdkWin32SingleFont *) list->data;
-	      DeleteObject (singlefont->xfont);
-
-	      list = list->next;
-	    }
-	  g_slist_free (private->fonts);
-	  break;
-
-	default:
-	  g_assert_not_reached ();
+	  
+	  list = list->next;
 	}
-      g_free (font);
+      g_slist_free (private->fonts);
+      break;
     }
+  g_free (font);
 }
 
 gint
 gdk_font_id (const GdkFont *font)
 {
-  const GdkFontPrivate *font_private;
+  const GdkFontPrivateWin32 *private;
 
   g_return_val_if_fail (font != NULL, 0);
 
-  font_private = (const GdkFontPrivate*) font;
+  private = (const GdkFontPrivateWin32 *) font;
 
   if (font->type == GDK_FONT_FONT)
-    return (gint) ((GdkWin32SingleFont *) font_private->fonts->data)->xfont;
+    return (gint) ((GdkWin32SingleFont *) private->fonts->data)->xfont;
   else
     return 0;
 }
@@ -966,14 +936,14 @@ gint
 gdk_font_equal (const GdkFont *fonta,
                 const GdkFont *fontb)
 {
-  const GdkFontPrivate *privatea;
-  const GdkFontPrivate *privateb;
+  const GdkFontPrivateWin32 *privatea;
+  const GdkFontPrivateWin32 *privateb;
 
   g_return_val_if_fail (fonta != NULL, FALSE);
   g_return_val_if_fail (fontb != NULL, FALSE);
 
-  privatea = (const GdkFontPrivate*) fonta;
-  privateb = (const GdkFontPrivate*) fontb;
+  privatea = (const GdkFontPrivateWin32 *) fonta;
+  privateb = (const GdkFontPrivateWin32 *) fontb;
 
   if (fonta->type == GDK_FONT_FONT && fontb->type == GDK_FONT_FONT)
     return (((GdkWin32SingleFont *) privatea->fonts->data)->xfont
@@ -1000,13 +970,6 @@ gdk_font_equal (const GdkFont *fonta,
     return 0;
 }
 
-gint
-gdk_string_width (GdkFont     *font,
-		  const gchar *string)
-{
-  return gdk_text_width (font, string, strlen (string));
-}
-
 /* This table classifies Unicode characters according to the Microsoft
  * Unicode subset numbering. This is from the table in "Developing
  * International Software for Windows 95 and Windows NT". This is almost,
@@ -1126,7 +1089,7 @@ gdk_wchar_text_handle (GdkFont       *font,
 					       void *),
 		       void          *arg)
 {
-  GdkFontPrivate *private;
+  GdkFontPrivateWin32 *private;
   GdkWin32SingleFont *singlefont;
   GSList *list;
   int i, block;
@@ -1134,9 +1097,9 @@ gdk_wchar_text_handle (GdkFont       *font,
 
   wcp = wcstr;
   end = wcp + wclen;
-  private = (GdkFontPrivate *) font;
+  private = (GdkFontPrivateWin32 *) font;
 
-  g_assert (private->ref_count > 0);
+  g_assert (private->base.ref_count > 0);
 
   while (wcp < end)
     {
@@ -1282,36 +1245,6 @@ gdk_text_width_wc (GdkFont	  *font,
   return arg.total.cx;
 }
 
-gint
-gdk_char_width (GdkFont *font,
-		gchar    character)
-{
-  if (((guchar) character) >= 128)
-    {
-      /* gtktext calls us with non-ASCII characters, sigh */
-      GdkWChar wc = (guchar) character;
-      return gdk_text_width_wc (font, &wc, 1);
-    }
-  return gdk_text_width (font, &character, 1);
-}
-
-gint
-gdk_char_width_wc (GdkFont *font,
-		   GdkWChar character)
-{
-  return gdk_text_width_wc (font, &character, 1);
-}
-
-gint
-gdk_string_measure (GdkFont     *font,
-                    const gchar *string)
-{
-  g_return_val_if_fail (font != NULL, -1);
-  g_return_val_if_fail (string != NULL, -1);
-
-  return gdk_text_measure (font, string, strlen (string));
-}
-
 void
 gdk_text_extents (GdkFont     *font,
                   const gchar *text,
@@ -1434,68 +1367,3 @@ gdk_text_extents_wc (GdkFont        *font,
   if (descent)
     *descent = font->descent + 1;
 }
-
-void
-gdk_string_extents (GdkFont     *font,
-		    const gchar *string,
-		    gint        *lbearing,
-		    gint        *rbearing,
-		    gint        *width,
-		    gint        *ascent,
-		    gint        *descent)
-{
-  g_return_if_fail (font != NULL);
-  g_return_if_fail (string != NULL);
-
-  gdk_text_extents (font, string, strlen (string),
-		    lbearing, rbearing, width, ascent, descent);
-}
-
-
-gint
-gdk_text_measure (GdkFont     *font,
-                  const gchar *text,
-                  gint         text_length)
-{
-  return gdk_text_width (font, text, text_length); /* ??? */
-}
-
-gint
-gdk_char_measure (GdkFont *font,
-                  gchar    character)
-{
-  return gdk_text_measure (font, &character, 1);
-}
-
-gint
-gdk_string_height (GdkFont     *font,
-		   const gchar *string)
-{
-  g_return_val_if_fail (font != NULL, -1);
-  g_return_val_if_fail (string != NULL, -1);
-
-  return gdk_text_height (font, string, strlen (string));
-}
-
-gint
-gdk_text_height (GdkFont     *font,
-		 const gchar *text,
-		 gint         text_length)
-{
-  gdk_text_size_arg arg;
-
-  arg.total.cx = arg.total.cy = 0;
-  arg.max.cx = arg.max.cy = 0;
-
-  if (!gdk_text_size (font, text, text_length, &arg))
-    return -1;
-
-  return arg.max.cy;
-}
-
-gint
-gdk_char_height (GdkFont *font,
-		 gchar    character)
-{
-  return gdk_text_height (font, &character, 1);
-}
diff --git a/gdk/win32/gdkgc-win32.c b/gdk/win32/gdkgc-win32.c
index e0fca11dbb..a577585951 100644
--- a/gdk/win32/gdkgc-win32.c
+++ b/gdk/win32/gdkgc-win32.c
@@ -32,21 +32,34 @@
 #include "gdkfont.h"
 #include "gdkpixmap.h"
 #include "gdkprivate.h"
-#include "gdkx.h"
+#include "gdkwin32.h"
+
+static void gdk_win32_gc_destroy    (GdkGC           *gc);
+static void gdk_win32_gc_get_values (GdkGC           *gc,
+				     GdkGCValues     *values);
+static void gdk_win32_gc_set_values (GdkGC           *gc,
+				     GdkGCValues     *values,
+				     GdkGCValuesMask  values_mask);
+static void gdk_win32_gc_set_dashes (GdkGC           *gc,
+				     gint             dash_offset,
+				     gchar            dash_list[],
+				     gint             n);
+
+static GdkGCClass gdk_win32_gc_class = {
+  gdk_win32_gc_destroy,
+  gdk_win32_gc_get_values,
+  gdk_win32_gc_set_values,
+  gdk_win32_gc_set_dashes
+};
 
 GdkGC*
-gdk_gc_new (GdkWindow *window)
-{
-  return gdk_gc_new_with_values (window, NULL, 0);
-}
-
-GdkGC*
-gdk_gc_new_with_values (GdkWindow	*window,
-			GdkGCValues	*values,
-			GdkGCValuesMask	 values_mask)
+_gdk_win32_gc_new (GdkDrawable	  *drawable,
+		   GdkGCValues	  *values,
+		   GdkGCValuesMask values_mask)
 {
   GdkGC *gc;
   GdkGCPrivate *private;
+  GdkGCWin32Data *data;
   static GdkColor black;
   static GdkColor white;
   static gboolean beenhere = FALSE;
@@ -58,174 +71,171 @@ gdk_gc_new_with_values (GdkWindow	*window,
       beenhere = TRUE;
     }
 
-  g_return_val_if_fail (window != NULL, NULL);
-
-  if (GDK_DRAWABLE_DESTROYED (window))
-    return NULL;
+  gc = gdk_gc_alloc ();
+  private = (GdkGCPrivate *)gc;
 
-  private = g_new (GdkGCPrivate, 1);
-  gc = (GdkGC*) private;
-
-  private->ref_count = 1;
-  private->rop2 = R2_COPYPEN;
-  private->fill_style = GDK_SOLID;
-  private->values_mask = values_mask;
-  private->values_mask |= GDK_GC_FUNCTION | GDK_GC_FILL;
+  private->klass = &gdk_win32_gc_class;
+  private->klass_data = data = g_new (GdkGCWin32Data, 1);
+    
+  data->rop2 = R2_COPYPEN;
+  data->fill_style = GDK_SOLID;
+  data->values_mask = values_mask;
+  data->values_mask |= GDK_GC_FUNCTION | GDK_GC_FILL;
 
-  GDK_NOTE (MISC, g_print ("gdk_gc_new: {"));
+  GDK_NOTE (MISC, g_print ("_gdk_win32_gc_new: {"));
 
   if (values_mask & GDK_GC_FOREGROUND)
     {
-      private->foreground = values->foreground;
+      data->foreground = values->foreground;
     }
   else
-    private->foreground = black;
+    data->foreground = black;
   
   if (values_mask & GDK_GC_BACKGROUND)
     {
-      private->background = values->background;
+      data->background = values->background;
     }
   else
-    private->background = white;
+    data->background = white;
 
   if ((values_mask & GDK_GC_FONT) && (values->font->type == GDK_FONT_FONT
 				      || values->font->type == GDK_FONT_FONTSET))
     {
-      private->font = values->font;
-      gdk_font_ref (private->font);
+      data->font = values->font;
+      gdk_font_ref (data->font);
       GDK_NOTE (MISC, g_print (" font"));
     }
   else
-    private->font = NULL;
+    data->font = NULL;
 
   if (values_mask & GDK_GC_FUNCTION)
     {
       switch (values->function)
 	{
 	case GDK_COPY:
-	  private->rop2 = R2_COPYPEN; break;
+	  data->rop2 = R2_COPYPEN; break;
 	case GDK_INVERT:
-	  private->rop2 = R2_NOT; break;
+	  data->rop2 = R2_NOT; break;
 	case GDK_XOR:
-	  private->rop2 = R2_XORPEN; break;
+	  data->rop2 = R2_XORPEN; break;
 	case GDK_CLEAR:
-	  private->rop2 = R2_BLACK; break;
+	  data->rop2 = R2_BLACK; break;
 	case GDK_AND:
-	  private->rop2 = R2_MASKPEN; break;
+	  data->rop2 = R2_MASKPEN; break;
 	case GDK_AND_REVERSE:
-	  private->rop2 = R2_MASKPENNOT; break;
+	  data->rop2 = R2_MASKPENNOT; break;
 	case GDK_AND_INVERT:
-	  private->rop2 = R2_MASKNOTPEN; break;
+	  data->rop2 = R2_MASKNOTPEN; break;
 	case GDK_NOOP:
-	  private->rop2 = R2_NOP; break;
+	  data->rop2 = R2_NOP; break;
 	case GDK_OR:
-	  private->rop2 = R2_MERGEPEN; break;
+	  data->rop2 = R2_MERGEPEN; break;
 	case GDK_EQUIV:
-	  private->rop2 = R2_NOTXORPEN; break;
+	  data->rop2 = R2_NOTXORPEN; break;
 	case GDK_OR_REVERSE:
-	  private->rop2 = R2_MERGEPENNOT; break;
+	  data->rop2 = R2_MERGEPENNOT; break;
 	case GDK_COPY_INVERT:
-	  private->rop2 = R2_NOTCOPYPEN; break;
+	  data->rop2 = R2_NOTCOPYPEN; break;
 	case GDK_OR_INVERT:
-	  private->rop2 = R2_MERGENOTPEN; break;
+	  data->rop2 = R2_MERGENOTPEN; break;
 	case GDK_NAND:
-	  private->rop2 = R2_NOTMASKPEN; break;
+	  data->rop2 = R2_NOTMASKPEN; break;
 	case GDK_SET:
-	  private->rop2 = R2_WHITE; break;
+	  data->rop2 = R2_WHITE; break;
 	}
-      GDK_NOTE (MISC, g_print (" function=%d", private->rop2));
+      GDK_NOTE (MISC, g_print (" function=%d", data->rop2));
     }
 
   if (values_mask & GDK_GC_FILL)
     {
-      private->fill_style = values->fill;
-      GDK_NOTE (MISC, g_print (" fill=%d", private->fill_style));
+      data->fill_style = values->fill;
+      GDK_NOTE (MISC, g_print (" fill=%d", data->fill_style));
     }
 
   if (values_mask & GDK_GC_TILE)
     {
-      private->tile = values->tile;
-      gdk_pixmap_ref (private->tile);
-      GDK_NOTE (MISC, g_print (" tile=%#x", GDK_DRAWABLE_XID (private->tile)));
+      data->tile = values->tile;
+      gdk_pixmap_ref (data->tile);
+      GDK_NOTE (MISC, g_print (" tile=%#x", GDK_DRAWABLE_XID (data->tile)));
     }
   else
-    private->tile = NULL;
+    data->tile = NULL;
 
   if (values_mask & GDK_GC_STIPPLE)
     {
-      private->stipple = values->stipple;
-      gdk_pixmap_ref (private->stipple);
-      GDK_NOTE (MISC, g_print (" stipple=%#x", GDK_DRAWABLE_XID (private->stipple)));
+      data->stipple = values->stipple;
+      gdk_pixmap_ref (data->stipple);
+      GDK_NOTE (MISC, g_print (" stipple=%#x", GDK_DRAWABLE_XID (data->stipple)));
     }
   else
-    private->stipple = NULL;
+    data->stipple = NULL;
 
   if (values_mask & GDK_GC_CLIP_MASK)
     {
-      private->clip_region =
+      data->clip_region =
 	BitmapToRegion ((HBITMAP) GDK_DRAWABLE_XID (values->clip_mask));
-      GDK_NOTE (MISC, g_print (" clip=%#x", private->clip_region));
+      GDK_NOTE (MISC, g_print (" clip=%#x", data->clip_region));
     }
   else
-    private->clip_region = NULL;
+    data->clip_region = NULL;
 
   if (values_mask & GDK_GC_SUBWINDOW)
     {
-      private->subwindow_mode = values->subwindow_mode;
-      GDK_NOTE (MISC, g_print (" subw=%d", private->subwindow_mode));
+      data->subwindow_mode = values->subwindow_mode;
+      GDK_NOTE (MISC, g_print (" subw=%d", data->subwindow_mode));
     }
 
   if (values_mask & GDK_GC_TS_X_ORIGIN)
     {
-      private->ts_x_origin = values->ts_x_origin;
-      GDK_NOTE (MISC, g_print (" ts_x=%d", private->ts_x_origin));
+      data->ts_x_origin = values->ts_x_origin;
+      GDK_NOTE (MISC, g_print (" ts_x=%d", data->ts_x_origin));
     }
 
   if (values_mask & GDK_GC_TS_Y_ORIGIN)
     {
-      private->ts_y_origin = values->ts_y_origin;
-      GDK_NOTE (MISC, g_print (" ts_y=%d", private->ts_y_origin));
+      data->ts_y_origin = values->ts_y_origin;
+      GDK_NOTE (MISC, g_print (" ts_y=%d", data->ts_y_origin));
     }
 
   if (values_mask & GDK_GC_CLIP_X_ORIGIN)
     {
-      private->clip_x_origin = values->clip_x_origin;
-      GDK_NOTE (MISC, g_print (" clip_x=%d", private->clip_x_origin));
+      data->clip_x_origin = values->clip_x_origin;
+      GDK_NOTE (MISC, g_print (" clip_x=%d", data->clip_x_origin));
     }
 
   if (values_mask & GDK_GC_CLIP_Y_ORIGIN)
     {
-      private->clip_y_origin = values->clip_y_origin; 
-      GDK_NOTE (MISC, g_print (" clip_y=%d", private->clip_y_origin));
+      data->clip_y_origin = values->clip_y_origin; 
+      GDK_NOTE (MISC, g_print (" clip_y=%d", data->clip_y_origin));
    }
  
   if (values_mask & GDK_GC_EXPOSURES)
     {
-      private->graphics_exposures = values->graphics_exposures;
-      GDK_NOTE (MISC, g_print (" exp=%d", private->graphics_exposures));
+      data->graphics_exposures = values->graphics_exposures;
+      GDK_NOTE (MISC, g_print (" exp=%d", data->graphics_exposures));
     }
 
-  private->pen_style = PS_GEOMETRIC;
-  private->pen_width = 1;
+  data->pen_style = PS_GEOMETRIC;
+  data->pen_width = 1;
 
   if (values_mask & (GDK_GC_LINE_WIDTH | GDK_GC_LINE_STYLE))
     {
       if (values_mask & GDK_GC_LINE_WIDTH)
 	{
-	  private->pen_width = values->line_width;
-	  GDK_NOTE (MISC, g_print (" pw=%d", private->pen_width));
+	  data->pen_width = values->line_width;
+	  GDK_NOTE (MISC, g_print (" pw=%d", data->pen_width));
 	}
       if (values_mask & GDK_GC_LINE_STYLE)
 	{
 	  switch (values->line_style)
 	    {
 	    case GDK_LINE_SOLID:
-	      private->pen_style |= PS_SOLID; break;
+	      data->pen_style |= PS_SOLID; break;
 	    case GDK_LINE_ON_OFF_DASH:
 	    case GDK_LINE_DOUBLE_DASH: /* ??? */
-	      private->pen_style |= PS_DASH; break;
+	      data->pen_style |= PS_DASH; break;
 	    }
-	  GDK_NOTE (MISC, g_print (" ps=%#x", private->pen_style));
+	  GDK_NOTE (MISC, g_print (" ps=%#x", data->pen_style));
 	}
     }
 
@@ -235,13 +245,13 @@ gdk_gc_new_with_values (GdkWindow	*window,
 	{
 	case GDK_CAP_NOT_LAST:	/* ??? */
 	case GDK_CAP_BUTT:
-	  private->pen_style |= PS_ENDCAP_FLAT;	break;
+	  data->pen_style |= PS_ENDCAP_FLAT;	break;
 	case GDK_CAP_ROUND:
-	  private->pen_style |= PS_ENDCAP_ROUND; break;
+	  data->pen_style |= PS_ENDCAP_ROUND; break;
 	case GDK_CAP_PROJECTING:
-	  private->pen_style |= PS_ENDCAP_SQUARE; break;
+	  data->pen_style |= PS_ENDCAP_SQUARE; break;
 	}
-      GDK_NOTE (MISC, g_print (" ps=%#x", private->pen_style));
+      GDK_NOTE (MISC, g_print (" ps=%#x", data->pen_style));
     }
 
   if (values_mask & GDK_GC_JOIN_STYLE)
@@ -249,86 +259,57 @@ gdk_gc_new_with_values (GdkWindow	*window,
       switch (values->join_style)
 	{
 	case GDK_JOIN_MITER:
-	  private->pen_style |= PS_JOIN_MITER;
+	  data->pen_style |= PS_JOIN_MITER;
 	  break;
 	case GDK_JOIN_ROUND:
-	  private->pen_style |= PS_JOIN_ROUND;
+	  data->pen_style |= PS_JOIN_ROUND;
 	  break;
 	case GDK_JOIN_BEVEL:
-	  private->pen_style |= PS_JOIN_BEVEL;
+	  data->pen_style |= PS_JOIN_BEVEL;
 	  break;
 	}
-      GDK_NOTE (MISC, g_print (" ps=%#x", private->pen_style));
+      GDK_NOTE (MISC, g_print (" ps=%#x", data->pen_style));
     }
 
-  private->hwnd = NULL;
-  private->xgc = NULL;
+  data->hwnd = NULL;
+  data->xgc = NULL;
 
-  GDK_NOTE (MISC, g_print ("} = %p\n", private));
+  GDK_NOTE (MISC, g_print ("} = %p\n", gc));
 
   return gc;
 }
 
-void
-gdk_gc_destroy (GdkGC *gc)
-{
-  gdk_gc_unref (gc);
-}
-
-GdkGC *
-gdk_gc_ref (GdkGC *gc)
+static void
+gdk_win32_gc_destroy (GdkGC *gc)
 {
-  GdkGCPrivate *private = (GdkGCPrivate*) gc;
-
-  g_return_val_if_fail (gc != NULL, NULL);
-  private->ref_count += 1;
+  GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
 
-  return gc;
-}
-
-void
-gdk_gc_unref (GdkGC *gc)
-{
-  GdkGCPrivate *private = (GdkGCPrivate*) gc;
+  if (data->values_mask & GDK_GC_FONT)
+    gdk_font_unref (data->font);
   
-  g_return_if_fail (gc != NULL);
+  if (data->values_mask & GDK_GC_TILE)
+    gdk_pixmap_unref (data->tile);
   
-  if (private->ref_count > 1)
-    private->ref_count -= 1;
-  else
-    {
-      if (private->values_mask & GDK_GC_FONT)
-	gdk_font_unref (private->font);
-
-      if (private->values_mask & GDK_GC_TILE)
-	gdk_pixmap_unref (private->tile);
-      
-      if (private->values_mask & GDK_GC_STIPPLE)
-	gdk_pixmap_unref (private->stipple);
-      
-      if (private->values_mask & GDK_GC_CLIP_MASK)
-	DeleteObject (private->clip_region);
+  if (data->values_mask & GDK_GC_STIPPLE)
+    gdk_pixmap_unref (data->stipple);
+  
+  if (data->values_mask & GDK_GC_CLIP_MASK)
+    DeleteObject (data->clip_region);
 
-      g_free (gc);
-    }
+  g_free (GDK_GC_WIN32DATA (gc));
 }
 
-void
-gdk_gc_get_values (GdkGC       *gc,
-		   GdkGCValues *values)
+static void
+gdk_win32_gc_get_values (GdkGC       *gc,
+			 GdkGCValues *values)
 {
-  GdkGCPrivate *private;
+  GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
 
-  g_return_if_fail (gc != NULL);
-  g_return_if_fail (values != NULL);
-
-  private = (GdkGCPrivate*) gc;
-
-  values->foreground = private->foreground;
-  values->background = private->background;
-  values->font = private->font;
+  values->foreground = data->foreground;
+  values->background = data->background;
+  values->font = data->font;
 
-  switch (private->rop2)
+  switch (data->rop2)
     {
     case R2_COPYPEN:
       values->function = GDK_COPY; break;
@@ -362,11 +343,11 @@ gdk_gc_get_values (GdkGC       *gc,
       values->function = GDK_SET; break;
     }
 
-  values->fill = private->fill_style;
+  values->fill = data->fill_style;
 
-  values->tile = private->tile;
-  values->stipple = private->stipple;
-  if (private->clip_region != NULL)
+  values->tile = data->tile;
+  values->stipple = data->stipple;
+  if (data->clip_region != NULL)
     {
       RECT rect;
       HBRUSH hbr;
@@ -374,7 +355,7 @@ gdk_gc_get_values (GdkGC       *gc,
       HGDIOBJ oldbitmap;
       GdkPixmap *pixmap;
 
-      GetRgnBox (private->clip_region, &rect);
+      GetRgnBox (data->clip_region, &rect);
       pixmap =
 	gdk_pixmap_new (NULL, rect.right - rect.left, rect.bottom - rect.top,
 			1);
@@ -388,7 +369,7 @@ gdk_gc_get_values (GdkGC       *gc,
       if (!FillRect (hdc, &rect, hbr))
 	g_warning ("gdk_gc_get_values: FillRect failed");
       hbr = GetStockObject (WHITE_BRUSH);
-      if (!FillRgn (hdc, private->clip_region, hbr))
+      if (!FillRgn (hdc, data->clip_region, hbr))
 	g_warning ("gdk_gc_get_values: FillRgn failed");
       if (SelectObject (hdc, oldbitmap) == NULL)
 	g_warning ("gdk_gc_get_values: SelectObject #2 failed");
@@ -397,505 +378,381 @@ gdk_gc_get_values (GdkGC       *gc,
     }
   else
     values->clip_mask = NULL;
-  values->subwindow_mode = private->subwindow_mode;
-  values->ts_x_origin = private->ts_x_origin;
-  values->ts_y_origin = private->ts_y_origin;
-  values->clip_x_origin = private->clip_x_origin;
-  values->clip_y_origin = private->clip_y_origin;
-  values->graphics_exposures = private->graphics_exposures;
-  values->line_width = private->pen_width;
+  values->subwindow_mode = data->subwindow_mode;
+  values->ts_x_origin = data->ts_x_origin;
+  values->ts_y_origin = data->ts_y_origin;
+  values->clip_x_origin = data->clip_x_origin;
+  values->clip_y_origin = data->clip_y_origin;
+  values->graphics_exposures = data->graphics_exposures;
+  values->line_width = data->pen_width;
   
-  if (private->pen_style & PS_SOLID)
+  if (data->pen_style & PS_SOLID)
     values->line_style = GDK_LINE_SOLID;
-  else if (private->pen_style & PS_DASH)
+  else if (data->pen_style & PS_DASH)
     values->line_style = GDK_LINE_ON_OFF_DASH;
   else
     values->line_style = GDK_LINE_SOLID;
 
   /* PS_ENDCAP_ROUND is zero */
-  if (private->pen_style & PS_ENDCAP_FLAT)
+  if (data->pen_style & PS_ENDCAP_FLAT)
     values->cap_style = GDK_CAP_BUTT;
-  else if (private->pen_style & PS_ENDCAP_SQUARE)
+  else if (data->pen_style & PS_ENDCAP_SQUARE)
     values->cap_style = GDK_CAP_PROJECTING;
   else
     values->cap_style = GDK_CAP_ROUND;
     
   /* PS_JOIN_ROUND is zero */
-  if (private->pen_style & PS_JOIN_MITER)
+  if (data->pen_style & PS_JOIN_MITER)
     values->join_style = GDK_JOIN_MITER;
-  else if (private->pen_style & PS_JOIN_BEVEL)
+  else if (data->pen_style & PS_JOIN_BEVEL)
     values->join_style = GDK_JOIN_BEVEL;
   else
     values->join_style = GDK_JOIN_ROUND;
 }
 
-void
-gdk_gc_set_foreground (GdkGC	*gc,
-		       GdkColor *color)
+static void
+gdk_win32_gc_set_values (GdkGC           *gc,
+			 GdkGCValues     *values,
+			 GdkGCValuesMask  values_mask)
 {
-  GdkGCPrivate *private;
-
-  g_return_if_fail (gc != NULL);
-  g_return_if_fail (color != NULL);
-
-  private = (GdkGCPrivate*) gc;
-  {
-    GDK_NOTE (MISC, g_print ("gdk_gc_set_foreground: (%d) %s\n",
-			     private, gdk_color_to_string (color)));
-    private->foreground = *color;
-    private->values_mask |= GDK_GC_FOREGROUND;
-  }
-}
-
-void
-gdk_gc_set_background (GdkGC	*gc,
-		       GdkColor *color)
-{
-  GdkGCPrivate *private;
-
-  g_return_if_fail (gc != NULL);
-  g_return_if_fail (color != NULL);
-
-  private = (GdkGCPrivate*) gc;
-
-  GDK_NOTE (MISC, g_print ("gdk_gc_set_backround: (%d) %s\n",
-			   private, gdk_color_to_string(color)));
-  private->background = *color;
-  private->values_mask |= GDK_GC_BACKGROUND;
-}
-
-void
-gdk_gc_set_font (GdkGC	 *gc,
-		 GdkFont *font)
-{
-  GdkGCPrivate *gc_private;
-  GdkFontPrivate *font_private;
+  GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
   gchar *xlfd;
 
-  g_return_if_fail (gc != NULL);
-  g_return_if_fail (font != NULL);
+  GDK_NOTE (MISC, g_print ("gdk_win32_gc_set_values: {"));
 
-  if (font->type == GDK_FONT_FONT
-      || font->type == GDK_FONT_FONTSET)
+  if (values_mask & GDK_GC_FOREGROUND)
     {
-      gc_private = (GdkGCPrivate*) gc;
-      
-      GDK_NOTE (MISC, (xlfd = gdk_font_xlfd_create (font),
-		       g_print ("gdk_gc_set_font: (%d) %s\n",
-				gc_private, xlfd),
-		       gdk_font_xlfd_free (xlfd)));
-
-      if (gc_private->font != NULL)
-	gdk_font_unref (gc_private->font);
-      gc_private->font = font;
-      gdk_font_ref (gc_private->font);
-      gc_private->values_mask |= GDK_GC_FONT;
+      GDK_NOTE (MISC, g_print ("fg = %s ",
+			       gdk_color_to_string (&values->foreground)));
+      data->foreground = values->foreground;
+      data->values_mask |= GDK_GC_FOREGROUND;
     }
-}
-
-void
-gdk_gc_set_function (GdkGC	 *gc,
-		     GdkFunction  function)
-{
-  GdkGCPrivate *private;
-
-  g_return_if_fail (gc != NULL);
-
-  private = (GdkGCPrivate*) gc;
-
-  GDK_NOTE (MISC, g_print ("gdk_gc_set_function: (%d) %d\n", private, function));
-
-  switch (function)
+  
+  if (values_mask & GDK_GC_BACKGROUND)
     {
-    case GDK_COPY:
-      private->rop2 = R2_COPYPEN; break;
-    case GDK_INVERT:
-      private->rop2 = R2_NOT; break;
-    case GDK_XOR:
-      private->rop2 = R2_XORPEN; break;
-    case GDK_CLEAR:
-      private->rop2 = R2_BLACK; break;
-    case GDK_AND:
-      private->rop2 = R2_MASKPEN; break;
-    case GDK_AND_REVERSE:
-      private->rop2 = R2_MASKPENNOT; break;
-    case GDK_AND_INVERT:
-      private->rop2 = R2_MASKNOTPEN; break;
-    case GDK_NOOP:
-      private->rop2 = R2_NOP; break;
-    case GDK_OR:
-      private->rop2 = R2_MERGEPEN; break;
-    case GDK_EQUIV:
-      private->rop2 = R2_NOTXORPEN; break;
-    case GDK_OR_REVERSE:
-      private->rop2 = R2_MERGEPENNOT; break;
-    case GDK_COPY_INVERT:
-      private->rop2 = R2_NOTCOPYPEN; break;
-    case GDK_OR_INVERT:
-      private->rop2 = R2_MERGENOTPEN; break;
-    case GDK_NAND:
-      private->rop2 = R2_NOTMASKPEN; break;
-    case GDK_SET:
-      private->rop2 = R2_WHITE; break;
+      GDK_NOTE (MISC, g_print ("bg = %s ",
+			       gdk_color_to_string (&values->foreground)));
+      data->background = values->background;
+      data->values_mask |= GDK_GC_BACKGROUND;
     }
-  private->values_mask |= GDK_GC_FUNCTION;
-}
-
-void
-gdk_gc_set_fill (GdkGC	 *gc,
-		 GdkFill  fill)
-{
-  GdkGCPrivate *private;
 
-  g_return_if_fail (gc != NULL);
-
-  private = (GdkGCPrivate*) gc;
-
-  private->fill_style = fill;
-  private->values_mask |= GDK_GC_FILL;
-}
-
-void
-gdk_gc_set_tile (GdkGC	   *gc,
-		 GdkPixmap *tile)
-{
-  GdkGCPrivate *private;
-  HBITMAP pixmap;
-
-  g_return_if_fail (gc != NULL);
-
-  private = (GdkGCPrivate*) gc;
-
-  pixmap = NULL;
-
-  if (tile)
-    pixmap = GDK_DRAWABLE_XID (tile);
-
-  if (private->tile != NULL)
-    gdk_pixmap_unref (private->tile);
-  private->tile = tile;
-  if (tile)
-    gdk_pixmap_ref (tile);
-  if (pixmap != NULL)
-    private->values_mask |= GDK_GC_TILE;
-  else
-    private->values_mask &= ~GDK_GC_TILE;
-}
-
-void
-gdk_gc_set_stipple (GdkGC     *gc,
-		    GdkPixmap *stipple)
-{
-  GdkGCPrivate *private;
-  HBITMAP pixmap;
-
-  g_return_if_fail (gc != NULL);
-
-  private = (GdkGCPrivate*) gc;
-
-  pixmap = NULL;
-
-  if (stipple)
-    pixmap = GDK_DRAWABLE_XID (stipple);
-
-  if (private->stipple != NULL)
-    gdk_pixmap_unref (private->stipple);
-  private->stipple = stipple;
-  if (stipple)
-    gdk_pixmap_ref (stipple);
-  if (pixmap != NULL)
-    private->values_mask |= GDK_GC_STIPPLE;
-  else
-    private->values_mask &= ~GDK_GC_STIPPLE;
-}
-
-void
-gdk_gc_set_ts_origin (GdkGC *gc,
-		      gint   x,
-		      gint   y)
-{
-  GdkGCPrivate *private;
-
-  g_return_if_fail (gc != NULL);
+  if (values_mask & GDK_GC_FONT)
+    {
+      if (data->font != NULL)
+	gdk_font_unref (data->font);
+      data->font = values->font;
+      if (data->font != NULL)
+	{
+	  GDK_NOTE (MISC, (xlfd = gdk_font_xlfd_create (data->font),
+			   g_print ("font = %s ", xlfd),
+			   gdk_font_xlfd_free (xlfd)));
+	  gdk_font_ref (data->font);
+	  data->values_mask |= GDK_GC_FONT;
+	}
+      else
+	{
+	  GDK_NOTE (MISC, g_print ("font = NULL "));
+	  data->values_mask &= ~GDK_GC_FONT;
+	}
+    }
 
-  private = (GdkGCPrivate*) gc;
+  if (values_mask & GDK_GC_FUNCTION)
+    {
+      GDK_NOTE (MISC, g_print ("fun = %d ", values->function));
 
-  private->ts_x_origin = x;
-  private->ts_y_origin = y;
-  private->values_mask |= GDK_GC_TS_X_ORIGIN |GDK_GC_TS_Y_ORIGIN;
-}
+      switch (values->function)
+	{
+	case GDK_COPY:
+	  data->rop2 = R2_COPYPEN; break;
+	case GDK_INVERT:
+	  data->rop2 = R2_NOT; break;
+	case GDK_XOR:
+	  data->rop2 = R2_XORPEN; break;
+	case GDK_CLEAR:
+	  data->rop2 = R2_BLACK; break;
+	case GDK_AND:
+	  data->rop2 = R2_MASKPEN; break;
+	case GDK_AND_REVERSE:
+	  data->rop2 = R2_MASKPENNOT; break;
+	case GDK_AND_INVERT:
+	  data->rop2 = R2_MASKNOTPEN; break;
+	case GDK_NOOP:
+	  data->rop2 = R2_NOP; break;
+	case GDK_OR:
+	  data->rop2 = R2_MERGEPEN; break;
+	case GDK_EQUIV:
+	  data->rop2 = R2_NOTXORPEN; break;
+	case GDK_OR_REVERSE:
+	  data->rop2 = R2_MERGEPENNOT; break;
+	case GDK_COPY_INVERT:
+	  data->rop2 = R2_NOTCOPYPEN; break;
+	case GDK_OR_INVERT:
+	  data->rop2 = R2_MERGENOTPEN; break;
+	case GDK_NAND:
+	  data->rop2 = R2_NOTMASKPEN; break;
+	case GDK_SET:
+	  data->rop2 = R2_WHITE; break;
+	}
+      data->values_mask |= GDK_GC_FUNCTION;
+    }
 
-void
-gdk_gc_set_clip_origin (GdkGC *gc,
-			gint   x,
-			gint   y)
-{
-  GdkGCPrivate *private;
+  if (values_mask & GDK_GC_FILL)
+    {
+      GDK_NOTE (MISC, g_print ("fill = %d ", values->fill));
+      data->fill_style = values->fill;
+      data->values_mask |= GDK_GC_FILL;
+    }
 
-  g_return_if_fail (gc != NULL);
+  if (values_mask & GDK_GC_TILE)
+    {
+      if (data->tile != NULL)
+	gdk_pixmap_unref (data->tile);
+      data->tile = values->tile;
+      if (data->tile != NULL)
+	{
+	  GDK_NOTE (MISC, g_print ("tile = %#x ",
+				   GDK_DRAWABLE_XID (values->tile)));
+	  gdk_pixmap_ref (data->tile);
+	  data->values_mask |= GDK_GC_TILE;
+	}
+      else
+	{
+	  GDK_NOTE (MISC, g_print ("tile = NULL "));
+	  data->values_mask &= ~GDK_GC_TILE;
+	}
+    }
 
-  private = (GdkGCPrivate*) gc;
+  if (values_mask & GDK_GC_STIPPLE)
+    {
+      if (data->stipple != NULL)
+	gdk_pixmap_unref (data->stipple);
+      data->stipple = values->stipple;
+      if (data->stipple != NULL)
+	{
+	  GDK_NOTE (MISC, g_print ("stipple = %#x ",
+				   GDK_DRAWABLE_XID (values->stipple)));
+	  gdk_pixmap_ref (data->stipple);
+	  data->values_mask |= GDK_GC_STIPPLE;
+	}
+      else
+	{
+	  GDK_NOTE (MISC, g_print ("stipple = NULL "));
+	  data->values_mask &= ~GDK_GC_STIPPLE;
+	}
+    }
 
-  GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_origin: (%d) +%d+%d\n",
-			   private, x, y));
+  if (values_mask & GDK_GC_CLIP_MASK)
+    {
+      if (data->clip_region != NULL)
+	if (!DeleteObject (data->clip_region))
+	  g_warning ("gdk_win32_gc_set_values: DeleteObject failed");
+      if (values->clip_mask != NULL)
+	{
+	  data->clip_region =
+	    BitmapToRegion (GDK_DRAWABLE_XID (values->clip_mask));
+	  data->values_mask |= GDK_GC_CLIP_MASK;
+	}
+      else
+	{
+	  data->clip_region = NULL;
+	  data->values_mask &= ~GDK_GC_CLIP_MASK;
+	}
+    }
 
-  private->clip_x_origin = x;
-  private->clip_y_origin = y;
-  private->values_mask |= GDK_GC_CLIP_X_ORIGIN |GDK_GC_CLIP_Y_ORIGIN;
-}
+  if (values_mask & GDK_GC_SUBWINDOW)
+    {
+      data->values_mask |= GDK_GC_SUBWINDOW;
+    }
 
-void
-gdk_gc_set_clip_mask (GdkGC	*gc,
-		      GdkBitmap *mask)
-{
-  GdkGCPrivate *private;
-  HBITMAP xmask;
+  if (values_mask & GDK_GC_TS_X_ORIGIN)
+    {
+      data->ts_x_origin = values->ts_x_origin;
+      data->values_mask |= GDK_GC_TS_X_ORIGIN;
+    }
   
-  g_return_if_fail (gc != NULL);
+  if (values_mask & GDK_GC_TS_Y_ORIGIN)
+    {
+      data->ts_y_origin = values->ts_y_origin;
+      data->values_mask |= GDK_GC_TS_Y_ORIGIN;
+    }
   
-  if (mask)
+  if (values_mask & GDK_GC_CLIP_X_ORIGIN)
     {
-      if (GDK_DRAWABLE_DESTROYED (mask))
-	return;
-      xmask = GDK_DRAWABLE_XID (mask);
+      data->clip_x_origin = values->clip_x_origin;
+      data->values_mask |= GDK_GC_CLIP_X_ORIGIN;
+    }
+  
+  if (values_mask & GDK_GC_CLIP_Y_ORIGIN)
+    {
+      data->clip_y_origin = values->clip_y_origin;
+      data->values_mask |= GDK_GC_CLIP_Y_ORIGIN;
+    }
+  
+  if (values_mask & GDK_GC_EXPOSURES)
+    {
+      data->values_mask |= GDK_GC_EXPOSURES;
     }
-  else
-    xmask = NULL;
-
-  private = (GdkGCPrivate*) gc;
 
-  GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_mask: (%d) %#x\n", private, xmask));
+  if (values_mask & GDK_GC_LINE_WIDTH)
+    {
+      data->pen_width = values->line_width;
+      data->values_mask |= GDK_GC_LINE_WIDTH;
+    }
 
-  if (private->clip_region != NULL)
-    if (!DeleteObject (private->clip_region))
-      g_warning ("gdk_gc_set_clip_mask: DeleteObject failed");
-  if (xmask != NULL)
+  if (values_mask & GDK_GC_LINE_STYLE)
     {
-      private->clip_region = BitmapToRegion (xmask);
-      {
-	RECT rect;
-	GetRgnBox (private->clip_region, &rect);
-	GDK_NOTE (MISC, g_print ("...box = %dx%d@+%d+%d\n",
-				 rect.right - rect.left, rect.bottom - rect.top,
-				 rect.left, rect.top));
-      }
-#if 0
-      /* Test code that sets clip region to whole of mask */
-      {
-	BITMAP bm;
-	GetObject (xmask, sizeof (bm), &bm);
-	private->clip_region = CreateRectRgn (0, 0, bm.bmWidth, bm.bmHeight);
-      }
-#endif
-      private->values_mask |= GDK_GC_CLIP_MASK;
+      data->pen_style &= ~(PS_STYLE_MASK);
+      switch (values->line_style)
+	{
+	case GDK_LINE_SOLID:
+	  data->pen_style |= PS_SOLID; break;
+	case GDK_LINE_ON_OFF_DASH:
+	case GDK_LINE_DOUBLE_DASH: /* ??? */
+	  data->pen_style |= PS_DASH; break;
+	}
+      data->values_mask |= GDK_GC_LINE_STYLE;
     }
-  else
+  
+  if (values_mask & GDK_GC_CAP_STYLE)
+    {
+      data->pen_style &= ~(PS_ENDCAP_MASK);
+      switch (values->cap_style)
+	{
+	case GDK_CAP_NOT_LAST:
+	  /* ??? */
+	  break;
+	case GDK_CAP_BUTT:
+	  data->pen_style |= PS_ENDCAP_FLAT; break;
+	case GDK_CAP_ROUND:
+	  data->pen_style |= PS_ENDCAP_ROUND; break;
+	case GDK_CAP_PROJECTING:
+	  data->pen_style |= PS_ENDCAP_SQUARE; break;
+	}
+      data->values_mask |= GDK_GC_CAP_STYLE;
+    }
+
+  if (values_mask & GDK_GC_JOIN_STYLE)
     {
-      private->values_mask &= ~GDK_GC_CLIP_MASK;
-      private->clip_region = NULL;
+      data->pen_style &= ~(PS_JOIN_MASK);
+
+      switch (values->join_style)
+	{
+	case GDK_JOIN_MITER:
+	  data->pen_style |= PS_JOIN_MITER; break;
+	case GDK_JOIN_ROUND:
+	  data->pen_style |= PS_JOIN_ROUND; break;
+	case GDK_JOIN_BEVEL:
+	  data->pen_style |= PS_JOIN_BEVEL; break;
+	}
+      data->values_mask |= GDK_GC_JOIN_STYLE;
     }
 }
 
+static void
+gdk_win32_gc_set_dashes (GdkGC *gc,
+			 gint	  dash_offset,
+			 gchar  dash_list[],
+			 gint   n)
+{
+  GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc);
+
+  /* XXX ??? */
+
+  data->pen_style &= ~(PS_STYLE_MASK);
+  data->pen_style |= PS_DASH;
+}
+
 void
 gdk_gc_set_clip_rectangle (GdkGC	*gc,
 			   GdkRectangle *rectangle)
 {
-  GdkGCPrivate *private;
+  GdkGCWin32Data *data;
    
   g_return_if_fail (gc != NULL);
 
-  private = (GdkGCPrivate*) gc;
+  data = GDK_GC_WIN32DATA (gc);
 
-  if (private->clip_region != NULL)
-    if (!DeleteObject (private->clip_region))
+  if (data->clip_region != NULL)
+    if (!DeleteObject (data->clip_region))
       g_warning ("gdk_gc_set_clip_rectangle: DeleteObject failed");
   if (rectangle)
     {
       GDK_NOTE (MISC,
 		g_print ("gdk_gc_set_clip_rectangle: (%d) %dx%d@+%d+%d\n",
-			 private,
+			 data,
 			 rectangle->width, rectangle->height,
 			 rectangle->x, rectangle->y));
-      if ((private->clip_region =
+      if ((data->clip_region =
 	   CreateRectRgn (rectangle->x, rectangle->y,
 			  rectangle->x + rectangle->width,
 			  rectangle->y + rectangle->height)) == NULL)
 	g_warning ("gdk_gc_set_clip_rectangle: CreateRectRgn failed");
 
-      private->values_mask |= GDK_GC_CLIP_MASK;
+      data->values_mask |= GDK_GC_CLIP_MASK;
     }
   else
     {
-      GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_rectangle: (%d) None\n",
-			       private));
-      private->clip_region = NULL;
-      private->values_mask &= ~GDK_GC_CLIP_MASK;
+      GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_rectangle: (%d) NULL\n",
+			       data));
+      data->clip_region = NULL;
+      data->values_mask &= ~GDK_GC_CLIP_MASK;
     }
-    private->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN |GDK_GC_CLIP_Y_ORIGIN);
+    data->values_mask &= ~(GDK_GC_CLIP_X_ORIGIN |GDK_GC_CLIP_Y_ORIGIN);
 } 
 
 void
 gdk_gc_set_clip_region (GdkGC		 *gc,
 			GdkRegion	 *region)
 {
-  GdkGCPrivate *private;
+  GdkGCWin32Data *data;
 
   g_return_if_fail (gc != NULL);
 
-  private = (GdkGCPrivate*) gc;
+  data = GDK_GC_WIN32DATA (gc);
 
   GDK_NOTE (MISC, g_print ("gdk_gc_set_clip_region: (%d) %s\n",
-			   private, (region != NULL ? "xxx" : "None")));
+			   data, (region != NULL ? "xxx" : "None")));
 
-  if (private->clip_region != NULL)
-    if (!DeleteObject (private->clip_region))
+  if (data->clip_region != NULL)
+    if (!DeleteObject (data->clip_region))
       g_warning ("gdk_gc_set_clip_region: DeleteObject failed");
   if (region)
     {
       GdkRegionPrivate *region_private;
 
       region_private = (GdkRegionPrivate*) region;
-      private->clip_region = CreateRectRgn (1, 1, 0, 0);
-      CombineRgn (private->clip_region, region_private->xregion, NULL, RGN_COPY);
-      private->values_mask |= GDK_GC_CLIP_MASK;
+      data->clip_region = CreateRectRgn (1, 1, 0, 0);
+      CombineRgn (data->clip_region, region_private->xregion, NULL, RGN_COPY);
+      data->values_mask |= GDK_GC_CLIP_MASK;
     }
   else
     {
-      private->clip_region = NULL;
-      private->values_mask &= ~GDK_GC_CLIP_MASK;
-    }
-}
-
-void
-gdk_gc_set_subwindow (GdkGC	       *gc,
-		      GdkSubwindowMode	mode)
-{
-  GdkGCPrivate *private;
-
-  g_return_if_fail (gc != NULL);
-
-  private = (GdkGCPrivate*) gc;
-
-  private->subwindow_mode = mode;
-  private->values_mask |= GDK_GC_SUBWINDOW;
-}
-
-void
-gdk_gc_set_exposures (GdkGC *gc,
-		      gint   exposures)
-{
-  GdkGCPrivate *private;
-
-  g_return_if_fail (gc != NULL);
-
-  private = (GdkGCPrivate*) gc;
-
-  private->graphics_exposures = exposures;
-  private->values_mask |= GDK_GC_EXPOSURES;;
-}
-
-void
-gdk_gc_set_line_attributes (GdkGC	*gc,
-			    gint	 line_width,
-			    GdkLineStyle line_style,
-			    GdkCapStyle	 cap_style,
-			    GdkJoinStyle join_style)
-{
-  GdkGCPrivate *private;
-  int xline_style;
-  int xcap_style;
-  int xjoin_style;
-
-  g_return_if_fail (gc != NULL);
-
-  private = (GdkGCPrivate*) gc;
-
-  GDK_NOTE (MISC,
-	    g_print ("gdk_gc_set_line_attributes: (%d) %d %s %s %s\n",
-		     private, line_width,
-		     (line_style == GDK_LINE_SOLID ? "SOLID" :
-		      (line_style == GDK_LINE_ON_OFF_DASH ? "ON_OFF_DASH" :
-		       (line_style == GDK_LINE_DOUBLE_DASH ? "DOUBLE_DASH" :
-			"???"))),
-		     (cap_style == GDK_CAP_BUTT ? "BUTT" :
-		      (cap_style == GDK_CAP_ROUND ? "ROUND" :
-		       (cap_style == GDK_CAP_PROJECTING ? "PROJECTING" :
-			"???"))),
-		     (join_style == GDK_JOIN_MITER ? "MITER" :
-		      (join_style == GDK_JOIN_ROUND ? "ROUND" :
-		       (join_style == GDK_JOIN_BEVEL ? "BEVEL" :
-			"???")))));
-
-  private->pen_width = line_width;
-
-  /* Mask old style bits away */
-  private->pen_style &= ~(PS_STYLE_MASK|PS_ENDCAP_MASK|PS_JOIN_MASK);
-
-  /* Add new bits */
-  switch (line_style)
-    {
-    case GDK_LINE_SOLID:
-      private->pen_style |= PS_SOLID; break;
-    case GDK_LINE_ON_OFF_DASH:
-    case GDK_LINE_DOUBLE_DASH: /* ??? */
-      private->pen_style |= PS_DASH; break;
-    }
-
-  switch (cap_style)
-    {
-    case GDK_CAP_NOT_LAST:
-      /* ??? */
-      break;
-    case GDK_CAP_BUTT:
-      private->pen_style |= PS_ENDCAP_FLAT; break;
-    case GDK_CAP_ROUND:
-      private->pen_style |= PS_ENDCAP_ROUND; break;
-    case GDK_CAP_PROJECTING:
-      private->pen_style |= PS_ENDCAP_SQUARE; break;
-    }
-
-  switch (join_style)
-    {
-    case GDK_JOIN_MITER:
-      private->pen_style |= PS_JOIN_MITER;
-      break;
-    case GDK_JOIN_ROUND:
-      private->pen_style |= PS_JOIN_ROUND;
-      break;
-    case GDK_JOIN_BEVEL:
-      private->pen_style |= PS_JOIN_BEVEL;
-      break;
+      data->clip_region = NULL;
+      data->values_mask &= ~GDK_GC_CLIP_MASK;
     }
 }
 
 void
-gdk_gc_set_dashes (GdkGC *gc,
-		   gint	  dash_offset,
-		   gchar  dash_list[],
-		   gint   n)
-{
-  GdkGCPrivate *private;
-
-  g_return_if_fail (gc != NULL);
-  g_return_if_fail (dash_list != NULL);
-
-  /* XXX ??? */
-
-  private = (GdkGCPrivate *) gc;
-
-  private->pen_style &= ~(PS_STYLE_MASK);
-  private->pen_style |= PS_DASH;
-}
-
-void
 gdk_gc_copy (GdkGC *dst_gc, GdkGC *src_gc)
 {
-  GdkGCPrivate *dst_private, *src_private;
-
-  src_private = (GdkGCPrivate *) src_gc;
-  dst_private = (GdkGCPrivate *) dst_gc;
-
-  *dst_private = *src_private;
+  GdkGCWin32Data *dst_data = GDK_GC_WIN32DATA (dst_gc);
+  GdkGCWin32Data *src_data = GDK_GC_WIN32DATA (src_gc);
+
+  if (dst_data->font)
+    gdk_font_unref (dst_data->font);
+  if (dst_data->tile)
+    gdk_pixmap_unref (dst_data->tile);
+  if (dst_data->stipple)
+    gdk_pixmap_unref (dst_data->stipple);
+  
+  *dst_data = *src_data;
+  
+  if (dst_data->font)
+    gdk_font_ref (dst_data->font);
+  if (dst_data->tile)
+    gdk_pixmap_ref (dst_data->tile);
+  if (dst_data->stipple)
+    gdk_pixmap_ref (dst_data->stipple);
 }
 
 HDC
@@ -903,8 +760,9 @@ gdk_gc_predraw (GdkDrawable  *drawable,
 		GdkGCPrivate *gc_private)
 {
   GdkDrawablePrivate *drawable_private = (GdkDrawablePrivate *) drawable;
-  GdkColormapPrivate *colormap_private =
-    (GdkColormapPrivate *) drawable_private->colormap;
+  GdkColormapPrivateWin32 *colormap_private =
+    (GdkColormapPrivateWin32 *) drawable_private->colormap;
+  GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc_private);
   GdkVisual *visual;
   COLORREF bg;
   COLORREF fg;
@@ -914,29 +772,29 @@ gdk_gc_predraw (GdkDrawable  *drawable,
   guchar r, g, b;
   static guint mask[9] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
 
-  g_assert (gc_private->xgc == NULL);
+  g_assert (data->xgc == NULL);
 
   if (GDK_DRAWABLE_TYPE (drawable) == GDK_DRAWABLE_PIXMAP)
     {
-      if ((gc_private->xgc = CreateCompatibleDC (NULL)) == NULL)
+      if ((data->xgc = CreateCompatibleDC (NULL)) == NULL)
 	g_warning ("gdk_gc_predraw: CreateCompatibleDC failed");
 
-      if ((gc_private->saved_dc = SaveDC (gc_private->xgc)) == 0)
+      if ((data->saved_dc = SaveDC (data->xgc)) == 0)
 	g_warning ("gdk_gc_predraw: SaveDC #1 failed");
       
-      if (SelectObject (gc_private->xgc, drawable_private->xwindow) == NULL)
+      if (SelectObject (data->xgc, GDK_DRAWABLE_XID (drawable)) == NULL)
 	g_warning ("gdk_gc_predraw: SelectObject #1 failed");
     }
   else
     {
-      if ((gc_private->xgc = GetDC (drawable_private->xwindow)) == NULL)
+      if ((data->xgc = GetDC (GDK_DRAWABLE_XID (drawable))) == NULL)
 	g_warning ("gdk_gc_predraw: GetDC failed");
       
-      if ((gc_private->saved_dc = SaveDC (gc_private->xgc)) == 0)
+      if ((data->saved_dc = SaveDC (data->xgc)) == 0)
 	g_warning ("gdk_gc_predraw: SaveDC #2 failed");
     }
   
-  gc_private->hwnd = drawable_private->xwindow;
+  data->hwnd = GDK_DRAWABLE_XID (drawable);
   
   if (colormap_private == NULL)
     {
@@ -965,69 +823,69 @@ gdk_gc_predraw (GdkDrawable  *drawable,
 	  if ((hpal = CreatePalette ((LOGPALETTE *) &logpal)) == NULL)
 	    g_warning ("gdk_gc_predraw: CreatePalette failed");
 	}
-      SelectPalette (gc_private->xgc, hpal, FALSE);
-      RealizePalette (gc_private->xgc);
-      fg = PALETTEINDEX (gc_private->foreground.pixel);
+      SelectPalette (data->xgc, hpal, FALSE);
+      RealizePalette (data->xgc);
+      fg = PALETTEINDEX (data->foreground.pixel);
     }
   else if (colormap_private->xcolormap->rc_palette)
     {
       int k;
-      if (SelectPalette (gc_private->xgc,
+      if (SelectPalette (data->xgc,
 			 colormap_private->xcolormap->palette, FALSE) == NULL)
 	g_warning ("gdk_gc_predraw: SelectPalette failed");
       if (TRUE || colormap_private->xcolormap->stale)
 	{
-	  if ((k = RealizePalette (gc_private->xgc)) == GDI_ERROR)
+	  if ((k = RealizePalette (data->xgc)) == GDI_ERROR)
 	    g_warning ("gdk_gc_predraw: RealizePalette failed");
 	  colormap_private->xcolormap->stale = FALSE;
 	}
 #if 0
       g_print ("Selected palette %#x for gc %#x, realized %d colors\n",
-	       colormap_private->xcolormap->palette, gc_private->xgc, k);
+	       colormap_private->xcolormap->palette, data->xgc, k);
 #endif
-      fg = PALETTEINDEX (gc_private->foreground.pixel);
+      fg = PALETTEINDEX (data->foreground.pixel);
     }
   else
     {
       visual = colormap_private->visual;
-      r = (gc_private->foreground.pixel & visual->red_mask) >> visual->red_shift;
+      r = (data->foreground.pixel & visual->red_mask) >> visual->red_shift;
       r = (r * 255) / mask[visual->red_prec];
-      g = (gc_private->foreground.pixel & visual->green_mask) >> visual->green_shift;
+      g = (data->foreground.pixel & visual->green_mask) >> visual->green_shift;
       g = (g * 255) / mask[visual->green_prec];
-      b = (gc_private->foreground.pixel & visual->blue_mask) >> visual->blue_shift;
+      b = (data->foreground.pixel & visual->blue_mask) >> visual->blue_shift;
       b = (b * 255) / mask[visual->blue_prec];
 
-      fg = GetNearestColor (gc_private->xgc, RGB (r, g, b));
+      fg = GetNearestColor (data->xgc, RGB (r, g, b));
     }
   logbrush.lbStyle = BS_SOLID;
   logbrush.lbColor = fg;
-  if ((hpen = ExtCreatePen (gc_private->pen_style, gc_private->pen_width,
+  if ((hpen = ExtCreatePen (data->pen_style, data->pen_width,
 			    &logbrush, 0, NULL)) == NULL)
     g_warning ("gdk_gc_predraw: CreatePen failed");
   
-  if (SelectObject (gc_private->xgc, hpen) == NULL)
+  if (SelectObject (data->xgc, hpen) == NULL)
     g_warning ("gdk_gc_predraw: SelectObject #2 failed");
 
-  if (SetTextColor (gc_private->xgc, fg) == CLR_INVALID)
+  if (SetTextColor (data->xgc, fg) == CLR_INVALID)
     g_warning ("gdk_gc_predraw: SetTextColor failed");
 
 #if 0
-  switch (gc_private->fill_style)
+  switch (data->fill_style)
     {
     case GDK_STIPPLED:
       {
-	GdkPixmap *stipple = gc_private->stipple;
+	GdkPixmap *stipple = data->stipple;
 	GdkPixmapPrivate *stipple_private = (GdkPixmapPrivate *) stipple;
-	HBITMAP hbm = stipple_private->xwindow;
+	HBITMAP hbm = GDK_DRAWABLE_XID (stipple);
 	if (NULL == (hbr = CreatePatternBrush (hbm)))
 	  g_warning ("gdk_gc_predraw: CreatePatternBrush failed");
 	
 #ifdef NATIVE_WIN16
-	SetBrushOrg  (gc_private->xgc, gc_private->ts_x_origin,
-		      gc_private->ts_y_origin);
+	SetBrushOrg  (data->xgc, data->ts_x_origin,
+		      data->ts_y_origin);
 #else
-	SetBrushOrgEx(gc_private->xgc, gc_private->ts_x_origin,
-		      gc_private->ts_y_origin, NULL);
+	SetBrushOrgEx(data->xgc, data->ts_x_origin,
+		      data->ts_y_origin, NULL);
 #endif
       }
       break;
@@ -1041,94 +899,95 @@ gdk_gc_predraw (GdkDrawable  *drawable,
   if ((hbr = CreateSolidBrush (fg)) == NULL)
     g_warning ("gdk_gc_predraw: CreateSolidBrush failed");
 #endif
-  if (SelectObject (gc_private->xgc, hbr) == NULL)
+  if (SelectObject (data->xgc, hbr) == NULL)
     g_warning ("gdk_gc_predraw: SelectObject #3 failed");
 
-  if (gc_private->values_mask & GDK_GC_BACKGROUND)
+  if (data->values_mask & GDK_GC_BACKGROUND)
     {
       if (colormap_private == NULL)
 	{
 	  /* a bitmap */
-	  bg = PALETTEINDEX (gc_private->background.pixel);
+	  bg = PALETTEINDEX (data->background.pixel);
 	}
       else if (colormap_private->xcolormap->rc_palette)
 	{
-	  bg = PALETTEINDEX (gc_private->background.pixel);
+	  bg = PALETTEINDEX (data->background.pixel);
 	}
       else
 	{
 	  visual = colormap_private->visual;
-	  r = (gc_private->background.pixel & visual->red_mask) >> visual->red_shift;
+	  r = (data->background.pixel & visual->red_mask) >> visual->red_shift;
 	  r = (r * 255) / mask[visual->red_prec];
-	  g = (gc_private->background.pixel & visual->green_mask) >> visual->green_shift;
+	  g = (data->background.pixel & visual->green_mask) >> visual->green_shift;
 	  g = (g * 255) / mask[visual->green_prec];
-	  b = (gc_private->background.pixel & visual->blue_mask) >> visual->blue_shift;
+	  b = (data->background.pixel & visual->blue_mask) >> visual->blue_shift;
 	  b = (b * 255) / mask[visual->green_prec];
 	  
-	  fg = GetNearestColor (gc_private->xgc, RGB (r, g, b));
+	  fg = GetNearestColor (data->xgc, RGB (r, g, b));
 	}
-      if (SetBkColor (gc_private->xgc, bg) == CLR_INVALID)
+      if (SetBkColor (data->xgc, bg) == CLR_INVALID)
 	g_warning ("gdk_gc_predraw: SetBkColor failed");
     }
   
-  if (SetBkMode (gc_private->xgc, TRANSPARENT) == 0)
+  if (SetBkMode (data->xgc, TRANSPARENT) == 0)
     g_warning ("gdk_gc_predraw: SetBkMode failed");
   
-  if (SetTextAlign (gc_private->xgc, TA_BASELINE) == GDI_ERROR)
+  if (SetTextAlign (data->xgc, TA_BASELINE) == GDI_ERROR)
     g_warning ("gdk_gc_predraw: SetTextAlign failed");
   
-  if (gc_private->values_mask & GDK_GC_FUNCTION)
-    if (SetROP2 (gc_private->xgc, gc_private->rop2) == 0)
+  if (data->values_mask & GDK_GC_FUNCTION)
+    if (SetROP2 (data->xgc, data->rop2) == 0)
       g_warning ("gdk_gc_predraw: SetROP2 failed");
 
-  if (gc_private->values_mask & GDK_GC_CLIP_MASK
-      && gc_private->clip_region != NULL)
+  if (data->values_mask & GDK_GC_CLIP_MASK
+      && data->clip_region != NULL)
     {
-      if (gc_private->values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN))
-	OffsetRgn (gc_private->clip_region,
-		   gc_private->clip_x_origin, gc_private->clip_y_origin);
-      SelectClipRgn (gc_private->xgc, gc_private->clip_region);
+      if (data->values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN))
+	OffsetRgn (data->clip_region,
+		   data->clip_x_origin, data->clip_y_origin);
+      SelectClipRgn (data->xgc, data->clip_region);
     }
 
-  return gc_private->xgc;
+  return data->xgc;
 }
 
 void
-gdk_gc_postdraw (GdkDrawable  *drawable_private,
+gdk_gc_postdraw (GdkDrawable  *drawable,
 		 GdkGCPrivate *gc_private)
 {
   GdkDrawablePrivate *drawable_private = (GdkDrawablePrivate *) drawable;
-  GdkColormapPrivate *colormap_private =
-    (GdkColormapPrivate *) drawable_private->colormap;
+  GdkColormapPrivateWin32 *colormap_private =
+    (GdkColormapPrivateWin32 *) drawable_private->colormap;
+  GdkGCWin32Data *data = GDK_GC_WIN32DATA (gc_private);
   HGDIOBJ hpen;
   HGDIOBJ hbr;
 
-  if ((hpen = GetCurrentObject (gc_private->xgc, OBJ_PEN)) == NULL)
+  if ((hpen = GetCurrentObject (data->xgc, OBJ_PEN)) == NULL)
     g_warning ("gdk_gc_postdraw: GetCurrentObject #1 failed");
 
-  if ((hbr = GetCurrentObject (gc_private->xgc, OBJ_BRUSH)) == NULL)
+  if ((hbr = GetCurrentObject (data->xgc, OBJ_BRUSH)) == NULL)
     g_warning ("gdk_gc_postdraw: GetCurrentObject #2 failed");
 
-  if (!RestoreDC (gc_private->xgc, gc_private->saved_dc))
+  if (!RestoreDC (data->xgc, data->saved_dc))
     g_warning ("gdk_gc_postdraw: RestoreDC failed");
 #if 0
   if (colormap_private != NULL
       && colormap_private->xcolormap->rc_palette
       && colormap_private->xcolormap->stale)
     {
-      SelectPalette (gc_private->xgc, GetStockObject (DEFAULT_PALETTE), FALSE);
+      SelectPalette (data->xgc, GetStockObject (DEFAULT_PALETTE), FALSE);
       if (!UnrealizeObject (colormap_private->xcolormap->palette))
 	g_warning ("gdk_gc_postraw: UnrealizeObject failed");
     }
 #endif
   if (GDK_DRAWABLE_TYPE (drawable) == GDK_DRAWABLE_PIXMAP)
     {
-      if (!DeleteDC (gc_private->xgc))
+      if (!DeleteDC (data->xgc))
 	g_warning ("gdk_gc_postdraw: DeleteDC failed");
     }
   else
     {
-      ReleaseDC (gc_private->hwnd, gc_private->xgc);
+      ReleaseDC (data->hwnd, data->xgc);
     }
 
   if (hpen != NULL)
@@ -1139,7 +998,7 @@ gdk_gc_postdraw (GdkDrawable  *drawable_private,
     if (!DeleteObject (hbr))
       g_warning ("gdk_gc_postdraw: DeleteObject #2 failed");
 
-  gc_private->xgc = NULL;
+  data->xgc = NULL;
 }
 
 /* This function originally from Jean-Edouard Lachand-Robert, and
diff --git a/gdk/win32/gdkim-win32.c b/gdk/win32/gdkim-win32.c
index a9083b96e3..a20c7826f4 100644
--- a/gdk/win32/gdkim-win32.c
+++ b/gdk/win32/gdkim-win32.c
@@ -35,7 +35,7 @@
 #include "gdkpixmap.h"
 #include "gdkprivate.h"
 #include "gdki18n.h"
-#include "gdkx.h"
+#include "gdkwin32.h"
 
 /*
  *--------------------------------------------------------------
diff --git a/gdk/win32/gdkprivate-win32.h b/gdk/win32/gdkprivate-win32.h
index 90e2f22675..f1c4fa3254 100644
--- a/gdk/win32/gdkprivate-win32.h
+++ b/gdk/win32/gdkprivate-win32.h
@@ -144,7 +144,7 @@ struct _GdkGCWin32Data
    * has been selected into it. Thus, we have to release and
    * reallocate a DC each time the GdkGC is used to paint into a new
    * window or pixmap. We thus keep all the necessary values in the
-   * GdkGCPrivate struct.
+   * GdkGCWin32Data struct.
    */
   HDC xgc;
   GdkGCValuesMask values_mask;
@@ -165,7 +165,8 @@ struct _GdkGCWin32Data
   gint pen_width;
   DWORD pen_style;
   HANDLE hwnd;			/* If a DC is allocated, for which window
-				   or what bitmap is selected into it */
+				 * or what bitmap is selected into it
+				 */
   int saved_dc;
 };