X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gdk%2Fwin32%2Fgdkwindow-win32.c;h=d4c279658cf8ae61239c5150d44e5ca53aa9a514;hb=1f149b3a8d4180024df25f700307406520159bec;hp=d8b5177acf8a36917f30fc64c1fdf80b64266fab;hpb=f527b8909f4aefbde3022da5270a5f3c0ec12587;p=~andy%2Fgtk

diff --git a/gdk/win32/gdkwindow-win32.c b/gdk/win32/gdkwindow-win32.c
index d8b5177ac..d4c279658 100644
--- a/gdk/win32/gdkwindow-win32.c
+++ b/gdk/win32/gdkwindow-win32.c
@@ -33,9 +33,15 @@
 #include "gdkevents.h"
 #include "gdkpixmap.h"
 #include "gdkwindow.h"
+#include "gdkinternals.h"
 #include "gdkprivate.h"
+#include "gdkprivate-win32.h"
 #include "gdkinputprivate.h"
-#include "gdkx.h"
+#include "gdkwin32.h"
+
+static gboolean gdk_window_gravity_works (void);
+static void     gdk_window_set_static_win_gravity (GdkWindow *window, 
+						   gboolean   on);
 
 /* The Win API function AdjustWindowRect may return negative values
  * resulting in obscured title bars. This helper function is coreccting it.
@@ -47,7 +53,10 @@ SafeAdjustWindowRectEx (RECT* lpRect,
 			DWORD dwExStyle)
 {
   if (!AdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle))
-    return FALSE;
+    {
+      WIN32_API_FAILED ("AdjustWindowRectEx");
+      return FALSE;
+    }
   if (lpRect->left < 0)
     {
       lpRect->right -= lpRect->left;
@@ -61,50 +70,66 @@ SafeAdjustWindowRectEx (RECT* lpRect,
   return TRUE;
 }
 
-/* Forward declarations */
-static gboolean gdk_window_gravity_works (void);
-static void     gdk_window_set_static_win_gravity (GdkWindow *window, 
-						   gboolean   on);
+GdkDrawableClass _gdk_windowing_window_class;
 
-/* 
- * The following fucntion by The Rasterman <raster@redhat.com>
- * This function returns the X Window ID in which the x y location is in 
- * (x and y being relative to the root window), excluding any windows listed
- * in the GList excludes (this is a list of X Window ID's - gpointer being
- * the Window ID).
- * 
- * This is primarily designed for internal gdk use - for DND for example
- * when using a shaped icon window as the drag object - you exclude the
- * X Window ID of the "icon" (perhaps more if excludes may be needed) and
- * You can get back an X Window ID as to what X Window ID is infact under
- * those X,Y co-ordinates.
- */
-HWND
-gdk_window_xid_at_coords (gint     x,
-			  gint     y,
-			  GList   *excludes,
-			  gboolean excl_child)
+static void
+gdk_win32_window_destroy (GdkDrawable *drawable)
 {
-  POINT pt;
-  gboolean warned = FALSE;
+  if (!GDK_DRAWABLE_DESTROYED (drawable))
+    {
+      if (GDK_DRAWABLE_TYPE (drawable) == GDK_WINDOW_FOREIGN)
+	gdk_xid_table_remove (GDK_DRAWABLE_XID (drawable));
+      else
+	g_warning ("losing last reference to undestroyed window\n");
+    }
+
+  if (GDK_WINDOW_WIN32DATA (drawable)->bg_type == GDK_WIN32_BG_PIXMAP
+      && GDK_WINDOW_WIN32DATA (drawable)->bg_pixmap != NULL)
+    gdk_drawable_unref (GDK_WINDOW_WIN32DATA (drawable)->bg_pixmap);
+
+  g_free (GDK_DRAWABLE_WIN32DATA (drawable));
+}
 
-  pt.x = x;
-  pt.y = y;
-  /* This is probably not correct, just a quick hack */
+static GdkWindow *
+gdk_win32_window_alloc (void)
+{
+  GdkWindow *window;
+  GdkWindowPrivate *private;
+  
+  static gboolean initialized = FALSE;
 
-  if (!warned)
+  if (!initialized)
     {
-      g_warning ("gdk_window_xid_at_coords probably not implemented correctly");
-      warned = TRUE;
+      initialized = TRUE;
+      
+      _gdk_windowing_window_class = _gdk_win32_drawable_class;
+      _gdk_win32_drawable_class.destroy = gdk_win32_window_destroy;
     }
 
-  /* XXX */
-  return WindowFromPoint (pt);
+  window = _gdk_window_alloc ();
+  private = (GdkWindowPrivate *) window;
+
+  private->drawable.klass = &_gdk_windowing_window_class;
+  private->drawable.klass_data = g_new (GdkWindowWin32Data, 1);
+
+  GDK_WINDOW_WIN32DATA (window)->event_mask = 0;
+  GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
+  GDK_WINDOW_WIN32DATA (window)->xcursor = NULL;
+  GDK_WINDOW_WIN32DATA (window)->hint_flags = 0;
+  GDK_WINDOW_WIN32DATA (window)->extension_events_selected = FALSE;
+  
+  GDK_WINDOW_WIN32DATA (window)->input_locale = GetKeyboardLayout (0);
+  TranslateCharsetInfo ((DWORD FAR *) GetACP (),
+			&GDK_WINDOW_WIN32DATA (window)->charset_info,
+			TCI_SRCCODEPAGE);
+
+  return window;
 }
 
 void
 gdk_window_init (void)
 {
+  GdkWindowPrivate *private;
   RECT r;
   guint width;
   guint height;
@@ -113,17 +138,15 @@ gdk_window_init (void)
   width  = r.right - r.left;
   height = r.bottom - r.top;
 
-  gdk_root_parent = g_new (GdkWindowPrivate, 1);
-  gdk_root_parent->drawable.xwindow = gdk_root_window;
-  gdk_root_parent->drawable.window_type = GDK_WINDOW_ROOT;
-  gdk_root_parent->drawable.drawable.user_data = NULL;
-  gdk_root_parent->drawable.width = width;
-  gdk_root_parent->drawable.height = height;
-  gdk_root_parent->drawable.ref_count = 1;
-  gdk_root_parent->drawable.colormap = NULL;
-  gdk_root_parent->children = NULL;
-
-  gdk_xid_table_insert (&gdk_root_window, gdk_root_parent);
+  gdk_parent_root = gdk_win32_window_alloc ();
+  private = (GdkWindowPrivate *) gdk_parent_root;
+  
+  GDK_DRAWABLE_WIN32DATA (gdk_parent_root)->xid = gdk_root_window;
+  private->drawable.window_type = GDK_WINDOW_ROOT;
+  private->drawable.width = width;
+  private->drawable.height = height;
+
+  gdk_xid_table_insert (&gdk_root_window, gdk_parent_root);
 }
 
 /* RegisterGdkClass
@@ -134,7 +157,7 @@ gdk_window_init (void)
  *   get its own class
  */
 ATOM
-RegisterGdkClass(GdkWindowType wtype)
+RegisterGdkClass (GdkDrawableType wtype)
 {
   static ATOM klassTOPLEVEL = 0;
   static ATOM klassDIALOG   = 0;
@@ -236,9 +259,13 @@ RegisterGdkClass(GdkWindowType wtype)
       break;
   }
 
+  if (klass == 0)
+    {
+      WIN32_API_FAILED ("RegisterClassEx");
+      g_error ("That is a fatal error");
+    }
   return klass;
-} /* RegisterGdkClass */
-
+}
 
 GdkWindow*
 gdk_window_new (GdkWindow     *parent,
@@ -254,7 +281,6 @@ gdk_window_new (GdkWindow     *parent,
   ATOM klass = 0;
   DWORD dwStyle, dwExStyle;
   RECT rect;
-  UINT acp;
   int width, height;
   int x, y;
   char *title;
@@ -266,38 +292,26 @@ gdk_window_new (GdkWindow     *parent,
   g_return_val_if_fail (attributes != NULL, NULL);
 
   if (!parent)
-    parent = (GdkWindow*) gdk_root_parent;
+    parent = gdk_parent_root;
 
   parent_private = (GdkWindowPrivate*) parent;
   if (GDK_DRAWABLE_DESTROYED (parent))
     return NULL;
 
-  xparent = parent_private->drawable.xwindow;
+  xparent = GDK_DRAWABLE_XID (parent);
 
-  private = g_new (GdkWindowPrivate, 1);
-  window = (GdkWindow*) private;
+  window = gdk_win32_window_alloc ();
+  private = (GdkWindowPrivate *)window;
 
   private->parent = parent;
 
-  private->drawable.destroyed = FALSE;
-  private->mapped = FALSE;
-  private->guffaw_gravity = FALSE;
-  private->resize_count = 0;
-  private->drawable.ref_count = 1;
-
   private->x = (attributes_mask & GDK_WA_X) ? attributes->x : 0;
   private->y = (attributes_mask & GDK_WA_Y) ? attributes->y : 0;
 
   private->drawable.width = (attributes->width > 1) ? (attributes->width) : (1);
   private->drawable.height = (attributes->height > 1) ? (attributes->height) : (1);
   private->drawable.window_type = attributes->window_type;
-  private->extension_events = 0;
-  private->extension_events_selected = FALSE;
-
-  private->filters = NULL;
-  private->children = NULL;
-
-  window->user_data = NULL;
+  GDK_WINDOW_WIN32DATA (window)->extension_events_selected = FALSE;
 
   if (attributes_mask & GDK_WA_VISUAL)
     visual = attributes->visual;
@@ -309,11 +323,10 @@ gdk_window_new (GdkWindow     *parent,
     title = attributes->title;
   else
     title = g_get_prgname ();
+  if (!title)
+    title = "GDK client window";
 
-  private->event_mask = GDK_STRUCTURE_MASK | attributes->event_mask;
-  private->bg_type = GDK_WIN32_BG_NORMAL;
-  private->hint_flags = 0;
-  private->xcursor = NULL;
+  GDK_WINDOW_WIN32DATA (window)->event_mask = GDK_STRUCTURE_MASK | attributes->event_mask;
       
   if (parent_private && parent_private->guffaw_gravity)
     {
@@ -332,8 +345,8 @@ gdk_window_new (GdkWindow     *parent,
     {
       dwExStyle = WS_EX_TRANSPARENT;
       private->drawable.colormap = NULL;
-      private->bg_type = GDK_WIN32_BG_TRANSPARENT;
-      private->bg_pixmap = NULL;
+      GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_TRANSPARENT;
+      GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
     }
 
   if (attributes_mask & GDK_WA_X)
@@ -362,7 +375,9 @@ gdk_window_new (GdkWindow     *parent,
       break;
     case GDK_WINDOW_DIALOG:
       dwStyle = WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU | WS_CAPTION | WS_THICKFRAME | WS_CLIPCHILDREN;
+#if 0
       dwExStyle |= WS_EX_TOPMOST; /* //HB: want this? */
+#endif
       xparent = gdk_root_window;
       break;
     case GDK_WINDOW_TEMP:
@@ -378,8 +393,6 @@ gdk_window_new (GdkWindow     *parent,
     }
 
   klass = RegisterGdkClass (private->drawable.window_type);
-  if (!klass)
-    g_error ("RegisterClassEx failed");
 
   if (private->drawable.window_type != GDK_WINDOW_CHILD)
     {
@@ -397,8 +410,7 @@ gdk_window_new (GdkWindow     *parent,
       rect.right = rect.left + private->drawable.width;
       rect.bottom = rect.top + private->drawable.height;
 
-      if (!SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
-	g_warning ("gdk_window_new: AdjustWindowRectEx failed");
+      SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
 
       if (x != CW_USEDEFAULT)
 	{
@@ -414,12 +426,6 @@ gdk_window_new (GdkWindow     *parent,
       height = private->drawable.height;
     }
 
-  acp = GetACP ();
-  private->input_locale = GetKeyboardLayout (0);
-  TranslateCharsetInfo ((DWORD FAR *) acp,
-			&private->charset_info,
-			TCI_SRCCODEPAGE);
-
   titlelen = strlen (title);
   wctitle = g_new (wchar_t, titlelen + 1);
   mbtitle = g_new (char, 3*titlelen + 1);
@@ -428,7 +434,7 @@ gdk_window_new (GdkWindow     *parent,
   WideCharToMultiByte (GetACP (), 0, wctitle, -1,
 		       mbtitle, 3*titlelen, NULL, NULL);
   
-  private->drawable.xwindow =
+  GDK_DRAWABLE_WIN32DATA (window)->xid =
     CreateWindowEx (dwExStyle,
 		    MAKEINTRESOURCE(klass),
 		    mbtitle,
@@ -441,7 +447,7 @@ gdk_window_new (GdkWindow     *parent,
 		    NULL);
 
   GDK_NOTE (MISC,
-	    g_print ("gdk_window_create: %s %s %dx%d@+%d+%d %#x = %#x\n"
+	    g_print ("gdk_window_new: %s %s %dx%d@+%d+%d %#x = %#x\n"
 		     "...locale %#x codepage %d\n",
 		     (private->drawable.window_type == GDK_WINDOW_TOPLEVEL ? "TOPLEVEL" :
 		      (private->drawable.window_type == GDK_WINDOW_CHILD ? "CHILD" :
@@ -451,22 +457,23 @@ gdk_window_new (GdkWindow     *parent,
 		     mbtitle,
 		     width, height, (x == CW_USEDEFAULT ? -9999 : x), y, 
 		     xparent,
-		     private->drawable.xwindow,
-		     private->input_locale,
-		     private->charset_info.ciACP));
+		     GDK_DRAWABLE_XID (window),
+		     GDK_WINDOW_WIN32DATA (window)->input_locale,
+		     GDK_WINDOW_WIN32DATA (window)->charset_info.ciACP));
 
   g_free (mbtitle);
   g_free (wctitle);
 
-  if (private->drawable.xwindow == NULL)
+  if (GDK_DRAWABLE_XID (window) == NULL)
     {
-      g_warning ("gdk_window_create: CreateWindowEx failed");
+      WIN32_API_FAILED ("CreateWindowEx");
+      g_free (GDK_DRAWABLE_WIN32DATA (window));
       g_free (private);
       return NULL;
     }
 
-  gdk_window_ref (window);
-  gdk_xid_table_insert (&private->drawable.xwindow, window);
+  gdk_drawable_ref (window);
+  gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
 
   if (private->drawable.colormap)
     gdk_colormap_ref (private->drawable.colormap);
@@ -488,8 +495,8 @@ gdk_window_foreign_new (guint32 anid)
   RECT rect;
   POINT point;
 
-  private = g_new (GdkWindowPrivate, 1);
-  window = (GdkWindow*) private;
+  window = gdk_win32_window_alloc ();
+  private = (GdkWindowPrivate *)window;
 
   parent = GetParent ((HWND) anid);
   private->parent = gdk_xid_table_lookup (parent);
@@ -499,7 +506,7 @@ gdk_window_foreign_new (guint32 anid)
   if (parent_private)
     parent_private->children = g_list_prepend (parent_private->children, window);
 
-  private->drawable.xwindow = (HWND) anid;
+  GDK_DRAWABLE_WIN32DATA (window)->xid = (HWND) anid;
   GetClientRect ((HWND) anid, &rect);
   point.x = rect.left;
   point.y = rect.right;
@@ -510,31 +517,21 @@ gdk_window_foreign_new (guint32 anid)
   private->y = point.y;
   private->drawable.width = rect.right - rect.left;
   private->drawable.height = rect.bottom - rect.top;
-  private->resize_count = 0;
-  private->drawable.ref_count = 1;
   private->drawable.window_type = GDK_WINDOW_FOREIGN;
   private->drawable.destroyed = FALSE;
-  private->mapped = IsWindowVisible (private->drawable.xwindow);
-  private->guffaw_gravity = FALSE;
-  private->extension_events = 0;
-  private->extension_events_selected = FALSE;
+  private->mapped = IsWindowVisible (GDK_DRAWABLE_XID (window));
 
   private->drawable.colormap = NULL;
 
-  private->filters = NULL;
-  private->children = NULL;
-
-  window->user_data = NULL;
-
-  gdk_window_ref (window);
-  gdk_xid_table_insert (&private->drawable.xwindow, window);
+  gdk_drawable_ref (window);
+  gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
 
   return window;
 }
 
 /* Call this function when you want a window and all its children to
- * disappear.  When xdestroy is true, a request to destroy the XWindow
- * is sent out.  When it is false, it is assumed that the XWindow has
+ * disappear.  When xdestroy is true, a request to destroy the window
+ * is sent out.  When it is false, it is assumed that the window has
  * been or will be destroyed by destroying some ancestor of this
  * window.
  */
@@ -551,12 +548,12 @@ gdk_window_internal_destroy (GdkWindow *window,
 
   g_return_if_fail (window != NULL);
 
-  private = (GdkWindowPrivate*) window;
+  private = (GdkWindowPrivate *) window;
 
   GDK_NOTE (MISC, g_print ("gdk_window_internal_destroy %#x\n",
-			   private->drawable.xwindow));
+			   GDK_DRAWABLE_XID (window)));
 
-  switch (private->drawable.window_type)
+  switch (GDK_DRAWABLE_TYPE (window))
     {
     case GDK_WINDOW_TOPLEVEL:
     case GDK_WINDOW_CHILD:
@@ -624,11 +621,11 @@ gdk_window_internal_destroy (GdkWindow *window,
 		   * OTOH, I don't think foreign windows are much
 		   * used, so the question is maybe academic.
 		   */
-		  PostMessage (private->drawable.xwindow, WM_QUIT, 0, 0);
+		  PostMessage (GDK_DRAWABLE_XID (window), WM_QUIT, 0, 0);
 		}
 	    }
 	  else if (xdestroy)
-	    DestroyWindow (private->drawable.xwindow);
+	    DestroyWindow (GDK_DRAWABLE_XID (window));
 
 	  if (private->drawable.colormap)
 	    gdk_colormap_unref (private->drawable.colormap);
@@ -643,7 +640,7 @@ gdk_window_internal_destroy (GdkWindow *window,
       break;
 
     case GDK_DRAWABLE_PIXMAP:
-      g_error ("called gdk_window_destroy on a pixmap (use gdk_pixmap_unref)");
+      g_error ("called gdk_window_destroy on a pixmap (use gdk_drawable_unref)");
       break;
     }
 }
@@ -655,108 +652,63 @@ void
 gdk_window_destroy (GdkWindow *window)
 {
   gdk_window_internal_destroy (window, TRUE, TRUE);
-  gdk_window_unref (window);
+  gdk_drawable_unref (window);
 }
 
-/* This function is called when the XWindow is really gone.  */
+/* This function is called when the window really gone.  */
 
 void
 gdk_window_destroy_notify (GdkWindow *window)
 {
   g_return_if_fail (window != NULL);
 
-  GDK_NOTE (EVENTS, g_print ("gdk_window_destroy_notify: %#x  %d\n",
-			     GDK_DRAWABLE_XID (window), GDK_DRAWABLE_DESTROYED (window)));
+  GDK_NOTE (EVENTS,
+	    g_print ("gdk_window_destroy_notify: %#x  %s\n",
+		     GDK_DRAWABLE_XID (window),
+		     (GDK_DRAWABLE_DESTROYED (window) ? "yes" : "no")));
 
   if (!GDK_DRAWABLE_DESTROYED (window))
     {
       if (GDK_DRAWABLE_TYPE(window) != GDK_WINDOW_FOREIGN)
-	g_warning ("GdkWindow %#lx unexpectedly destroyed", GDK_DRAWABLE_XID (window));
+	g_warning ("window %#x unexpectedly destroyed",
+		   GDK_DRAWABLE_XID (window));
 
       gdk_window_internal_destroy (window, FALSE, FALSE);
     }
   
   gdk_xid_table_remove (GDK_DRAWABLE_XID (window));
-  gdk_window_unref (window);
-}
-
-GdkWindow*
-gdk_window_ref (GdkWindow *window)
-{
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-  g_return_val_if_fail (window != NULL, NULL);
-  
-  private->drawable.ref_count += 1;
-
-  GDK_NOTE (MISC, g_print ("gdk_window_ref %#x %d\n",
-			   GDK_DRAWABLE_XID (window),
-			   private->drawable.ref_count));
-
-  return window;
-}
-
-void
-gdk_window_unref (GdkWindow *window)
-{
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-  g_return_if_fail (window != NULL);
-
-  private->drawable.ref_count -= 1;
-
-  GDK_NOTE (MISC, g_print ("gdk_window_unref %#x %d%s\n",
-			   private->drawable.xwindow,
-			   private->drawable.ref_count,
-			   (private->drawable.ref_count == 0 ? " freeing" : "")));
-
-  if (private->drawable.ref_count == 0)
-    {
-      if (private->bg_type == GDK_WIN32_BG_PIXMAP
-	  && private->bg_pixmap != NULL)
-	gdk_pixmap_unref (private->bg_pixmap);
-
-      if (!private->drawable.destroyed)
-	{
-	  if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
-	    gdk_xid_table_remove (private->drawable.xwindow);
-	  else
-	    g_warning ("losing last reference to undestroyed window");
-	}
-      g_dataset_destroy (window);
-      g_free (window);
-    }
+  gdk_drawable_unref (window);
 }
 
 void
 gdk_window_show (GdkWindow *window)
 {
-  GdkWindowPrivate *private;
-
   g_return_if_fail (window != NULL);
 
-  private = (GdkWindowPrivate*) window;
-  if (!private->drawable.destroyed)
+  if (!GDK_DRAWABLE_DESTROYED (window))
     {
       GDK_NOTE (MISC, g_print ("gdk_window_show: %#x\n",
-			       private->drawable.xwindow));
+			       GDK_DRAWABLE_XID (window)));
 
-      private->mapped = TRUE;
-      if (private->drawable.window_type == GDK_WINDOW_TEMP)
+      ((GdkWindowPrivate *) window)->mapped = TRUE;
+      if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TEMP)
 	{
-	  ShowWindow (private->drawable.xwindow, SW_SHOWNOACTIVATE);
-	  SetWindowPos (private->drawable.xwindow, HWND_TOPMOST, 0, 0, 0, 0,
+	  ShowWindow (GDK_DRAWABLE_XID (window), SW_SHOWNOACTIVATE);
+	  SetWindowPos (GDK_DRAWABLE_XID (window), HWND_TOPMOST, 0, 0, 0, 0,
 			SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
 #if 0
-	  ShowWindow (private->drawable.xwindow, SW_HIDE); /* Don't put on toolbar */
+	  /* Don't put on toolbar */
+	  ShowWindow (GDK_DRAWABLE_XID (window), SW_HIDE);
 #endif
 	}
       else
 	{
-	  ShowWindow (private->drawable.xwindow, SW_SHOWNORMAL);
-	  ShowWindow (private->drawable.xwindow, SW_RESTORE);
-	  SetForegroundWindow (private->drawable.xwindow);
-	  BringWindowToTop (private->drawable.xwindow);
+	  ShowWindow (GDK_DRAWABLE_XID (window), SW_SHOWNORMAL);
+	  ShowWindow (GDK_DRAWABLE_XID (window), SW_RESTORE);
+	  SetForegroundWindow (GDK_DRAWABLE_XID (window));
+	  BringWindowToTop (GDK_DRAWABLE_XID (window));
 #if 0
-	  ShowOwnedPopups (private->drawable.xwindow, TRUE);
+	  ShowOwnedPopups (GDK_DRAWABLE_XID (window), TRUE);
 #endif
 	}
     }
@@ -765,25 +717,22 @@ gdk_window_show (GdkWindow *window)
 void
 gdk_window_hide (GdkWindow *window)
 {
-  GdkWindowPrivate *private;
-
   g_return_if_fail (window != NULL);
 
-  private = (GdkWindowPrivate*) window;
-  if (!private->drawable.destroyed)
+  if (!GDK_DRAWABLE_DESTROYED (window))
     {
       GDK_NOTE (MISC, g_print ("gdk_window_hide: %#x\n",
-			       private->drawable.xwindow));
+			       GDK_DRAWABLE_XID (window)));
 
-      private->mapped = FALSE;
-      if (private->drawable.window_type == GDK_WINDOW_TOPLEVEL)
-	ShowOwnedPopups (private->drawable.xwindow, FALSE);
+      ((GdkWindowPrivate *) window)->mapped = FALSE;
+      if (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_TOPLEVEL)
+	ShowOwnedPopups (GDK_DRAWABLE_XID (window), FALSE);
 #if 1
-      ShowWindow (private->drawable.xwindow, SW_HIDE);
+      ShowWindow (GDK_DRAWABLE_XID (window), SW_HIDE);
 #elif 0
-      ShowWindow (private->drawable.xwindow, SW_MINIMIZE);
+      ShowWindow (GDK_DRAWABLE_XID (window), SW_MINIMIZE);
 #else
-      CloseWindow (private->drawable.xwindow);
+      CloseWindow (GDK_DRAWABLE_XID (window));
 #endif
     }
 }
@@ -791,15 +740,12 @@ gdk_window_hide (GdkWindow *window)
 void
 gdk_window_withdraw (GdkWindow *window)
 {
-  GdkWindowPrivate *private;
-
   g_return_if_fail (window != NULL);
 
-  private = (GdkWindowPrivate*) window;
-  if (!private->drawable.destroyed)
+  if (!GDK_DRAWABLE_DESTROYED (window))
     {
       GDK_NOTE (MISC, g_print ("gdk_window_withdraw: %#x\n",
-			       private->drawable.xwindow));
+			       GDK_DRAWABLE_XID (window)));
 
       gdk_window_hide (window);	/* XXX */
     }
@@ -814,17 +760,17 @@ gdk_window_move (GdkWindow *window,
 
   g_return_if_fail (window != NULL);
 
-  private = (GdkWindowPrivate*) window;
-  if (!private->drawable.destroyed)
+  if (!GDK_DRAWABLE_DESTROYED (window))
     {
       RECT rect;
 
       GDK_NOTE (MISC, g_print ("gdk_window_move: %#x +%d+%d\n",
-			       private->drawable.xwindow, x, y));
+			       GDK_DRAWABLE_XID (window), x, y));
 
-      GetClientRect (private->drawable.xwindow, &rect);
+      private = (GdkWindowPrivate *) window;
+      GetClientRect (GDK_DRAWABLE_XID (window), &rect);
 
-      if (private->drawable.window_type != GDK_WINDOW_CHILD)
+      if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_CHILD)
 	{
 	  POINT ptTL, ptBR;
 	  DWORD dwStyle;
@@ -832,20 +778,19 @@ gdk_window_move (GdkWindow *window,
 
 	  ptTL.x = 0;
 	  ptTL.y = 0; 
-	  ClientToScreen (private->drawable.xwindow, &ptTL);
+	  ClientToScreen (GDK_DRAWABLE_XID (window), &ptTL);
 	  rect.left = x;
 	  rect.top = y;
 
 	  ptBR.x = rect.right;
 	  ptBR.y = rect.bottom;
-	  ClientToScreen (private->drawable.xwindow, &ptBR);
+	  ClientToScreen (GDK_DRAWABLE_XID (window), &ptBR);
 	  rect.right = x + ptBR.x - ptTL.x;
 	  rect.bottom = y + ptBR.y - ptTL.y;
 
-	  dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
-	  dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
-	  if (!SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
-	    g_warning ("gdk_window_move: AdjustWindowRectEx failed");
+	  dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+	  dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
+	  SafeAdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
 
 	  x = rect.left;
 	  y = rect.top;
@@ -856,13 +801,13 @@ gdk_window_move (GdkWindow *window,
 	  private->y = y;
 	}
       GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
-			       private->drawable.xwindow,
+			       GDK_DRAWABLE_XID (window),
 			       rect.right - rect.left, rect.bottom - rect.top,
 			       x, y));
-      if (!MoveWindow (private->drawable.xwindow,
+      if (!MoveWindow (GDK_DRAWABLE_XID (window),
 		       x, y, rect.right - rect.left, rect.bottom - rect.top,
 		       TRUE))
-	g_warning ("gdk_window_move: MoveWindow failed");
+	WIN32_API_FAILED ("MoveWindow");
     }
 }
 
@@ -890,7 +835,7 @@ gdk_window_resize (GdkWindow *window,
       int x, y;
 
       GDK_NOTE (MISC, g_print ("gdk_window_resize: %#x %dx%d\n",
-			       private->drawable.xwindow, width, height));
+			       GDK_DRAWABLE_XID (window), width, height));
       
       if (private->drawable.window_type != GDK_WINDOW_CHILD)
 	{
@@ -901,16 +846,16 @@ gdk_window_resize (GdkWindow *window,
 
 	  pt.x = 0;
 	  pt.y = 0; 
-	  ClientToScreen (private->drawable.xwindow, &pt);
+	  ClientToScreen (GDK_DRAWABLE_XID (window), &pt);
 	  rect.left = pt.x;
 	  rect.top = pt.y;
 	  rect.right = pt.x + width;
 	  rect.bottom = pt.y + height;
 
-	  dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
-	  dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
+	  dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+	  dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
 	  if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
-	    g_warning ("gdk_window_resize: AdjustWindowRectEx failed");
+	    WIN32_API_FAILED ("AdjustWindowRectEx");
 
 	  x = rect.left;
 	  y = rect.top;
@@ -927,12 +872,13 @@ gdk_window_resize (GdkWindow *window,
 
       private->resize_count += 1;
 
-      GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
-			       private->drawable.xwindow, width, height, x, y));
-      if (!MoveWindow (private->drawable.xwindow,
+      GDK_NOTE (MISC,
+		g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
+			 GDK_DRAWABLE_XID (window), width, height, x, y));
+      if (!MoveWindow (GDK_DRAWABLE_XID (window),
 		       x, y, width, height,
 		       TRUE))
-	g_warning ("gdk_window_resize: MoveWindow failed");
+	WIN32_API_FAILED ("MoveWindow");
     }
 }
 
@@ -952,25 +898,25 @@ gdk_window_move_resize (GdkWindow *window,
   if ((gint16) height < 1)
     height = 1;
 
-  private = (GdkWindowPrivate*) window;
-  if (!private->drawable.destroyed)
+  if (!GDK_DRAWABLE_DESTROYED (window))
     {
       RECT rect;
       DWORD dwStyle;
       DWORD dwExStyle;
 
       GDK_NOTE (MISC, g_print ("gdk_window_move_resize: %#x %dx%d@+%d+%d\n",
-			       private->drawable.xwindow, width, height, x, y));
+			       GDK_DRAWABLE_XID (window), width, height, x, y));
       
+      private = (GdkWindowPrivate*) window;
       rect.left = x;
       rect.top = y;
       rect.right = x + width;
       rect.bottom = y + height;
 
-      dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
-      dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
+      dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+      dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
       if (!AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle))
-	g_warning ("gdk_window_move_resize: AdjustWindowRectEx failed");
+	WIN32_API_FAILED ("AdjustWindowRectEx");
 
       if (private->drawable.window_type == GDK_WINDOW_CHILD)
 	{
@@ -980,14 +926,14 @@ gdk_window_move_resize (GdkWindow *window,
 	  private->drawable.height = height;
 	}
       GDK_NOTE (MISC, g_print ("...MoveWindow(%#x,%dx%d@+%d+%d)\n",
-			       private->drawable.xwindow,
+			       GDK_DRAWABLE_XID (window),
 			       rect.right - rect.left, rect.bottom - rect.top,
 			       rect.left, rect.top));
-      if (!MoveWindow (private->drawable.xwindow,
+      if (!MoveWindow (GDK_DRAWABLE_XID (window),
 		       rect.left, rect.top,
 		       rect.right - rect.left, rect.bottom - rect.top,
 		       TRUE))
-	g_warning ("gdk_window_move_resize: MoveWindow failed");
+	WIN32_API_FAILED ("MoveWindow");
 
       if (private->guffaw_gravity)
 	{
@@ -1019,31 +965,35 @@ gdk_window_reparent (GdkWindow *window,
   g_return_if_fail (window != NULL);
 
   if (!new_parent)
-    new_parent = (GdkWindow*) gdk_root_parent;
+    new_parent = gdk_parent_root;
 
   window_private = (GdkWindowPrivate*) window;
-  old_parent_private = (GdkWindowPrivate*)window_private->parent;
+  old_parent_private = (GdkWindowPrivate *) window_private->parent;
   parent_private = (GdkWindowPrivate*) new_parent;
 
-  if (!window_private->drawable.destroyed && !parent_private->drawable.destroyed)
+  if (!GDK_DRAWABLE_DESTROYED (window)
+      && !GDK_DRAWABLE_DESTROYED (new_parent))
     {
       GDK_NOTE (MISC, g_print ("gdk_window_reparent: %#x %#x\n",
-			       window_private->drawable.xwindow,
-			       parent_private->drawable.xwindow));
-      if (!SetParent (window_private->drawable.xwindow, parent_private->drawable.xwindow))
-	g_warning ("gdk_window_reparent: SetParent failed");
+			       GDK_DRAWABLE_XID (window),
+			       GDK_DRAWABLE_XID (new_parent)));
+      if (!SetParent (GDK_DRAWABLE_XID (window),
+		      GDK_DRAWABLE_XID (new_parent)))
+	WIN32_API_FAILED ("SetParent");
 
-      if (!MoveWindow (window_private->drawable.xwindow,
+      if (!MoveWindow (GDK_DRAWABLE_XID (window),
 		       x, y,
-		       window_private->drawable.width, window_private->drawable.height,
+		       window_private->drawable.width,
+		       window_private->drawable.height,
 		       TRUE))
-	g_warning ("gdk_window_reparent: MoveWindow failed");
+	WIN32_API_FAILED ("MoveWindow");
     }
   
   window_private->parent = new_parent;
 
   if (old_parent_private)
-    old_parent_private->children = g_list_remove (old_parent_private->children, window);
+    old_parent_private->children =
+      g_list_remove (old_parent_private->children, window);
 
   if ((old_parent_private &&
        (!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) ||
@@ -1060,16 +1010,16 @@ gdk_window_clear (GdkWindow *window)
   g_return_if_fail (GDK_IS_WINDOW (window));
 
   if (!GDK_DRAWABLE_DESTROYED (window))
-    gdk_window_clear_area (window, 0, 0, -1, -1);
+    gdk_window_clear_area (window, 0, 0, 0, 0);
 }
 
 
 void
-gdk_window_clear_area (GdkWindow *window,
-		       gint       x,
-		       gint       y,
-		       gint       width,
-		       gint       height)
+_gdk_windowing_window_clear_area (GdkWindow *window,
+				  gint       x,
+				  gint       y,
+				  gint       width,
+				  gint       height)
 {
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -1078,25 +1028,26 @@ gdk_window_clear_area (GdkWindow *window,
     {
       HDC hdc;
 
-      if (width == -1)
-	width = G_MAXSHORT/2;		/* Yeah, right */
-      if (height == -1)
-	height = G_MAXSHORT/2;
-      GDK_NOTE (MISC, g_print ("gdk_window_clear_area: %#x %dx%d@+%d+%d\n",
+      if (width == 0)
+	width = ((GdkDrawablePrivate *) window)->width - x;
+      if (height == 0)
+	height = ((GdkDrawablePrivate *) window)->height - y;
+      GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area: "
+			       "%#x %dx%d@+%d+%d\n",
 			       GDK_DRAWABLE_XID (window), width, height, x, y));
       hdc = GetDC (GDK_DRAWABLE_XID (window));
-      IntersectClipRect (hdc, x, y, x + width, y + height);
+      IntersectClipRect (hdc, x, y, x + width + 1, y + height + 1);
       SendMessage (GDK_DRAWABLE_XID (window), WM_ERASEBKGND, (WPARAM) hdc, 0);
       ReleaseDC (GDK_DRAWABLE_XID (window), hdc);
     }
 }
 
 void
-gdk_window_clear_area_e (GdkWindow *window,
-		         gint       x,
-		         gint       y,
-		         gint       width,
-		         gint       height)
+_gdk_windowing_window_clear_area_e (GdkWindow *window,
+				    gint       x,
+				    gint       y,
+				    gint       width,
+				    gint       height)
 {
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -1105,15 +1056,16 @@ gdk_window_clear_area_e (GdkWindow *window,
     {
       RECT rect;
 
-      GDK_NOTE (MISC, g_print ("gdk_window_clear_area_e: %#x %dx%d@+%d+%d\n",
+      GDK_NOTE (MISC, g_print ("_gdk_windowing_window_clear_area_e: "
+			       "%#x %dx%d@+%d+%d\n",
 			       GDK_DRAWABLE_XID (window), width, height, x, y));
 
       rect.left = x;
-      rect.right = x + width;
+      rect.right = x + width + 1;
       rect.top = y;
-      rect.bottom = y + height;
+      rect.bottom = y + height + 1;
       if (!InvalidateRect (GDK_DRAWABLE_XID (window), &rect, TRUE))
-	g_warning ("gdk_window_clear_area_e: InvalidateRect failed");
+	WIN32_GDI_FAILED ("InvalidateRect");
       UpdateWindow (GDK_DRAWABLE_XID (window));
     }
 }
@@ -1130,7 +1082,7 @@ gdk_window_raise (GdkWindow *window)
 			       GDK_DRAWABLE_XID (window)));
 
       if (!BringWindowToTop (GDK_DRAWABLE_XID (window)))
-	g_warning ("gdk_window_raise: BringWindowToTop failed");
+	WIN32_API_FAILED ("BringWindowToTop");
     }
 }
 
@@ -1147,19 +1099,10 @@ gdk_window_lower (GdkWindow *window)
 
       if (!SetWindowPos (GDK_DRAWABLE_XID (window), HWND_BOTTOM, 0, 0, 0, 0,
 			 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE))
-	g_warning ("gdk_window_lower: SetWindowPos failed");
+	WIN32_API_FAILED ("SetWindowPos");
     }
 }
 
-void
-gdk_window_set_user_data (GdkWindow *window,
-			  gpointer   user_data)
-{
-  g_return_if_fail (window != NULL);
-  
-  window->user_data = user_data;
-}
-
 void
 gdk_window_set_hints (GdkWindow *window,
 		      gint       x,
@@ -1170,7 +1113,6 @@ gdk_window_set_hints (GdkWindow *window,
 		      gint       max_height,
 		      gint       flags)
 {
-  GdkWindowPrivate *private;
   WINDOWPLACEMENT size_hints;
   RECT rect;
   DWORD dwStyle;
@@ -1183,21 +1125,19 @@ gdk_window_set_hints (GdkWindow *window,
   if (GDK_DRAWABLE_DESTROYED (window))
     return;
   
-  private = (GdkWindowPrivate*) window;
-
   GDK_NOTE (MISC, g_print ("gdk_window_set_hints: %#x %dx%d..%dx%d @+%d+%d\n",
-			   private->drawable.xwindow,
+			   GDK_DRAWABLE_XID (window),
 			   min_width, min_height, max_width, max_height,
 			   x, y));
 
-  private->hint_flags = flags;
+  GDK_WINDOW_WIN32DATA (window)->hint_flags = flags;
   size_hints.length = sizeof (size_hints);
 
   if (flags)
     {
       if (flags & GDK_HINT_POS)
-	if (!GetWindowPlacement (private->drawable.xwindow, &size_hints))
-	  g_warning ("gdk_window_set_hints: GetWindowPlacement failed");
+	if (!GetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
+	  WIN32_API_FAILED ("GetWindowPlacement");
 	else
 	  {
 	    GDK_NOTE (MISC, g_print ("...rcNormalPosition:"
@@ -1213,8 +1153,8 @@ gdk_window_set_hints (GdkWindow *window,
 	    rect.top = y;
 	    rect.right = rect.left + 200;	/* dummy */
 	    rect.bottom = rect.top + 200;
-	    dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
-	    dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
+	    dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+	    dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
 	    AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
 	    size_hints.flags = 0;
 	    size_hints.showCmd = SW_SHOWNA;
@@ -1233,10 +1173,10 @@ gdk_window_set_hints (GdkWindow *window,
 				     size_hints.rcNormalPosition.top,
 				     size_hints.rcNormalPosition.right,
 				     size_hints.rcNormalPosition.bottom));
-	    if (!SetWindowPlacement (private->drawable.xwindow, &size_hints))
-	      g_warning ("gdk_window_set_hints: SetWindowPlacement failed");
-	    private->hint_x = rect.left;
-	    private->hint_y = rect.top;
+	    if (!SetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
+	      WIN32_API_FAILED ("SetWindowPlacement");
+	    GDK_WINDOW_WIN32DATA (window)->hint_x = rect.left;
+	    GDK_WINDOW_WIN32DATA (window)->hint_y = rect.top;
 	  }
 
       if (flags & GDK_HINT_MIN_SIZE)
@@ -1245,14 +1185,16 @@ gdk_window_set_hints (GdkWindow *window,
 	  rect.top = 0;
 	  rect.right = min_width;
 	  rect.bottom = min_height;
-	  dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
-	  dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
+	  dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+	  dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
 	  AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
-	  private->hint_min_width = rect.right - rect.left;
-	  private->hint_min_height = rect.bottom - rect.top;
+	  GDK_WINDOW_WIN32DATA (window)->hint_min_width =
+	    rect.right - rect.left;
+	  GDK_WINDOW_WIN32DATA (window)->hint_min_height =
+	    rect.bottom - rect.top;
 
 	  /* Also chek if he current size of the window is in bounds. */
-	  GetClientRect (private->drawable.xwindow, &rect);
+	  GetClientRect (GDK_DRAWABLE_XID (window), &rect);
 	  if (rect.right < min_width && rect.bottom < min_height)
 	    gdk_window_resize (window, min_width, min_height);
 	  else if (rect.right < min_width)
@@ -1260,19 +1202,22 @@ gdk_window_set_hints (GdkWindow *window,
 	  else if (rect.bottom < min_height)
 	    gdk_window_resize (window, rect.right, min_height);
 	}
+
       if (flags & GDK_HINT_MAX_SIZE)
 	{
 	  rect.left = 0;
 	  rect.top = 0;
 	  rect.right = max_width;
 	  rect.bottom = max_height;
-	  dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
-	  dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
+	  dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+	  dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
 	  AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
-	  private->hint_max_width = rect.right - rect.left;
-	  private->hint_max_height = rect.bottom - rect.top;
+	  GDK_WINDOW_WIN32DATA (window)->hint_max_width =
+	    rect.right - rect.left;
+	  GDK_WINDOW_WIN32DATA (window)->hint_max_height =
+	    rect.bottom - rect.top;
 	  /* Again, check if the window is too large currently. */
-	  GetClientRect (private->drawable.xwindow, &rect);
+	  GetClientRect (GDK_DRAWABLE_XID (window), &rect);
 	  if (rect.right > max_width && rect.bottom > max_height)
 	    gdk_window_resize (window, max_width, max_height);
 	  else if (rect.right > max_width)
@@ -1288,7 +1233,6 @@ gdk_window_set_geometry_hints (GdkWindow      *window,
 			       GdkGeometry    *geometry,
 			       GdkWindowHints  geom_mask)
 {
-  GdkWindowPrivate *private;
   WINDOWPLACEMENT size_hints;
   RECT rect;
   DWORD dwStyle;
@@ -1301,11 +1245,9 @@ gdk_window_set_geometry_hints (GdkWindow      *window,
   if (GDK_DRAWABLE_DESTROYED (window))
     return;
 
-  private = (GdkWindowPrivate*) window;
-  
   size_hints.length = sizeof (size_hints);
 
-  private->hint_flags = geom_mask;
+  GDK_WINDOW_WIN32DATA (window)->hint_flags = geom_mask;
 
   if (geom_mask & GDK_HINT_POS)
     ; /* XXX */
@@ -1316,14 +1258,14 @@ gdk_window_set_geometry_hints (GdkWindow      *window,
       rect.top = 0;
       rect.right = geometry->min_width;
       rect.bottom = geometry->min_height;
-      dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
-      dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
+      dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+      dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
       AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
-      private->hint_min_width = rect.right - rect.left;
-      private->hint_min_height = rect.bottom - rect.top;
+      GDK_WINDOW_WIN32DATA (window)->hint_min_width = rect.right - rect.left;
+      GDK_WINDOW_WIN32DATA (window)->hint_min_height = rect.bottom - rect.top;
 
       /* Also check if he current size of the window is in bounds */
-      GetClientRect (private->drawable.xwindow, &rect);
+      GetClientRect (GDK_DRAWABLE_XID (window), &rect);
       if (rect.right < geometry->min_width
 	  && rect.bottom < geometry->min_height)
 	gdk_window_resize (window, geometry->min_width, geometry->min_height);
@@ -1339,14 +1281,14 @@ gdk_window_set_geometry_hints (GdkWindow      *window,
       rect.top = 0;
       rect.right = geometry->max_width;
       rect.bottom = geometry->max_height;
-      dwStyle = GetWindowLong (private->drawable.xwindow, GWL_STYLE);
-      dwExStyle = GetWindowLong (private->drawable.xwindow, GWL_EXSTYLE);
+      dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
+      dwExStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_EXSTYLE);
       AdjustWindowRectEx (&rect, dwStyle, FALSE, dwExStyle);
-      private->hint_max_width = rect.right - rect.left;
-      private->hint_max_height = rect.bottom - rect.top;
+      GDK_WINDOW_WIN32DATA (window)->hint_max_width = rect.right - rect.left;
+      GDK_WINDOW_WIN32DATA (window)->hint_max_height = rect.bottom - rect.top;
 
       /* Again, check if the window is too large currently. */
-      GetClientRect (private->drawable.xwindow, &rect);
+      GetClientRect (GDK_DRAWABLE_XID (window), &rect);
       if (rect.right > geometry->max_width
 	  && rect.bottom > geometry->max_height)
 	gdk_window_resize (window, geometry->max_width, geometry->max_height);
@@ -1360,8 +1302,8 @@ gdk_window_set_geometry_hints (GdkWindow      *window,
   if (geom_mask & GDK_HINT_BASE_SIZE
       && geometry->base_width > 0
       && geometry->base_height > 0)
-    if (!GetWindowPlacement (private->drawable.xwindow, &size_hints))
-      g_warning ("gdk_window_set_hints: GetWindowPlacement failed");
+    if (!GetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
+      WIN32_API_FAILED ("GetWindowPlacement");
     else
       {
 	GDK_NOTE (MISC, g_print ("gdk_window_set_geometry_hints:"
@@ -1379,8 +1321,8 @@ gdk_window_set_geometry_hints (GdkWindow      *window,
 				 size_hints.rcNormalPosition.top,
 				 size_hints.rcNormalPosition.right,
 				 size_hints.rcNormalPosition.bottom));
-	if (!SetWindowPlacement (private->drawable.xwindow, &size_hints))
-	  g_warning ("gdk_window_set_hints: SetWindowPlacement failed");
+	if (!SetWindowPlacement (GDK_DRAWABLE_XID (window), &size_hints))
+	  WIN32_API_FAILED ("SetWindowPlacement");
       }
   
   if (geom_mask & GDK_HINT_RESIZE_INC)
@@ -1405,12 +1347,14 @@ gdk_window_set_title (GdkWindow   *window,
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
+  g_return_if_fail (title != NULL);
+  g_return_if_fail (strlen (title) > 0);
   
   GDK_NOTE (MISC, g_print ("gdk_window_set_title: %#x %s\n",
 			   GDK_DRAWABLE_XID (window), title));
   if (!GDK_DRAWABLE_DESTROYED (window))
     {
-      /* As the title most is in UTF-8 we must translate it
+      /* As the title is in UTF-8 we must translate it
        * to the system codepage.
        */
       titlelen = strlen (title);
@@ -1422,7 +1366,7 @@ gdk_window_set_title (GdkWindow   *window,
 			   mbstr, 3*titlelen, NULL, NULL);
 
       if (!SetWindowText (GDK_DRAWABLE_XID (window), mbstr))
-	g_warning ("gdk_window_set_title: SetWindowText failed");
+	WIN32_API_FAILED ("SetWindowText");
 
       g_free (mbstr);
       g_free (wcstr);
@@ -1458,29 +1402,26 @@ void
 gdk_window_set_background (GdkWindow *window,
 			   GdkColor  *color)
 {
-  GdkWindowPrivate *private;
-  
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  private = (GdkWindowPrivate*) window;
   if (!GDK_DRAWABLE_DESTROYED (window))
     {
       GDK_NOTE (MISC, g_print ("gdk_window_set_background: %#x %s\n",
-			       private->drawable.xwindow, 
+			       GDK_DRAWABLE_XID (window), 
 			       gdk_color_to_string (color)));
 
-      if (private->bg_type == GDK_WIN32_BG_PIXMAP)
+      if (GDK_WINDOW_WIN32DATA (window)->bg_type == GDK_WIN32_BG_PIXMAP)
 	{
-	  if (private->bg_pixmap != NULL)
+	  if (GDK_WINDOW_WIN32DATA (window)->bg_pixmap != NULL)
 	    {
-	      gdk_pixmap_unref (private->bg_pixmap);
-	      private->bg_pixmap = NULL;
+	      gdk_drawable_unref (GDK_WINDOW_WIN32DATA (window)->bg_pixmap);
+	      GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
 	    }
-	  private->bg_type = GDK_WIN32_BG_NORMAL;
+	  GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
 	}
-      private->bg_type = GDK_WIN32_BG_PIXEL;
-      private->bg_pixel = *color;
+      GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_PIXEL;
+      GDK_WINDOW_WIN32DATA (window)->bg_pixel = color->pixel;
     }
 }
 
@@ -1489,27 +1430,24 @@ gdk_window_set_back_pixmap (GdkWindow *window,
 			    GdkPixmap *pixmap,
 			    gint       parent_relative)
 {
-  GdkWindowPrivate *private;
-
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  private = (GdkWindowPrivate*) window;
-
   if (!GDK_DRAWABLE_DESTROYED (window))
     {
-      if (private->bg_type == GDK_WIN32_BG_PIXMAP)
+      if (GDK_WINDOW_WIN32DATA (window)->bg_type == GDK_WIN32_BG_PIXMAP)
 	{
-	  if (private->bg_pixmap != NULL)
+	  if (GDK_WINDOW_WIN32DATA (window)->bg_pixmap != NULL)
 	    {
-	      gdk_pixmap_unref (private->bg_pixmap);
-	      private->bg_pixmap = NULL;
+	      gdk_drawable_unref (GDK_WINDOW_WIN32DATA (window)->bg_pixmap);
+	      GDK_WINDOW_WIN32DATA (window)->bg_pixmap = NULL;
 	    }
-	  private->bg_type = GDK_WIN32_BG_NORMAL;
+	  GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_NORMAL;
 	}
       if (parent_relative)
 	{
-	  private->bg_type = GDK_WIN32_BG_PARENT_RELATIVE;
+	  GDK_WINDOW_WIN32DATA (window)->bg_type =
+	    GDK_WIN32_BG_PARENT_RELATIVE;
 	}
       else if (!pixmap)
 	{
@@ -1517,12 +1455,12 @@ gdk_window_set_back_pixmap (GdkWindow *window,
 	}
       else
 	{
-	  /* We must cache the pixmap in the WindowPrivate and
+	  /* We must cache the pixmap in the GdkWindowWin32Data and
 	   * paint it each time we get WM_ERASEBKGND
 	   */
-	  private->bg_type = GDK_WIN32_BG_PIXMAP;
-	  private->bg_pixmap = pixmap;
-	  gdk_pixmap_ref (pixmap);
+	  GDK_WINDOW_WIN32DATA (window)->bg_type = GDK_WIN32_BG_PIXMAP;
+	  GDK_WINDOW_WIN32DATA (window)->bg_pixmap = pixmap;
+	  gdk_drawable_ref (pixmap);
 	}
     }
 }
@@ -1531,14 +1469,13 @@ void
 gdk_window_set_cursor (GdkWindow *window,
 		       GdkCursor *cursor)
 {
-  GdkWindowPrivate *window_private;
   GdkCursorPrivate *cursor_private;
   HCURSOR xcursor;
+  POINT pt;
   
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  window_private = (GdkWindowPrivate*) window;
   cursor_private = (GdkCursorPrivate*) cursor;
   
   if (!GDK_DRAWABLE_DESTROYED (window))
@@ -1549,18 +1486,13 @@ gdk_window_set_cursor (GdkWindow *window,
 	xcursor = cursor_private->xcursor;
 
       GDK_NOTE (MISC, g_print ("gdk_window_set_cursor: %#x %#x\n",
-			       window_private->drawable.xwindow, xcursor));
-      window_private->xcursor = xcursor;
-    }
-}
+			       GDK_DRAWABLE_XID (window), xcursor));
+      GDK_WINDOW_WIN32DATA (window)->xcursor = xcursor;
 
-void
-gdk_window_get_user_data (GdkWindow *window,
-			  gpointer  *data)
-{
-  g_return_if_fail (window != NULL);
-  
-  *data = window->user_data;
+      GetCursorPos (&pt);
+      if (ChildWindowFromPoint (GDK_DRAWABLE_XID (window), pt) == GDK_DRAWABLE_XID (window))
+	SetCursor (xcursor);
+    }
 }
 
 void
@@ -1574,14 +1506,14 @@ gdk_window_get_geometry (GdkWindow *window,
   g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
   
   if (!window)
-    window = (GdkWindow*) gdk_root_parent;
+    window = gdk_parent_root;
   
   if (!GDK_DRAWABLE_DESTROYED (window))
     {
       RECT rect;
 
       if (!GetClientRect (GDK_DRAWABLE_XID (window), &rect))
-	g_warning ("gdk_window_get_geometry: GetClientRect failed");
+	WIN32_API_FAILED ("GetClientRect");
 
       if (x)
 	*x = rect.left;
@@ -1596,24 +1528,6 @@ gdk_window_get_geometry (GdkWindow *window,
     }
 }
 
-void
-gdk_window_get_position (GdkWindow *window,
-			 gint      *x,
-			 gint      *y)
-{
-  GdkWindowPrivate *window_private;
-  
-  g_return_if_fail (window != NULL);
-  g_return_if_fail (GDK_IS_WINDOW (window));
-  
-  window_private = (GdkWindowPrivate*) window;
-  
-  if (x)
-    *x = window_private->x;
-  if (y)
-    *y = window_private->y;
-}
-
 gint
 gdk_window_get_origin (GdkWindow *window,
 		       gint      *x,
@@ -1662,13 +1576,13 @@ gdk_window_get_root_origin (GdkWindow *window,
 			    gint      *x,
 			    gint      *y)
 {
-  GdkWindowPrivate *private;
+  GdkWindowPrivate *rover;
   POINT pt;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  private = (GdkWindowPrivate*) window;
+  rover = (GdkWindowPrivate*) window;
   if (x)
     *x = 0;
   if (y)
@@ -1676,14 +1590,14 @@ gdk_window_get_root_origin (GdkWindow *window,
   if (GDK_DRAWABLE_DESTROYED (window))
     return;
       
-  while (private->parent && ((GdkWindowPrivate*) private->parent)->parent)
-    private = (GdkWindowPrivate*) private->parent;
-  if (private->drawable.destroyed)
+  while (rover->parent && ((GdkWindowPrivate*) rover->parent)->parent)
+    rover = (GdkWindowPrivate *) rover->parent;
+  if (rover->drawable.destroyed)
     return;
 
   pt.x = 0;
   pt.y = 0;
-  ClientToScreen (private->drawable.xwindow, &pt);
+  ClientToScreen (GDK_DRAWABLE_XID (rover), &pt);
   if (x)
     *x = pt.x;
   if (y)
@@ -1691,7 +1605,7 @@ gdk_window_get_root_origin (GdkWindow *window,
 
   GDK_NOTE (MISC, g_print ("gdk_window_get_root_origin: %#x: (%#x) +%d+%d\n",
 			   GDK_DRAWABLE_XID (window),
-			   private->drawable.xwindow, pt.x, pt.y));
+			   GDK_DRAWABLE_XID (rover), pt.x, pt.y));
 }
 
 GdkWindow*
@@ -1707,7 +1621,7 @@ gdk_window_get_pointer (GdkWindow       *window,
   g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
   
   if (!window)
-    window = (GdkWindow*) gdk_root_parent;
+    window = gdk_parent_root;
 
   return_val = NULL;
   GetCursorPos (&pointc);
@@ -1771,7 +1685,7 @@ gdk_window_at_pointer (gint *win_x,
 
   if (hwnd == NULL)
     {
-      window = (GdkWindow *) gdk_root_parent;
+      window = gdk_parent_root;
       if (win_x)
 	*win_x = pointc.x;
       if (win_y)
@@ -1805,27 +1719,6 @@ gdk_window_at_pointer (gint *win_x,
   return window;
 }
 
-GdkWindow*
-gdk_window_get_parent (GdkWindow *window)
-{
-  g_return_val_if_fail (window != NULL, NULL);
-  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
-
-  return ((GdkWindowPrivate*) window)->parent;
-}
-
-GdkWindow*
-gdk_window_get_toplevel (GdkWindow *window)
-{
-  g_return_val_if_fail (window != NULL, NULL);
-  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
-
-  while (GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_CHILD)
-    window = ((GdkWindowPrivate*) window)->parent;
-
-  return window;
-}
-
 GList*
 gdk_window_get_children (GdkWindow *window)
 {
@@ -1848,32 +1741,26 @@ gdk_window_get_children (GdkWindow *window)
 GdkEventMask  
 gdk_window_get_events (GdkWindow *window)
 {
-  GdkWindowPrivate *private;
-
   g_return_val_if_fail (window != NULL, 0);
   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
 
-  private = (GdkWindowPrivate*) window;
   if (GDK_DRAWABLE_DESTROYED (window))
     return 0;
 
-  return private->event_mask;
+  return GDK_WINDOW_WIN32DATA (window)->event_mask;
 }
 
 void          
 gdk_window_set_events (GdkWindow   *window,
 		       GdkEventMask event_mask)
 {
-  GdkWindowPrivate *private;
-
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  private = (GdkWindowPrivate*) window;
   if (GDK_DRAWABLE_DESTROYED (window))
     return;
 
-  private->event_mask = event_mask;
+  GDK_WINDOW_WIN32DATA (window)->event_mask = event_mask;
 }
 
 void
@@ -1898,19 +1785,17 @@ gdk_window_shape_combine_mask (GdkWindow *window,
     }
   else
     {
-      GdkDrawablePrivate *pixmap_private;
       HRGN hrgn;
       DWORD dwStyle;
       DWORD dwExStyle;
       RECT rect;
 
       /* Convert mask bitmap to region */
-      pixmap_private = (GdkDrawablePrivate*) mask;
-      hrgn = BitmapToRegion (pixmap_private->xwindow);
+      hrgn = BitmapToRegion (GDK_DRAWABLE_XID (mask));
 
       GDK_NOTE (MISC, g_print ("gdk_window_shape_combine_mask: %#x %#x\n",
 			       GDK_DRAWABLE_XID (window),
-			       pixmap_private->xwindow));
+			       GDK_DRAWABLE_XID (mask)));
 
       /* SetWindowRgn wants window (not client) coordinates */ 
       dwStyle = GetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE);
@@ -1933,73 +1818,6 @@ gdk_window_shape_combine_mask (GdkWindow *window,
     }
 }
 
-void          
-gdk_window_add_filter (GdkWindow     *window,
-		       GdkFilterFunc  function,
-		       gpointer       data)
-{
-  GdkWindowPrivate *private;
-  GList *tmp_list;
-  GdkEventFilter *filter;
-  
-  g_return_if_fail (window != NULL);
-  g_return_if_fail (GDK_IS_WINDOW (window));
-
-  private = (GdkWindowPrivate*) window;
-  if (private && GDK_DRAWABLE_DESTROYED (window))
-    return;
-  
-  tmp_list = private->filters;
-  
-  while (tmp_list)
-    {
-      filter = (GdkEventFilter *)tmp_list->data;
-      if ((filter->function == function) && (filter->data == data))
-	return;
-      tmp_list = tmp_list->next;
-    }
-  
-  filter = g_new (GdkEventFilter, 1);
-  filter->function = function;
-  filter->data = data;
-  
-  private->filters = g_list_append (private->filters, filter);
-}
-
-void
-gdk_window_remove_filter (GdkWindow     *window,
-			  GdkFilterFunc  function,
-			  gpointer       data)
-{
-  GdkWindowPrivate *private;
-  GList *tmp_list, *node;
-  GdkEventFilter *filter;
-  
-  g_return_if_fail (window != NULL);
-  g_return_if_fail (GDK_IS_WINDOW (window));
-
-  private = (GdkWindowPrivate*) window;
-  
-  tmp_list = private->filters;
-  
-  while (tmp_list)
-    {
-      filter = (GdkEventFilter *)tmp_list->data;
-      node = tmp_list;
-      tmp_list = tmp_list->next;
-      
-      if ((filter->function == function) && (filter->data == data))
-	{
-	  private->filters = g_list_remove_link (private->filters, node);
-
-	  g_list_free_1 (node);
-	  g_free (filter);
-	  
-	  return;
-	}
-    }
-}
-
 void
 gdk_window_set_override_redirect (GdkWindow *window,
 				  gboolean   override_redirect)
@@ -2022,12 +1840,15 @@ gdk_window_set_icon (GdkWindow *window,
   if (GDK_DRAWABLE_DESTROYED (window))
     return;
   
-  g_warning ("gdk_window_set_icon not implemented");
+  /* Nothing to do, really. As we share window classes between windows
+   * we can't have window-specific icons, sorry. Don't print any warning
+   * either.
+   */
 }
 
 void
-gdk_window_set_icon_name (GdkWindow *window, 
-			  gchar     *name)
+gdk_window_set_icon_name (GdkWindow   *window, 
+			  const gchar *name)
 {
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -2036,7 +1857,7 @@ gdk_window_set_icon_name (GdkWindow *window,
     return;
   
   if (!SetWindowText (GDK_DRAWABLE_XID (window), name))
-    g_warning ("gdk_window_set_icon_name: SetWindowText failed");
+    WIN32_API_FAILED ("SetWindowText");
 }
 
 void          
@@ -2121,22 +1942,6 @@ gdk_window_set_functions (GdkWindow    *window,
   SetWindowLong (GDK_DRAWABLE_XID (window), GWL_STYLE, style);
 }
 
-GList *
-gdk_window_get_toplevels (void)
-{
-  GList *new_list = NULL;
-  GList *tmp_list;
-
-  tmp_list = gdk_root_parent->children;
-  while (tmp_list)
-    {
-      new_list = g_list_prepend (new_list, tmp_list->data);
-      tmp_list = tmp_list->next;
-    }
-
-  return new_list;
-}
-
 /* 
  * propagate the shapes from all child windows of a GDK window to the parent 
  * window. Shamelessly ripped from Enlightenment's code
@@ -2201,7 +2006,7 @@ gdk_propagate_shapes (HANDLE   win,
        for (i = 0; i < num; i++)
 	 {
 	   GetWindowPlacement (list[i], &placement);
-	   if (placement.showCmd = SW_SHOWNORMAL)
+	   if (placement.showCmd == SW_SHOWNORMAL)
 	     {
 	       childRegion = CreateRectRgnIndirect (&emptyRect);
 	       GetWindowRgn (list[i], childRegion);
@@ -2239,59 +2044,6 @@ gdk_window_merge_child_shapes (GdkWindow *window)
   gdk_propagate_shapes (GDK_DRAWABLE_XID (window), TRUE);
 }
 
-/*************************************************************
- * gdk_window_is_visible:
- *     Check if the given window is mapped.
- *   arguments:
- *     window: 
- *   results:
- *     is the window mapped
- *************************************************************/
-
-gboolean 
-gdk_window_is_visible (GdkWindow *window)
-{
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
-  g_return_val_if_fail (window != NULL, FALSE);
-  g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
-
-  return private->mapped;
-}
-
-/*************************************************************
- * gdk_window_is_viewable:
- *     Check if the window and all ancestors of the window
- *     are mapped. (This is not necessarily "viewable" in
- *     the X sense, since we only check as far as we have
- *     GDK window parents, not to the root window)
- *   arguments:
- *     window:
- *   results:
- *     is the window viewable
- *************************************************************/
-
-gboolean 
-gdk_window_is_viewable (GdkWindow *window)
-{
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
-  g_return_val_if_fail (window != NULL, FALSE);
-  g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
-
-  while (private && 
-	 (private != gdk_root_parent) &&
-	 (private->drawable.window_type != GDK_WINDOW_FOREIGN))
-    {
-      if (!private->mapped)
-	return FALSE;
-
-      private = (GdkWindowPrivate *)private->parent;
-    }
-
-  return TRUE;
-}
-
 /* Support for windows that can be guffaw-scrolled
  * (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
  */