Make this compile without framebuffer enabled

2000-06-20  Havoc Pennington  <hp@redhat.com>

* modules/linux-fb/Makefile.am: Make this compile
without framebuffer enabled

* gdk/linux-fb/Makefile.am: Add conditional to not build
framebuffer unless specified in configure

* gdk/gdkdraw.c (gdk_draw_drawable): Fix bug where I was getting
the size of the target instead of source if -1 was passed for
width/height

* gdk/x11/gdkgeometry-x11.c (gdk_window_compute_position): Fix
width/height confusion.

2000-06-19  Havoc Pennington  <hp@redhat.com>

* gdk/x11/gdkx.h (GDK_WINDOW_XWINDOW): change this to be
GDK_DRAWABLE_XID. In the future, we probably want to make it
faster with G_DISABLE_CHECKS turned on.

2000-06-14  Havoc Pennington  <hp@redhat.com>

        * gdk/Makefile.am: add gdkpixmap.c

	* gdk/gdk.c: s/gdk_window_init/_gdk_windowing_window_init/
	s/gdk_image_init/_gdk_windowing_image_init

	* gdk/gdkcolor.c: make ref/unref compat wrappers for GObject
	ref/unref

	* gdk/gdkcolor.h: make GdkColormap a GObject subclass

	* gdk/gdkcompat.h: remove GdkWindowType compat, since
	GdkWindowType is now non-deprecated;
	change gdk_window_get_type() compat to be
	gdk_window_get_window_type().

	* gdk/gdkdnd.h: make GdkDragContext a GObject.

	* gdk/gdkdraw.c, gdk/gdkdraw.h: Convert GdkDrawable to a pure
	virtual GObject. Make all functions call into the vtable.
	Move gdk_image_put() guts in here. Remove GdkDrawableType
	and gdk_drawable_get_type(), these are now GdkWindow-specific.
	draw_image, get_depth, get_size, set_colormap, get_colormap,
	get_visual added to the vtable.

	* gdk/gdkgc.h, gdk/gdkgc.c: Convert GdkGC to a pure virtual
	GObject. Virtualize everything.
	(gdk_gc_new_with_values): remove check for destroyed window,
	because now GdkWindow::create_gc will check this.
	(gdk_gc_set_values): New function to set GC values, this
	was already implemented but wasn't in the header

	* gdk/gdkimage.h, gdk/gdkimage.c: Convert GdkImage to a GObject.

	* gdk/gdkinternals.h: Remove _gdk_window_alloc(), remove
	_gdk_window_draw_image(), remove _gdk_windowing_window_class,
	remove _gdk_window_class; add _gdk_window_impl_get_type() and
	_gdk_pixmap_impl_get_type(). Rename gdk_window_init to
	_gdk_windowing_window_init, rename gdk_image_init to
	_gdk_windowing_image_init.

	* gdk/gdkpango.c: Reflect GObject-ification of PangoContext.
	(gdk_draw_layout): Remove check for destroyed window,
	because all the drawable methods already check it.

	* gdk/gdkpixmap.h, gdk/gdkpixmap.c: Convert GdkPixmap to GObject.
	Add gdkpixmap.c which contains implementation of GdkDrawable
	virtual table (by chaining to a platform-specific implementation
	object).

	* gdk/gdkprivate.h: Remove GDK_IS_WINDOW, GDK_IS_PIXMAP,
	GDK_DRAWABLE_DESTROYED. Add GDK_WINDOW_DESTROYED. Replace
	GDK_DRAWABLE_TYPE with GDK_WINDOW_TYPE. Remove GdkDrawablePrivate,
	GdkWindowPrivate, GdkImageClass, GdkImagePrivate, GdkGCPrivate,
	GdkColormapPrivate.

	* gdk/gdktypes.h: #include <glib-object.h>

	* gdk/gdkwindow.h, gdk/gdkwindow.c: Convert GdkWindow to GObject.
	Move most functionality to platform-specific implementation
	object. GdkWindow itself now handles the backing store, then
	chains to the platform-specific implementation.
	(gdk_window_get_window_type): return GdkWindowType of the window.
	(gdk_window_peek_children): New routine, returns the children of
	a GdkWindow
	(gdk_window_get_children): Was in X11-specific code and did
	XQueryTree. Changed to simply return a copy of window->children;
	so it can go in cross-platform code.

	* gdk/x11/Makefile.am: fix broken MKINSTALLDIRS path

	* gdk/x11/gdkcolor-x11.c: implement X-specific parts of
	GdkColormap; just changed to use the new private data instead
	of casting to GdkColormapPrivate.

	* gdk/x11/gdkcursor-x11.c: added a couple typechecks to
	gdk_cursor_new().

	* gdk/x11/gdkdnd-x11.c: Change the way we access private fields
	(private data member in the GObject).
	(xdnd_manager_source_filter): Function had broken
	error handling, fix it (use gdk_error_trap_push).

	* gdk/x11/gdkdrawable-x11.c: This file now implements
	a base class for GdkWindowImplX11/GdkPixmapImplX11. This
	base class is purely for the convenience of the X port,
	and not part of the interface to cross-platform GDK.

	* gdk/x11/gdkevents-x11.c: Reflect various renamings.

	* gdk/x11/gdkgc-x11.c: Implement a subclass of GdkGC that's
	specific to X, and returned by the create_gc virtual method
	of GdkDrawableImplX11.
	(gdk_x11_gc_set_dashes): Change this to take an array of gint8
	rather than gchar, this was also changed in the GdkGC vtable.
	(gdk_x11_gc_values_to_xvalues): If GdkGCValues is NULL, or the
	mask is 0, return immediately, instead of checking every flag.
	This is faster, and keeps us from segfaulting if values is NULL
	and the mask contains some nonzero flags.

	* gdk/x11/gdkgeometry-x11.c: deal with all the rearranging of
	GdkWindow.

	* gdk/x11/gdkglobals-x11.c: change type of grab window, since
	GdkWindowPrivate is gone.

	* gdk/x11/gdkim-x11.c: rename things that got renamed.

	* gdk/x11/gdkimage-x11.c: implement in terms of GObject, and
	remove the image_put stuff that got transferred to GdkDrawable.

	* gdk/x11/gdkinput.c: renamings

	* gdk/x11/gdkmain-x11.c: #include <pango/pangox.h>

	* gdk/x11/gdkpixmap-x11.c: GObject conversion

	* gdk/x11/gdkprivate-x11.h: indentation fixes

	* gdk/x11/gdkproperty-x11.c: renamings

	* gdk/x11/gdkselection-x11.c: renamings

	* gdk/x11/gdkwindow-x11.c: Restructuring and renaming; this now
	implements the platform-specific "impl" object.
	Moved gdk_window_get_children to gdk/gdkwindow.c

	* gdk/x11/gdkx.h: Remove all the private structs and private datas
	that no longer exist. Add declaration of GdkGCX11 object here.
	Fix all the macros to still work.

	* gtk/gtk-boxed.defs: Remove GtkStyle, GdkColormap, GdkWindow,
	GdkDragContext from the boxed types since they are now GObjects.

	* gtk/gtkstyle.h, gtk/gtkstyle.c: Converted GtkStyle to a GObject,
	moved xthickness/ythickness into the instance. GtkStyleClass
	functions are now in the standard vtable for GtkStyle, so you have
	to create a GObject subclass to write a theme engine.
	(gtk_style_copy): fixed a leaked PangoFontDescription
	(gtk_style_init): renamed gtk_style_realize, so gtk_style_init
	can be the standard GObject function.

	* Throughout GTK:
	s/style->klass->[xy]thickness/style->[xy]thickness
	s/pango_layout_unref/g_object_unref/

	* gtk/gtkrc.h, gtk/gtkrc.c: Converted GtkRcStyle to a GObject.

	* gtk/gtksocket.c: Use gdk_window_get_user_data() instead of
	accessing GDK internals.

	* gtk/gtkwidget.c: Use gdk_window_peek_children() instead of
	accessing GDK internals.

101 files changed, 5434 insertions, 2868 deletions

diff --git a/ChangeLog b/ChangeLog
index eaaadd5c58..54808d8d1d 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,179 @@
+2000-06-20  Havoc Pennington  <hp@redhat.com>
+
+	* modules/linux-fb/Makefile.am: Make this compile
+	without framebuffer enabled
+
+	* gdk/linux-fb/Makefile.am: Add conditional to not build
+	framebuffer unless specified in configure
+
+	* gdk/gdkdraw.c (gdk_draw_drawable): Fix bug where I was getting
+	the size of the target instead of source if -1 was passed for
+	width/height
+
+	* gdk/x11/gdkgeometry-x11.c (gdk_window_compute_position): Fix 
+	width/height confusion.
+
+2000-06-19  Havoc Pennington  <hp@redhat.com>
+
+	* gdk/x11/gdkx.h (GDK_WINDOW_XWINDOW): change this to be
+	GDK_DRAWABLE_XID. In the future, we probably want to make it
+	faster with G_DISABLE_CHECKS turned on.
+
+2000-06-14  Havoc Pennington  <hp@redhat.com>
+
+        * gdk/Makefile.am: add gdkpixmap.c
+
+	* gdk/gdk.c: s/gdk_window_init/_gdk_windowing_window_init/
+	s/gdk_image_init/_gdk_windowing_image_init
+
+	* gdk/gdkcolor.c: make ref/unref compat wrappers for GObject
+	ref/unref
+
+	* gdk/gdkcolor.h: make GdkColormap a GObject subclass
+
+	* gdk/gdkcompat.h: remove GdkWindowType compat, since
+	GdkWindowType is now non-deprecated; 
+	change gdk_window_get_type() compat to be
+	gdk_window_get_window_type().
+
+	* gdk/gdkdnd.h: make GdkDragContext a GObject.
+
+	* gdk/gdkdraw.c, gdk/gdkdraw.h: Convert GdkDrawable to a pure
+	virtual GObject. Make all functions call into the vtable.
+	Move gdk_image_put() guts in here. Remove GdkDrawableType
+	and gdk_drawable_get_type(), these are now GdkWindow-specific.
+	draw_image, get_depth, get_size, set_colormap, get_colormap,
+	get_visual added to the vtable.
+	
+	* gdk/gdkgc.h, gdk/gdkgc.c: Convert GdkGC to a pure virtual 
+	GObject. Virtualize everything. 
+	(gdk_gc_new_with_values): remove check for destroyed window,
+	because now GdkWindow::create_gc will check this.
+	(gdk_gc_set_values): New function to set GC values, this 
+	was already implemented but wasn't in the header
+
+	* gdk/gdkimage.h, gdk/gdkimage.c: Convert GdkImage to a GObject.
+
+	* gdk/gdkinternals.h: Remove _gdk_window_alloc(), remove
+	_gdk_window_draw_image(), remove _gdk_windowing_window_class,
+	remove _gdk_window_class; add _gdk_window_impl_get_type() and
+	_gdk_pixmap_impl_get_type(). Rename gdk_window_init to
+	_gdk_windowing_window_init, rename gdk_image_init to
+	_gdk_windowing_image_init.
+	
+	* gdk/gdkpango.c: Reflect GObject-ification of PangoContext.
+	(gdk_draw_layout): Remove check for destroyed window, 
+	because all the drawable methods already check it.
+	
+	* gdk/gdkpixmap.h, gdk/gdkpixmap.c: Convert GdkPixmap to GObject.
+	Add gdkpixmap.c which contains implementation of GdkDrawable
+	virtual table (by chaining to a platform-specific implementation
+	object).
+	
+	* gdk/gdkprivate.h: Remove GDK_IS_WINDOW, GDK_IS_PIXMAP, 
+	GDK_DRAWABLE_DESTROYED. Add GDK_WINDOW_DESTROYED. Replace
+	GDK_DRAWABLE_TYPE with GDK_WINDOW_TYPE. Remove GdkDrawablePrivate,
+	GdkWindowPrivate, GdkImageClass, GdkImagePrivate, GdkGCPrivate,
+	GdkColormapPrivate. 
+
+	* gdk/gdktypes.h: #include <glib-object.h>
+
+	* gdk/gdkwindow.h, gdk/gdkwindow.c: Convert GdkWindow to GObject.
+	Move most functionality to platform-specific implementation
+	object. GdkWindow itself now handles the backing store, then
+	chains to the platform-specific implementation.
+	(gdk_window_get_window_type): return GdkWindowType of the window.
+	(gdk_window_peek_children): New routine, returns the children of 
+	a GdkWindow
+	(gdk_window_get_children): Was in X11-specific code and did 
+	XQueryTree. Changed to simply return a copy of window->children; 
+	so it can go in cross-platform code.
+	
+	* gdk/x11/Makefile.am: fix broken MKINSTALLDIRS path
+
+	* gdk/x11/gdkcolor-x11.c: implement X-specific parts of 
+	GdkColormap; just changed to use the new private data instead
+	of casting to GdkColormapPrivate.
+
+	* gdk/x11/gdkcursor-x11.c: added a couple typechecks to 
+	gdk_cursor_new().
+
+	* gdk/x11/gdkdnd-x11.c: Change the way we access private fields 
+	(private data member in the GObject). 
+	(xdnd_manager_source_filter): Function had broken 
+	error handling, fix it (use gdk_error_trap_push).
+
+	* gdk/x11/gdkdrawable-x11.c: This file now implements
+	a base class for GdkWindowImplX11/GdkPixmapImplX11. This 
+	base class is purely for the convenience of the X port,
+	and not part of the interface to cross-platform GDK.
+
+	* gdk/x11/gdkevents-x11.c: Reflect various renamings.
+	
+	* gdk/x11/gdkgc-x11.c: Implement a subclass of GdkGC that's
+	specific to X, and returned by the create_gc virtual method
+	of GdkDrawableImplX11. 
+	(gdk_x11_gc_set_dashes): Change this to take an array of gint8
+	rather than gchar, this was also changed in the GdkGC vtable.
+	(gdk_x11_gc_values_to_xvalues): If GdkGCValues is NULL, or the
+	mask is 0, return immediately, instead of checking every flag.
+	This is faster, and keeps us from segfaulting if values is NULL
+	and the mask contains some nonzero flags.
+
+	* gdk/x11/gdkgeometry-x11.c: deal with all the rearranging of
+	GdkWindow.
+
+	* gdk/x11/gdkglobals-x11.c: change type of grab window, since 
+	GdkWindowPrivate is gone.
+
+	* gdk/x11/gdkim-x11.c: rename things that got renamed.
+
+	* gdk/x11/gdkimage-x11.c: implement in terms of GObject, and 
+	remove the image_put stuff that got transferred to GdkDrawable.
+	
+	* gdk/x11/gdkinput.c: renamings
+
+	* gdk/x11/gdkmain-x11.c: #include <pango/pangox.h>
+
+	* gdk/x11/gdkpixmap-x11.c: GObject conversion
+
+	* gdk/x11/gdkprivate-x11.h: indentation fixes
+
+	* gdk/x11/gdkproperty-x11.c: renamings
+
+	* gdk/x11/gdkselection-x11.c: renamings
+
+	* gdk/x11/gdkwindow-x11.c: Restructuring and renaming; this now 
+	implements the platform-specific "impl" object.
+	Moved gdk_window_get_children to gdk/gdkwindow.c
+
+	* gdk/x11/gdkx.h: Remove all the private structs and private datas
+	that no longer exist. Add declaration of GdkGCX11 object here.
+	Fix all the macros to still work. 
+
+	* gtk/gtk-boxed.defs: Remove GtkStyle, GdkColormap, GdkWindow,
+	GdkDragContext from the boxed types since they are now GObjects.
+
+	* gtk/gtkstyle.h, gtk/gtkstyle.c: Converted GtkStyle to a GObject,
+	moved xthickness/ythickness into the instance. GtkStyleClass
+	functions are now in the standard vtable for GtkStyle, so you have
+	to create a GObject subclass to write a theme engine.
+	(gtk_style_copy): fixed a leaked PangoFontDescription
+	(gtk_style_init): renamed gtk_style_realize, so gtk_style_init
+	can be the standard GObject function.
+	
+	* Throughout GTK:
+	s/style->klass->[xy]thickness/style->[xy]thickness
+	s/pango_layout_unref/g_object_unref/
+
+	* gtk/gtkrc.h, gtk/gtkrc.c: Converted GtkRcStyle to a GObject.
+	
+	* gtk/gtksocket.c: Use gdk_window_get_user_data() instead of 
+	accessing GDK internals.
+
+	* gtk/gtkwidget.c: Use gdk_window_peek_children() instead of 
+	accessing GDK internals.
+
 2000-06-18  Elliot Lee  <sopwith@redhat.com>
 
 	* gtk/gtkwindow.c: Don't allow creation of a window bigger than the screen.
@@ -84,7 +260,7 @@ Mon Jun  5 19:32:53 CEST 2000 Paolo Molaro <lupus@linuxcare.com>
 	* gdk/nanox/gdk*generic*: delete generic region code.
 	* gdk/linux-fb/gdk*generic*: delete generic region code.
 	* README.nanox: update information.
-
+	
 Tue Jun  6 10:53:59 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* gtk/gtktoolbar.c (gtk_toolbar_prepend_widget): Fix to
diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0
index eaaadd5c58..54808d8d1d 100644
--- a/ChangeLog.pre-2-0
+++ b/ChangeLog.pre-2-0
@@ -1,3 +1,179 @@
+2000-06-20  Havoc Pennington  <hp@redhat.com>
+
+	* modules/linux-fb/Makefile.am: Make this compile
+	without framebuffer enabled
+
+	* gdk/linux-fb/Makefile.am: Add conditional to not build
+	framebuffer unless specified in configure
+
+	* gdk/gdkdraw.c (gdk_draw_drawable): Fix bug where I was getting
+	the size of the target instead of source if -1 was passed for
+	width/height
+
+	* gdk/x11/gdkgeometry-x11.c (gdk_window_compute_position): Fix 
+	width/height confusion.
+
+2000-06-19  Havoc Pennington  <hp@redhat.com>
+
+	* gdk/x11/gdkx.h (GDK_WINDOW_XWINDOW): change this to be
+	GDK_DRAWABLE_XID. In the future, we probably want to make it
+	faster with G_DISABLE_CHECKS turned on.
+
+2000-06-14  Havoc Pennington  <hp@redhat.com>
+
+        * gdk/Makefile.am: add gdkpixmap.c
+
+	* gdk/gdk.c: s/gdk_window_init/_gdk_windowing_window_init/
+	s/gdk_image_init/_gdk_windowing_image_init
+
+	* gdk/gdkcolor.c: make ref/unref compat wrappers for GObject
+	ref/unref
+
+	* gdk/gdkcolor.h: make GdkColormap a GObject subclass
+
+	* gdk/gdkcompat.h: remove GdkWindowType compat, since
+	GdkWindowType is now non-deprecated; 
+	change gdk_window_get_type() compat to be
+	gdk_window_get_window_type().
+
+	* gdk/gdkdnd.h: make GdkDragContext a GObject.
+
+	* gdk/gdkdraw.c, gdk/gdkdraw.h: Convert GdkDrawable to a pure
+	virtual GObject. Make all functions call into the vtable.
+	Move gdk_image_put() guts in here. Remove GdkDrawableType
+	and gdk_drawable_get_type(), these are now GdkWindow-specific.
+	draw_image, get_depth, get_size, set_colormap, get_colormap,
+	get_visual added to the vtable.
+	
+	* gdk/gdkgc.h, gdk/gdkgc.c: Convert GdkGC to a pure virtual 
+	GObject. Virtualize everything. 
+	(gdk_gc_new_with_values): remove check for destroyed window,
+	because now GdkWindow::create_gc will check this.
+	(gdk_gc_set_values): New function to set GC values, this 
+	was already implemented but wasn't in the header
+
+	* gdk/gdkimage.h, gdk/gdkimage.c: Convert GdkImage to a GObject.
+
+	* gdk/gdkinternals.h: Remove _gdk_window_alloc(), remove
+	_gdk_window_draw_image(), remove _gdk_windowing_window_class,
+	remove _gdk_window_class; add _gdk_window_impl_get_type() and
+	_gdk_pixmap_impl_get_type(). Rename gdk_window_init to
+	_gdk_windowing_window_init, rename gdk_image_init to
+	_gdk_windowing_image_init.
+	
+	* gdk/gdkpango.c: Reflect GObject-ification of PangoContext.
+	(gdk_draw_layout): Remove check for destroyed window, 
+	because all the drawable methods already check it.
+	
+	* gdk/gdkpixmap.h, gdk/gdkpixmap.c: Convert GdkPixmap to GObject.
+	Add gdkpixmap.c which contains implementation of GdkDrawable
+	virtual table (by chaining to a platform-specific implementation
+	object).
+	
+	* gdk/gdkprivate.h: Remove GDK_IS_WINDOW, GDK_IS_PIXMAP, 
+	GDK_DRAWABLE_DESTROYED. Add GDK_WINDOW_DESTROYED. Replace
+	GDK_DRAWABLE_TYPE with GDK_WINDOW_TYPE. Remove GdkDrawablePrivate,
+	GdkWindowPrivate, GdkImageClass, GdkImagePrivate, GdkGCPrivate,
+	GdkColormapPrivate. 
+
+	* gdk/gdktypes.h: #include <glib-object.h>
+
+	* gdk/gdkwindow.h, gdk/gdkwindow.c: Convert GdkWindow to GObject.
+	Move most functionality to platform-specific implementation
+	object. GdkWindow itself now handles the backing store, then
+	chains to the platform-specific implementation.
+	(gdk_window_get_window_type): return GdkWindowType of the window.
+	(gdk_window_peek_children): New routine, returns the children of 
+	a GdkWindow
+	(gdk_window_get_children): Was in X11-specific code and did 
+	XQueryTree. Changed to simply return a copy of window->children; 
+	so it can go in cross-platform code.
+	
+	* gdk/x11/Makefile.am: fix broken MKINSTALLDIRS path
+
+	* gdk/x11/gdkcolor-x11.c: implement X-specific parts of 
+	GdkColormap; just changed to use the new private data instead
+	of casting to GdkColormapPrivate.
+
+	* gdk/x11/gdkcursor-x11.c: added a couple typechecks to 
+	gdk_cursor_new().
+
+	* gdk/x11/gdkdnd-x11.c: Change the way we access private fields 
+	(private data member in the GObject). 
+	(xdnd_manager_source_filter): Function had broken 
+	error handling, fix it (use gdk_error_trap_push).
+
+	* gdk/x11/gdkdrawable-x11.c: This file now implements
+	a base class for GdkWindowImplX11/GdkPixmapImplX11. This 
+	base class is purely for the convenience of the X port,
+	and not part of the interface to cross-platform GDK.
+
+	* gdk/x11/gdkevents-x11.c: Reflect various renamings.
+	
+	* gdk/x11/gdkgc-x11.c: Implement a subclass of GdkGC that's
+	specific to X, and returned by the create_gc virtual method
+	of GdkDrawableImplX11. 
+	(gdk_x11_gc_set_dashes): Change this to take an array of gint8
+	rather than gchar, this was also changed in the GdkGC vtable.
+	(gdk_x11_gc_values_to_xvalues): If GdkGCValues is NULL, or the
+	mask is 0, return immediately, instead of checking every flag.
+	This is faster, and keeps us from segfaulting if values is NULL
+	and the mask contains some nonzero flags.
+
+	* gdk/x11/gdkgeometry-x11.c: deal with all the rearranging of
+	GdkWindow.
+
+	* gdk/x11/gdkglobals-x11.c: change type of grab window, since 
+	GdkWindowPrivate is gone.
+
+	* gdk/x11/gdkim-x11.c: rename things that got renamed.
+
+	* gdk/x11/gdkimage-x11.c: implement in terms of GObject, and 
+	remove the image_put stuff that got transferred to GdkDrawable.
+	
+	* gdk/x11/gdkinput.c: renamings
+
+	* gdk/x11/gdkmain-x11.c: #include <pango/pangox.h>
+
+	* gdk/x11/gdkpixmap-x11.c: GObject conversion
+
+	* gdk/x11/gdkprivate-x11.h: indentation fixes
+
+	* gdk/x11/gdkproperty-x11.c: renamings
+
+	* gdk/x11/gdkselection-x11.c: renamings
+
+	* gdk/x11/gdkwindow-x11.c: Restructuring and renaming; this now 
+	implements the platform-specific "impl" object.
+	Moved gdk_window_get_children to gdk/gdkwindow.c
+
+	* gdk/x11/gdkx.h: Remove all the private structs and private datas
+	that no longer exist. Add declaration of GdkGCX11 object here.
+	Fix all the macros to still work. 
+
+	* gtk/gtk-boxed.defs: Remove GtkStyle, GdkColormap, GdkWindow,
+	GdkDragContext from the boxed types since they are now GObjects.
+
+	* gtk/gtkstyle.h, gtk/gtkstyle.c: Converted GtkStyle to a GObject,
+	moved xthickness/ythickness into the instance. GtkStyleClass
+	functions are now in the standard vtable for GtkStyle, so you have
+	to create a GObject subclass to write a theme engine.
+	(gtk_style_copy): fixed a leaked PangoFontDescription
+	(gtk_style_init): renamed gtk_style_realize, so gtk_style_init
+	can be the standard GObject function.
+	
+	* Throughout GTK:
+	s/style->klass->[xy]thickness/style->[xy]thickness
+	s/pango_layout_unref/g_object_unref/
+
+	* gtk/gtkrc.h, gtk/gtkrc.c: Converted GtkRcStyle to a GObject.
+	
+	* gtk/gtksocket.c: Use gdk_window_get_user_data() instead of 
+	accessing GDK internals.
+
+	* gtk/gtkwidget.c: Use gdk_window_peek_children() instead of 
+	accessing GDK internals.
+
 2000-06-18  Elliot Lee  <sopwith@redhat.com>
 
 	* gtk/gtkwindow.c: Don't allow creation of a window bigger than the screen.
@@ -84,7 +260,7 @@ Mon Jun  5 19:32:53 CEST 2000 Paolo Molaro <lupus@linuxcare.com>
 	* gdk/nanox/gdk*generic*: delete generic region code.
 	* gdk/linux-fb/gdk*generic*: delete generic region code.
 	* README.nanox: update information.
-
+	
 Tue Jun  6 10:53:59 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* gtk/gtktoolbar.c (gtk_toolbar_prepend_widget): Fix to
diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10
index eaaadd5c58..54808d8d1d 100644
--- a/ChangeLog.pre-2-10
+++ b/ChangeLog.pre-2-10
@@ -1,3 +1,179 @@
+2000-06-20  Havoc Pennington  <hp@redhat.com>
+
+	* modules/linux-fb/Makefile.am: Make this compile
+	without framebuffer enabled
+
+	* gdk/linux-fb/Makefile.am: Add conditional to not build
+	framebuffer unless specified in configure
+
+	* gdk/gdkdraw.c (gdk_draw_drawable): Fix bug where I was getting
+	the size of the target instead of source if -1 was passed for
+	width/height
+
+	* gdk/x11/gdkgeometry-x11.c (gdk_window_compute_position): Fix 
+	width/height confusion.
+
+2000-06-19  Havoc Pennington  <hp@redhat.com>
+
+	* gdk/x11/gdkx.h (GDK_WINDOW_XWINDOW): change this to be
+	GDK_DRAWABLE_XID. In the future, we probably want to make it
+	faster with G_DISABLE_CHECKS turned on.
+
+2000-06-14  Havoc Pennington  <hp@redhat.com>
+
+        * gdk/Makefile.am: add gdkpixmap.c
+
+	* gdk/gdk.c: s/gdk_window_init/_gdk_windowing_window_init/
+	s/gdk_image_init/_gdk_windowing_image_init
+
+	* gdk/gdkcolor.c: make ref/unref compat wrappers for GObject
+	ref/unref
+
+	* gdk/gdkcolor.h: make GdkColormap a GObject subclass
+
+	* gdk/gdkcompat.h: remove GdkWindowType compat, since
+	GdkWindowType is now non-deprecated; 
+	change gdk_window_get_type() compat to be
+	gdk_window_get_window_type().
+
+	* gdk/gdkdnd.h: make GdkDragContext a GObject.
+
+	* gdk/gdkdraw.c, gdk/gdkdraw.h: Convert GdkDrawable to a pure
+	virtual GObject. Make all functions call into the vtable.
+	Move gdk_image_put() guts in here. Remove GdkDrawableType
+	and gdk_drawable_get_type(), these are now GdkWindow-specific.
+	draw_image, get_depth, get_size, set_colormap, get_colormap,
+	get_visual added to the vtable.
+	
+	* gdk/gdkgc.h, gdk/gdkgc.c: Convert GdkGC to a pure virtual 
+	GObject. Virtualize everything. 
+	(gdk_gc_new_with_values): remove check for destroyed window,
+	because now GdkWindow::create_gc will check this.
+	(gdk_gc_set_values): New function to set GC values, this 
+	was already implemented but wasn't in the header
+
+	* gdk/gdkimage.h, gdk/gdkimage.c: Convert GdkImage to a GObject.
+
+	* gdk/gdkinternals.h: Remove _gdk_window_alloc(), remove
+	_gdk_window_draw_image(), remove _gdk_windowing_window_class,
+	remove _gdk_window_class; add _gdk_window_impl_get_type() and
+	_gdk_pixmap_impl_get_type(). Rename gdk_window_init to
+	_gdk_windowing_window_init, rename gdk_image_init to
+	_gdk_windowing_image_init.
+	
+	* gdk/gdkpango.c: Reflect GObject-ification of PangoContext.
+	(gdk_draw_layout): Remove check for destroyed window, 
+	because all the drawable methods already check it.
+	
+	* gdk/gdkpixmap.h, gdk/gdkpixmap.c: Convert GdkPixmap to GObject.
+	Add gdkpixmap.c which contains implementation of GdkDrawable
+	virtual table (by chaining to a platform-specific implementation
+	object).
+	
+	* gdk/gdkprivate.h: Remove GDK_IS_WINDOW, GDK_IS_PIXMAP, 
+	GDK_DRAWABLE_DESTROYED. Add GDK_WINDOW_DESTROYED. Replace
+	GDK_DRAWABLE_TYPE with GDK_WINDOW_TYPE. Remove GdkDrawablePrivate,
+	GdkWindowPrivate, GdkImageClass, GdkImagePrivate, GdkGCPrivate,
+	GdkColormapPrivate. 
+
+	* gdk/gdktypes.h: #include <glib-object.h>
+
+	* gdk/gdkwindow.h, gdk/gdkwindow.c: Convert GdkWindow to GObject.
+	Move most functionality to platform-specific implementation
+	object. GdkWindow itself now handles the backing store, then
+	chains to the platform-specific implementation.
+	(gdk_window_get_window_type): return GdkWindowType of the window.
+	(gdk_window_peek_children): New routine, returns the children of 
+	a GdkWindow
+	(gdk_window_get_children): Was in X11-specific code and did 
+	XQueryTree. Changed to simply return a copy of window->children; 
+	so it can go in cross-platform code.
+	
+	* gdk/x11/Makefile.am: fix broken MKINSTALLDIRS path
+
+	* gdk/x11/gdkcolor-x11.c: implement X-specific parts of 
+	GdkColormap; just changed to use the new private data instead
+	of casting to GdkColormapPrivate.
+
+	* gdk/x11/gdkcursor-x11.c: added a couple typechecks to 
+	gdk_cursor_new().
+
+	* gdk/x11/gdkdnd-x11.c: Change the way we access private fields 
+	(private data member in the GObject). 
+	(xdnd_manager_source_filter): Function had broken 
+	error handling, fix it (use gdk_error_trap_push).
+
+	* gdk/x11/gdkdrawable-x11.c: This file now implements
+	a base class for GdkWindowImplX11/GdkPixmapImplX11. This 
+	base class is purely for the convenience of the X port,
+	and not part of the interface to cross-platform GDK.
+
+	* gdk/x11/gdkevents-x11.c: Reflect various renamings.
+	
+	* gdk/x11/gdkgc-x11.c: Implement a subclass of GdkGC that's
+	specific to X, and returned by the create_gc virtual method
+	of GdkDrawableImplX11. 
+	(gdk_x11_gc_set_dashes): Change this to take an array of gint8
+	rather than gchar, this was also changed in the GdkGC vtable.
+	(gdk_x11_gc_values_to_xvalues): If GdkGCValues is NULL, or the
+	mask is 0, return immediately, instead of checking every flag.
+	This is faster, and keeps us from segfaulting if values is NULL
+	and the mask contains some nonzero flags.
+
+	* gdk/x11/gdkgeometry-x11.c: deal with all the rearranging of
+	GdkWindow.
+
+	* gdk/x11/gdkglobals-x11.c: change type of grab window, since 
+	GdkWindowPrivate is gone.
+
+	* gdk/x11/gdkim-x11.c: rename things that got renamed.
+
+	* gdk/x11/gdkimage-x11.c: implement in terms of GObject, and 
+	remove the image_put stuff that got transferred to GdkDrawable.
+	
+	* gdk/x11/gdkinput.c: renamings
+
+	* gdk/x11/gdkmain-x11.c: #include <pango/pangox.h>
+
+	* gdk/x11/gdkpixmap-x11.c: GObject conversion
+
+	* gdk/x11/gdkprivate-x11.h: indentation fixes
+
+	* gdk/x11/gdkproperty-x11.c: renamings
+
+	* gdk/x11/gdkselection-x11.c: renamings
+
+	* gdk/x11/gdkwindow-x11.c: Restructuring and renaming; this now 
+	implements the platform-specific "impl" object.
+	Moved gdk_window_get_children to gdk/gdkwindow.c
+
+	* gdk/x11/gdkx.h: Remove all the private structs and private datas
+	that no longer exist. Add declaration of GdkGCX11 object here.
+	Fix all the macros to still work. 
+
+	* gtk/gtk-boxed.defs: Remove GtkStyle, GdkColormap, GdkWindow,
+	GdkDragContext from the boxed types since they are now GObjects.
+
+	* gtk/gtkstyle.h, gtk/gtkstyle.c: Converted GtkStyle to a GObject,
+	moved xthickness/ythickness into the instance. GtkStyleClass
+	functions are now in the standard vtable for GtkStyle, so you have
+	to create a GObject subclass to write a theme engine.
+	(gtk_style_copy): fixed a leaked PangoFontDescription
+	(gtk_style_init): renamed gtk_style_realize, so gtk_style_init
+	can be the standard GObject function.
+	
+	* Throughout GTK:
+	s/style->klass->[xy]thickness/style->[xy]thickness
+	s/pango_layout_unref/g_object_unref/
+
+	* gtk/gtkrc.h, gtk/gtkrc.c: Converted GtkRcStyle to a GObject.
+	
+	* gtk/gtksocket.c: Use gdk_window_get_user_data() instead of 
+	accessing GDK internals.
+
+	* gtk/gtkwidget.c: Use gdk_window_peek_children() instead of 
+	accessing GDK internals.
+
 2000-06-18  Elliot Lee  <sopwith@redhat.com>
 
 	* gtk/gtkwindow.c: Don't allow creation of a window bigger than the screen.
@@ -84,7 +260,7 @@ Mon Jun  5 19:32:53 CEST 2000 Paolo Molaro <lupus@linuxcare.com>
 	* gdk/nanox/gdk*generic*: delete generic region code.
 	* gdk/linux-fb/gdk*generic*: delete generic region code.
 	* README.nanox: update information.
-
+	
 Tue Jun  6 10:53:59 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* gtk/gtktoolbar.c (gtk_toolbar_prepend_widget): Fix to
diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2
index eaaadd5c58..54808d8d1d 100644
--- a/ChangeLog.pre-2-2
+++ b/ChangeLog.pre-2-2
@@ -1,3 +1,179 @@
+2000-06-20  Havoc Pennington  <hp@redhat.com>
+
+	* modules/linux-fb/Makefile.am: Make this compile
+	without framebuffer enabled
+
+	* gdk/linux-fb/Makefile.am: Add conditional to not build
+	framebuffer unless specified in configure
+
+	* gdk/gdkdraw.c (gdk_draw_drawable): Fix bug where I was getting
+	the size of the target instead of source if -1 was passed for
+	width/height
+
+	* gdk/x11/gdkgeometry-x11.c (gdk_window_compute_position): Fix 
+	width/height confusion.
+
+2000-06-19  Havoc Pennington  <hp@redhat.com>
+
+	* gdk/x11/gdkx.h (GDK_WINDOW_XWINDOW): change this to be
+	GDK_DRAWABLE_XID. In the future, we probably want to make it
+	faster with G_DISABLE_CHECKS turned on.
+
+2000-06-14  Havoc Pennington  <hp@redhat.com>
+
+        * gdk/Makefile.am: add gdkpixmap.c
+
+	* gdk/gdk.c: s/gdk_window_init/_gdk_windowing_window_init/
+	s/gdk_image_init/_gdk_windowing_image_init
+
+	* gdk/gdkcolor.c: make ref/unref compat wrappers for GObject
+	ref/unref
+
+	* gdk/gdkcolor.h: make GdkColormap a GObject subclass
+
+	* gdk/gdkcompat.h: remove GdkWindowType compat, since
+	GdkWindowType is now non-deprecated; 
+	change gdk_window_get_type() compat to be
+	gdk_window_get_window_type().
+
+	* gdk/gdkdnd.h: make GdkDragContext a GObject.
+
+	* gdk/gdkdraw.c, gdk/gdkdraw.h: Convert GdkDrawable to a pure
+	virtual GObject. Make all functions call into the vtable.
+	Move gdk_image_put() guts in here. Remove GdkDrawableType
+	and gdk_drawable_get_type(), these are now GdkWindow-specific.
+	draw_image, get_depth, get_size, set_colormap, get_colormap,
+	get_visual added to the vtable.
+	
+	* gdk/gdkgc.h, gdk/gdkgc.c: Convert GdkGC to a pure virtual 
+	GObject. Virtualize everything. 
+	(gdk_gc_new_with_values): remove check for destroyed window,
+	because now GdkWindow::create_gc will check this.
+	(gdk_gc_set_values): New function to set GC values, this 
+	was already implemented but wasn't in the header
+
+	* gdk/gdkimage.h, gdk/gdkimage.c: Convert GdkImage to a GObject.
+
+	* gdk/gdkinternals.h: Remove _gdk_window_alloc(), remove
+	_gdk_window_draw_image(), remove _gdk_windowing_window_class,
+	remove _gdk_window_class; add _gdk_window_impl_get_type() and
+	_gdk_pixmap_impl_get_type(). Rename gdk_window_init to
+	_gdk_windowing_window_init, rename gdk_image_init to
+	_gdk_windowing_image_init.
+	
+	* gdk/gdkpango.c: Reflect GObject-ification of PangoContext.
+	(gdk_draw_layout): Remove check for destroyed window, 
+	because all the drawable methods already check it.
+	
+	* gdk/gdkpixmap.h, gdk/gdkpixmap.c: Convert GdkPixmap to GObject.
+	Add gdkpixmap.c which contains implementation of GdkDrawable
+	virtual table (by chaining to a platform-specific implementation
+	object).
+	
+	* gdk/gdkprivate.h: Remove GDK_IS_WINDOW, GDK_IS_PIXMAP, 
+	GDK_DRAWABLE_DESTROYED. Add GDK_WINDOW_DESTROYED. Replace
+	GDK_DRAWABLE_TYPE with GDK_WINDOW_TYPE. Remove GdkDrawablePrivate,
+	GdkWindowPrivate, GdkImageClass, GdkImagePrivate, GdkGCPrivate,
+	GdkColormapPrivate. 
+
+	* gdk/gdktypes.h: #include <glib-object.h>
+
+	* gdk/gdkwindow.h, gdk/gdkwindow.c: Convert GdkWindow to GObject.
+	Move most functionality to platform-specific implementation
+	object. GdkWindow itself now handles the backing store, then
+	chains to the platform-specific implementation.
+	(gdk_window_get_window_type): return GdkWindowType of the window.
+	(gdk_window_peek_children): New routine, returns the children of 
+	a GdkWindow
+	(gdk_window_get_children): Was in X11-specific code and did 
+	XQueryTree. Changed to simply return a copy of window->children; 
+	so it can go in cross-platform code.
+	
+	* gdk/x11/Makefile.am: fix broken MKINSTALLDIRS path
+
+	* gdk/x11/gdkcolor-x11.c: implement X-specific parts of 
+	GdkColormap; just changed to use the new private data instead
+	of casting to GdkColormapPrivate.
+
+	* gdk/x11/gdkcursor-x11.c: added a couple typechecks to 
+	gdk_cursor_new().
+
+	* gdk/x11/gdkdnd-x11.c: Change the way we access private fields 
+	(private data member in the GObject). 
+	(xdnd_manager_source_filter): Function had broken 
+	error handling, fix it (use gdk_error_trap_push).
+
+	* gdk/x11/gdkdrawable-x11.c: This file now implements
+	a base class for GdkWindowImplX11/GdkPixmapImplX11. This 
+	base class is purely for the convenience of the X port,
+	and not part of the interface to cross-platform GDK.
+
+	* gdk/x11/gdkevents-x11.c: Reflect various renamings.
+	
+	* gdk/x11/gdkgc-x11.c: Implement a subclass of GdkGC that's
+	specific to X, and returned by the create_gc virtual method
+	of GdkDrawableImplX11. 
+	(gdk_x11_gc_set_dashes): Change this to take an array of gint8
+	rather than gchar, this was also changed in the GdkGC vtable.
+	(gdk_x11_gc_values_to_xvalues): If GdkGCValues is NULL, or the
+	mask is 0, return immediately, instead of checking every flag.
+	This is faster, and keeps us from segfaulting if values is NULL
+	and the mask contains some nonzero flags.
+
+	* gdk/x11/gdkgeometry-x11.c: deal with all the rearranging of
+	GdkWindow.
+
+	* gdk/x11/gdkglobals-x11.c: change type of grab window, since 
+	GdkWindowPrivate is gone.
+
+	* gdk/x11/gdkim-x11.c: rename things that got renamed.
+
+	* gdk/x11/gdkimage-x11.c: implement in terms of GObject, and 
+	remove the image_put stuff that got transferred to GdkDrawable.
+	
+	* gdk/x11/gdkinput.c: renamings
+
+	* gdk/x11/gdkmain-x11.c: #include <pango/pangox.h>
+
+	* gdk/x11/gdkpixmap-x11.c: GObject conversion
+
+	* gdk/x11/gdkprivate-x11.h: indentation fixes
+
+	* gdk/x11/gdkproperty-x11.c: renamings
+
+	* gdk/x11/gdkselection-x11.c: renamings
+
+	* gdk/x11/gdkwindow-x11.c: Restructuring and renaming; this now 
+	implements the platform-specific "impl" object.
+	Moved gdk_window_get_children to gdk/gdkwindow.c
+
+	* gdk/x11/gdkx.h: Remove all the private structs and private datas
+	that no longer exist. Add declaration of GdkGCX11 object here.
+	Fix all the macros to still work. 
+
+	* gtk/gtk-boxed.defs: Remove GtkStyle, GdkColormap, GdkWindow,
+	GdkDragContext from the boxed types since they are now GObjects.
+
+	* gtk/gtkstyle.h, gtk/gtkstyle.c: Converted GtkStyle to a GObject,
+	moved xthickness/ythickness into the instance. GtkStyleClass
+	functions are now in the standard vtable for GtkStyle, so you have
+	to create a GObject subclass to write a theme engine.
+	(gtk_style_copy): fixed a leaked PangoFontDescription
+	(gtk_style_init): renamed gtk_style_realize, so gtk_style_init
+	can be the standard GObject function.
+	
+	* Throughout GTK:
+	s/style->klass->[xy]thickness/style->[xy]thickness
+	s/pango_layout_unref/g_object_unref/
+
+	* gtk/gtkrc.h, gtk/gtkrc.c: Converted GtkRcStyle to a GObject.
+	
+	* gtk/gtksocket.c: Use gdk_window_get_user_data() instead of 
+	accessing GDK internals.
+
+	* gtk/gtkwidget.c: Use gdk_window_peek_children() instead of 
+	accessing GDK internals.
+
 2000-06-18  Elliot Lee  <sopwith@redhat.com>
 
 	* gtk/gtkwindow.c: Don't allow creation of a window bigger than the screen.
@@ -84,7 +260,7 @@ Mon Jun  5 19:32:53 CEST 2000 Paolo Molaro <lupus@linuxcare.com>
 	* gdk/nanox/gdk*generic*: delete generic region code.
 	* gdk/linux-fb/gdk*generic*: delete generic region code.
 	* README.nanox: update information.
-
+	
 Tue Jun  6 10:53:59 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* gtk/gtktoolbar.c (gtk_toolbar_prepend_widget): Fix to
diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4
index eaaadd5c58..54808d8d1d 100644
--- a/ChangeLog.pre-2-4
+++ b/ChangeLog.pre-2-4
@@ -1,3 +1,179 @@
+2000-06-20  Havoc Pennington  <hp@redhat.com>
+
+	* modules/linux-fb/Makefile.am: Make this compile
+	without framebuffer enabled
+
+	* gdk/linux-fb/Makefile.am: Add conditional to not build
+	framebuffer unless specified in configure
+
+	* gdk/gdkdraw.c (gdk_draw_drawable): Fix bug where I was getting
+	the size of the target instead of source if -1 was passed for
+	width/height
+
+	* gdk/x11/gdkgeometry-x11.c (gdk_window_compute_position): Fix 
+	width/height confusion.
+
+2000-06-19  Havoc Pennington  <hp@redhat.com>
+
+	* gdk/x11/gdkx.h (GDK_WINDOW_XWINDOW): change this to be
+	GDK_DRAWABLE_XID. In the future, we probably want to make it
+	faster with G_DISABLE_CHECKS turned on.
+
+2000-06-14  Havoc Pennington  <hp@redhat.com>
+
+        * gdk/Makefile.am: add gdkpixmap.c
+
+	* gdk/gdk.c: s/gdk_window_init/_gdk_windowing_window_init/
+	s/gdk_image_init/_gdk_windowing_image_init
+
+	* gdk/gdkcolor.c: make ref/unref compat wrappers for GObject
+	ref/unref
+
+	* gdk/gdkcolor.h: make GdkColormap a GObject subclass
+
+	* gdk/gdkcompat.h: remove GdkWindowType compat, since
+	GdkWindowType is now non-deprecated; 
+	change gdk_window_get_type() compat to be
+	gdk_window_get_window_type().
+
+	* gdk/gdkdnd.h: make GdkDragContext a GObject.
+
+	* gdk/gdkdraw.c, gdk/gdkdraw.h: Convert GdkDrawable to a pure
+	virtual GObject. Make all functions call into the vtable.
+	Move gdk_image_put() guts in here. Remove GdkDrawableType
+	and gdk_drawable_get_type(), these are now GdkWindow-specific.
+	draw_image, get_depth, get_size, set_colormap, get_colormap,
+	get_visual added to the vtable.
+	
+	* gdk/gdkgc.h, gdk/gdkgc.c: Convert GdkGC to a pure virtual 
+	GObject. Virtualize everything. 
+	(gdk_gc_new_with_values): remove check for destroyed window,
+	because now GdkWindow::create_gc will check this.
+	(gdk_gc_set_values): New function to set GC values, this 
+	was already implemented but wasn't in the header
+
+	* gdk/gdkimage.h, gdk/gdkimage.c: Convert GdkImage to a GObject.
+
+	* gdk/gdkinternals.h: Remove _gdk_window_alloc(), remove
+	_gdk_window_draw_image(), remove _gdk_windowing_window_class,
+	remove _gdk_window_class; add _gdk_window_impl_get_type() and
+	_gdk_pixmap_impl_get_type(). Rename gdk_window_init to
+	_gdk_windowing_window_init, rename gdk_image_init to
+	_gdk_windowing_image_init.
+	
+	* gdk/gdkpango.c: Reflect GObject-ification of PangoContext.
+	(gdk_draw_layout): Remove check for destroyed window, 
+	because all the drawable methods already check it.
+	
+	* gdk/gdkpixmap.h, gdk/gdkpixmap.c: Convert GdkPixmap to GObject.
+	Add gdkpixmap.c which contains implementation of GdkDrawable
+	virtual table (by chaining to a platform-specific implementation
+	object).
+	
+	* gdk/gdkprivate.h: Remove GDK_IS_WINDOW, GDK_IS_PIXMAP, 
+	GDK_DRAWABLE_DESTROYED. Add GDK_WINDOW_DESTROYED. Replace
+	GDK_DRAWABLE_TYPE with GDK_WINDOW_TYPE. Remove GdkDrawablePrivate,
+	GdkWindowPrivate, GdkImageClass, GdkImagePrivate, GdkGCPrivate,
+	GdkColormapPrivate. 
+
+	* gdk/gdktypes.h: #include <glib-object.h>
+
+	* gdk/gdkwindow.h, gdk/gdkwindow.c: Convert GdkWindow to GObject.
+	Move most functionality to platform-specific implementation
+	object. GdkWindow itself now handles the backing store, then
+	chains to the platform-specific implementation.
+	(gdk_window_get_window_type): return GdkWindowType of the window.
+	(gdk_window_peek_children): New routine, returns the children of 
+	a GdkWindow
+	(gdk_window_get_children): Was in X11-specific code and did 
+	XQueryTree. Changed to simply return a copy of window->children; 
+	so it can go in cross-platform code.
+	
+	* gdk/x11/Makefile.am: fix broken MKINSTALLDIRS path
+
+	* gdk/x11/gdkcolor-x11.c: implement X-specific parts of 
+	GdkColormap; just changed to use the new private data instead
+	of casting to GdkColormapPrivate.
+
+	* gdk/x11/gdkcursor-x11.c: added a couple typechecks to 
+	gdk_cursor_new().
+
+	* gdk/x11/gdkdnd-x11.c: Change the way we access private fields 
+	(private data member in the GObject). 
+	(xdnd_manager_source_filter): Function had broken 
+	error handling, fix it (use gdk_error_trap_push).
+
+	* gdk/x11/gdkdrawable-x11.c: This file now implements
+	a base class for GdkWindowImplX11/GdkPixmapImplX11. This 
+	base class is purely for the convenience of the X port,
+	and not part of the interface to cross-platform GDK.
+
+	* gdk/x11/gdkevents-x11.c: Reflect various renamings.
+	
+	* gdk/x11/gdkgc-x11.c: Implement a subclass of GdkGC that's
+	specific to X, and returned by the create_gc virtual method
+	of GdkDrawableImplX11. 
+	(gdk_x11_gc_set_dashes): Change this to take an array of gint8
+	rather than gchar, this was also changed in the GdkGC vtable.
+	(gdk_x11_gc_values_to_xvalues): If GdkGCValues is NULL, or the
+	mask is 0, return immediately, instead of checking every flag.
+	This is faster, and keeps us from segfaulting if values is NULL
+	and the mask contains some nonzero flags.
+
+	* gdk/x11/gdkgeometry-x11.c: deal with all the rearranging of
+	GdkWindow.
+
+	* gdk/x11/gdkglobals-x11.c: change type of grab window, since 
+	GdkWindowPrivate is gone.
+
+	* gdk/x11/gdkim-x11.c: rename things that got renamed.
+
+	* gdk/x11/gdkimage-x11.c: implement in terms of GObject, and 
+	remove the image_put stuff that got transferred to GdkDrawable.
+	
+	* gdk/x11/gdkinput.c: renamings
+
+	* gdk/x11/gdkmain-x11.c: #include <pango/pangox.h>
+
+	* gdk/x11/gdkpixmap-x11.c: GObject conversion
+
+	* gdk/x11/gdkprivate-x11.h: indentation fixes
+
+	* gdk/x11/gdkproperty-x11.c: renamings
+
+	* gdk/x11/gdkselection-x11.c: renamings
+
+	* gdk/x11/gdkwindow-x11.c: Restructuring and renaming; this now 
+	implements the platform-specific "impl" object.
+	Moved gdk_window_get_children to gdk/gdkwindow.c
+
+	* gdk/x11/gdkx.h: Remove all the private structs and private datas
+	that no longer exist. Add declaration of GdkGCX11 object here.
+	Fix all the macros to still work. 
+
+	* gtk/gtk-boxed.defs: Remove GtkStyle, GdkColormap, GdkWindow,
+	GdkDragContext from the boxed types since they are now GObjects.
+
+	* gtk/gtkstyle.h, gtk/gtkstyle.c: Converted GtkStyle to a GObject,
+	moved xthickness/ythickness into the instance. GtkStyleClass
+	functions are now in the standard vtable for GtkStyle, so you have
+	to create a GObject subclass to write a theme engine.
+	(gtk_style_copy): fixed a leaked PangoFontDescription
+	(gtk_style_init): renamed gtk_style_realize, so gtk_style_init
+	can be the standard GObject function.
+	
+	* Throughout GTK:
+	s/style->klass->[xy]thickness/style->[xy]thickness
+	s/pango_layout_unref/g_object_unref/
+
+	* gtk/gtkrc.h, gtk/gtkrc.c: Converted GtkRcStyle to a GObject.
+	
+	* gtk/gtksocket.c: Use gdk_window_get_user_data() instead of 
+	accessing GDK internals.
+
+	* gtk/gtkwidget.c: Use gdk_window_peek_children() instead of 
+	accessing GDK internals.
+
 2000-06-18  Elliot Lee  <sopwith@redhat.com>
 
 	* gtk/gtkwindow.c: Don't allow creation of a window bigger than the screen.
@@ -84,7 +260,7 @@ Mon Jun  5 19:32:53 CEST 2000 Paolo Molaro <lupus@linuxcare.com>
 	* gdk/nanox/gdk*generic*: delete generic region code.
 	* gdk/linux-fb/gdk*generic*: delete generic region code.
 	* README.nanox: update information.
-
+	
 Tue Jun  6 10:53:59 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* gtk/gtktoolbar.c (gtk_toolbar_prepend_widget): Fix to
diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6
index eaaadd5c58..54808d8d1d 100644
--- a/ChangeLog.pre-2-6
+++ b/ChangeLog.pre-2-6
@@ -1,3 +1,179 @@
+2000-06-20  Havoc Pennington  <hp@redhat.com>
+
+	* modules/linux-fb/Makefile.am: Make this compile
+	without framebuffer enabled
+
+	* gdk/linux-fb/Makefile.am: Add conditional to not build
+	framebuffer unless specified in configure
+
+	* gdk/gdkdraw.c (gdk_draw_drawable): Fix bug where I was getting
+	the size of the target instead of source if -1 was passed for
+	width/height
+
+	* gdk/x11/gdkgeometry-x11.c (gdk_window_compute_position): Fix 
+	width/height confusion.
+
+2000-06-19  Havoc Pennington  <hp@redhat.com>
+
+	* gdk/x11/gdkx.h (GDK_WINDOW_XWINDOW): change this to be
+	GDK_DRAWABLE_XID. In the future, we probably want to make it
+	faster with G_DISABLE_CHECKS turned on.
+
+2000-06-14  Havoc Pennington  <hp@redhat.com>
+
+        * gdk/Makefile.am: add gdkpixmap.c
+
+	* gdk/gdk.c: s/gdk_window_init/_gdk_windowing_window_init/
+	s/gdk_image_init/_gdk_windowing_image_init
+
+	* gdk/gdkcolor.c: make ref/unref compat wrappers for GObject
+	ref/unref
+
+	* gdk/gdkcolor.h: make GdkColormap a GObject subclass
+
+	* gdk/gdkcompat.h: remove GdkWindowType compat, since
+	GdkWindowType is now non-deprecated; 
+	change gdk_window_get_type() compat to be
+	gdk_window_get_window_type().
+
+	* gdk/gdkdnd.h: make GdkDragContext a GObject.
+
+	* gdk/gdkdraw.c, gdk/gdkdraw.h: Convert GdkDrawable to a pure
+	virtual GObject. Make all functions call into the vtable.
+	Move gdk_image_put() guts in here. Remove GdkDrawableType
+	and gdk_drawable_get_type(), these are now GdkWindow-specific.
+	draw_image, get_depth, get_size, set_colormap, get_colormap,
+	get_visual added to the vtable.
+	
+	* gdk/gdkgc.h, gdk/gdkgc.c: Convert GdkGC to a pure virtual 
+	GObject. Virtualize everything. 
+	(gdk_gc_new_with_values): remove check for destroyed window,
+	because now GdkWindow::create_gc will check this.
+	(gdk_gc_set_values): New function to set GC values, this 
+	was already implemented but wasn't in the header
+
+	* gdk/gdkimage.h, gdk/gdkimage.c: Convert GdkImage to a GObject.
+
+	* gdk/gdkinternals.h: Remove _gdk_window_alloc(), remove
+	_gdk_window_draw_image(), remove _gdk_windowing_window_class,
+	remove _gdk_window_class; add _gdk_window_impl_get_type() and
+	_gdk_pixmap_impl_get_type(). Rename gdk_window_init to
+	_gdk_windowing_window_init, rename gdk_image_init to
+	_gdk_windowing_image_init.
+	
+	* gdk/gdkpango.c: Reflect GObject-ification of PangoContext.
+	(gdk_draw_layout): Remove check for destroyed window, 
+	because all the drawable methods already check it.
+	
+	* gdk/gdkpixmap.h, gdk/gdkpixmap.c: Convert GdkPixmap to GObject.
+	Add gdkpixmap.c which contains implementation of GdkDrawable
+	virtual table (by chaining to a platform-specific implementation
+	object).
+	
+	* gdk/gdkprivate.h: Remove GDK_IS_WINDOW, GDK_IS_PIXMAP, 
+	GDK_DRAWABLE_DESTROYED. Add GDK_WINDOW_DESTROYED. Replace
+	GDK_DRAWABLE_TYPE with GDK_WINDOW_TYPE. Remove GdkDrawablePrivate,
+	GdkWindowPrivate, GdkImageClass, GdkImagePrivate, GdkGCPrivate,
+	GdkColormapPrivate. 
+
+	* gdk/gdktypes.h: #include <glib-object.h>
+
+	* gdk/gdkwindow.h, gdk/gdkwindow.c: Convert GdkWindow to GObject.
+	Move most functionality to platform-specific implementation
+	object. GdkWindow itself now handles the backing store, then
+	chains to the platform-specific implementation.
+	(gdk_window_get_window_type): return GdkWindowType of the window.
+	(gdk_window_peek_children): New routine, returns the children of 
+	a GdkWindow
+	(gdk_window_get_children): Was in X11-specific code and did 
+	XQueryTree. Changed to simply return a copy of window->children; 
+	so it can go in cross-platform code.
+	
+	* gdk/x11/Makefile.am: fix broken MKINSTALLDIRS path
+
+	* gdk/x11/gdkcolor-x11.c: implement X-specific parts of 
+	GdkColormap; just changed to use the new private data instead
+	of casting to GdkColormapPrivate.
+
+	* gdk/x11/gdkcursor-x11.c: added a couple typechecks to 
+	gdk_cursor_new().
+
+	* gdk/x11/gdkdnd-x11.c: Change the way we access private fields 
+	(private data member in the GObject). 
+	(xdnd_manager_source_filter): Function had broken 
+	error handling, fix it (use gdk_error_trap_push).
+
+	* gdk/x11/gdkdrawable-x11.c: This file now implements
+	a base class for GdkWindowImplX11/GdkPixmapImplX11. This 
+	base class is purely for the convenience of the X port,
+	and not part of the interface to cross-platform GDK.
+
+	* gdk/x11/gdkevents-x11.c: Reflect various renamings.
+	
+	* gdk/x11/gdkgc-x11.c: Implement a subclass of GdkGC that's
+	specific to X, and returned by the create_gc virtual method
+	of GdkDrawableImplX11. 
+	(gdk_x11_gc_set_dashes): Change this to take an array of gint8
+	rather than gchar, this was also changed in the GdkGC vtable.
+	(gdk_x11_gc_values_to_xvalues): If GdkGCValues is NULL, or the
+	mask is 0, return immediately, instead of checking every flag.
+	This is faster, and keeps us from segfaulting if values is NULL
+	and the mask contains some nonzero flags.
+
+	* gdk/x11/gdkgeometry-x11.c: deal with all the rearranging of
+	GdkWindow.
+
+	* gdk/x11/gdkglobals-x11.c: change type of grab window, since 
+	GdkWindowPrivate is gone.
+
+	* gdk/x11/gdkim-x11.c: rename things that got renamed.
+
+	* gdk/x11/gdkimage-x11.c: implement in terms of GObject, and 
+	remove the image_put stuff that got transferred to GdkDrawable.
+	
+	* gdk/x11/gdkinput.c: renamings
+
+	* gdk/x11/gdkmain-x11.c: #include <pango/pangox.h>
+
+	* gdk/x11/gdkpixmap-x11.c: GObject conversion
+
+	* gdk/x11/gdkprivate-x11.h: indentation fixes
+
+	* gdk/x11/gdkproperty-x11.c: renamings
+
+	* gdk/x11/gdkselection-x11.c: renamings
+
+	* gdk/x11/gdkwindow-x11.c: Restructuring and renaming; this now 
+	implements the platform-specific "impl" object.
+	Moved gdk_window_get_children to gdk/gdkwindow.c
+
+	* gdk/x11/gdkx.h: Remove all the private structs and private datas
+	that no longer exist. Add declaration of GdkGCX11 object here.
+	Fix all the macros to still work. 
+
+	* gtk/gtk-boxed.defs: Remove GtkStyle, GdkColormap, GdkWindow,
+	GdkDragContext from the boxed types since they are now GObjects.
+
+	* gtk/gtkstyle.h, gtk/gtkstyle.c: Converted GtkStyle to a GObject,
+	moved xthickness/ythickness into the instance. GtkStyleClass
+	functions are now in the standard vtable for GtkStyle, so you have
+	to create a GObject subclass to write a theme engine.
+	(gtk_style_copy): fixed a leaked PangoFontDescription
+	(gtk_style_init): renamed gtk_style_realize, so gtk_style_init
+	can be the standard GObject function.
+	
+	* Throughout GTK:
+	s/style->klass->[xy]thickness/style->[xy]thickness
+	s/pango_layout_unref/g_object_unref/
+
+	* gtk/gtkrc.h, gtk/gtkrc.c: Converted GtkRcStyle to a GObject.
+	
+	* gtk/gtksocket.c: Use gdk_window_get_user_data() instead of 
+	accessing GDK internals.
+
+	* gtk/gtkwidget.c: Use gdk_window_peek_children() instead of 
+	accessing GDK internals.
+
 2000-06-18  Elliot Lee  <sopwith@redhat.com>
 
 	* gtk/gtkwindow.c: Don't allow creation of a window bigger than the screen.
@@ -84,7 +260,7 @@ Mon Jun  5 19:32:53 CEST 2000 Paolo Molaro <lupus@linuxcare.com>
 	* gdk/nanox/gdk*generic*: delete generic region code.
 	* gdk/linux-fb/gdk*generic*: delete generic region code.
 	* README.nanox: update information.
-
+	
 Tue Jun  6 10:53:59 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* gtk/gtktoolbar.c (gtk_toolbar_prepend_widget): Fix to
diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8
index eaaadd5c58..54808d8d1d 100644
--- a/ChangeLog.pre-2-8
+++ b/ChangeLog.pre-2-8
@@ -1,3 +1,179 @@
+2000-06-20  Havoc Pennington  <hp@redhat.com>
+
+	* modules/linux-fb/Makefile.am: Make this compile
+	without framebuffer enabled
+
+	* gdk/linux-fb/Makefile.am: Add conditional to not build
+	framebuffer unless specified in configure
+
+	* gdk/gdkdraw.c (gdk_draw_drawable): Fix bug where I was getting
+	the size of the target instead of source if -1 was passed for
+	width/height
+
+	* gdk/x11/gdkgeometry-x11.c (gdk_window_compute_position): Fix 
+	width/height confusion.
+
+2000-06-19  Havoc Pennington  <hp@redhat.com>
+
+	* gdk/x11/gdkx.h (GDK_WINDOW_XWINDOW): change this to be
+	GDK_DRAWABLE_XID. In the future, we probably want to make it
+	faster with G_DISABLE_CHECKS turned on.
+
+2000-06-14  Havoc Pennington  <hp@redhat.com>
+
+        * gdk/Makefile.am: add gdkpixmap.c
+
+	* gdk/gdk.c: s/gdk_window_init/_gdk_windowing_window_init/
+	s/gdk_image_init/_gdk_windowing_image_init
+
+	* gdk/gdkcolor.c: make ref/unref compat wrappers for GObject
+	ref/unref
+
+	* gdk/gdkcolor.h: make GdkColormap a GObject subclass
+
+	* gdk/gdkcompat.h: remove GdkWindowType compat, since
+	GdkWindowType is now non-deprecated; 
+	change gdk_window_get_type() compat to be
+	gdk_window_get_window_type().
+
+	* gdk/gdkdnd.h: make GdkDragContext a GObject.
+
+	* gdk/gdkdraw.c, gdk/gdkdraw.h: Convert GdkDrawable to a pure
+	virtual GObject. Make all functions call into the vtable.
+	Move gdk_image_put() guts in here. Remove GdkDrawableType
+	and gdk_drawable_get_type(), these are now GdkWindow-specific.
+	draw_image, get_depth, get_size, set_colormap, get_colormap,
+	get_visual added to the vtable.
+	
+	* gdk/gdkgc.h, gdk/gdkgc.c: Convert GdkGC to a pure virtual 
+	GObject. Virtualize everything. 
+	(gdk_gc_new_with_values): remove check for destroyed window,
+	because now GdkWindow::create_gc will check this.
+	(gdk_gc_set_values): New function to set GC values, this 
+	was already implemented but wasn't in the header
+
+	* gdk/gdkimage.h, gdk/gdkimage.c: Convert GdkImage to a GObject.
+
+	* gdk/gdkinternals.h: Remove _gdk_window_alloc(), remove
+	_gdk_window_draw_image(), remove _gdk_windowing_window_class,
+	remove _gdk_window_class; add _gdk_window_impl_get_type() and
+	_gdk_pixmap_impl_get_type(). Rename gdk_window_init to
+	_gdk_windowing_window_init, rename gdk_image_init to
+	_gdk_windowing_image_init.
+	
+	* gdk/gdkpango.c: Reflect GObject-ification of PangoContext.
+	(gdk_draw_layout): Remove check for destroyed window, 
+	because all the drawable methods already check it.
+	
+	* gdk/gdkpixmap.h, gdk/gdkpixmap.c: Convert GdkPixmap to GObject.
+	Add gdkpixmap.c which contains implementation of GdkDrawable
+	virtual table (by chaining to a platform-specific implementation
+	object).
+	
+	* gdk/gdkprivate.h: Remove GDK_IS_WINDOW, GDK_IS_PIXMAP, 
+	GDK_DRAWABLE_DESTROYED. Add GDK_WINDOW_DESTROYED. Replace
+	GDK_DRAWABLE_TYPE with GDK_WINDOW_TYPE. Remove GdkDrawablePrivate,
+	GdkWindowPrivate, GdkImageClass, GdkImagePrivate, GdkGCPrivate,
+	GdkColormapPrivate. 
+
+	* gdk/gdktypes.h: #include <glib-object.h>
+
+	* gdk/gdkwindow.h, gdk/gdkwindow.c: Convert GdkWindow to GObject.
+	Move most functionality to platform-specific implementation
+	object. GdkWindow itself now handles the backing store, then
+	chains to the platform-specific implementation.
+	(gdk_window_get_window_type): return GdkWindowType of the window.
+	(gdk_window_peek_children): New routine, returns the children of 
+	a GdkWindow
+	(gdk_window_get_children): Was in X11-specific code and did 
+	XQueryTree. Changed to simply return a copy of window->children; 
+	so it can go in cross-platform code.
+	
+	* gdk/x11/Makefile.am: fix broken MKINSTALLDIRS path
+
+	* gdk/x11/gdkcolor-x11.c: implement X-specific parts of 
+	GdkColormap; just changed to use the new private data instead
+	of casting to GdkColormapPrivate.
+
+	* gdk/x11/gdkcursor-x11.c: added a couple typechecks to 
+	gdk_cursor_new().
+
+	* gdk/x11/gdkdnd-x11.c: Change the way we access private fields 
+	(private data member in the GObject). 
+	(xdnd_manager_source_filter): Function had broken 
+	error handling, fix it (use gdk_error_trap_push).
+
+	* gdk/x11/gdkdrawable-x11.c: This file now implements
+	a base class for GdkWindowImplX11/GdkPixmapImplX11. This 
+	base class is purely for the convenience of the X port,
+	and not part of the interface to cross-platform GDK.
+
+	* gdk/x11/gdkevents-x11.c: Reflect various renamings.
+	
+	* gdk/x11/gdkgc-x11.c: Implement a subclass of GdkGC that's
+	specific to X, and returned by the create_gc virtual method
+	of GdkDrawableImplX11. 
+	(gdk_x11_gc_set_dashes): Change this to take an array of gint8
+	rather than gchar, this was also changed in the GdkGC vtable.
+	(gdk_x11_gc_values_to_xvalues): If GdkGCValues is NULL, or the
+	mask is 0, return immediately, instead of checking every flag.
+	This is faster, and keeps us from segfaulting if values is NULL
+	and the mask contains some nonzero flags.
+
+	* gdk/x11/gdkgeometry-x11.c: deal with all the rearranging of
+	GdkWindow.
+
+	* gdk/x11/gdkglobals-x11.c: change type of grab window, since 
+	GdkWindowPrivate is gone.
+
+	* gdk/x11/gdkim-x11.c: rename things that got renamed.
+
+	* gdk/x11/gdkimage-x11.c: implement in terms of GObject, and 
+	remove the image_put stuff that got transferred to GdkDrawable.
+	
+	* gdk/x11/gdkinput.c: renamings
+
+	* gdk/x11/gdkmain-x11.c: #include <pango/pangox.h>
+
+	* gdk/x11/gdkpixmap-x11.c: GObject conversion
+
+	* gdk/x11/gdkprivate-x11.h: indentation fixes
+
+	* gdk/x11/gdkproperty-x11.c: renamings
+
+	* gdk/x11/gdkselection-x11.c: renamings
+
+	* gdk/x11/gdkwindow-x11.c: Restructuring and renaming; this now 
+	implements the platform-specific "impl" object.
+	Moved gdk_window_get_children to gdk/gdkwindow.c
+
+	* gdk/x11/gdkx.h: Remove all the private structs and private datas
+	that no longer exist. Add declaration of GdkGCX11 object here.
+	Fix all the macros to still work. 
+
+	* gtk/gtk-boxed.defs: Remove GtkStyle, GdkColormap, GdkWindow,
+	GdkDragContext from the boxed types since they are now GObjects.
+
+	* gtk/gtkstyle.h, gtk/gtkstyle.c: Converted GtkStyle to a GObject,
+	moved xthickness/ythickness into the instance. GtkStyleClass
+	functions are now in the standard vtable for GtkStyle, so you have
+	to create a GObject subclass to write a theme engine.
+	(gtk_style_copy): fixed a leaked PangoFontDescription
+	(gtk_style_init): renamed gtk_style_realize, so gtk_style_init
+	can be the standard GObject function.
+	
+	* Throughout GTK:
+	s/style->klass->[xy]thickness/style->[xy]thickness
+	s/pango_layout_unref/g_object_unref/
+
+	* gtk/gtkrc.h, gtk/gtkrc.c: Converted GtkRcStyle to a GObject.
+	
+	* gtk/gtksocket.c: Use gdk_window_get_user_data() instead of 
+	accessing GDK internals.
+
+	* gtk/gtkwidget.c: Use gdk_window_peek_children() instead of 
+	accessing GDK internals.
+
 2000-06-18  Elliot Lee  <sopwith@redhat.com>
 
 	* gtk/gtkwindow.c: Don't allow creation of a window bigger than the screen.
@@ -84,7 +260,7 @@ Mon Jun  5 19:32:53 CEST 2000 Paolo Molaro <lupus@linuxcare.com>
 	* gdk/nanox/gdk*generic*: delete generic region code.
 	* gdk/linux-fb/gdk*generic*: delete generic region code.
 	* README.nanox: update information.
-
+	
 Tue Jun  6 10:53:59 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* gtk/gtktoolbar.c (gtk_toolbar_prepend_widget): Fix to
diff --git a/gdk/Makefile.am b/gdk/Makefile.am
index 6f23194a3a..168750d0bd 100644
--- a/gdk/Makefile.am
+++ b/gdk/Makefile.am
@@ -74,6 +74,7 @@ gdk_public_h_sources = @STRIP_BEGIN@ \
 	gdkvisual.h	\
 	gdkwindow.h	\
 @STRIP_END@
+
 gdk_c_sources = @STRIP_BEGIN@ 	\
 	gdk.c			\
 	gdkcolor.c		\
@@ -87,6 +88,7 @@ gdk_c_sources = @STRIP_BEGIN@ 	\
 	gdkimage.c		\
 	gdkinternals.h  	\
 	gdkpango.c		\
+	gdkpixmap.c		\
 	gdkpoly-generic.h	\
 	gdkpolyreg-generic.c	\
 	gdkrgb.c		\
diff --git a/gdk/gdk.c b/gdk/gdk.c
index 0e3e93c299..21aaf2624b 100644
--- a/gdk/gdk.c
+++ b/gdk/gdk.c
@@ -312,7 +312,7 @@ gdk_init_check (int    *argc,
 					      gdk_ndebug_keys);
   }
 #endif	/* G_ENABLE_DEBUG */
-
+  
   arg_context = gdk_arg_context_new (NULL);
   gdk_arg_context_add_table (arg_context, gdk_args);
   gdk_arg_context_add_table (arg_context, _gdk_windowing_args);
@@ -336,8 +336,8 @@ gdk_init_check (int    *argc,
   
   gdk_events_init ();
   gdk_visual_init ();
-  gdk_window_init ();
-  gdk_image_init ();
+  _gdk_windowing_window_init ();
+  _gdk_windowing_image_init ();
   gdk_input_init ();
   gdk_dnd_init ();
 
diff --git a/gdk/gdkcolor.c b/gdk/gdkcolor.c
index e06bc400a8..fc53956d73 100644
--- a/gdk/gdkcolor.c
+++ b/gdk/gdkcolor.c
@@ -32,37 +32,21 @@
 GdkColormap*
 gdk_colormap_ref (GdkColormap *cmap)
 {
-  GdkColormapPrivate *private = (GdkColormapPrivate *)cmap;
-
-  g_return_val_if_fail (cmap != NULL, NULL);
-
-  private->ref_count += 1;
-  return cmap;
+  return (GdkColormap *) g_object_ref (G_OBJECT (cmap));
 }
 
 void
 gdk_colormap_unref (GdkColormap *cmap)
 {
-  GdkColormapPrivate *private = (GdkColormapPrivate *)cmap;
-
-  g_return_if_fail (cmap != NULL);
-  g_return_if_fail (private->ref_count > 0);
-
-  private->ref_count -= 1;
-  if (private->ref_count == 0)
-    _gdk_colormap_real_destroy (cmap);
+  g_object_unref (G_OBJECT (cmap));
 }
 
 GdkVisual *
 gdk_colormap_get_visual (GdkColormap *colormap)
 {
-  GdkColormapPrivate *private;
-
-  g_return_val_if_fail (colormap != NULL, NULL);
-  
-  private = (GdkColormapPrivate *)colormap;
+  g_return_val_if_fail (GDK_IS_COLORMAP (colormap), NULL);
 
-  return private->visual;
+  return colormap->visual;
 }
      
 void
diff --git a/gdk/gdkcolor.h b/gdk/gdkcolor.h
index d2af35266a..f7ab3ff5da 100644
--- a/gdk/gdkcolor.h
+++ b/gdk/gdkcolor.h
@@ -24,12 +24,38 @@ struct _GdkColor
 
 /* The colormap type.
  */
+
+typedef struct _GdkColormapClass GdkColormapClass;
+
+#define GDK_TYPE_COLORMAP              (gdk_colormap_get_type ())
+#define GDK_COLORMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_COLORMAP, GdkColormap))
+#define GDK_COLORMAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_COLORMAP, GdkColormapClass))
+#define GDK_IS_COLORMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_COLORMAP))
+#define GDK_IS_COLORMAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_COLORMAP))
+#define GDK_COLORMAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_COLORMAP, GdkColormapClass))
+
+
 struct _GdkColormap
 {
+  GObject parent_instance;
+
+  /*< public >*/
   gint      size;
   GdkColor *colors;
+
+  /*< private >*/
+  GdkVisual *visual;
+  
+  gpointer windowing_data;
+};
+
+struct _GdkColormapClass
+{
+  GObjectClass parent_class;
+
 };
 
+GType        gdk_colormap_get_type (void);
 
 GdkColormap* gdk_colormap_new	  (GdkVisual   *visual,
 				   gboolean	allocate);
diff --git a/gdk/gdkcompat.h b/gdk/gdkcompat.h
index b078370869..742f0082d1 100644
--- a/gdk/gdkcompat.h
+++ b/gdk/gdkcompat.h
@@ -11,13 +11,11 @@ extern "C" {
  */
 #ifndef	GDK_DISABLE_COMPAT_H
 
-#define GdkWindowType                  GdkDrawableType
-
 #define gdk_draw_pixmap                gdk_draw_drawable
 #define gdk_draw_bitmap                gdk_draw_drawable
 
 #define gdk_window_get_size            gdk_drawable_get_size
-#define gdk_window_get_type            gdk_drawable_get_type
+#define gdk_window_get_type            gdk_window_get_window_type
 #define gdk_window_get_colormap        gdk_drawable_get_colormap
 #define gdk_window_set_colormap        gdk_drawable_set_colormap
 #define gdk_window_get_visual          gdk_drawable_get_visual
diff --git a/gdk/gdkdnd.h b/gdk/gdkdnd.h
index 657e00c820..803872b9c1 100644
--- a/gdk/gdkdnd.h
+++ b/gdk/gdkdnd.h
@@ -31,10 +31,24 @@ typedef enum
   GDK_DRAG_PROTO_LOCAL            /* Intra-app */
 } GdkDragProtocol;
 
-/* Structure that holds information about a drag in progress.
+/* Object that holds information about a drag in progress.
  * this is used on both source and destination sides.
  */
+
+typedef struct _GdkDragContextClass GdkDragContextClass;
+
+#define GDK_TYPE_DRAG_CONTEXT              (gdk_drag_context_get_type ())
+#define GDK_DRAG_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAG_CONTEXT, GdkDragContext))
+#define GDK_DRAG_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DRAG_CONTEXT, GdkDragContextClass))
+#define GDK_IS_DRAG_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAG_CONTEXT))
+#define GDK_IS_DRAG_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DRAG_CONTEXT))
+#define GDK_DRAG_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DRAG_CONTEXT, GdkDragContextClass))
+
 struct _GdkDragContext {
+  GObject parent_instance;
+
+  /*< public >*/
+  
   GdkDragProtocol protocol;
   
   gboolean is_source;
@@ -48,10 +62,21 @@ struct _GdkDragContext {
   GdkDragAction action; 
 
   guint32 start_time;
+
+  /*< private >*/
+  
+  gpointer windowing_data;
+};
+
+struct _GdkDragContextClass {
+  GObjectClass parent_class;
+
+  
 };
 
 /* Drag and Drop */
 
+GType            gdk_drag_context_get_type   (void);
 GdkDragContext * gdk_drag_context_new        (void);
 void             gdk_drag_context_ref        (GdkDragContext *context);
 void             gdk_drag_context_unref      (GdkDragContext *context);
diff --git a/gdk/gdkdraw.c b/gdk/gdkdraw.c
index ceb3db0d1b..8503035df8 100644
--- a/gdk/gdkdraw.c
+++ b/gdk/gdkdraw.c
@@ -28,54 +28,59 @@
 #include "gdkinternals.h"
 #include "gdkwindow.h"
 
-/* Manipulation of drawables
- */
-GdkDrawable *
-gdk_drawable_alloc (void)
+GType
+gdk_drawable_get_type (void)
 {
-  GdkDrawablePrivate *private = g_new (GdkDrawablePrivate, 1);
-  GdkDrawable *drawable = (GdkDrawable*) private;
-  
-  drawable->user_data = NULL;
-
-  private->ref_count = 1;
-  private->destroyed = FALSE;
-  private->klass = NULL;
-  private->klass_data = NULL;
-  private->window_type = GDK_WINDOW_CHILD;
-
-  private->width = 1;
-  private->height = 1;
-
-  private->depth = 0;
-
-  private->colormap = NULL;
+  static GType object_type = 0;
 
-  return drawable;
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkDrawableClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) NULL,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkDrawable),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) NULL,
+      };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "GdkDrawable",
+                                            &object_info);
+    }  
+
+  return object_type;
 }
 
+/* Manipulation of drawables
+ */
+
 void          
 gdk_drawable_set_data (GdkDrawable   *drawable,
 		       const gchar   *key,
 		       gpointer	      data,
 		       GDestroyNotify destroy_func)
 {
-  g_dataset_set_data_full (drawable, key, data, destroy_func);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  
+  g_object_set_qdata_full (G_OBJECT (drawable),
+                           g_quark_from_string (key),
+                           data,
+                           destroy_func);
 }
 
 gpointer
 gdk_drawable_get_data (GdkDrawable   *drawable,
 		       const gchar   *key)
 {
-  return g_dataset_get_data (drawable, key);
-}
-
-GdkDrawableType
-gdk_drawable_get_type (GdkDrawable *drawable)
-{
-  g_return_val_if_fail (drawable != NULL, (GdkDrawableType) -1);
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
   
-  return GDK_DRAWABLE_TYPE (drawable);
+  return g_object_get_qdata (G_OBJECT (drawable),
+                             g_quark_try_string (key));
 }
 
 void
@@ -83,63 +88,56 @@ gdk_drawable_get_size (GdkDrawable *drawable,
 		       gint        *width,
 		       gint        *height)
 {
-  GdkDrawablePrivate *drawable_private;
-  
-  g_return_if_fail (drawable != NULL);
-  
-  drawable_private = (GdkDrawablePrivate*) drawable;
-  
-  if (width)
-    *width = drawable_private->width;
-  if (height)
-    *height = drawable_private->height;
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+
+  GDK_DRAWABLE_GET_CLASS (drawable)->get_size (drawable, width, height);  
 }
 
 GdkVisual*
 gdk_drawable_get_visual (GdkDrawable *drawable)
 {
-  GdkColormap *colormap;
-
-  g_return_val_if_fail (drawable != NULL, NULL);
-
-  colormap = gdk_drawable_get_colormap (drawable);
-  return colormap ? gdk_colormap_get_visual (colormap) : NULL;
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
+  
+  return GDK_DRAWABLE_GET_CLASS (drawable)->get_visual (drawable);
 }
 
 gint
 gdk_drawable_get_depth (GdkDrawable *drawable)
 {
-  GdkDrawablePrivate *private = (GdkDrawablePrivate *)drawable;
-  g_return_val_if_fail (drawable != NULL, 0);
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), 0);
 
-  return private->depth;
+  return GDK_DRAWABLE_GET_CLASS (drawable)->get_depth (drawable);
+}
+
+void
+gdk_drawable_set_colormap (GdkDrawable *drawable,
+                           GdkColormap *cmap)
+{
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+
+  GDK_DRAWABLE_GET_CLASS (drawable)->set_colormap (drawable, cmap);
+}
+
+GdkColormap*
+gdk_drawable_get_colormap (GdkDrawable *drawable)
+{
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
+
+  return GDK_DRAWABLE_GET_CLASS (drawable)->get_colormap (drawable);
 }
 
 GdkDrawable*
 gdk_drawable_ref (GdkDrawable *drawable)
 {
-  GdkDrawablePrivate *private = (GdkDrawablePrivate *)drawable;
-  g_return_val_if_fail (drawable != NULL, NULL);
-  
-  private->ref_count += 1;
-  return drawable;
+  return (GdkDrawable *) g_object_ref (G_OBJECT (drawable));
 }
 
 void
 gdk_drawable_unref (GdkDrawable *drawable)
 {
-  GdkDrawablePrivate *private = (GdkDrawablePrivate *)drawable;
-  
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (private->ref_count > 0);
-  
-  private->ref_count -= 1;
-  if (private->ref_count == 0)
-    {
-      private->klass->destroy (drawable);
-      g_dataset_destroy (drawable);
-      g_free (drawable);
-    }
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+
+  g_object_unref (G_OBJECT (drawable));
 }
 
 /* Drawing
@@ -150,20 +148,15 @@ gdk_draw_point (GdkDrawable *drawable,
                 gint         x,
                 gint         y)
 {
-  GdkGCPrivate *gc_private;
   GdkPoint point;
 
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (gc != NULL);
-
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-  gc_private = (GdkGCPrivate*) gc;
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
 
   point.x = x;
   point.y = y;
   
-  ((GdkDrawablePrivate *)drawable)->klass->draw_points (drawable, gc, &point, 1);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_points (drawable, gc, &point, 1);
 }
 
 void
@@ -174,21 +167,18 @@ gdk_draw_line (GdkDrawable *drawable,
 	       gint         x2,
 	       gint         y2)
 {
-  GdkGCPrivate *gc_private;
   GdkSegment segment;
 
   g_return_if_fail (drawable != NULL);
   g_return_if_fail (gc != NULL);
-
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-  gc_private = (GdkGCPrivate*) gc;
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
 
   segment.x1 = x1;
   segment.y1 = y1;
   segment.x2 = x2;
   segment.y2 = y2;
-  ((GdkDrawablePrivate *)drawable)->klass->draw_segments (drawable, gc, &segment, 1);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_segments (drawable, gc, &segment, 1);
 }
 
 void
@@ -199,23 +189,25 @@ gdk_draw_rectangle (GdkDrawable *drawable,
 		    gint         y,
 		    gint         width,
 		    gint         height)
-{
-  GdkDrawablePrivate *drawable_private;
-
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (gc != NULL);
+{  
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  drawable_private = (GdkDrawablePrivate*) drawable;
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-
-  if (width < 0)
-    width = drawable_private->width;
-  if (height < 0)
-    height = drawable_private->height;
+  if (width < 0 || height < 0)
+    {
+      gint real_width;
+      gint real_height;
+      
+      gdk_drawable_get_size (drawable, &real_width, &real_height);
+
+      if (width < 0)
+        width = real_width;
+      if (height < 0)
+        height = real_height;
+    }
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_rectangle (drawable, gc, filled, x, y,
-							   width, height);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_rectangle (drawable, gc, filled, x, y,
+                                                     width, height);
 }
 
 void
@@ -228,25 +220,25 @@ gdk_draw_arc (GdkDrawable *drawable,
 	      gint         height,
 	      gint         angle1,
 	      gint         angle2)
-{
-  GdkDrawablePrivate *drawable_private;
-  GdkGCPrivate *gc_private;
+{  
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (gc != NULL);
-
-  drawable_private = (GdkDrawablePrivate*) drawable;
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-  gc_private = (GdkGCPrivate*) gc;
-
-  if (width < 0)
-    width = drawable_private->width;
-  if (height < 0)
-    height = drawable_private->height;
+  if (width < 0 || height < 0)
+    {
+      gint real_width;
+      gint real_height;
+      
+      gdk_drawable_get_size (drawable, &real_width, &real_height);
+
+      if (width < 0)
+        width = real_width;
+      if (height < 0)
+        height = real_height;
+    }
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_arc (drawable, gc, filled,
-						     x, y, width, height, angle1, angle2);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_arc (drawable, gc, filled,
+                                               x, y, width, height, angle1, angle2);
 }
 
 void
@@ -256,14 +248,11 @@ gdk_draw_polygon (GdkDrawable *drawable,
 		  GdkPoint    *points,
 		  gint         npoints)
 {
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (gc != NULL);
-
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_polygon (drawable, gc, filled,
-							 points, npoints);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_polygon (drawable, gc, filled,
+                                                   points, npoints);
 }
 
 /* gdk_draw_string
@@ -298,12 +287,12 @@ gdk_draw_text (GdkDrawable *drawable,
 	       const gchar *text,
 	       gint         text_length)
 {
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail (font != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (text != NULL);
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_text (drawable, font, gc, x, y, text, text_length);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_text (drawable, font, gc, x, y, text, text_length);
 }
 
 void
@@ -315,12 +304,12 @@ gdk_draw_text_wc (GdkDrawable	 *drawable,
 		  const GdkWChar *text,
 		  gint		  text_length)
 {
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail (font != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (text != NULL);
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_text_wc (drawable, font, gc, x, y, text, text_length);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_text_wc (drawable, font, gc, x, y, text, text_length);
 }
 
 void
@@ -334,21 +323,26 @@ gdk_draw_drawable (GdkDrawable *drawable,
 		   gint         width,
 		   gint         height)
 {
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail (src != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  if (GDK_DRAWABLE_DESTROYED (drawable) || GDK_DRAWABLE_DESTROYED (src))
-    return;
-
-  if (width == -1)
-    width = ((GdkDrawablePrivate *)src)->width;
-  if (height == -1)
-    height = ((GdkDrawablePrivate *)src)->height;
+  if (width < 0 || height < 0)
+    {
+      gint real_width;
+      gint real_height;
+      
+      gdk_drawable_get_size (src, &real_width, &real_height);
+
+      if (width < 0)
+        width = real_width;
+      if (height < 0)
+        height = real_height;
+    }
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_drawable (drawable, gc, src,
-							  xsrc, ysrc, xdest, ydest,
-							  width, height);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_drawable (drawable, gc, src,
+                                                    xsrc, ysrc, xdest, ydest,
+                                                    width, height);
 }
 
 void
@@ -362,25 +356,17 @@ gdk_draw_image (GdkDrawable *drawable,
 		gint         width,
 		gint         height)
 {
-  GdkImagePrivate *image_private;
-
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail (image != NULL);
-  g_return_if_fail (gc != NULL);
-
-  image_private = (GdkImagePrivate*) image;
+  g_return_if_fail (GDK_IS_GC (gc));
 
   if (width == -1)
     width = image->width;
   if (height == -1)
     height = image->height;
 
-  if (GDK_IS_WINDOW (drawable))
-    _gdk_window_draw_image (drawable, gc, image, xsrc, ysrc,
-			    xdest, ydest, width, height);
-  else
-    image_private->klass->image_put (image, drawable, gc, xsrc, ysrc,
-				     xdest, ydest, width, height);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_image (drawable, gc, image, xsrc, ysrc,
+                                                 xdest, ydest, width, height);
 }
 
 void
@@ -389,18 +375,15 @@ gdk_draw_points (GdkDrawable *drawable,
 		 GdkPoint    *points,
 		 gint         npoints)
 {
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail ((points != NULL) && (npoints > 0));
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (npoints >= 0);
 
   if (npoints == 0)
     return;
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-
-  ((GdkDrawablePrivate *)drawable)->klass->draw_points (drawable, gc, points, npoints);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_points (drawable, gc, points, npoints);
 }
 
 void
@@ -409,19 +392,16 @@ gdk_draw_segments (GdkDrawable *drawable,
 		   GdkSegment  *segs,
 		   gint         nsegs)
 {
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
 
   if (nsegs == 0)
     return;
 
   g_return_if_fail (segs != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (nsegs >= 0);
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-
-  ((GdkDrawablePrivate *)drawable)->klass->draw_segments (drawable, gc, segs, nsegs);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_segments (drawable, gc, segs, nsegs);
 }
 
 void
@@ -431,18 +411,15 @@ gdk_draw_lines (GdkDrawable *drawable,
 		gint         npoints)
 {
 
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail (points != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (npoints >= 0);
 
   if (npoints == 0)
     return;
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-
-  ((GdkDrawablePrivate *)drawable)->klass->draw_lines (drawable, gc, points, npoints);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_lines (drawable, gc, points, npoints);
 }
 
 void
@@ -454,11 +431,11 @@ gdk_draw_glyphs (GdkDrawable      *drawable,
 		 PangoGlyphString *glyphs)
 {
 
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_glyphs (drawable, gc, font, x, y, glyphs);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_glyphs (drawable, gc, font, x, y, glyphs);
 }
+
+
diff --git a/gdk/gdkdrawable.h b/gdk/gdkdrawable.h
index c7a6ef41eb..0091858ef5 100644
--- a/gdk/gdkdrawable.h
+++ b/gdk/gdkdrawable.h
@@ -10,45 +10,22 @@ extern "C" {
 
 typedef struct _GdkDrawableClass GdkDrawableClass;
 
-/* Types of windows.
- *   Root: There is only 1 root window and it is initialized
- *	   at startup. Creating a window of type GDK_WINDOW_ROOT
- *	   is an error.
- *   Toplevel: Windows which interact with the window manager.
- *   Child: Windows which are children of some other type of window.
- *	    (Any other type of window). Most windows are child windows.
- *   Dialog: A special kind of toplevel window which interacts with
- *	     the window manager slightly differently than a regular
- *	     toplevel window. Dialog windows should be used for any
- *	     transient window.
- *   Pixmap: Pixmaps are really just another kind of window which
- *	     doesn't actually appear on the screen. It can't have
- *	     children, either and is really just a convenience so
- *	     that the drawing functions can work on both windows
- *	     and pixmaps transparently. (ie. You shouldn't pass a
- *	     pixmap to any procedure which accepts a window with the
- *	     exception of the drawing functions).
- *   Foreign: A window that actually belongs to another application
- */
-typedef enum
-{
-  GDK_WINDOW_ROOT,
-  GDK_WINDOW_TOPLEVEL,
-  GDK_WINDOW_CHILD,
-  GDK_WINDOW_DIALOG,
-  GDK_WINDOW_TEMP,
-  GDK_DRAWABLE_PIXMAP,
-  GDK_WINDOW_FOREIGN
-} GdkDrawableType;
+#define GDK_TYPE_DRAWABLE              (gdk_drawable_get_type ())
+#define GDK_DRAWABLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAWABLE, GdkDrawable))
+#define GDK_DRAWABLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DRAWABLE, GdkDrawableClass))
+#define GDK_IS_DRAWABLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAWABLE))
+#define GDK_IS_DRAWABLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DRAWABLE))
+#define GDK_DRAWABLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DRAWABLE, GdkDrawableClass))
 
 struct _GdkDrawable
 {
-  gpointer user_data;
+  GObject parent_instance;
 };
  
 struct _GdkDrawableClass 
 {
-  void  (*destroy)       (GdkDrawable    *drawable);
+  GObjectClass parent_class;
+  
   GdkGC *(*create_gc)    (GdkDrawable    *drawable,
 		          GdkGCValues    *values,
 		          GdkGCValuesMask mask);
@@ -108,19 +85,40 @@ struct _GdkDrawableClass
 			  GdkGC        *gc,
 			  GdkPoint     *points,
 			  gint          npoints);
+
   void (*draw_glyphs)    (GdkDrawable      *drawable,
 			  GdkGC	           *gc,
 			  PangoFont        *font,
 			  gint              x,
 			  gint              y,
 			  PangoGlyphString *glyphs);
+
+  void (*draw_image)     (GdkDrawable *drawable,
+                          GdkGC	      *gc,
+                          GdkImage    *image,
+                          gint	       xsrc,
+                          gint	       ysrc,
+                          gint	       xdest,
+                          gint	       ydest,
+                          gint	       width,
+                          gint	       height);
+  
+  gint (*get_depth)      (GdkDrawable  *drawable);
+  void (*get_size)       (GdkDrawable  *drawable,
+                          gint         *width,
+                          gint         *height);
+
+  void (*set_colormap)   (GdkDrawable  *drawable,
+                          GdkColormap  *cmap);
+
+  GdkColormap* (*get_colormap) (GdkDrawable *drawable);
+  GdkVisual*   (*get_visual) (GdkDrawable  *drawable);
 };
 
+GType           gdk_drawable_get_type     (void);
+
 /* Manipulation of drawables
  */
-GdkDrawable *   gdk_drawable_alloc        (void);
-
-GdkDrawableType gdk_drawable_get_type     (GdkDrawable	  *window);
 
 void            gdk_drawable_set_data     (GdkDrawable    *drawable,
 					   const gchar    *key,
@@ -129,7 +127,7 @@ void            gdk_drawable_set_data     (GdkDrawable    *drawable,
 gpointer        gdk_drawable_get_data     (GdkDrawable    *drawable,
 					   const gchar    *key);
 
-void            gdk_drawable_get_size     (GdkWindow	  *drawable,
+void            gdk_drawable_get_size     (GdkDrawable	  *drawable,
 					   gint	          *width,
 					   gint  	  *height);
 void	        gdk_drawable_set_colormap (GdkDrawable	  *drawable,
diff --git a/gdk/gdkgc.c b/gdk/gdkgc.c
index 8eb6eaad46..099ba1cc2b 100644
--- a/gdk/gdkgc.c
+++ b/gdk/gdkgc.c
@@ -29,21 +29,32 @@
 #include "gdkgc.h"
 #include "gdkprivate.h"
 
-GdkGC*
-gdk_gc_alloc (void)
+GType
+gdk_gc_get_type (void)
 {
-  GdkGCPrivate *private;
-
-  private = g_new (GdkGCPrivate, 1);
-  private->ref_count = 1;
-  private->klass = NULL;
-  private->klass_data = NULL;
-  private->clip_x_origin = 0;
-  private->clip_y_origin = 0;
-  private->ts_x_origin = 0;
-  private->ts_y_origin = 0;
-
-  return (GdkGC *)private;
+  static GType object_type = 0;
+
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkGCClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) NULL,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkGC),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) NULL,
+      };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "GdkGC",
+                                            &object_info);
+    }
+  
+  return object_type;
 }
 
 GdkGC*
@@ -51,9 +62,6 @@ gdk_gc_new (GdkDrawable *drawable)
 {
   g_return_val_if_fail (drawable != NULL, NULL);
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return NULL;
-
   return gdk_gc_new_with_values (drawable, NULL, 0);
 }
 
@@ -63,26 +71,24 @@ gdk_gc_new_with_values (GdkDrawable	*drawable,
 			GdkGCValuesMask	 values_mask)
 {
   GdkGC *gc;
-  GdkGCPrivate *private;
 
   g_return_val_if_fail (drawable != NULL, NULL);
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return NULL;
+  gc = GDK_DRAWABLE_GET_CLASS (drawable)->create_gc (drawable,
+                                                     values,
+                                                     values_mask);
 
-  gc = ((GdkDrawablePrivate *)drawable)->klass->create_gc (drawable,
-							   values,
-							   values_mask);
-  private = (GdkGCPrivate *)gc;
+  if (gc == NULL) /* This would mean the drawable was destroyed. */
+    return NULL;
   
   if (values_mask & GDK_GC_CLIP_X_ORIGIN)
-    private->clip_x_origin = values->clip_x_origin;
+    gc->clip_x_origin = values->clip_x_origin;
   if (values_mask & GDK_GC_CLIP_Y_ORIGIN)
-    private->clip_y_origin = values->clip_y_origin;
+    gc->clip_y_origin = values->clip_y_origin;
   if (values_mask & GDK_GC_TS_X_ORIGIN)
-    private->ts_x_origin = values->ts_x_origin;
+    gc->ts_x_origin = values->ts_x_origin;
   if (values_mask & GDK_GC_TS_Y_ORIGIN)
-    private->ts_y_origin = values->ts_y_origin;
+    gc->ts_y_origin = values->ts_y_origin;
 
   return gc;
 }
@@ -90,39 +96,23 @@ gdk_gc_new_with_values (GdkDrawable	*drawable,
 GdkGC *
 gdk_gc_ref (GdkGC *gc)
 {
-  GdkGCPrivate *private = (GdkGCPrivate*) gc;
-
-  g_return_val_if_fail (gc != NULL, NULL);
-  private->ref_count += 1;
-
-  return gc;
+  return (GdkGC *) g_object_ref (G_OBJECT (gc));
 }
 
 void
 gdk_gc_unref (GdkGC *gc)
 {
-  GdkGCPrivate *private = (GdkGCPrivate*) gc;
-  
-  g_return_if_fail (gc != NULL);
-  g_return_if_fail (private->ref_count > 0);
-  
-  private->ref_count--;
-
-  if (private->ref_count == 0)
-    {
-      private->klass->destroy (gc);
-      g_free (private);
-    }
+  g_object_unref (G_OBJECT (gc));
 }
 
 void
 gdk_gc_get_values (GdkGC       *gc,
 		   GdkGCValues *values)
 {
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (values != NULL);
 
-  ((GdkGCPrivate *)gc)->klass->get_values (gc, values);
+  GDK_GC_GET_CLASS (gc)->get_values (gc, values);
 }
 
 void
@@ -130,21 +120,19 @@ gdk_gc_set_values (GdkGC           *gc,
 		   GdkGCValues	   *values,
 		   GdkGCValuesMask  values_mask)
 {
-  GdkGCPrivate *private = (GdkGCPrivate *)gc;
-  
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (values != NULL);
 
   if (values_mask & GDK_GC_CLIP_X_ORIGIN)
-    private->clip_x_origin = values->clip_x_origin;
+    gc->clip_x_origin = values->clip_x_origin;
   if (values_mask & GDK_GC_CLIP_Y_ORIGIN)
-    private->clip_y_origin = values->clip_y_origin;
+    gc->clip_y_origin = values->clip_y_origin;
   if (values_mask & GDK_GC_TS_X_ORIGIN)
-    private->ts_x_origin = values->ts_x_origin;
+    gc->ts_x_origin = values->ts_x_origin;
   if (values_mask & GDK_GC_TS_Y_ORIGIN)
-    private->ts_y_origin = values->ts_y_origin;
+    gc->ts_y_origin = values->ts_y_origin;
   
-  private->klass->set_values (gc, values, values_mask);
+  GDK_GC_GET_CLASS (gc)->set_values (gc, values, values_mask);
 }
 
 void
@@ -153,7 +141,7 @@ gdk_gc_set_foreground (GdkGC	*gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (color != NULL);
 
   values.foreground = *color;
@@ -166,7 +154,7 @@ gdk_gc_set_background (GdkGC	*gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (color != NULL);
 
   values.background = *color;
@@ -179,7 +167,7 @@ gdk_gc_set_font (GdkGC	 *gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (font != NULL);
 
   values.font = font;
@@ -192,7 +180,7 @@ gdk_gc_set_function (GdkGC	 *gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
   values.function = function;
   gdk_gc_set_values (gc, &values, GDK_GC_FUNCTION);
@@ -204,7 +192,7 @@ gdk_gc_set_fill (GdkGC	 *gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
   values.fill = fill;
   gdk_gc_set_values (gc, &values, GDK_GC_FILL);
@@ -216,7 +204,7 @@ gdk_gc_set_tile (GdkGC	   *gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
   values.tile = tile;
   gdk_gc_set_values (gc, &values, GDK_GC_TILE);
@@ -228,7 +216,7 @@ gdk_gc_set_stipple (GdkGC     *gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
   values.stipple = stipple;
   gdk_gc_set_values (gc, &values, GDK_GC_STIPPLE);
@@ -241,7 +229,7 @@ gdk_gc_set_ts_origin (GdkGC *gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
   values.ts_x_origin = x;
   values.ts_y_origin = y;
@@ -257,7 +245,7 @@ gdk_gc_set_clip_origin (GdkGC *gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
   values.clip_x_origin = x;
   values.clip_y_origin = y;
@@ -272,7 +260,7 @@ gdk_gc_set_clip_mask (GdkGC	*gc,
 {
   GdkGCValues values;
   
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   
   values.clip_mask = mask;
   gdk_gc_set_values (gc, &values, GDK_GC_CLIP_MASK);
@@ -285,7 +273,7 @@ gdk_gc_set_subwindow (GdkGC	       *gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
   values.subwindow_mode = mode;
   gdk_gc_set_values (gc, &values, GDK_GC_SUBWINDOW);
@@ -297,7 +285,7 @@ gdk_gc_set_exposures (GdkGC     *gc,
 {
   GdkGCValues values;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
   values.graphics_exposures = exposures;
   gdk_gc_set_values (gc, &values, GDK_GC_EXPOSURES);
@@ -330,8 +318,8 @@ gdk_gc_set_dashes (GdkGC *gc,
 		   gint8  dash_list[],
 		   gint   n)
 {
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (dash_list != NULL);
 
-  ((GdkGCPrivate *)gc)->klass->set_dashes (gc, dash_offset, dash_list, n);
+  GDK_GC_GET_CLASS (gc)->set_dashes (gc, dash_offset, dash_list, n);
 }
diff --git a/gdk/gdkgc.h b/gdk/gdkgc.h
index 95eaa15ad1..4ae317a881 100644
--- a/gdk/gdkgc.h
+++ b/gdk/gdkgc.h
@@ -151,14 +151,27 @@ struct _GdkGCValues
   GdkJoinStyle	    join_style;
 };
 
+#define GDK_TYPE_GC              (gdk_gc_get_type ())
+#define GDK_GC(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_GC, GdkGC))
+#define GDK_GC_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_GC, GdkGCClass))
+#define GDK_IS_GC(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_GC))
+#define GDK_IS_GC_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_GC))
+#define GDK_GC_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_GC, GdkGCClass))
+
 struct _GdkGC
 {
-  gint dummy_var;
+  GObject parent_instance;
+
+  gint clip_x_origin;
+  gint clip_y_origin;
+  gint ts_x_origin;
+  gint ts_y_origin;
 };
 
 struct _GdkGCClass 
 {
-  void (*destroy)        (GdkGC          *gc);
+  GObjectClass parent_class;
+  
   void (*get_values)     (GdkGC          *gc,
 			  GdkGCValues    *values);
   void (*set_values)     (GdkGC          *gc,
@@ -166,23 +179,23 @@ struct _GdkGCClass
 			  GdkGCValuesMask mask);
   void (*set_dashes)     (GdkGC          *gc,
 			  gint	          dash_offset,
-			  gchar           dash_list[],
+			  gint8           dash_list[],
 			  gint            n);
 };
 
 
+GType  gdk_gc_get_type            (void);
 GdkGC *gdk_gc_new		  (GdkDrawable	    *drawable);
-GdkGC *gdk_gc_alloc		  (void);
-
 GdkGC *gdk_gc_new_with_values	  (GdkDrawable	    *drawable,
 				   GdkGCValues	    *values,
 				   GdkGCValuesMask   values_mask);
-void   gdk_gc_init                (GdkGC            *gc,
-				   GdkGCClass       *klass);
 GdkGC *gdk_gc_ref		  (GdkGC	    *gc);
 void   gdk_gc_unref		  (GdkGC	    *gc);
 void   gdk_gc_get_values	  (GdkGC	    *gc,
 				   GdkGCValues	    *values);
+void   gdk_gc_set_values          (GdkGC           *gc,
+                                   GdkGCValues	   *values,
+                                   GdkGCValuesMask  values_mask);
 void   gdk_gc_set_foreground	  (GdkGC	    *gc,
 				   GdkColor	    *color);
 void   gdk_gc_set_background	  (GdkGC	    *gc,
diff --git a/gdk/gdkimage.c b/gdk/gdkimage.c
index 1e82d50df2..7eaf462161 100644
--- a/gdk/gdkimage.c
+++ b/gdk/gdkimage.c
@@ -33,26 +33,13 @@
 GdkImage *
 gdk_image_ref (GdkImage *image)
 {
-  GdkImagePrivate *private = (GdkImagePrivate *)image;
-  
-  g_return_val_if_fail (image != NULL, NULL);
-
-  private->ref_count++;
-
-  return image;
+  return (GdkImage *) g_object_ref (G_OBJECT (image));
 }
 
 void
 gdk_image_unref (GdkImage *image)
 {
-  GdkImagePrivate *private = (GdkImagePrivate *)image;
-  
-  g_return_if_fail (image != NULL);
-  g_return_if_fail (private->ref_count > 0);
+  g_return_if_fail (GDK_IS_IMAGE (image));
 
-  private->ref_count--;
-  if (private->ref_count == 0)
-    private->klass->destroy (image);
+  g_object_unref (G_OBJECT (image));
 }
-
-
diff --git a/gdk/gdkimage.h b/gdk/gdkimage.h
index 1dc8a880cd..ee0154e210 100644
--- a/gdk/gdkimage.h
+++ b/gdk/gdkimage.h
@@ -29,8 +29,19 @@ typedef enum
   GDK_IMAGE_SHARED_PIXMAP
 } GdkImageType;
 
+typedef struct _GdkImageClass GdkImageClass;
+
+#define GDK_TYPE_IMAGE              (gdk_image_get_type ())
+#define GDK_IMAGE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_IMAGE, GdkImage))
+#define GDK_IMAGE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_IMAGE, GdkImageClass))
+#define GDK_IS_IMAGE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_IMAGE))
+#define GDK_IS_IMAGE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_IMAGE))
+#define GDK_IMAGE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_IMAGE, GdkImageClass))
+
 struct _GdkImage
 {
+  GObject parent_instance;
+  
   GdkImageType	type;
   GdkVisual    *visual;	    /* visual used to create the image */
   GdkByteOrder	byte_order;
@@ -40,9 +51,18 @@ struct _GdkImage
   guint16	bpp;	    /* bytes per pixel */
   guint16	bpl;	    /* bytes per line */
   gpointer	mem;
+
+  gpointer windowing_data;
+};
+
+struct _GdkImageClass
+{
+  GObjectClass parent_class;
 };
 
-GdkImage* gdk_image_new_bitmap(GdkVisual     *visual,
+GType     gdk_image_get_type   (void);
+
+GdkImage* gdk_image_new_bitmap (GdkVisual     *visual,
 				gpointer      data,
 				gint          width,
 				gint          height);
@@ -74,7 +94,6 @@ guint32	   gdk_image_get_pixel (GdkImage     *image,
 				gint	      x,
 				gint	      y);
 
-
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/gdk/gdkinternals.h b/gdk/gdkinternals.h
index 925a36ab40..60daff5c5c 100644
--- a/gdk/gdkinternals.h
+++ b/gdk/gdkinternals.h
@@ -129,16 +129,6 @@ void   gdk_im_close		 (void);
 void   gdk_ic_cleanup		 (void);
 #endif /* USE_XIM */
 
-GdkWindow* _gdk_window_alloc             (void);
-void       _gdk_window_draw_image        (GdkDrawable *drawable,
-					  GdkGC       *gc,
-					  GdkImage    *image,
-					  gint         xsrc,
-					  gint         ysrc,
-					  gint         xdest,
-					  gint         ydest,
-					  gint         width,
-					  gint         height);
 void       _gdk_window_destroy           (GdkWindow   *window,
 					  gboolean     foreign_destroy);
 void       _gdk_window_clear_update_area (GdkWindow   *window);
@@ -156,15 +146,6 @@ void _gdk_colormap_real_destroy (GdkColormap *colormap);
 
 void _gdk_cursor_destroy (GdkCursor *cursor);
 
-/* Class supplied by windowing-system-dependent code for GdkWindow.
- */
-extern GdkDrawableClass _gdk_windowing_window_class;
-
-/* Class for covering over windowing-system-dependent and backing-store
- * code for GdkWindow
- */
-extern GdkDrawableClass _gdk_window_class;
-
 extern GdkArgDesc _gdk_windowing_args[];
 gboolean _gdk_windowing_init_check              (int         argc,
 						 char      **argv);
@@ -208,15 +189,19 @@ void _gdk_windowing_window_destroy (GdkWindow *window,
 				    gboolean   recursing,
 				    gboolean   foreign_destroy);
 
+/* Implementation types */
+GType _gdk_window_impl_get_type (void);
+GType _gdk_pixmap_impl_get_type (void);
+
 /************************************
  * Initialization and exit routines *
  ************************************/
 
-void gdk_window_init (void);
+void _gdk_windowing_window_init (void);
 void gdk_visual_init (void);
 void gdk_dnd_init    (void);
 
-void gdk_image_init  (void);
+void _gdk_windowing_image_init  (void);
 void gdk_image_exit  (void);
 
 void gdk_input_init  (void);
diff --git a/gdk/gdkpango.c b/gdk/gdkpango.c
index 521df43149..85c582a466 100644
--- a/gdk/gdkpango.c
+++ b/gdk/gdkpango.c
@@ -48,14 +48,17 @@ gdk_pango_context_destroy (GdkPangoContextInfo *info)
 static GdkPangoContextInfo *
 gdk_pango_context_get_info (PangoContext *context, gboolean create)
 {
-  GdkPangoContextInfo *info = pango_context_get_data (context, GDK_INFO_KEY);
+  GdkPangoContextInfo *info =
+    g_object_get_qdata (G_OBJECT (context),
+                        g_quark_try_string (GDK_INFO_KEY));
   if (!info && create)
     {
       info = g_new (GdkPangoContextInfo, 1);
       info->colormap = NULL;
 
-      pango_context_set_data (context, GDK_INFO_KEY,
-			      info, (GDestroyNotify)gdk_pango_context_destroy);
+      g_object_set_qdata_full (G_OBJECT (context),
+                               g_quark_from_static_string (GDK_INFO_KEY),
+                               info, (GDestroyNotify)gdk_pango_context_destroy);
     }
 
   return info;
@@ -156,9 +159,6 @@ gdk_draw_layout_line (GdkDrawable      *drawable,
   g_return_if_fail (gc != NULL);
   g_return_if_fail (line != NULL);
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-
   context = pango_layout_get_context (line->layout);
   
   pango_layout_line_get_extents (line,NULL, &overall_rect);
@@ -260,11 +260,6 @@ gdk_draw_layout (GdkDrawable     *drawable,
   g_return_if_fail (gc != NULL);
   g_return_if_fail (layout != NULL);
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-
-  g_return_if_fail (layout != NULL);
-
   indent = pango_layout_get_indent (layout);
   width = pango_layout_get_width (layout);
   align = pango_layout_get_alignment (layout);
diff --git a/gdk/gdkpixmap.c b/gdk/gdkpixmap.c
new file mode 100644
index 0000000000..70c825f915
--- /dev/null
+++ b/gdk/gdkpixmap.c
@@ -0,0 +1,411 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#include "gdkpixmap.h"
+#include "gdkinternals.h"
+
+static GdkGC *gdk_pixmap_create_gc      (GdkDrawable     *drawable,
+                                         GdkGCValues     *values,
+                                         GdkGCValuesMask  mask);
+static void   gdk_pixmap_draw_rectangle (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 gint             filled,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void   gdk_pixmap_draw_arc       (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 gint             filled,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height,
+					 gint             angle1,
+					 gint             angle2);
+static void   gdk_pixmap_draw_polygon   (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 gint             filled,
+					 GdkPoint        *points,
+					 gint             npoints);
+static void   gdk_pixmap_draw_text      (GdkDrawable     *drawable,
+					 GdkFont         *font,
+					 GdkGC           *gc,
+					 gint             x,
+					 gint             y,
+					 const gchar     *text,
+					 gint             text_length);
+static void   gdk_pixmap_draw_text_wc   (GdkDrawable     *drawable,
+					 GdkFont         *font,
+					 GdkGC           *gc,
+					 gint             x,
+					 gint             y,
+					 const GdkWChar  *text,
+					 gint             text_length);
+static void   gdk_pixmap_draw_drawable  (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 GdkPixmap       *src,
+					 gint             xsrc,
+					 gint             ysrc,
+					 gint             xdest,
+					 gint             ydest,
+					 gint             width,
+					 gint             height);
+static void   gdk_pixmap_draw_points    (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 GdkPoint        *points,
+					 gint             npoints);
+static void   gdk_pixmap_draw_segments  (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 GdkSegment      *segs,
+					 gint             nsegs);
+static void   gdk_pixmap_draw_lines     (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 GdkPoint        *points,
+					 gint             npoints);
+static void   gdk_pixmap_draw_glyphs    (GdkDrawable      *drawable,
+                                         GdkGC            *gc,
+                                         PangoFont        *font,
+                                         gint              x,
+                                         gint              y,
+                                         PangoGlyphString *glyphs);
+static void   gdk_pixmap_draw_image     (GdkDrawable     *drawable,
+                                         GdkGC           *gc,
+                                         GdkImage        *image,
+                                         gint             xsrc,
+                                         gint             ysrc,
+                                         gint             xdest,
+                                         gint             ydest,
+                                         gint             width,
+                                         gint             height);
+
+static void   gdk_pixmap_real_get_size  (GdkDrawable     *drawable,
+                                         gint            *width,
+                                         gint            *height);
+
+static GdkVisual*   gdk_pixmap_real_get_visual   (GdkDrawable *drawable);
+static gint         gdk_pixmap_real_get_depth    (GdkDrawable *drawable);
+static void         gdk_pixmap_real_set_colormap (GdkDrawable *drawable,
+                                                  GdkColormap *cmap);
+static GdkColormap* gdk_pixmap_real_get_colormap (GdkDrawable *drawable);
+
+static void gdk_pixmap_init       (GdkPixmapObject      *pixmap);
+static void gdk_pixmap_class_init (GdkPixmapObjectClass *klass);
+static void gdk_pixmap_finalize   (GObject              *object);
+
+static gpointer parent_class = NULL;
+
+GType
+gdk_pixmap_get_type (void)
+{
+  static GType object_type = 0;
+
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkPixmapObjectClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_pixmap_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkPixmapObject),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) gdk_pixmap_init,
+      };
+      
+      object_type = g_type_register_static (GDK_TYPE_DRAWABLE,
+                                            "GdkPixmap",
+                                            &object_info);
+    }
+  
+  return object_type;
+}
+
+static void
+gdk_pixmap_init (GdkPixmapObject *pixmap)
+{
+  /* 0-initialization is good for all other fields. */
+  pixmap->impl =
+    GDK_DRAWABLE (g_type_create_instance (_gdk_pixmap_impl_get_type ()));
+}
+
+static void
+gdk_pixmap_class_init (GdkPixmapObjectClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
+  
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->finalize = gdk_pixmap_finalize;
+
+  drawable_class->create_gc = gdk_pixmap_create_gc;
+  drawable_class->draw_rectangle = gdk_pixmap_draw_rectangle;
+  drawable_class->draw_arc = gdk_pixmap_draw_arc;
+  drawable_class->draw_polygon = gdk_pixmap_draw_polygon;
+  drawable_class->draw_text = gdk_pixmap_draw_text;
+  drawable_class->draw_text_wc = gdk_pixmap_draw_text_wc;
+  drawable_class->draw_drawable = gdk_pixmap_draw_drawable;
+  drawable_class->draw_points = gdk_pixmap_draw_points;
+  drawable_class->draw_segments = gdk_pixmap_draw_segments;
+  drawable_class->draw_lines = gdk_pixmap_draw_lines;
+  drawable_class->draw_glyphs = gdk_pixmap_draw_glyphs;
+  drawable_class->draw_image = gdk_pixmap_draw_image;
+  drawable_class->get_depth = gdk_pixmap_real_get_depth;
+  drawable_class->get_size = gdk_pixmap_real_get_size;
+  drawable_class->set_colormap = gdk_pixmap_real_set_colormap;
+  drawable_class->get_colormap = gdk_pixmap_real_get_colormap;
+  drawable_class->get_visual = gdk_pixmap_real_get_visual;
+}
+
+static void
+gdk_pixmap_finalize (GObject *object)
+{
+  GdkPixmapObject *obj = (GdkPixmapObject *) object;
+
+  g_object_unref (G_OBJECT (obj->impl));
+  obj->impl = NULL;
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static GdkGC *
+gdk_pixmap_create_gc (GdkDrawable     *drawable,
+                      GdkGCValues     *values,
+                      GdkGCValuesMask  mask)
+{
+  return gdk_gc_new_with_values (((GdkPixmapObject *) drawable)->impl,
+                                 values, mask);
+}
+
+static void
+gdk_pixmap_draw_rectangle (GdkDrawable *drawable,
+			   GdkGC       *gc,
+			   gint         filled,
+			   gint         x,
+			   gint         y,
+			   gint         width,
+			   gint         height)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_rectangle (private->impl, gc, filled,
+                      x, y, width, height);
+}
+
+static void
+gdk_pixmap_draw_arc (GdkDrawable *drawable,
+		     GdkGC       *gc,
+		     gint         filled,
+		     gint         x,
+		     gint         y,
+		     gint         width,
+		     gint         height,
+		     gint         angle1,
+		     gint         angle2)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_arc (private->impl, gc, filled,
+                x, y,
+                width, height, angle1, angle2);
+}
+
+static void
+gdk_pixmap_draw_polygon (GdkDrawable *drawable,
+			 GdkGC       *gc,
+			 gint         filled,
+			 GdkPoint    *points,
+			 gint         npoints)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_polygon (private->impl, gc, filled, points, npoints);
+}
+
+static void
+gdk_pixmap_draw_text (GdkDrawable *drawable,
+		      GdkFont     *font,
+		      GdkGC       *gc,
+		      gint         x,
+		      gint         y,
+		      const gchar *text,
+		      gint         text_length)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_text (private->impl, font, gc,
+                 x, y, text, text_length);
+}
+
+static void
+gdk_pixmap_draw_text_wc (GdkDrawable    *drawable,
+			 GdkFont        *font,
+			 GdkGC          *gc,
+			 gint            x,
+			 gint            y,
+			 const GdkWChar *text,
+			 gint            text_length)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_text_wc (private->impl, font, gc,
+                    x, y, text, text_length);
+}
+
+static void
+gdk_pixmap_draw_drawable (GdkDrawable *drawable,
+			  GdkGC       *gc,
+			  GdkPixmap   *src,
+			  gint         xsrc,
+			  gint         ysrc,
+			  gint         xdest,
+			  gint         ydest,
+			  gint         width,
+			  gint         height)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_drawable (private->impl, gc, src, xsrc, ysrc,
+                     xdest, ydest,
+                     width, height);
+}
+
+static void
+gdk_pixmap_draw_points (GdkDrawable *drawable,
+			GdkGC       *gc,
+			GdkPoint    *points,
+			gint         npoints)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_points (private->impl, gc, points, npoints);
+}
+
+static void
+gdk_pixmap_draw_segments (GdkDrawable *drawable,
+			  GdkGC       *gc,
+			  GdkSegment  *segs,
+			  gint         nsegs)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_segments (private->impl, gc, segs, nsegs);
+}
+
+static void
+gdk_pixmap_draw_lines (GdkDrawable *drawable,
+		       GdkGC       *gc,
+		       GdkPoint    *points,
+		       gint         npoints)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_lines (private->impl, gc, points, npoints);
+}
+
+static void
+gdk_pixmap_draw_glyphs (GdkDrawable      *drawable,
+                        GdkGC            *gc,
+                        PangoFont        *font,
+                        gint              x,
+                        gint              y,
+                        PangoGlyphString *glyphs)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_glyphs (private->impl, gc, font, x, y, glyphs);
+}
+
+static void
+gdk_pixmap_draw_image (GdkDrawable     *drawable,
+                       GdkGC           *gc,
+                       GdkImage        *image,
+                       gint             xsrc,
+                       gint             ysrc,
+                       gint             xdest,
+                       gint             ydest,
+                       gint             width,
+                       gint             height)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  gdk_draw_image (private->impl, gc, image, xsrc, ysrc, xdest, ydest,
+                  width, height);
+}
+
+static void
+gdk_pixmap_real_get_size (GdkDrawable *drawable,
+                          gint *width,
+                          gint *height)
+{
+  g_return_if_fail (GDK_IS_PIXMAP (drawable));
+
+  gdk_drawable_get_size (GDK_DRAWABLE (((GdkPixmapObject*)drawable)->impl),
+                         width, height);
+}
+
+static GdkVisual*
+gdk_pixmap_real_get_visual (GdkDrawable *drawable)
+{
+  GdkColormap *colormap;
+
+  g_return_val_if_fail (GDK_IS_PIXMAP (drawable), NULL);
+
+  colormap = gdk_drawable_get_colormap (drawable);
+  return colormap ? gdk_colormap_get_visual (colormap) : NULL;
+}
+
+static gint
+gdk_pixmap_real_get_depth (GdkDrawable *drawable)
+{
+  gint depth;
+  
+  g_return_val_if_fail (GDK_IS_PIXMAP (drawable), 0);
+
+  depth = GDK_PIXMAP_OBJECT (drawable)->depth;
+
+  return depth;
+}
+
+static void
+gdk_pixmap_real_set_colormap (GdkDrawable *drawable,
+                              GdkColormap *cmap)
+{
+  g_return_if_fail (GDK_IS_PIXMAP (drawable));  
+  
+  gdk_drawable_set_colormap (((GdkPixmapObject*)drawable)->impl, cmap);
+}
+
+static GdkColormap*
+gdk_pixmap_real_get_colormap (GdkDrawable *drawable)
+{
+  g_return_val_if_fail (GDK_IS_PIXMAP (drawable), NULL);
+  
+  return gdk_drawable_get_colormap (((GdkPixmapObject*)drawable)->impl);
+}
diff --git a/gdk/gdkpixmap.h b/gdk/gdkpixmap.h
index f4807be10f..700d0007cf 100644
--- a/gdk/gdkpixmap.h
+++ b/gdk/gdkpixmap.h
@@ -2,11 +2,40 @@
 #define __GDK_PIXMAP_H__
 
 #include <gdk/gdktypes.h>
+#include <gdk/gdkdrawable.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
+typedef struct _GdkPixmapObject GdkPixmapObject;
+typedef struct _GdkPixmapObjectClass GdkPixmapObjectClass;
+
+#define GDK_TYPE_PIXMAP              (gdk_pixmap_get_type ())
+#define GDK_PIXMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXMAP, GdkPixmap))
+#define GDK_PIXMAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXMAP, GdkPixmapObjectClass))
+#define GDK_IS_PIXMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXMAP))
+#define GDK_IS_PIXMAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXMAP))
+#define GDK_PIXMAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXMAP, GdkPixmapClass))
+#define GDK_PIXMAP_OBJECT(object)    ((GdkPixmapObject *) GDK_PIXMAP (object))
+
+struct _GdkPixmapObject
+{
+  GdkDrawable parent_instance;
+  
+  GdkDrawable *impl;  /* window-system-specific delegate object */
+
+  gint depth;
+};
+
+struct _GdkPixmapObjectClass
+{
+  GdkDrawableClass parent_class;
+
+};
+
+GType      gdk_pixmap_get_type          (void);
+
 /* Pixmaps
  */
 GdkPixmap* gdk_pixmap_new		(GdkWindow  *window,
diff --git a/gdk/gdkprivate.h b/gdk/gdkprivate.h
index f882c35829..3df7bbbf6d 100644
--- a/gdk/gdkprivate.h
+++ b/gdk/gdkprivate.h
@@ -44,111 +44,24 @@ extern "C" {
 #define GDK_PARENT_RELATIVE_BG ((GdkPixmap *)1L)
 #define GDK_NO_BG ((GdkPixmap *)2L)
 
-#define GDK_DRAWABLE_TYPE(d) (((GdkDrawablePrivate *)d)->window_type)
-#define GDK_IS_WINDOW(d) (GDK_DRAWABLE_TYPE(d) <= GDK_WINDOW_TEMP || \
-                          GDK_DRAWABLE_TYPE(d) == GDK_WINDOW_FOREIGN)
-#define GDK_IS_PIXMAP(d) (GDK_DRAWABLE_TYPE(d) == GDK_DRAWABLE_PIXMAP)
-#define GDK_DRAWABLE_DESTROYED(d) (((GdkDrawablePrivate *)d)->destroyed)
-#define GDK_DRAWABLE_P(d) ((GdkDrawablePrivate*)d)
-#define GDK_WINDOW_P(d) ((GdkWindowPrivate*)d)
-#define GDK_GC_P(d) ((GdkGCPrivate*)d)
-
-typedef struct _GdkDrawablePrivate     GdkDrawablePrivate;
-typedef struct _GdkWindowPrivate       GdkWindowPrivate;
-typedef struct _GdkImageClass	       GdkImageClass;
-typedef struct _GdkImagePrivate	       GdkImagePrivate;
-typedef struct _GdkGCPrivate	       GdkGCPrivate;
-typedef struct _GdkColormapPrivate     GdkColormapPrivate;
+#define GDK_WINDOW_TYPE(d) (((GdkWindowObject*)(GDK_WINDOW (d)))->window_type)
+#define GDK_WINDOW_DESTROYED(d) (((GdkWindowObject*)(GDK_WINDOW (d)))->destroyed)
+
+#define gdk_window_lookup(xid)	   ((GdkWindow*) gdk_xid_table_lookup (xid))
+#define gdk_pixmap_lookup(xid)	   ((GdkPixmap*) gdk_xid_table_lookup (xid))
+#define gdk_font_lookup(xid)	   ((GdkFont*) gdk_xid_table_lookup (xid))
+
 typedef struct _GdkColorInfo           GdkColorInfo;
 typedef struct _GdkFontPrivate	       GdkFontPrivate;
 typedef struct _GdkEventFilter	       GdkEventFilter;
 typedef struct _GdkClientFilter	       GdkClientFilter;
 
-struct _GdkDrawablePrivate
-{
-  GdkDrawable drawable;
-  GdkDrawableClass *klass;
-  gpointer klass_data;
-
-  guint ref_count;
-
-  gint width;
-  gint height;
-
-  GdkColormap *colormap;
-
-  guint8 window_type;
-  guint8 depth;
-  
-  guint destroyed : 2;
-};
-
-struct _GdkWindowPrivate
-{
-  GdkDrawablePrivate drawable;
-  
-  GdkWindow *parent;
-  gint x;
-  gint y;
-  guint8 resize_count;
-  guint mapped : 1;
-  guint guffaw_gravity : 1;
-  guint input_only : 1;
-
-  gint extension_events;
-
-  GList *filters;
-  GList *children;
-
-  GdkColor bg_color;
-  GdkPixmap *bg_pixmap;
-  
-  GSList *paint_stack;
-  
-  GdkRegion *update_area;
-  guint update_freeze_count;
-};
-
-struct _GdkImageClass 
-{
-  void (*destroy)   (GdkImage    *image);
-  void (*image_put) (GdkImage	 *image,
-		     GdkDrawable *window,
-		     GdkGC	 *gc,
-		     gint	  xsrc,
-		     gint	  ysrc,
-		     gint	  xdest,
-		     gint	  ydest,
-		     gint	  width,
-		     gint	  height);
-};
-
-struct _GdkImagePrivate
-{
-  GdkImage image;
-
-  guint ref_count;
-  GdkImageClass *klass;
-};
-
 struct _GdkFontPrivate
 {
   GdkFont font;
   guint ref_count;
 };
 
-struct _GdkGCPrivate
-{
-  guint ref_count;
-  GdkGCClass *klass;
-  gpointer klass_data;
-
-  gint clip_x_origin;
-  gint clip_y_origin;
-  gint ts_x_origin;
-  gint ts_y_origin;
-};
-
 typedef enum {
   GDK_COLOR_WRITEABLE = 1 << 0
 } GdkColorInfoFlags;
@@ -159,14 +72,6 @@ struct _GdkColorInfo
   guint ref_count;
 };
 
-struct _GdkColormapPrivate
-{
-  GdkColormap colormap;
-  GdkVisual *visual;
-
-  guint ref_count;
-};
-
 struct _GdkEventFilter {
   GdkFilterFunc function;
   gpointer data;
diff --git a/gdk/gdktypes.h b/gdk/gdktypes.h
index a4055e2d70..91112510fb 100644
--- a/gdk/gdktypes.h
+++ b/gdk/gdktypes.h
@@ -31,6 +31,7 @@
  */
 #include <glib.h>
 #include <pango/pango.h>
+#include <glib-object.h>
 
 #ifdef G_OS_WIN32
 #  ifdef GDK_COMPILATION
diff --git a/gdk/gdkwindow.c b/gdk/gdkwindow.c
index ff25f7f70a..0f4ce13c8c 100644
--- a/gdk/gdkwindow.c
+++ b/gdk/gdkwindow.c
@@ -44,63 +44,61 @@ struct _GdkWindowPaint
   gint x_offset;
   gint y_offset;
 };
-
-static void   gdk_window_draw_destroy   (GdkDrawable     *drawable);
-static GdkGC *gdk_window_draw_create_gc (GdkDrawable     *drawable,
-					 GdkGCValues     *values,
-					 GdkGCValuesMask  mask);
+static GdkGC *gdk_window_create_gc      (GdkDrawable     *drawable,
+                                         GdkGCValues     *values,
+                                         GdkGCValuesMask  mask);
 static void   gdk_window_draw_rectangle (GdkDrawable     *drawable,
-					 GdkGC           *gc,
-					 gint             filled,
-					 gint             x,
-					 gint             y,
-					 gint             width,
-					 gint             height);
+                                         GdkGC           *gc,
+                                         gint             filled,
+                                         gint             x,
+                                         gint             y,
+                                         gint             width,
+                                         gint             height);
 static void   gdk_window_draw_arc       (GdkDrawable     *drawable,
-					 GdkGC           *gc,
-					 gint             filled,
-					 gint             x,
-					 gint             y,
-					 gint             width,
-					 gint             height,
-					 gint             angle1,
-					 gint             angle2);
+                                         GdkGC           *gc,
+                                         gint             filled,
+                                         gint             x,
+                                         gint             y,
+                                         gint             width,
+                                         gint             height,
+                                         gint             angle1,
+                                         gint             angle2);
 static void   gdk_window_draw_polygon   (GdkDrawable     *drawable,
-					 GdkGC           *gc,
-					 gint             filled,
-					 GdkPoint        *points,
-					 gint             npoints);
+                                         GdkGC           *gc,
+                                         gint             filled,
+                                         GdkPoint        *points,
+                                         gint             npoints);
 static void   gdk_window_draw_text      (GdkDrawable     *drawable,
-					 GdkFont         *font,
-					 GdkGC           *gc,
-					 gint             x,
-					 gint             y,
-					 const gchar     *text,
-					 gint             text_length);
+                                         GdkFont         *font,
+                                         GdkGC           *gc,
+                                         gint             x,
+                                         gint             y,
+                                         const gchar     *text,
+                                         gint             text_length);
 static void   gdk_window_draw_text_wc   (GdkDrawable     *drawable,
-					 GdkFont         *font,
-					 GdkGC           *gc,
-					 gint             x,
-					 gint             y,
-					 const GdkWChar  *text,
-					 gint             text_length);
+                                         GdkFont         *font,
+                                         GdkGC           *gc,
+                                         gint             x,
+                                         gint             y,
+                                         const GdkWChar  *text,
+                                         gint             text_length);
 static void   gdk_window_draw_drawable  (GdkDrawable     *drawable,
-					 GdkGC           *gc,
-					 GdkPixmap       *src,
-					 gint             xsrc,
-					 gint             ysrc,
-					 gint             xdest,
-					 gint             ydest,
-					 gint             width,
-					 gint             height);
+                                         GdkGC           *gc,
+                                         GdkPixmap       *src,
+                                         gint             xsrc,
+                                         gint             ysrc,
+                                         gint             xdest,
+                                         gint             ydest,
+                                         gint             width,
+                                         gint             height);
 static void   gdk_window_draw_points    (GdkDrawable     *drawable,
-					 GdkGC           *gc,
-					 GdkPoint        *points,
-					 gint             npoints);
+                                         GdkGC           *gc,
+                                         GdkPoint        *points,
+                                         gint             npoints);
 static void   gdk_window_draw_segments  (GdkDrawable     *drawable,
-					 GdkGC           *gc,
-					 GdkSegment      *segs,
-					 gint             nsegs);
+                                         GdkGC           *gc,
+                                         GdkSegment      *segs,
+                                         gint             nsegs);
 static void   gdk_window_draw_lines     (GdkDrawable     *drawable,
 					 GdkGC           *gc,
 					 GdkPoint        *points,
@@ -112,74 +110,131 @@ static void   gdk_window_draw_glyphs    (GdkDrawable      *drawable,
 					 gint              y,
 					 PangoGlyphString *glyphs);
 
+static void   gdk_window_draw_image     (GdkDrawable     *drawable,
+                                         GdkGC           *gc,
+                                         GdkImage        *image,
+                                         gint             xsrc,
+                                         gint             ysrc,
+                                         gint             xdest,
+                                         gint             ydest,
+                                         gint             width,
+                                         gint             height);
+
+
+static void   gdk_window_real_get_size  (GdkDrawable     *drawable,
+                                         gint            *width,
+                                         gint            *height);
+
+static GdkVisual*   gdk_window_real_get_visual   (GdkDrawable *drawable);
+static gint         gdk_window_real_get_depth    (GdkDrawable *drawable);
+static void         gdk_window_real_set_colormap (GdkDrawable *drawable,
+                                             GdkColormap *cmap);
+static GdkColormap* gdk_window_real_get_colormap (GdkDrawable *drawable);
+     
 static void gdk_window_free_paint_stack (GdkWindow *window);
 
-/* All drawing operations on windows are forwarded through the following
- * class to enable the automatic-backing-store feature.
- */
-GdkDrawableClass _gdk_window_class = {
-  gdk_window_draw_destroy,
-  gdk_window_draw_create_gc,
-  gdk_window_draw_rectangle,
-  gdk_window_draw_arc,
-  gdk_window_draw_polygon,
-  gdk_window_draw_text,
-  gdk_window_draw_text_wc,
-  gdk_window_draw_drawable,
-  gdk_window_draw_points,
-  gdk_window_draw_segments,
-  gdk_window_draw_lines,
-  gdk_window_draw_glyphs,
-};
+static void gdk_window_init       (GdkWindowObject      *window);
+static void gdk_window_class_init (GdkWindowObjectClass *klass);
+static void gdk_window_finalize   (GObject              *object);
 
-GdkWindow *
-_gdk_window_alloc (void)
+static gpointer parent_class = NULL;
+
+GType
+gdk_window_object_get_type (void)
 {
-  GdkWindowPrivate *private = g_new (GdkWindowPrivate, 1);
-  GdkWindow *window = (GdkWindow*) private;
-  
-  window->user_data = NULL;
+  static GType object_type = 0;
 
-  private->drawable.ref_count = 1;
-  private->drawable.destroyed = FALSE;
-  private->drawable.klass = NULL;
-  private->drawable.klass_data = NULL;
-  private->drawable.window_type = GDK_WINDOW_CHILD;
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkWindowObjectClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_window_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkWindowObject),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) gdk_window_init,
+      };
+      
+      object_type = g_type_register_static (GDK_TYPE_DRAWABLE,
+                                            "GdkWindow",
+                                            &object_info);
+    }
+  
+  return object_type;
+}
 
-  private->drawable.width = 1;
-  private->drawable.height = 1;
+static void
+gdk_window_init (GdkWindowObject *window)
+{
+  /* 0-initialization is good for all other fields. */
 
-  private->drawable.colormap = NULL;
+  window->window_type = GDK_WINDOW_CHILD;
 
-  private->parent = NULL;
-  private->x = 0;
-  private->y = 0;
-  private->resize_count = 0;
+  window->impl =
+    GDK_DRAWABLE (g_type_create_instance (_gdk_window_impl_get_type ()));
+}
 
-  private->mapped = FALSE;
-  private->guffaw_gravity = FALSE;
-  private->extension_events = FALSE;
+static void
+gdk_window_class_init (GdkWindowObjectClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
   
-  private->filters = NULL;
-  private->children = NULL;
-
-  private->bg_color.pixel = 0;
-  private->bg_color.red = 0;
-  private->bg_color.green = 0;
-  private->bg_color.blue = 0;
-
-  private->bg_pixmap = NULL;
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->finalize = gdk_window_finalize;
+
+  drawable_class->create_gc = gdk_window_create_gc;
+  drawable_class->draw_rectangle = gdk_window_draw_rectangle;
+  drawable_class->draw_arc = gdk_window_draw_arc;
+  drawable_class->draw_polygon = gdk_window_draw_polygon;
+  drawable_class->draw_text = gdk_window_draw_text;
+  drawable_class->draw_text_wc = gdk_window_draw_text_wc;
+  drawable_class->draw_drawable = gdk_window_draw_drawable;
+  drawable_class->draw_points = gdk_window_draw_points;
+  drawable_class->draw_segments = gdk_window_draw_segments;
+  drawable_class->draw_lines = gdk_window_draw_lines;
+  drawable_class->draw_glyphs = gdk_window_draw_glyphs;
+  drawable_class->draw_image = gdk_window_draw_image;
+  drawable_class->get_depth = gdk_window_real_get_depth;
+  drawable_class->get_size = gdk_window_real_get_size;
+  drawable_class->set_colormap = gdk_window_real_set_colormap;
+  drawable_class->get_colormap = gdk_window_real_get_colormap;
+  drawable_class->get_visual = gdk_window_real_get_visual;
+}
 
-  private->paint_stack = NULL;
+static void
+gdk_window_finalize (GObject *object)
+{
+  GdkWindow *window = GDK_WINDOW (object);
+  GdkWindowObject *obj = (GdkWindowObject *) object;
+  
+  if (!GDK_WINDOW_DESTROYED (window))
+    {
+      if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
+	{
+	  g_warning ("losing last reference to undestroyed window\n");
+	  _gdk_window_destroy (window, FALSE);
+	}
+      else
+	/* We use TRUE here, to keep us from actually calling
+	 * XDestroyWindow() on the window
+	 */
+	_gdk_window_destroy (window, TRUE);
+    }
 
-  private->update_area = NULL;
-  private->update_freeze_count = 0;
+  g_object_unref (G_OBJECT (obj->impl));
+  obj->impl = NULL;
   
-  return window;
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 /**
- * _gdk_window_destroy_heirarchy:
+ * _gdk_window_destroy_hierarchy:
  * @window: a #GdkWindow
  * @recursing: If TRUE, then this is being called because a parent
  *            was destroyed. This generally means that the call to the windowing system
@@ -195,37 +250,37 @@ _gdk_window_alloc (void)
  * drop the reference count created by gdk_window_new().
  **/
 static void
-_gdk_window_destroy_heirarchy (GdkWindow *window,
+_gdk_window_destroy_hierarchy (GdkWindow *window,
 			       gboolean   recursing,
 			       gboolean   foreign_destroy)
 {
-  GdkWindowPrivate *private;
-  GdkWindowPrivate *temp_private;
+  GdkWindowObject *private;
+  GdkWindowObject *temp_private;
   GdkWindow *temp_window;
   GList *children;
   GList *tmp;
   
   g_return_if_fail (window != NULL);
   
-  private = (GdkWindowPrivate*) window;
+  private = (GdkWindowObject*) window;
   
-  switch (private->drawable.window_type)
+  switch (GDK_WINDOW_TYPE (window))
     {
     case GDK_WINDOW_TOPLEVEL:
     case GDK_WINDOW_CHILD:
     case GDK_WINDOW_DIALOG:
     case GDK_WINDOW_TEMP:
     case GDK_WINDOW_FOREIGN:
-      if (!GDK_DRAWABLE_DESTROYED (window))
+      if (!GDK_WINDOW_DESTROYED (window))
 	{
 	  private->mapped = FALSE;
-	  private->drawable.destroyed = TRUE;
+	  private->destroyed = TRUE;
 	  
 	  _gdk_windowing_window_destroy (window, recursing, foreign_destroy);
 
 	  if (private->parent)
 	    {
-	      GdkWindowPrivate *parent_private = (GdkWindowPrivate *)private->parent;
+	      GdkWindowObject *parent_private = (GdkWindowObject *)private->parent;
 	      if (parent_private->children)
 		parent_private->children = g_list_remove (parent_private->children, window);
 	    }
@@ -239,7 +294,7 @@ _gdk_window_destroy_heirarchy (GdkWindow *window,
 	      private->bg_pixmap = NULL;
 	    }
 	  
-	  if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_FOREIGN)
+	  if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
 	    {
 	      children = tmp = private->children;
 	      private->children = NULL;
@@ -249,9 +304,9 @@ _gdk_window_destroy_heirarchy (GdkWindow *window,
 		  temp_window = tmp->data;
 		  tmp = tmp->next;
 		  
-		  temp_private = (GdkWindowPrivate*) temp_window;
+		  temp_private = (GdkWindowObject*) temp_window;
 		  if (temp_private)
-		    _gdk_window_destroy_heirarchy (temp_window, TRUE, foreign_destroy);
+		    _gdk_window_destroy_hierarchy (temp_window, TRUE, foreign_destroy);
 		}
 	      
 	      g_list_free (children);
@@ -270,22 +325,14 @@ _gdk_window_destroy_heirarchy (GdkWindow *window,
 	      g_list_free (private->filters);
 	      private->filters = NULL;
 	    }
-	  
-	  if (private->drawable.colormap)
-	    {
-	      gdk_colormap_unref (private->drawable.colormap);
-	      private->drawable.colormap = NULL;
-	    }
+
+          gdk_drawable_set_colormap (GDK_DRAWABLE (window), NULL);
 	}
       break;
       
     case GDK_WINDOW_ROOT:
       g_error ("attempted to destroy root window");
       break;
-      
-    case GDK_WINDOW_PIXMAP:
-      g_error ("called gdk_window_destroy on a pixmap (use gdk_pixmap_unref)");
-      break;
     }
 }
 
@@ -304,13 +351,13 @@ void
 _gdk_window_destroy (GdkWindow *window,
 		     gboolean   foreign_destroy)
 {
-  _gdk_window_destroy_heirarchy (window, FALSE, foreign_destroy);
+  _gdk_window_destroy_hierarchy (window, FALSE, foreign_destroy);
 }
 
 void
 gdk_window_destroy (GdkWindow *window)
 {
-  _gdk_window_destroy_heirarchy (window, FALSE, FALSE);
+  _gdk_window_destroy_hierarchy (window, FALSE, FALSE);
   gdk_drawable_unref (window);
 }
 
@@ -320,7 +367,7 @@ gdk_window_set_user_data (GdkWindow *window,
 {
   g_return_if_fail (window != NULL);
   
-  window->user_data = user_data;
+  ((GdkWindowObject*)window)->user_data = user_data;
 }
 
 void
@@ -329,7 +376,15 @@ gdk_window_get_user_data (GdkWindow *window,
 {
   g_return_if_fail (window != NULL);
   
-  *data = window->user_data;
+  *data = ((GdkWindowObject*)window)->user_data;
+}
+
+GdkWindowType
+gdk_window_get_window_type (GdkWindow *window)
+{
+  g_return_val_if_fail (GDK_IS_WINDOW (window), (GdkWindowType) -1);
+  
+  return GDK_WINDOW_TYPE (window);
 }
 
 void
@@ -337,41 +392,60 @@ gdk_window_get_position (GdkWindow *window,
 			 gint      *x,
 			 gint      *y)
 {
-  GdkWindowPrivate *window_private;
+  GdkWindowObject *obj;
   
-  g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  window_private = (GdkWindowPrivate*) window;
+  obj = (GdkWindowObject*) window;
   
   if (x)
-    *x = window_private->x;
+    *x = obj->x;
   if (y)
-    *y = window_private->y;
+    *y = obj->y;
 }
 
 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;
+  return (GdkWindow*) ((GdkWindowObject*) window)->parent;
 }
 
 GdkWindow*
 gdk_window_get_toplevel (GdkWindow *window)
 {
-  GdkWindowPrivate *private;
+  GdkWindowObject *obj;
   
-  g_return_val_if_fail (window != NULL, NULL);
   g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
 
-  private = (GdkWindowPrivate *)window;
-  while (GDK_DRAWABLE_TYPE (private) == GDK_WINDOW_CHILD)
-    private = (GdkWindowPrivate *)private->parent;
+  obj = (GdkWindowObject *)window;
+  while (GDK_WINDOW_TYPE (obj) == GDK_WINDOW_CHILD)
+    obj = (GdkWindowObject *)obj->parent;
   
-  return (GdkWindow *)window;
+  return GDK_WINDOW (obj);
+}
+
+GList*
+gdk_window_get_children (GdkWindow *window)
+{
+  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
+
+  if (GDK_WINDOW_DESTROYED (window))
+    return NULL;
+
+  return g_list_copy (GDK_WINDOW_OBJECT (window)->children);
+}
+
+GList *
+gdk_window_peek_children (GdkWindow       *window)
+{
+  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
+
+  if (GDK_WINDOW_DESTROYED (window))
+    return NULL;
+
+  return GDK_WINDOW_OBJECT (window)->children;
 }
 
 void          
@@ -379,15 +453,15 @@ gdk_window_add_filter (GdkWindow     *window,
 		       GdkFilterFunc  function,
 		       gpointer       data)
 {
-  GdkWindowPrivate *private;
+  GdkWindowObject *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))
+  private = (GdkWindowObject*) window;
+  if (private && GDK_WINDOW_DESTROYED (window))
     return;
   
   if (private)
@@ -418,14 +492,14 @@ gdk_window_remove_filter (GdkWindow     *window,
 			  GdkFilterFunc  function,
 			  gpointer       data)
 {
-  GdkWindowPrivate *private;
+  GdkWindowObject *private;
   GList *tmp_list, *node;
   GdkEventFilter *filter;
   
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  private = (GdkWindowPrivate*) window;
+  private = (GdkWindowObject*) window;
   
   if (private)
     tmp_list = private->filters;
@@ -458,7 +532,7 @@ gdk_window_get_toplevels (void)
   GList *new_list = NULL;
   GList *tmp_list;
   
-  tmp_list = ((GdkWindowPrivate *)gdk_parent_root)->children;
+  tmp_list = ((GdkWindowObject *)gdk_parent_root)->children;
   while (tmp_list)
     {
       new_list = g_list_prepend (new_list, tmp_list->data);
@@ -480,7 +554,7 @@ gdk_window_get_toplevels (void)
 gboolean 
 gdk_window_is_visible (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   
   g_return_val_if_fail (window != NULL, FALSE);
   g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
@@ -503,19 +577,19 @@ gdk_window_is_visible (GdkWindow *window)
 gboolean 
 gdk_window_is_viewable (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   
   g_return_val_if_fail (window != NULL, FALSE);
   g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
   
   while (private && 
-	 (private != (GdkWindowPrivate *)gdk_parent_root) &&
-	 (private->drawable.window_type != GDK_WINDOW_FOREIGN))
+	 (private != (GdkWindowObject *)gdk_parent_root) &&
+	 (GDK_WINDOW_TYPE (private) != GDK_WINDOW_FOREIGN))
     {
       if (!private->mapped)
 	return FALSE;
       
-      private = (GdkWindowPrivate *)private->parent;
+      private = (GdkWindowObject *)private->parent;
     }
   
   return TRUE;
@@ -538,7 +612,7 @@ gdk_window_begin_paint_rect (GdkWindow    *window,
 static GdkGC *
 gdk_window_get_bg_gc (GdkWindow *window, GdkWindowPaint *paint)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
 
   guint gc_mask = 0;
   GdkGCValues gc_values;
@@ -549,7 +623,7 @@ gdk_window_get_bg_gc (GdkWindow *window, GdkWindowPaint *paint)
       tmp_paint.x_offset += private->x;
       tmp_paint.y_offset += private->y;
       
-      return gdk_window_get_bg_gc (private->parent, &tmp_paint);
+      return gdk_window_get_bg_gc (GDK_WINDOW (private->parent), &tmp_paint);
     }
   else if (private->bg_pixmap && private->bg_pixmap != GDK_PARENT_RELATIVE_BG && private->bg_pixmap != GDK_NO_BG)
     {
@@ -586,7 +660,7 @@ gdk_window_begin_paint_region (GdkWindow *window,
 			       GdkRegion *region)
 {
 #ifdef USE_BACKING_STORE
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   GdkRectangle clip_box;
   GdkWindowPaint *paint;
   GdkRegion *init_region;
@@ -595,7 +669,7 @@ gdk_window_begin_paint_region (GdkWindow *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
   paint = g_new (GdkWindowPaint, 1);
@@ -681,7 +755,7 @@ void
 gdk_window_end_paint (GdkWindow *window)
 {
 #ifdef USE_BACKING_STORE
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   GdkWindowPaint *paint;
   GdkGC *tmp_gc;
   GdkRectangle clip_box;
@@ -690,7 +764,7 @@ gdk_window_end_paint (GdkWindow *window)
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
   g_return_if_fail (private->paint_stack != NULL);
@@ -707,11 +781,11 @@ gdk_window_end_paint (GdkWindow *window)
   gdk_gc_set_clip_region (tmp_gc, paint->region);
   gdk_gc_set_clip_origin (tmp_gc, -x_offset, -y_offset);
 
-  _gdk_windowing_window_class.draw_drawable (window, tmp_gc, paint->pixmap,
-					     clip_box.x - paint->x_offset,
-					     clip_box.y - paint->y_offset,
-					     clip_box.x - x_offset, clip_box.y - y_offset,
-					     clip_box.width, clip_box.height);
+  gdk_draw_drawable (private->impl, tmp_gc, paint->pixmap,
+                     clip_box.x - paint->x_offset,
+                     clip_box.y - paint->y_offset,
+                     clip_box.x - x_offset, clip_box.y - y_offset,
+                     clip_box.width, clip_box.height);
   gdk_gc_unref (tmp_gc);
 
   if (private->paint_stack)
@@ -736,7 +810,7 @@ gdk_window_end_paint (GdkWindow *window)
 static void
 gdk_window_free_paint_stack (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   
   if (private->paint_stack)
     {
@@ -765,7 +839,7 @@ gdk_window_get_offsets (GdkWindow *window,
 			gint      *x_offset,
 			gint      *y_offset)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   
   if (private->paint_stack)
     {
@@ -779,10 +853,10 @@ gdk_window_get_offsets (GdkWindow *window,
 
 #define OFFSET_GC(gc)                                         \
     gint x_offset, y_offset; 				      \
-    gint old_clip_x = ((GdkGCPrivate *)gc)->clip_x_origin;    \
-    gint old_clip_y = ((GdkGCPrivate *)gc)->clip_y_origin;    \
-    gint old_ts_x = ((GdkGCPrivate *)gc)->ts_x_origin;        \
-    gint old_ts_y = ((GdkGCPrivate *)gc)->ts_y_origin;        \
+    gint old_clip_x = gc->clip_x_origin;    \
+    gint old_clip_y = gc->clip_y_origin;    \
+    gint old_ts_x = gc->ts_x_origin;        \
+    gint old_ts_y = gc->ts_y_origin;        \
     gdk_window_get_offsets (drawable, &x_offset, &y_offset);  \
     if (x_offset != 0 || y_offset != 0)             	      \
       {                                                       \
@@ -799,18 +873,18 @@ gdk_window_get_offsets (GdkWindow *window,
        gdk_gc_set_ts_origin (gc, old_ts_x, old_ts_y);       \
      }
 
-static void
-gdk_window_draw_destroy (GdkDrawable *drawable)
-{
-  _gdk_windowing_window_class.destroy (drawable);
-}
-
 static GdkGC *
-gdk_window_draw_create_gc (GdkDrawable     *drawable,
-			   GdkGCValues     *values,
-			   GdkGCValuesMask  mask)
+gdk_window_create_gc (GdkDrawable     *drawable,
+                      GdkGCValues     *values,
+                      GdkGCValuesMask  mask)
 {
-  return _gdk_windowing_window_class.create_gc (drawable, values, mask);
+  g_return_val_if_fail (GDK_IS_WINDOW (drawable), NULL);
+  
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return NULL;
+
+  return gdk_gc_new_with_values (((GdkWindowObject *) drawable)->impl,
+                                 values, mask);
 }
 
 static void
@@ -822,8 +896,11 @@ gdk_window_draw_rectangle (GdkDrawable *drawable,
 			   gint         width,
 			   gint         height)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
   OFFSET_GC (gc);
+
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
   
   if (private->paint_stack)
     {
@@ -832,8 +909,8 @@ gdk_window_draw_rectangle (GdkDrawable *drawable,
 			  x - x_offset, y - y_offset, width, height);
     }
   else
-    _gdk_windowing_window_class.draw_rectangle (drawable, gc, filled,
-						x - x_offset, y - y_offset, width, height);
+    gdk_draw_rectangle (private->impl, gc, filled,
+                        x - x_offset, y - y_offset, width, height);
 
   RESTORE_GC (gc);
 }
@@ -849,9 +926,12 @@ gdk_window_draw_arc (GdkDrawable *drawable,
 		     gint         angle1,
 		     gint         angle2)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
   OFFSET_GC (gc);
 
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
+  
   if (private->paint_stack)
     {
       GdkWindowPaint *paint = private->paint_stack->data;
@@ -860,9 +940,9 @@ gdk_window_draw_arc (GdkDrawable *drawable,
 		    width, height, angle1, angle2);
     }
   else
-    _gdk_windowing_window_class.draw_arc (drawable, gc, filled,
-					  x - x_offset, y - y_offset,
-					  width, height, angle1, angle2);
+    gdk_draw_arc (private->impl, gc, filled,
+                  x - x_offset, y - y_offset,
+                  width, height, angle1, angle2);
   RESTORE_GC (gc);
 }
 
@@ -873,11 +953,14 @@ gdk_window_draw_polygon (GdkDrawable *drawable,
 			 GdkPoint    *points,
 			 gint         npoints)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
   GdkPoint *new_points;
   
   OFFSET_GC (gc);
 
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
+  
   if (x_offset != 0 || y_offset != 0)
     {
       int i;
@@ -899,8 +982,8 @@ gdk_window_draw_polygon (GdkDrawable *drawable,
 
     }
   else
-    _gdk_windowing_window_class.draw_polygon (drawable, gc, filled, new_points, npoints);
-
+    gdk_draw_polygon (private->impl, gc, filled, new_points, npoints);
+  
   if (new_points != points)
     g_free (new_points);
 
@@ -916,9 +999,12 @@ gdk_window_draw_text (GdkDrawable *drawable,
 		      const gchar *text,
 		      gint         text_length)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
   OFFSET_GC (gc);
 
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
+  
   if (private->paint_stack)
     {
       GdkWindowPaint *paint = private->paint_stack->data;
@@ -927,8 +1013,8 @@ gdk_window_draw_text (GdkDrawable *drawable,
 
     }
   else
-    _gdk_windowing_window_class.draw_text (drawable, font, gc,
-					   x - x_offset, y - y_offset, text, text_length);
+    gdk_draw_text (private->impl, font, gc,
+                   x - x_offset, y - y_offset, text, text_length);
 
   RESTORE_GC (gc);
 }
@@ -942,9 +1028,12 @@ gdk_window_draw_text_wc (GdkDrawable    *drawable,
 			 const GdkWChar *text,
 			 gint            text_length)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
   OFFSET_GC (gc);
 
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
+  
   if (private->paint_stack)
     {
       GdkWindowPaint *paint = private->paint_stack->data;
@@ -952,9 +1041,9 @@ gdk_window_draw_text_wc (GdkDrawable    *drawable,
 			x - x_offset, y - y_offset, text, text_length);
     }
   else
-    _gdk_windowing_window_class.draw_text_wc (drawable, font, gc,
-					      x - x_offset, y - y_offset, text, text_length);
-
+    gdk_draw_text_wc (private->impl, font, gc,
+                      x - x_offset, y - y_offset, text, text_length);
+  
   RESTORE_GC (gc);
 }
 
@@ -969,9 +1058,12 @@ gdk_window_draw_drawable (GdkDrawable *drawable,
 			  gint         width,
 			  gint         height)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
   OFFSET_GC (gc);
 
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
+  
   if (private->paint_stack)
     {
       GdkWindowPaint *paint = private->paint_stack->data;
@@ -980,9 +1072,9 @@ gdk_window_draw_drawable (GdkDrawable *drawable,
 
     }
   else
-    _gdk_windowing_window_class.draw_drawable (drawable, gc, src, xsrc, ysrc,
-					       xdest - x_offset, ydest - y_offset,
-					       width, height);
+    gdk_draw_drawable (private->impl, gc, src, xsrc, ysrc,
+                       xdest - x_offset, ydest - y_offset,
+                       width, height);
   RESTORE_GC (gc);
 }
 
@@ -992,11 +1084,14 @@ gdk_window_draw_points (GdkDrawable *drawable,
 			GdkPoint    *points,
 			gint         npoints)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
   GdkPoint *new_points;
   
   OFFSET_GC (gc);
 
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
+  
   if (x_offset != 0 || y_offset != 0)
     {
       gint i;
@@ -1017,7 +1112,7 @@ gdk_window_draw_points (GdkDrawable *drawable,
       gdk_draw_points (paint->pixmap, gc, new_points, npoints);
     }
   else
-    _gdk_windowing_window_class.draw_points (drawable, gc, points, npoints);
+    gdk_draw_points (private->impl, gc, points, npoints);
 
   if (new_points != points)
     g_free (new_points);
@@ -1031,11 +1126,14 @@ gdk_window_draw_segments (GdkDrawable *drawable,
 			  GdkSegment  *segs,
 			  gint         nsegs)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
   GdkSegment *new_segs;
 
   OFFSET_GC (gc);
 
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
+  
   if (x_offset != 0 || y_offset != 0)
     {
       gint i;
@@ -1058,8 +1156,8 @@ gdk_window_draw_segments (GdkDrawable *drawable,
       gdk_draw_segments (paint->pixmap, gc, new_segs, nsegs);
     }
   else
-    _gdk_windowing_window_class.draw_segments (drawable, gc, new_segs, nsegs);
-
+    gdk_draw_segments (private->impl, gc, new_segs, nsegs);
+  
   if (new_segs != segs)
     g_free (new_segs);
 
@@ -1072,11 +1170,14 @@ gdk_window_draw_lines (GdkDrawable *drawable,
 		       GdkPoint    *points,
 		       gint         npoints)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
   GdkPoint *new_points;
 
   OFFSET_GC (gc);
 
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
+  
   if (x_offset != 0 || y_offset != 0)
     {
       gint i;
@@ -1097,7 +1198,7 @@ gdk_window_draw_lines (GdkDrawable *drawable,
       gdk_draw_lines (paint->pixmap, gc, new_points, npoints);
     }
   else
-    _gdk_windowing_window_class.draw_lines (drawable, gc, new_points, npoints);
+    gdk_draw_lines (private->impl, gc, new_points, npoints);
 
   if (new_points != points)
     g_free (new_points);
@@ -1113,10 +1214,13 @@ gdk_window_draw_glyphs (GdkDrawable      *drawable,
 			gint              y,
 			PangoGlyphString *glyphs)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
 
   OFFSET_GC (gc);
 
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
+  
   if (private->paint_stack)
     {
       GdkWindowPaint *paint = private->paint_stack->data;
@@ -1124,8 +1228,8 @@ gdk_window_draw_glyphs (GdkDrawable      *drawable,
       gdk_draw_glyphs (paint->pixmap, gc, font, x - x_offset, y - y_offset, glyphs);
     }
   else
-    _gdk_windowing_window_class.draw_glyphs (drawable, gc, font,
-					     x - x_offset, y - y_offset, glyphs);
+    gdk_draw_glyphs (private->impl, gc, font,
+                     x - x_offset, y - y_offset, glyphs);
 
   RESTORE_GC (gc);
 }
@@ -1138,10 +1242,13 @@ gdk_window_clear_backing_rect (GdkWindow *window,
 			       gint       width,
 			       gint       height)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   GdkWindowPaint *paint = private->paint_stack->data;
   GdkGC *tmp_gc;
 
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
+  
   tmp_gc = gdk_window_get_bg_gc (window, paint);
   gdk_draw_rectangle (paint->pixmap, tmp_gc, TRUE,
 		      x - paint->x_offset, y - paint->y_offset, width, height);
@@ -1151,13 +1258,15 @@ gdk_window_clear_backing_rect (GdkWindow *window,
 void
 gdk_window_clear (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
+  gint width, height;
+  
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
+  gdk_drawable_get_size (GDK_DRAWABLE (window), &width, &height);
+  
   gdk_window_clear_area (window, 0, 0,
-			 private->drawable.width, private->drawable.height);
+                         width, height);
 }
 
 void
@@ -1167,7 +1276,7 @@ gdk_window_clear_area (GdkWindow *window,
 		       gint       width,
 		       gint       height)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -1185,7 +1294,7 @@ gdk_window_clear_area_e (GdkWindow *window,
 		         gint       width,
 		         gint       height)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -1196,38 +1305,104 @@ gdk_window_clear_area_e (GdkWindow *window,
   _gdk_windowing_window_clear_area_e (window, x, y, width, height);
 }
 
-void
-_gdk_window_draw_image (GdkDrawable *drawable,
-			GdkGC       *gc,
-			GdkImage    *image,
-			gint         xsrc,
-			gint         ysrc,
-			gint         xdest,
-			gint         ydest,
-			gint         width,
-			gint         height)
+static void
+gdk_window_draw_image (GdkDrawable *drawable,
+                       GdkGC       *gc,
+                       GdkImage    *image,
+                       gint         xsrc,
+                       gint         ysrc,
+                       gint         xdest,
+                       gint         ydest,
+                       gint         width,
+                       gint         height)
 {
-  GdkImagePrivate *image_private = (GdkImagePrivate*) image;
-  GdkWindowPrivate *private = (GdkWindowPrivate *)drawable;
+  GdkWindowObject *private = (GdkWindowObject *)drawable;
 
   OFFSET_GC (gc);
+
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
   
   if (private->paint_stack)
     {
       GdkWindowPaint *paint = private->paint_stack->data;
-      image_private->klass->image_put (image, paint->pixmap, gc, xsrc, ysrc,
-				       xdest - x_offset, ydest - y_offset,
-				       width, height);
+      gdk_draw_image (paint->pixmap, gc, image, xsrc, ysrc,
+                      xdest - x_offset, ydest - y_offset,
+                      width, height);
 
     }
   else
-    image_private->klass->image_put (image, drawable, gc, xsrc, ysrc,
-				     xdest - x_offset, ydest - y_offset,
-				     width, height);
+    gdk_draw_image (private->impl, gc, image, xsrc, ysrc,
+                    xdest - x_offset, ydest - y_offset,
+                    width, height);
 
   RESTORE_GC (gc);
 }
 
+
+static void
+gdk_window_real_get_size (GdkDrawable *drawable,
+                          gint *width,
+                          gint *height)
+{
+  g_return_if_fail (GDK_IS_WINDOW (drawable));
+
+  gdk_drawable_get_size (GDK_WINDOW_OBJECT (drawable)->impl,
+                         width, height);
+}
+
+static GdkVisual*
+gdk_window_real_get_visual (GdkDrawable *drawable)
+{
+  GdkColormap *colormap;
+
+  g_return_val_if_fail (GDK_IS_WINDOW (drawable), NULL);
+
+  colormap = gdk_drawable_get_colormap (drawable);
+  return colormap ? gdk_colormap_get_visual (colormap) : NULL;
+}
+
+static gint
+gdk_window_real_get_depth (GdkDrawable *drawable)
+{
+  gint depth;
+  
+  g_return_val_if_fail (GDK_IS_WINDOW (drawable), 0);
+
+  depth = ((GdkWindowObject *)GDK_WINDOW (drawable))->depth;
+
+  if (depth == 0)
+    {
+      g_print ("0 depth for type %s\n", g_type_name (G_OBJECT_TYPE (drawable)));
+      G_BREAKPOINT ();
+    }
+
+  return depth;
+}
+
+static void
+gdk_window_real_set_colormap (GdkDrawable *drawable,
+                              GdkColormap *cmap)
+{
+  g_return_if_fail (GDK_IS_WINDOW (drawable));  
+
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return;
+  
+  gdk_drawable_set_colormap (((GdkWindowObject*)drawable)->impl, cmap);
+}
+
+static GdkColormap*
+gdk_window_real_get_colormap (GdkDrawable *drawable)
+{
+  g_return_val_if_fail (GDK_IS_WINDOW (drawable), NULL);
+
+  if (GDK_WINDOW_DESTROYED (drawable))
+    return NULL;
+  
+  return gdk_drawable_get_colormap (((GdkWindowObject*)drawable)->impl);
+}
+
 /* Code for dirty-region queueing
  */
 
@@ -1237,7 +1412,7 @@ static guint update_idle = 0;
 static void
 gdk_window_process_updates_internal (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   gboolean save_region = FALSE;
 
   /* If an update got queued during update processing, we can get a
@@ -1253,11 +1428,14 @@ gdk_window_process_updates_internal (GdkWindow *window)
 	{
 	  GdkEvent event;
 	  GdkRectangle window_rect;
-	  
+          gint width, height;
+
+          gdk_drawable_get_size (GDK_DRAWABLE (private), &width, &height);
+          
 	  window_rect.x = 0;
 	  window_rect.y = 0;
-	  window_rect.width = private->drawable.width;
-	  window_rect.height = private->drawable.height;
+	  window_rect.width = width;
+	  window_rect.height = height;
 
 	  save_region = _gdk_windowing_window_queue_antiexpose (window, update_area);
       
@@ -1314,7 +1492,7 @@ void
 gdk_window_process_updates (GdkWindow *window,
 			    gboolean   update_children)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -1342,20 +1520,21 @@ gdk_window_invalidate_rect   (GdkWindow    *window,
 			      gboolean      invalidate_children)
 {
   GdkRectangle window_rect;
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
   if (!rect)
     {
       window_rect.x = 0;
       window_rect.y = 0;
-      window_rect.width = private->drawable.width;
-      window_rect.height = private->drawable.height;
+      gdk_drawable_get_size (GDK_DRAWABLE (window),
+                             &window_rect.width,
+                             &window_rect.height);
       rect = &window_rect;
     }
   
@@ -1382,18 +1561,20 @@ gdk_window_invalidate_rect   (GdkWindow    *window,
       tmp_list = private->children;
       while (tmp_list)
 	{
-	  GdkWindowPrivate *child = tmp_list->data;
+	  GdkWindowObject *child = tmp_list->data;
 	  tmp_list = tmp_list->next;
 
-	  /* FIXME: this is a HACK to figure out if the child is
-	   *        input-only.
-	   */
-	  if (child->drawable.colormap)
+	  if (!child->input_only)
 	    {
+              gint width, height;
+
+              gdk_drawable_get_size (GDK_DRAWABLE (child),
+                                     &width, &height);
+              
 	      child_rect.x = child->x;
 	      child_rect.y = child->y;
-	      child_rect.width = child->drawable.width;
-	      child_rect.height = child->drawable.height;
+	      child_rect.width = width;
+	      child_rect.height = height;
 	      
 	      if (gdk_rectangle_intersect (rect, &child_rect, &new_rect))
 		{
@@ -1412,12 +1593,12 @@ gdk_window_invalidate_region (GdkWindow *window,
 			      GdkRegion *region,
 			      gboolean   invalidate_children)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
   if (private->input_only)
@@ -1446,15 +1627,20 @@ gdk_window_invalidate_region (GdkWindow *window,
       tmp_list = private->children;
       while (tmp_list)
 	{
-	  GdkWindowPrivate *child = tmp_list->data;
+	  GdkWindowObject *child = tmp_list->data;
 	  tmp_list = tmp_list->next;
 
 	  if (child->input_only)
 	    {
+              gint width, height;
+
+              gdk_drawable_get_size (GDK_DRAWABLE (child),
+                                     &width, &height);
+              
 	      child_rect.x = child->x;
 	      child_rect.y = child->y;
-	      child_rect.width = child->drawable.width;
-	      child_rect.height = child->drawable.height;
+	      child_rect.width = width;
+	      child_rect.height = height;
 	      
 	      child_region = gdk_region_rectangle (&child_rect);
 	      gdk_region_intersect (child_region, region);
@@ -1474,7 +1660,7 @@ gdk_window_invalidate_region (GdkWindow *window,
 GdkRegion *
 gdk_window_get_update_area (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   GdkRegion *tmp_region;
 
   g_return_val_if_fail (window != NULL, NULL);
@@ -1503,7 +1689,7 @@ gdk_window_get_update_area (GdkWindow *window)
 void
 _gdk_window_clear_update_area (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -1520,7 +1706,7 @@ _gdk_window_clear_update_area (GdkWindow *window)
 void
 gdk_window_freeze_updates (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -1531,7 +1717,7 @@ gdk_window_freeze_updates (GdkWindow *window)
 void
 gdk_window_thaw_updates (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
diff --git a/gdk/gdkwindow.h b/gdk/gdkwindow.h
index 3738c0851f..ccce0dbb70 100644
--- a/gdk/gdkwindow.h
+++ b/gdk/gdkwindow.h
@@ -28,6 +28,28 @@ typedef enum
   GDK_INPUT_ONLY
 } GdkWindowClass;
 
+/* Types of windows.
+ *   Root: There is only 1 root window and it is initialized
+ *	   at startup. Creating a window of type GDK_WINDOW_ROOT
+ *	   is an error.
+ *   Toplevel: Windows which interact with the window manager.
+ *   Child: Windows which are children of some other type of window.
+ *	    (Any other type of window). Most windows are child windows.
+ *   Dialog: A special kind of toplevel window which interacts with
+ *	     the window manager slightly differently than a regular
+ *	     toplevel window. Dialog windows should be used for any
+ *	     transient window.
+ *   Foreign: A window that actually belongs to another application
+ */
+typedef enum
+{
+  GDK_WINDOW_ROOT,
+  GDK_WINDOW_TOPLEVEL,
+  GDK_WINDOW_CHILD,
+  GDK_WINDOW_DIALOG,
+  GDK_WINDOW_TEMP,
+  GDK_WINDOW_FOREIGN
+} GdkWindowType;
 
 /* Window attribute mask values.
  *   GDK_WA_TITLE: The "title" field is valid.
@@ -97,7 +119,7 @@ struct _GdkWindowAttr
   GdkWindowClass wclass;
   GdkVisual *visual;
   GdkColormap *colormap;
-  GdkDrawableType window_type;
+  GdkWindowType window_type;
   GdkCursor *cursor;
   gchar *wmclass_name;
   gchar *wmclass_class;
@@ -118,61 +140,114 @@ struct _GdkGeometry {
   /* GdkGravity gravity; */
 };
 
+typedef struct _GdkWindowObject GdkWindowObject;
+typedef struct _GdkWindowObjectClass GdkWindowObjectClass;
+
+#define GDK_TYPE_WINDOW              (gdk_window_object_get_type ())
+#define GDK_WINDOW(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW, GdkWindow))
+#define GDK_WINDOW_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW, GdkWindowObjectClass))
+#define GDK_IS_WINDOW(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW))
+#define GDK_IS_WINDOW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW))
+#define GDK_WINDOW_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW, GdkWindowObjectClass))
+#define GDK_WINDOW_OBJECT(object)    ((GdkWindowObject *) GDK_WINDOW (object))
+
+struct _GdkWindowObject
+{
+  GdkDrawable parent_instance;
+
+  gpointer user_data;
+
+  GdkDrawable *impl; /* window-system-specific delegate object */  
+  
+  GdkWindowObject *parent;
+
+  gint x;
+  gint y;
+  
+  gint extension_events;
+
+  GList *filters;
+  GList *children;
+
+  GdkColor bg_color;
+  GdkPixmap *bg_pixmap;
+  
+  GSList *paint_stack;
+  
+  GdkRegion *update_area;
+  guint update_freeze_count;
+  
+  guint8 window_type;
+  guint8 depth;
+  guint8 resize_count;
+  guint mapped : 1;
+  guint guffaw_gravity : 1;
+  guint input_only : 1;
+  
+  guint destroyed : 2;
+};
+
+struct _GdkWindowObjectClass
+{
+  GdkDrawableClass parent_class;
+
+
+};
+
 /* Windows
  */
-GdkWindow* gdk_window_new                   (GdkWindow     *parent,
-					     GdkWindowAttr *attributes,
-					     gint           attributes_mask);
-void       gdk_window_destroy               (GdkWindow     *window);
-
-GdkWindow* gdk_window_at_pointer            (gint          *win_x,
-					     gint          *win_y);
-void       gdk_window_show                  (GdkWindow     *window);
-void       gdk_window_hide                  (GdkWindow     *window);
-void       gdk_window_withdraw              (GdkWindow     *window);
-void       gdk_window_move                  (GdkWindow     *window,
-					     gint           x,
-					     gint           y);
-void       gdk_window_resize                (GdkWindow     *window,
-					     gint           width,
-					     gint           height);
-void       gdk_window_move_resize           (GdkWindow     *window,
-					     gint           x,
-					     gint           y,
-					     gint           width,
-					     gint           height);
-void       gdk_window_scroll                (GdkWindow     *window,
-					     gint           dx,
-					     gint           dy);
-void       gdk_window_reparent              (GdkWindow     *window,
-					     GdkWindow     *new_parent,
-					     gint           x,
-					     gint           y);
-void       gdk_window_clear                 (GdkWindow     *window);
-void       gdk_window_clear_area            (GdkWindow     *window,
-					     gint           x,
-					     gint           y,
-					     gint           width,
-					     gint           height);
-void       gdk_window_clear_area_e          (GdkWindow     *window,
-					     gint           x,
-					     gint           y,
-					     gint           width,
-					     gint           height);
-void       gdk_window_raise                 (GdkWindow     *window);
-void       gdk_window_lower                 (GdkWindow     *window);
-
-void       gdk_window_set_user_data         (GdkWindow     *window,
-					     gpointer       user_data);
-void       gdk_window_set_override_redirect (GdkWindow     *window,
-					     gboolean       override_redirect);
-
-void       gdk_window_add_filter            (GdkWindow     *window,
-					     GdkFilterFunc  function,
-					     gpointer       data);
-void       gdk_window_remove_filter         (GdkWindow     *window,
-					     GdkFilterFunc  function,
-					     gpointer       data);
+GType         gdk_window_object_get_type       (void);
+GdkWindow*    gdk_window_new                   (GdkWindow     *parent,
+                                                GdkWindowAttr *attributes,
+                                                gint           attributes_mask);
+void          gdk_window_destroy               (GdkWindow     *window);
+GdkWindowType gdk_window_get_window_type       (GdkWindow     *window);
+GdkWindow*    gdk_window_at_pointer            (gint          *win_x,
+                                                gint          *win_y);
+void          gdk_window_show                  (GdkWindow     *window);
+void          gdk_window_hide                  (GdkWindow     *window);
+void          gdk_window_withdraw              (GdkWindow     *window);
+void          gdk_window_move                  (GdkWindow     *window,
+                                                gint           x,
+                                                gint           y);
+void          gdk_window_resize                (GdkWindow     *window,
+                                                gint           width,
+                                                gint           height);
+void          gdk_window_move_resize           (GdkWindow     *window,
+                                                gint           x,
+                                                gint           y,
+                                                gint           width,
+                                                gint           height);
+void          gdk_window_reparent              (GdkWindow     *window,
+                                                GdkWindow     *new_parent,
+                                                gint           x,
+                                                gint           y);
+void          gdk_window_clear                 (GdkWindow     *window);
+void          gdk_window_clear_area            (GdkWindow     *window,
+                                                gint           x,
+                                                gint           y,
+                                                gint           width,
+                                                gint           height);
+void          gdk_window_clear_area_e          (GdkWindow     *window,
+                                                gint           x,
+                                                gint           y,
+                                                gint           width,
+                                                gint           height);
+void          gdk_window_raise                 (GdkWindow     *window);
+void          gdk_window_lower                 (GdkWindow     *window);
+void          gdk_window_set_user_data         (GdkWindow     *window,
+                                                gpointer       user_data);
+void          gdk_window_set_override_redirect (GdkWindow     *window,
+                                                gboolean       override_redirect);
+void          gdk_window_add_filter            (GdkWindow     *window,
+                                                GdkFilterFunc  function,
+                                                gpointer       data);
+void          gdk_window_remove_filter         (GdkWindow     *window,
+                                                GdkFilterFunc  function,
+                                                gpointer       data);
+void          gdk_window_scroll                (GdkWindow *window,
+                                                gint       dx,
+                                                gint       dy);
 
 /* 
  * This allows for making shaped (partially transparent) windows
@@ -279,6 +354,7 @@ GdkWindow *   gdk_window_get_parent      (GdkWindow       *window);
 GdkWindow *   gdk_window_get_toplevel    (GdkWindow       *window);
 
 GList *	      gdk_window_get_children	 (GdkWindow	  *window);
+GList *       gdk_window_peek_children   (GdkWindow       *window);
 GdkEventMask  gdk_window_get_events	 (GdkWindow	  *window);
 void	      gdk_window_set_events	 (GdkWindow	  *window,
 					  GdkEventMask	   event_mask);
diff --git a/gdk/linux-fb/Makefile.am b/gdk/linux-fb/Makefile.am
index 21462c1628..c2eb72de27 100644
--- a/gdk/linux-fb/Makefile.am
+++ b/gdk/linux-fb/Makefile.am
@@ -19,6 +19,8 @@ LDFLAGS = @STRIP_BEGIN@ \
 	-lm		\
 @STRIP_END@
 
+if USE_LINUX_FB
+
 noinst_LTLIBRARIES = libgdk-linux-fb.la
 noinst_PROGRAMS=#test-fb
 
@@ -59,3 +61,7 @@ libgdk_linux_fb_la_SOURCES =    	\
 	mispans.c		\
 	gdkpango-fb.c
 	mispans.c
+
+else
+noinst_LTLIBRARIES =
+endif
diff --git a/gdk/x11/Makefile.am b/gdk/x11/Makefile.am
index 1e8e1ad103..5cca5f4224 100644
--- a/gdk/x11/Makefile.am
+++ b/gdk/x11/Makefile.am
@@ -83,7 +83,7 @@ gxid_LDADD = $(LDADDS)
 endif
 
 install-data-local:
-	../../$(MKINSTALLDIRS) $(includedir)/gdk
+	$(MKINSTALLDIRS) $(includedir)/gdk
 	$(INSTALL_DATA) $(srcdir)/gdkx.h $(includedir)/gdk
-	../../$(MKINSTALLDIRS) $(includedir)/gdk/x11
+	$(MKINSTALLDIRS) $(includedir)/gdk/x11
 	$(INSTALL_DATA) $(srcdir)/gdkprivate-x11.h $(includedir)/gdk/x11
diff --git a/gdk/x11/gdkcolor-x11.c b/gdk/x11/gdkcolor-x11.c
index 156933cec4..d32f85451e 100644
--- a/gdk/x11/gdkcolor-x11.c
+++ b/gdk/x11/gdkcolor-x11.c
@@ -29,6 +29,8 @@
 #include "gdkcolor.h"
 #include "gdkprivate-x11.h"
 
+#define GDK_COLORMAP_PRIVATE_DATA(cmap) ((GdkColormapPrivateX11 *) GDK_COLORMAP (cmap)->windowing_data)
+
 static gint  gdk_colormap_match_color (GdkColormap *cmap,
 				       GdkColor    *color,
 				       const gchar *available);
@@ -38,36 +40,113 @@ static guint gdk_colormap_hash        (Colormap    *cmap);
 static gint  gdk_colormap_cmp         (Colormap    *a,
 				       Colormap    *b);
 
+static void gdk_colormap_init       (GdkColormap      *colormap);
+static void gdk_colormap_class_init (GdkColormapClass *klass);
+static void gdk_colormap_finalize   (GObject              *object);
+
+static gpointer parent_class = NULL;
+
 static GHashTable *colormap_hash = NULL;
 
+GType
+gdk_colormap_get_type (void)
+{
+  static GType object_type = 0;
+
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkColormapClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_colormap_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkColormap),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) gdk_colormap_init,
+      };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "GdkColormap",
+                                            &object_info);
+    }
+  
+  return object_type;
+}
+
+static void
+gdk_colormap_init (GdkColormap *colormap)
+{
+  GdkColormapPrivateX11 *private;
+
+  private = g_new (GdkColormapPrivateX11, 1);
+
+  colormap->windowing_data = private;
+  
+  private->xdisplay = gdk_display;
+  private->hash = NULL;
+  private->last_sync_time = 0;
+  private->info = NULL;
+
+  colormap->size = 0;
+  colormap->colors = NULL;
+}
+
+static void
+gdk_colormap_class_init (GdkColormapClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->finalize = gdk_colormap_finalize;
+}
+
+static void
+gdk_colormap_finalize (GObject *object)
+{
+  GdkColormap *colormap = GDK_COLORMAP (object);
+  GdkColormapPrivateX11 *private = GDK_COLORMAP_PRIVATE_DATA (colormap);
+
+  gdk_colormap_remove (colormap);
+
+  XFreeColormap (private->xdisplay, private->xcolormap);
+
+  if (private->hash)
+    g_hash_table_destroy (private->hash);
+  
+  g_free (private->info);
+  g_free (colormap->colors);
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
 
 GdkColormap*
 gdk_colormap_new (GdkVisual *visual,
 		  gboolean   private_cmap)
 {
   GdkColormap *colormap;
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   Visual *xvisual;
   int size;
   int i;
 
+  /* FIXME when object properties settle down, there needs to be some
+   * kind of default construction (and construct-only arguments)
+   */
+  
   g_return_val_if_fail (visual != NULL, NULL);
 
-  private = g_new (GdkColormapPrivateX, 1);
-  colormap = (GdkColormap*) private;
+  colormap = GDK_COLORMAP (g_type_create_instance (gdk_colormap_get_type ()));
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
 
-  private->xdisplay = gdk_display;
-  private->base.visual = visual;
-  private->base.ref_count = 1;
-
-  private->hash = NULL;
-  private->last_sync_time = 0;
-  private->info = NULL;
+  colormap->visual = visual;
   
   xvisual = ((GdkVisualPrivate*) visual)->xvisual;
 
   colormap->size = visual->colormap_size;
-  colormap->colors = NULL;
 
   switch (visual->type)
     {
@@ -145,22 +224,6 @@ gdk_colormap_new (GdkVisual *visual,
   return colormap;
 }
 
-void
-_gdk_colormap_real_destroy (GdkColormap *colormap)
-{
-  GdkColormapPrivateX *private = (GdkColormapPrivateX*) colormap;
-
-  gdk_colormap_remove (colormap);
-  XFreeColormap (private->xdisplay, private->xcolormap);
-
-  if (private->hash)
-    g_hash_table_destroy (private->hash);
-  
-  g_free (private->info);
-  g_free (colormap->colors);
-  g_free (colormap);
-}
-
 #define MIN_SYNC_TIME 2
 
 void
@@ -168,12 +231,12 @@ gdk_colormap_sync (GdkColormap *colormap,
 		   gboolean     force)
 {
   time_t current_time;
-  GdkColormapPrivateX *private = (GdkColormapPrivateX *)colormap;
+  GdkColormapPrivateX11 *private = GDK_COLORMAP_PRIVATE_DATA (colormap);
   XColor *xpalette;
   gint nlookup;
   gint i;
   
-  g_return_if_fail (colormap != NULL);
+  g_return_if_fail (GDK_IS_COLORMAP (colormap));
 
   current_time = time (NULL);
   if (!force && ((current_time - private->last_sync_time) < MIN_SYNC_TIME))
@@ -215,35 +278,34 @@ GdkColormap*
 gdk_colormap_get_system (void)
 {
   static GdkColormap *colormap = NULL;
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
 
   if (!colormap)
     {
-      private = g_new (GdkColormapPrivateX, 1);
-      colormap = (GdkColormap*) private;
+      colormap = GDK_COLORMAP (g_type_create_instance (gdk_colormap_get_type ()));
+      private = GDK_COLORMAP_PRIVATE_DATA (colormap);
 
       private->xdisplay = gdk_display;
       private->xcolormap = DefaultColormap (gdk_display, gdk_screen);
-      private->base.visual = gdk_visual_get_system ();
+      colormap->visual = gdk_visual_get_system ();
       private->private_val = FALSE;
-      private->base.ref_count = 1;
 
       private->hash = NULL;
       private->last_sync_time = 0;
       private->info = NULL;
 
       colormap->colors = NULL;
-      colormap->size = private->base.visual->colormap_size;
+      colormap->size = colormap->visual->colormap_size;
 
-      if ((private->base.visual->type == GDK_VISUAL_GRAYSCALE) ||
-	  (private->base.visual->type == GDK_VISUAL_PSEUDO_COLOR))
+      if ((colormap->visual->type == GDK_VISUAL_GRAYSCALE) ||
+	  (colormap->visual->type == GDK_VISUAL_PSEUDO_COLOR))
 	{
 	  private->info = g_new0 (GdkColorInfo, colormap->size);
 	  colormap->colors = g_new (GdkColor, colormap->size);
 	  
 	  private->hash = g_hash_table_new ((GHashFunc) gdk_color_hash,
 					    (GCompareFunc) gdk_color_equal);
-
+          
 	  gdk_colormap_sync (colormap, TRUE);
 	}
 
@@ -263,7 +325,7 @@ void
 gdk_colormap_change (GdkColormap *colormap,
 		     gint         ncolors)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   GdkVisual *visual;
   XColor *palette;
   gint shift;
@@ -271,12 +333,12 @@ gdk_colormap_change (GdkColormap *colormap,
   int size;
   int i;
 
-  g_return_if_fail (colormap != NULL);
+  g_return_if_fail (GDK_IS_COLORMAP (colormap));
 
   palette = g_new (XColor, ncolors);
 
-  private = (GdkColormapPrivateX*) colormap;
-  switch (private->base.visual->type)
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
+  switch (colormap->visual->type)
     {
     case GDK_VISUAL_GRAYSCALE:
     case GDK_VISUAL_PSEUDO_COLOR:
@@ -293,7 +355,7 @@ gdk_colormap_change (GdkColormap *colormap,
       break;
 
     case GDK_VISUAL_DIRECT_COLOR:
-      visual = private->base.visual;
+      visual = colormap->visual;
 
       shift = visual->red_shift;
       max_colors = 1 << visual->red_prec;
@@ -350,13 +412,13 @@ gdk_colors_alloc (GdkColormap   *colormap,
 		  gulong        *pixels,
 		  gint           npixels)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   gint return_val;
   gint i;
 
-  g_return_val_if_fail (colormap != NULL, 0);
+  g_return_val_if_fail (GDK_IS_COLORMAP (colormap), 0);
 
-  private = (GdkColormapPrivateX*) colormap;
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
 
   return_val = XAllocColorCells (private->xdisplay, private->xcolormap,
 				 contiguous, planes, nplanes, pixels, npixels);
@@ -408,18 +470,18 @@ gdk_colors_free (GdkColormap *colormap,
 		 gint         in_npixels,
 		 gulong       planes)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   gulong *pixels;
   gint npixels = 0;
   gint i;
 
-  g_return_if_fail (colormap != NULL);
+  g_return_if_fail (GDK_IS_COLORMAP (colormap));
   g_return_if_fail (in_pixels != NULL);
 
-  private = (GdkColormapPrivateX*) colormap;
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
 
-  if ((private->base.visual->type != GDK_VISUAL_PSEUDO_COLOR) &&
-      (private->base.visual->type != GDK_VISUAL_GRAYSCALE))
+  if ((colormap->visual->type != GDK_VISUAL_PSEUDO_COLOR) &&
+      (colormap->visual->type != GDK_VISUAL_GRAYSCALE))
     return;
   
   pixels = g_new (gulong, in_npixels);
@@ -456,18 +518,18 @@ gdk_colormap_free_colors (GdkColormap *colormap,
 			  GdkColor    *colors,
 			  gint         ncolors)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   gulong *pixels;
   gint npixels = 0;
   gint i;
 
-  g_return_if_fail (colormap != NULL);
+  g_return_if_fail (GDK_IS_COLORMAP (colormap));
   g_return_if_fail (colors != NULL);
 
-  private = (GdkColormapPrivateX*) colormap;
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
 
-  if ((private->base.visual->type != GDK_VISUAL_PSEUDO_COLOR) &&
-      (private->base.visual->type != GDK_VISUAL_GRAYSCALE))
+  if ((colormap->visual->type != GDK_VISUAL_PSEUDO_COLOR) &&
+      (colormap->visual->type != GDK_VISUAL_GRAYSCALE))
     return;
 
   pixels = g_new (gulong, ncolors);
@@ -509,10 +571,10 @@ gdk_colormap_alloc1 (GdkColormap *colormap,
 		     GdkColor    *color,
 		     GdkColor    *ret)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   XColor xcolor;
 
-  private = (GdkColormapPrivateX*) colormap;
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
 
   xcolor.red = color->red;
   xcolor.green = color->green;
@@ -561,12 +623,12 @@ gdk_colormap_alloc_colors_writeable (GdkColormap *colormap,
 				     gboolean     best_match,
 				     gboolean    *success)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   gulong *pixels;
   Status status;
   gint i, index;
 
-  private = (GdkColormapPrivateX*) colormap;
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
 
   if (private->private_val)
     {
@@ -619,13 +681,13 @@ gdk_colormap_alloc_colors_private (GdkColormap *colormap,
 				   gboolean     best_match,
 				   gboolean    *success)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   gint i, index;
   XColor *store = g_new (XColor, ncolors);
   gint nstore = 0;
   gint nremaining = 0;
   
-  private = (GdkColormapPrivateX*) colormap;
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
   index = -1;
 
   /* First, store the colors we have room for */
@@ -698,12 +760,12 @@ gdk_colormap_alloc_colors_shared (GdkColormap *colormap,
 				  gboolean     best_match,
 				  gboolean    *success)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   gint i, index;
   gint nremaining = 0;
   gint nfailed = 0;
 
-  private = (GdkColormapPrivateX*) colormap;
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
   index = -1;
 
   for (i=0; i<ncolors; i++)
@@ -790,12 +852,12 @@ gdk_colormap_alloc_colors_pseudocolor (GdkColormap *colormap,
 				       gboolean     best_match,
 				       gboolean    *success)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   GdkColor *lookup_color;
   gint i;
   gint nremaining = 0;
 
-  private = (GdkColormapPrivateX*) colormap;
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
 
   /* Check for an exact match among previously allocated colors */
 
@@ -837,23 +899,23 @@ gdk_colormap_alloc_colors (GdkColormap *colormap,
 			   gboolean     best_match,
 			   gboolean    *success)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   GdkVisual *visual;
   gint i;
   gint nremaining = 0;
   XColor xcolor;
 
-  g_return_val_if_fail (colormap != NULL, FALSE);
+  g_return_val_if_fail (GDK_IS_COLORMAP (colormap), FALSE);
   g_return_val_if_fail (colors != NULL, FALSE);
 
-  private = (GdkColormapPrivateX*) colormap;
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
 
   for (i=0; i<ncolors; i++)
     {
       success[i] = FALSE;
     }
 
-  switch (private->base.visual->type)
+  switch (colormap->visual->type)
     {
     case GDK_VISUAL_PSEUDO_COLOR:
     case GDK_VISUAL_GRAYSCALE:
@@ -867,7 +929,7 @@ gdk_colormap_alloc_colors (GdkColormap *colormap,
 
     case GDK_VISUAL_DIRECT_COLOR:
     case GDK_VISUAL_TRUE_COLOR:
-      visual = private->base.visual;
+      visual = colormap->visual;
 
       for (i=0; i<ncolors; i++)
 	{
@@ -905,10 +967,10 @@ gboolean
 gdk_color_change (GdkColormap *colormap,
 		  GdkColor    *color)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
   XColor xcolor;
 
-  g_return_val_if_fail (colormap != NULL, FALSE);
+  g_return_val_if_fail (GDK_IS_COLORMAP (colormap), FALSE);
   g_return_val_if_fail (color != NULL, FALSE);
 
   xcolor.pixel = color->pixel;
@@ -917,7 +979,7 @@ gdk_color_change (GdkColormap *colormap,
   xcolor.blue = color->blue;
   xcolor.flags = DoRed | DoGreen | DoBlue;
 
-  private = (GdkColormapPrivateX*) colormap;
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
   XStoreColor (private->xdisplay, private->xcolormap, &xcolor);
 
   return TRUE;
@@ -930,7 +992,7 @@ GdkColormap*
 gdkx_colormap_get (Colormap xcolormap)
 {
   GdkColormap *colormap;
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
 
   colormap = gdk_colormap_lookup (xcolormap);
   if (colormap)
@@ -939,12 +1001,12 @@ gdkx_colormap_get (Colormap xcolormap)
   if (xcolormap == DefaultColormap (gdk_display, gdk_screen))
     return gdk_colormap_get_system ();
 
-  private = g_new (GdkColormapPrivateX, 1);
-  colormap = (GdkColormap*) private;
+  colormap = GDK_COLORMAP (g_type_create_instance (gdk_colormap_get_type ()));
+  private = GDK_COLORMAP_PRIVATE_DATA (colormap);
 
   private->xdisplay = gdk_display;
   private->xcolormap = xcolormap;
-  private->base.visual = NULL;
+  colormap->visual = NULL;
   private->private_val = TRUE;
 
   /* To do the following safely, we would have to have some way of finding
@@ -1035,13 +1097,13 @@ gdk_colormap_lookup (Colormap xcolormap)
 static void
 gdk_colormap_add (GdkColormap *cmap)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
 
   if (!colormap_hash)
     colormap_hash = g_hash_table_new ((GHashFunc) gdk_colormap_hash,
 				      (GCompareFunc) gdk_colormap_cmp);
 
-  private = (GdkColormapPrivateX*)cmap;
+  private = GDK_COLORMAP_PRIVATE_DATA (cmap);
 
   g_hash_table_insert (colormap_hash, &private->xcolormap, cmap);
 }
@@ -1049,13 +1111,13 @@ gdk_colormap_add (GdkColormap *cmap)
 static void
 gdk_colormap_remove (GdkColormap *cmap)
 {
-  GdkColormapPrivateX *private;
+  GdkColormapPrivateX11 *private;
 
   if (!colormap_hash)
     colormap_hash = g_hash_table_new ((GHashFunc) gdk_colormap_hash,
 				      (GCompareFunc) gdk_colormap_cmp);
 
-  private = (GdkColormapPrivateX *)cmap;
+  private = GDK_COLORMAP_PRIVATE_DATA (cmap);
 
   g_hash_table_remove (colormap_hash, &private->xcolormap);
 }
diff --git a/gdk/x11/gdkcursor-x11.c b/gdk/x11/gdkcursor-x11.c
index d0a580cccd..277bd2e264 100644
--- a/gdk/x11/gdkcursor-x11.c
+++ b/gdk/x11/gdkcursor-x11.c
@@ -29,6 +29,8 @@
 
 #include "gdkx.h"
 #include "gdkcursor.h"
+#include "gdkpixmap-x11.h"
+#include <gdk/gdkpixmap.h>
 
 GdkCursor*
 gdk_cursor_new (GdkCursorType cursor_type)
@@ -62,12 +64,13 @@ gdk_cursor_new_from_pixmap (GdkPixmap *source,
   Cursor xcursor;
   XColor xfg, xbg;
 
-  g_return_val_if_fail (source != NULL, NULL);
+  g_return_val_if_fail (GDK_IS_PIXMAP (source), NULL);
+  g_return_val_if_fail (GDK_IS_PIXMAP (mask), NULL);
   g_return_val_if_fail (fg != NULL, NULL);
   g_return_val_if_fail (bg != NULL, NULL);
 
-  source_pixmap = GDK_DRAWABLE_XID (source);
-  mask_pixmap   = GDK_DRAWABLE_XID (mask);
+  source_pixmap = GDK_PIXMAP_XID (source);
+  mask_pixmap   = GDK_PIXMAP_XID (mask);
 
   xfg.pixel = fg->pixel;
   xfg.red = fg->red;
diff --git a/gdk/x11/gdkdnd-x11.c b/gdk/x11/gdkdnd-x11.c
index 8509b3220e..05faffd556 100644
--- a/gdk/x11/gdkdnd-x11.c
+++ b/gdk/x11/gdkdnd-x11.c
@@ -34,7 +34,7 @@
 #include "gdkinternals.h"
 #include "gdkprivate-x11.h"
 
-typedef struct _GdkDragContextPrivate GdkDragContextPrivate;
+typedef struct _GdkDragContextPrivateX11 GdkDragContextPrivateX11;
 
 typedef enum {
   GDK_DRAG_STATUS_DRAG,
@@ -58,7 +58,7 @@ typedef struct {
 /* Structure that holds information about a drag in progress.
  * this is used on both source and destination sides.
  */
-struct _GdkDragContextPrivate {
+struct _GdkDragContextPrivateX11 {
   GdkDragContext context;
 
   GdkAtom motif_selection;
@@ -82,6 +82,8 @@ struct _GdkDragContextPrivate {
   GdkWindowCache *window_cache;
 };
 
+#define PRIVATE_DATA(context) ((GdkDragContextPrivateX11 *) GDK_DRAG_CONTEXT (context)->windowing_data)
+
 GdkDragContext *current_dest_drag = NULL;
 
 /* Forward declarations */
@@ -121,66 +123,115 @@ static void   xdnd_manage_source_filter (GdkDragContext *context,
 					 GdkWindow      *window,
 					 gboolean        add_filter);
 
-/* Drag Contexts */
+static void gdk_drag_context_init       (GdkDragContext      *dragcontext);
+static void gdk_drag_context_class_init (GdkDragContextClass *klass);
+static void gdk_drag_context_finalize   (GObject              *object);
 
+static gpointer parent_class = NULL;
 static GList *contexts;
 
-GdkDragContext *
-gdk_drag_context_new        (void)
+GType
+gdk_drag_context_get_type (void)
 {
-  GdkDragContextPrivate *result;
+  static GType object_type = 0;
+
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkDragContextClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_drag_context_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkDragContext),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) gdk_drag_context_init,
+      };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "GdkDragContext",
+                                            &object_info);
+    }
+  
+  return object_type;
+}
 
-  result = g_new0 (GdkDragContextPrivate, 1);
+static void
+gdk_drag_context_init (GdkDragContext *dragcontext)
+{
+  GdkDragContextPrivateX11 *private;
 
-  result->ref_count = 1;
+  private = g_new0 (GdkDragContextPrivateX11, 1);
 
-  contexts = g_list_prepend (contexts, result);
+  dragcontext->windowing_data = private;
 
-  return (GdkDragContext *)result;
+  contexts = g_list_prepend (contexts, dragcontext);
 }
 
-void            
-gdk_drag_context_ref (GdkDragContext *context)
+static void
+gdk_drag_context_class_init (GdkDragContextClass *klass)
 {
-  g_return_if_fail (context != NULL);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  parent_class = g_type_class_peek_parent (klass);
 
-  ((GdkDragContextPrivate *)context)->ref_count++;
+  object_class->finalize = gdk_drag_context_finalize;
 }
 
-void            
-gdk_drag_context_unref (GdkDragContext *context)
+static void
+gdk_drag_context_finalize (GObject *object)
 {
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
-
-  g_return_if_fail (context != NULL);
-  g_return_if_fail (private->ref_count > 0);
-
-  private->ref_count--;
+  GdkDragContext *context = GDK_DRAG_CONTEXT (object);
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
   
-  if (private->ref_count == 0)
+  g_list_free (context->targets);
+
+  if (context->source_window)
     {
-      g_dataset_destroy (private);
+      if ((context->protocol == GDK_DRAG_PROTO_XDND) &&
+          !context->is_source)
+        xdnd_manage_source_filter (context, context->source_window, FALSE);
       
-      g_list_free (context->targets);
+      gdk_window_unref (context->source_window);
+    }
+  
+  if (context->dest_window)
+    gdk_window_unref (context->dest_window);
+  
+  if (private->window_cache)
+    gdk_window_cache_destroy (private->window_cache);
+  
+  contexts = g_list_remove (contexts, context);
 
-      if (context->source_window)
-	{
-	  if ((context->protocol == GDK_DRAG_PROTO_XDND) &&
-	      !context->is_source)
-	    xdnd_manage_source_filter (context, context->source_window, FALSE);
+  g_free (private);
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
 
-	  gdk_window_unref (context->source_window);
-	}
+/* Drag Contexts */
+
+GdkDragContext *
+gdk_drag_context_new        (void)
+{
+  return GDK_DRAG_CONTEXT (g_type_create_instance (gdk_drag_context_get_type ()));
+}
+
+void            
+gdk_drag_context_ref (GdkDragContext *context)
+{
+  g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
 
-      if (context->dest_window)
-	gdk_window_unref (context->dest_window);
+  g_object_ref (G_OBJECT (context));
+}
 
-      if (private->window_cache)
-	gdk_window_cache_destroy (private->window_cache);
+void            
+gdk_drag_context_unref (GdkDragContext *context)
+{
+  g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
 
-      contexts = g_list_remove (contexts, private);
-      g_free (private);
-    }
+  g_object_unref (G_OBJECT (context));
 }
 
 static GdkDragContext *
@@ -190,19 +241,19 @@ gdk_drag_context_find (gboolean is_source,
 {
   GList *tmp_list = contexts;
   GdkDragContext *context;
-  GdkDragContextPrivate *private;
+  GdkDragContextPrivateX11 *private;
   Window context_dest_xid;
 
   while (tmp_list)
     {
       context = (GdkDragContext *)tmp_list->data;
-      private = (GdkDragContextPrivate *)context;
+      private = PRIVATE_DATA (context);
 
       context_dest_xid = context->dest_window ? 
-	                   (private->drop_xid ?
-			      private->drop_xid :
-			      GDK_DRAWABLE_XID (context->dest_window)) :
-	                   None;
+                            (private->drop_xid ?
+                              private->drop_xid :
+                              GDK_DRAWABLE_XID (context->dest_window)) :
+	                     None;
 
       if ((!context->is_source == !is_source) &&
 	  ((source_xid == None) || (context->source_window &&
@@ -1250,7 +1301,7 @@ motif_dnd_get_flags (GdkDragContext *context)
 static void
 motif_set_targets (GdkDragContext *context)
 {
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
   MotifDragInitiatorInfo info;
   gint i;
   static GdkAtom motif_drag_initiator_info = GDK_NONE;
@@ -1334,7 +1385,7 @@ motif_send_enter (GdkDragContext  *context,
 		  guint32          time)
 {
   XEvent xev;
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
 
   xev.xclient.type = ClientMessage;
   xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
@@ -1393,7 +1444,7 @@ motif_send_motion (GdkDragContext  *context,
 {
   gboolean retval;
   XEvent xev;
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
 
   xev.xclient.type = ClientMessage;
   xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
@@ -1436,7 +1487,7 @@ static void
 motif_send_drop (GdkDragContext *context, guint32 time)
 {
   XEvent xev;
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
 
   xev.xclient.type = ClientMessage;
   xev.xclient.message_type = gdk_atom_intern ("_MOTIF_DRAG_AND_DROP_MESSAGE", FALSE);
@@ -1537,7 +1588,7 @@ motif_drag_context_new (GdkWindow *dest_window,
 			guint32    atom)
 {
   GdkDragContext *new_context;
-  GdkDragContextPrivate *private;
+  GdkDragContextPrivateX11 *private;
 
   /* FIXME, current_dest_drag really shouldn't be NULL'd
    * if we error below.
@@ -1554,7 +1605,7 @@ motif_drag_context_new (GdkWindow *dest_window,
     }
 
   new_context = gdk_drag_context_new ();
-  private = (GdkDragContextPrivate *)new_context;
+  private = PRIVATE_DATA (new_context);
 
   new_context->protocol = GDK_DRAG_PROTO_MOTIF;
   new_context->is_source = FALSE;
@@ -1651,7 +1702,7 @@ motif_motion (GdkEvent *event,
 	      gint16    x_root,
 	      gint16    y_root)
 {
-  GdkDragContextPrivate *private;
+  GdkDragContextPrivateX11 *private;
 
   GDK_NOTE(DND, g_message ("Motif DND motion: flags: %#4x time: %d (%d, %d)",
 			   flags, timestamp, x_root, y_root));
@@ -1660,7 +1711,7 @@ motif_motion (GdkEvent *event,
       (current_dest_drag->protocol == GDK_DRAG_PROTO_MOTIF) &&
       (timestamp >= current_dest_drag->start_time))
     {
-      private = (GdkDragContextPrivate *)current_dest_drag;
+      private = PRIVATE_DATA (current_dest_drag);
 
       event->dnd.type = GDK_DRAG_MOTION;
       event->dnd.context = current_dest_drag;
@@ -1689,7 +1740,7 @@ motif_operation_changed (GdkEvent *event,
 			 guint16   flags, 
 			 guint32   timestamp)
 {
-  GdkDragContextPrivate *private;
+  GdkDragContextPrivateX11 *private;
 
   GDK_NOTE(DND, g_message ("Motif DND operation changed: flags: %#4x time: %d",
 			   flags, timestamp));
@@ -1704,7 +1755,7 @@ motif_operation_changed (GdkEvent *event,
       gdk_drag_context_ref (current_dest_drag);
 
       event->dnd.time = timestamp;
-      private = (GdkDragContextPrivate *)current_dest_drag;
+      private = PRIVATE_DATA (current_dest_drag);
 
       motif_dnd_translate_flags (current_dest_drag, flags);
 
@@ -1768,7 +1819,7 @@ motif_drag_status (GdkEvent *event,
 
   if (context)
     {
-      GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+      GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
       if ((private->drag_status == GDK_DRAG_STATUS_MOTION_WAIT) ||
 	  (private->drag_status == GDK_DRAG_STATUS_ACTION_WAIT))
 	private->drag_status = GDK_DRAG_STATUS_DRAG;
@@ -1967,7 +2018,7 @@ xdnd_status_filter (GdkXEvent *xev,
   context = gdk_drag_context_find (TRUE, xevent->xclient.window, dest_window);
   if (context)
     {
-      GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+      GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
       if (private->drag_status == GDK_DRAG_STATUS_MOTION_WAIT)
 	private->drag_status = GDK_DRAG_STATUS_DRAG;
       
@@ -2020,7 +2071,7 @@ xdnd_finished_filter (GdkXEvent *xev,
 static void
 xdnd_set_targets (GdkDragContext *context)
 {
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
   GdkAtom *atomlist;
   GList *tmp_list = context->targets;
   gint i;
@@ -2049,7 +2100,7 @@ xdnd_set_targets (GdkDragContext *context)
 static void
 xdnd_set_actions (GdkDragContext *context)
 {
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
   GdkAtom *atomlist;
   gint i;
   gint n_atoms;
@@ -2119,7 +2170,7 @@ static void
 xdnd_send_enter (GdkDragContext *context)
 {
   XEvent xev;
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
 
   xev.xclient.type = ClientMessage;
   xev.xclient.message_type = gdk_atom_intern ("XdndEnter", FALSE);
@@ -2171,7 +2222,7 @@ xdnd_send_leave (GdkDragContext *context)
 {
   XEvent xev;
 
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
 
   xev.xclient.type = ClientMessage;
   xev.xclient.message_type = gdk_atom_intern ("XdndLeave", FALSE);
@@ -2199,7 +2250,7 @@ xdnd_send_leave (GdkDragContext *context)
 static void
 xdnd_send_drop (GdkDragContext *context, guint32 time)
 {
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
   XEvent xev;
 
   xev.xclient.type = ClientMessage;
@@ -2232,7 +2283,7 @@ xdnd_send_motion (GdkDragContext *context,
 		  GdkDragAction   action,
 		  guint32         time)
 {
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
   XEvent xev;
 
   xev.xclient.type = ClientMessage;
@@ -2365,7 +2416,7 @@ xdnd_read_actions (GdkDragContext *context)
       for (i=0; i<nitems; i++)
 	context->actions |= xdnd_action_from_atom (data[i]);
 
-      ((GdkDragContextPrivate *)context)->xdnd_have_actions = TRUE;
+      (PRIVATE_DATA (context))->xdnd_have_actions = TRUE;
 
 #ifdef G_ENABLE_DEBUG
       if (gdk_debug_flags & GDK_DEBUG_DND)
@@ -2423,16 +2474,10 @@ xdnd_manage_source_filter (GdkDragContext *context,
 			   gboolean        add_filter)
 {
   gint old_warnings = 0;	/* quiet gcc */
-			       
-  gboolean is_foreign = GDK_DRAWABLE_TYPE (window);
 
-  if (is_foreign)
-    {
-      old_warnings = gdk_error_warnings;
-      gdk_error_warnings = 0;
-    }
+  gdk_error_trap_push ();
 
-  if (!GDK_DRAWABLE_DESTROYED (window))
+  if (!GDK_WINDOW_DESTROYED (window))
     {
       if (add_filter)
 	{
@@ -2454,11 +2499,8 @@ xdnd_manage_source_filter (GdkDragContext *context,
 	}
     }
 
-  if (is_foreign)
-    {
-      gdk_flush();
-      gdk_error_warnings = old_warnings;
-    }
+  gdk_flush ();
+  gdk_error_trap_pop ();  
 }
 
 static GdkFilterReturn 
@@ -2558,7 +2600,7 @@ xdnd_enter_filter (GdkXEvent *xev,
   gdk_drag_context_ref (new_context);
 
   current_dest_drag = new_context;
-  ((GdkDragContextPrivate *)new_context)->xdnd_selection = 
+  (PRIVATE_DATA (new_context))->xdnd_selection = 
     gdk_atom_intern ("XdndSelection", FALSE);
 
   return GDK_FILTER_TRANSLATE;
@@ -2620,14 +2662,14 @@ xdnd_position_filter (GdkXEvent *xev,
       event->dnd.time = time;
 
       current_dest_drag->suggested_action = xdnd_action_from_atom (action);
-      if (!((GdkDragContextPrivate *)current_dest_drag)->xdnd_have_actions)
+      if (!(PRIVATE_DATA (current_dest_drag))->xdnd_have_actions)
 	current_dest_drag->actions = current_dest_drag->suggested_action;
 
       event->dnd.x_root = x_root;
       event->dnd.y_root = y_root;
 
-      ((GdkDragContextPrivate *)current_dest_drag)->last_x = x_root;
-      ((GdkDragContextPrivate *)current_dest_drag)->last_y = y_root;
+      (PRIVATE_DATA (current_dest_drag))->last_x = x_root;
+      (PRIVATE_DATA (current_dest_drag))->last_y = y_root;
       
       return GDK_FILTER_TRANSLATE;
     }
@@ -2652,8 +2694,8 @@ xdnd_drop_filter (GdkXEvent *xev,
       (current_dest_drag->protocol == GDK_DRAG_PROTO_XDND) &&
       (GDK_DRAWABLE_XID (current_dest_drag->source_window) == source_window))
     {
-      GdkDragContextPrivate *private;
-      private = (GdkDragContextPrivate *)current_dest_drag;
+      GdkDragContextPrivateX11 *private;
+      private = PRIVATE_DATA (current_dest_drag);
 
       event->dnd.type = GDK_DROP_START;
 
@@ -2843,7 +2885,7 @@ gdk_drag_find_window (GdkDragContext  *context,
 		      GdkWindow      **dest_window,
 		      GdkDragProtocol *protocol)
 {
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
   Window dest;
 
   g_return_if_fail (context != NULL);
@@ -2899,7 +2941,7 @@ gdk_drag_motion (GdkDragContext *context,
 		 GdkDragAction   possible_actions,
 		 guint32         time)
 {
-  GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
+  GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
 
   g_return_val_if_fail (context != NULL, FALSE);
 
@@ -3073,12 +3115,12 @@ gdk_drag_status (GdkDragContext   *context,
 		 GdkDragAction     action,
 		 guint32           time)
 {
-  GdkDragContextPrivate *private;
+  GdkDragContextPrivateX11 *private;
   XEvent xev;
 
   g_return_if_fail (context != NULL);
 
-  private = (GdkDragContextPrivate *)context;
+  private = PRIVATE_DATA (context);
 
   context->action = action;
   
@@ -3167,11 +3209,11 @@ gdk_drop_reply (GdkDragContext   *context,
 		gboolean          ok,
 		guint32           time)
 {
-  GdkDragContextPrivate *private;
+  GdkDragContextPrivateX11 *private;
 
   g_return_if_fail (context != NULL);
 
-  private = (GdkDragContextPrivate *)context;
+  private = PRIVATE_DATA (context);
   
   if (context->protocol == GDK_DRAG_PROTO_MOTIF)
     {
@@ -3291,9 +3333,9 @@ gdk_drag_get_selection (GdkDragContext *context)
   g_return_val_if_fail (context != NULL, GDK_NONE);
 
   if (context->protocol == GDK_DRAG_PROTO_MOTIF)
-    return ((GdkDragContextPrivate *)context)->motif_selection;
+    return (PRIVATE_DATA (context))->motif_selection;
   else if (context->protocol == GDK_DRAG_PROTO_XDND)
-    return ((GdkDragContextPrivate *)context)->xdnd_selection;
+    return (PRIVATE_DATA (context))->xdnd_selection;
   else 
     return GDK_NONE;
 }
diff --git a/gdk/x11/gdkdrawable-x11.c b/gdk/x11/gdkdrawable-x11.c
index 91cc77647a..6ed59558af 100644
--- a/gdk/x11/gdkdrawable-x11.c
+++ b/gdk/x11/gdkdrawable-x11.c
@@ -26,161 +26,196 @@
 
 #include "gdkprivate-x11.h"
 #include <pango/pangox.h>
+#include <config.h>
 
-static void gdk_x11_drawable_destroy (GdkDrawable      *drawable);
-
-static void gdk_x11_draw_rectangle   (GdkDrawable      *drawable,
-				      GdkGC            *gc,
-				      gint              filled,
-				      gint              x,
-				      gint              y,
-				      gint              width,
-				      gint              height);
-static void gdk_x11_draw_arc         (GdkDrawable      *drawable,
-				      GdkGC            *gc,
-				      gint              filled,
-				      gint              x,
-				      gint              y,
-				      gint              width,
-				      gint              height,
-				      gint              angle1,
-				      gint              angle2);
-static void gdk_x11_draw_polygon     (GdkDrawable      *drawable,
-				      GdkGC            *gc,
-				      gint              filled,
-				      GdkPoint         *points,
-				      gint              npoints);
-static void gdk_x11_draw_text        (GdkDrawable      *drawable,
-				      GdkFont          *font,
-				      GdkGC            *gc,
-				      gint              x,
-				      gint              y,
-				      const gchar      *text,
-				      gint              text_length);
-static void gdk_x11_draw_text_wc     (GdkDrawable      *drawable,
-				      GdkFont          *font,
-				      GdkGC            *gc,
-				      gint              x,
-				      gint              y,
-				      const GdkWChar   *text,
-				      gint              text_length);
-static void gdk_x11_draw_drawable    (GdkDrawable      *drawable,
-				      GdkGC            *gc,
-				      GdkPixmap        *src,
-				      gint              xsrc,
-				      gint              ysrc,
-				      gint              xdest,
-				      gint              ydest,
-				      gint              width,
-				      gint              height);
-static void gdk_x11_draw_points      (GdkDrawable      *drawable,
-				      GdkGC            *gc,
-				      GdkPoint         *points,
-				      gint              npoints);
-static void gdk_x11_draw_segments    (GdkDrawable      *drawable,
-				      GdkGC            *gc,
-				      GdkSegment       *segs,
-				      gint              nsegs);
-static void gdk_x11_draw_lines       (GdkDrawable      *drawable,
-				      GdkGC            *gc,
-				      GdkPoint         *points,
-				      gint              npoints);
-static void gdk_x11_draw_glyphs      (GdkDrawable      *drawable,
-				      GdkGC            *gc,
-				      PangoFont        *font,
-				      gint              x,
-				      gint              y,
-				      PangoGlyphString *glyphs);
-
-GdkDrawableClass _gdk_x11_drawable_class = {
-  gdk_x11_drawable_destroy,
-  _gdk_x11_gc_new,
-  gdk_x11_draw_rectangle,
-  gdk_x11_draw_arc,
-  gdk_x11_draw_polygon,
-  gdk_x11_draw_text,
-  gdk_x11_draw_text_wc,
-  gdk_x11_draw_drawable,
-  gdk_x11_draw_points,
-  gdk_x11_draw_segments,
-  gdk_x11_draw_lines,
-  gdk_x11_draw_glyphs,
-};
+#include <stdlib.h>
 
-/*****************************************************
- * X11 specific implementations of generic functions *
- *****************************************************/
+#if defined (HAVE_IPC_H) && defined (HAVE_SHM_H) && defined (HAVE_XSHM_H)
+#define USE_SHM
+#endif
 
-GdkColormap*
-gdk_drawable_get_colormap (GdkDrawable *drawable)
+#ifdef USE_SHM
+#include <X11/extensions/XShm.h>
+#endif /* USE_SHM */
+
+#include "gdkprivate-x11.h"
+#include "gdkdrawable-x11.h"
+#include "gdkpixmap-x11.h"
+
+static void gdk_x11_draw_rectangle (GdkDrawable    *drawable,
+				    GdkGC          *gc,
+				    gint            filled,
+				    gint            x,
+				    gint            y,
+				    gint            width,
+				    gint            height);
+static void gdk_x11_draw_arc       (GdkDrawable    *drawable,
+				    GdkGC          *gc,
+				    gint            filled,
+				    gint            x,
+				    gint            y,
+				    gint            width,
+				    gint            height,
+				    gint            angle1,
+				    gint            angle2);
+static void gdk_x11_draw_polygon   (GdkDrawable    *drawable,
+				    GdkGC          *gc,
+				    gint            filled,
+				    GdkPoint       *points,
+				    gint            npoints);
+static void gdk_x11_draw_text      (GdkDrawable    *drawable,
+				    GdkFont        *font,
+				    GdkGC          *gc,
+				    gint            x,
+				    gint            y,
+				    const gchar    *text,
+				    gint            text_length);
+static void gdk_x11_draw_text_wc   (GdkDrawable    *drawable,
+				    GdkFont        *font,
+				    GdkGC          *gc,
+				    gint            x,
+				    gint            y,
+				    const GdkWChar *text,
+				    gint            text_length);
+static void gdk_x11_draw_drawable  (GdkDrawable    *drawable,
+				    GdkGC          *gc,
+				    GdkPixmap      *src,
+				    gint            xsrc,
+				    gint            ysrc,
+				    gint            xdest,
+				    gint            ydest,
+				    gint            width,
+				    gint            height);
+static void gdk_x11_draw_points    (GdkDrawable    *drawable,
+				    GdkGC          *gc,
+				    GdkPoint       *points,
+				    gint            npoints);
+static void gdk_x11_draw_segments  (GdkDrawable    *drawable,
+				    GdkGC          *gc,
+				    GdkSegment     *segs,
+				    gint            nsegs);
+static void gdk_x11_draw_lines     (GdkDrawable    *drawable,
+				    GdkGC          *gc,
+				    GdkPoint       *points,
+				    gint            npoints);
+static void gdk_x11_draw_glyphs    (GdkDrawable      *drawable,
+                                    GdkGC            *gc,
+                                    PangoFont        *font,
+                                    gint              x,
+                                    gint              y,
+                                    PangoGlyphString *glyphs);
+static void gdk_x11_draw_image     (GdkDrawable     *drawable,
+                                    GdkGC           *gc,
+                                    GdkImage        *image,
+                                    gint             xsrc,
+                                    gint             ysrc,
+                                    gint             xdest,
+                                    gint             ydest,
+                                    gint             width,
+                                    gint             height);
+
+static void gdk_x11_set_colormap   (GdkDrawable    *drawable,
+                                    GdkColormap    *colormap);
+
+static GdkColormap* gdk_x11_get_colormap   (GdkDrawable    *drawable);
+
+static gint         gdk_x11_get_depth      (GdkDrawable    *drawable);
+
+static void gdk_drawable_impl_x11_class_init (GdkDrawableImplX11Class *klass);
+
+static gpointer parent_class = NULL;
+
+GType
+gdk_drawable_impl_x11_get_type (void)
 {
-  GdkDrawablePrivate *drawable_private;
-  XWindowAttributes window_attributes;
-  
-  g_return_val_if_fail (drawable != NULL, NULL);
-  drawable_private = (GdkDrawablePrivate*) drawable;
-  
-  if (!GDK_DRAWABLE_DESTROYED (drawable))
-    {
-      if (drawable_private->colormap == NULL &&
-	  GDK_IS_WINDOW (drawable))
-	{
-	  XGetWindowAttributes (GDK_DRAWABLE_XDISPLAY (drawable),
-				GDK_DRAWABLE_XID (drawable),
-				&window_attributes);
-	  drawable_private->colormap =  gdk_colormap_lookup (window_attributes.colormap);
-	}
+  static GType object_type = 0;
 
-      return drawable_private->colormap;
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkDrawableImplX11Class),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_drawable_impl_x11_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkDrawableImplX11),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) NULL,
+      };
+      
+      object_type = g_type_register_static (GDK_TYPE_DRAWABLE,
+                                            "GdkDrawableImplX11",
+                                            &object_info);
     }
   
-  return NULL;
+  return object_type;
 }
 
-void
-gdk_drawable_set_colormap (GdkDrawable *drawable,
-			   GdkColormap *colormap)
+static void
+gdk_drawable_impl_x11_class_init (GdkDrawableImplX11Class *klass)
 {
-  GdkDrawablePrivate *drawable_private;
-  GdkColormapPrivateX *colormap_private;
-  
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (colormap != NULL);
+  GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  drawable_class->create_gc = _gdk_x11_gc_new;
+  drawable_class->draw_rectangle = gdk_x11_draw_rectangle;
+  drawable_class->draw_arc = gdk_x11_draw_arc;
+  drawable_class->draw_polygon = gdk_x11_draw_polygon;
+  drawable_class->draw_text = gdk_x11_draw_text;
+  drawable_class->draw_text_wc = gdk_x11_draw_text_wc;
+  drawable_class->draw_drawable = gdk_x11_draw_drawable;
+  drawable_class->draw_points = gdk_x11_draw_points;
+  drawable_class->draw_segments = gdk_x11_draw_segments;
+  drawable_class->draw_lines = gdk_x11_draw_lines;
+  drawable_class->draw_glyphs = gdk_x11_draw_glyphs;
+  drawable_class->draw_image = gdk_x11_draw_image;
   
-  drawable_private = (GdkDrawablePrivate *)drawable;
-  colormap_private = (GdkColormapPrivateX *)colormap;
-  
-  if (!GDK_DRAWABLE_DESTROYED (drawable))
-    {
-      if (GDK_IS_WINDOW (drawable))
-	{
-	  g_return_if_fail (colormap_private->base.visual !=
-			    ((GdkColormapPrivate *)(drawable_private->colormap))->visual);
+  drawable_class->set_colormap = gdk_x11_set_colormap;
+  drawable_class->get_colormap = gdk_x11_get_colormap;
 
-	  XSetWindowColormap (GDK_DRAWABLE_XDISPLAY (drawable),
-			      GDK_DRAWABLE_XID (drawable),
-			      colormap_private->xcolormap);
-	}
+  drawable_class->get_depth = gdk_x11_get_depth;
+}
 
-      if (drawable_private->colormap)
-	gdk_colormap_unref (drawable_private->colormap);
-      drawable_private->colormap = colormap;
-      gdk_colormap_ref (drawable_private->colormap);
+/*****************************************************
+ * X11 specific implementations of generic functions *
+ *****************************************************/
 
-      if (GDK_IS_WINDOW (drawable) &&
-	  drawable_private->window_type != GDK_WINDOW_TOPLEVEL)
-	gdk_window_add_colormap_windows (drawable);
-    }
+static GdkColormap*
+gdk_x11_get_colormap (GdkDrawable *drawable)
+{
+  GdkDrawableImplX11 *impl;
+
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+
+  return impl->colormap;
 }
 
-/* Drawing
- */
-static void 
-gdk_x11_drawable_destroy (GdkDrawable *drawable)
+static void
+gdk_x11_set_colormap (GdkDrawable *drawable,
+                      GdkColormap *colormap)
 {
+  GdkDrawableImplX11 *impl;
+  
+  g_return_if_fail (colormap != NULL);  
+
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+
+  if (impl->colormap == colormap)
+    return;
   
+  if (impl->colormap)
+    gdk_colormap_unref (impl->colormap);
+  impl->colormap = colormap;
+  if (impl->colormap)
+    gdk_colormap_ref (impl->colormap);
 }
 
+/* Drawing
+ */
+
 static void
 gdk_x11_draw_rectangle (GdkDrawable *drawable,
 			GdkGC       *gc,
@@ -190,11 +225,15 @@ gdk_x11_draw_rectangle (GdkDrawable *drawable,
 			gint         width,
 			gint         height)
 {
+  GdkDrawableImplX11 *impl;
+
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+  
   if (filled)
-    XFillRectangle (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+    XFillRectangle (impl->xdisplay, impl->xid,
 		    GDK_GC_GET_XGC (gc), x, y, width, height);
   else
-    XDrawRectangle (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+    XDrawRectangle (impl->xdisplay, impl->xid,
 		    GDK_GC_GET_XGC (gc), x, y, width, height);
 }
 
@@ -209,11 +248,16 @@ gdk_x11_draw_arc (GdkDrawable *drawable,
 		  gint         angle1,
 		  gint         angle2)
 {
+  GdkDrawableImplX11 *impl;
+
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+
+  
   if (filled)
-    XFillArc (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+    XFillArc (impl->xdisplay, impl->xid,
 	      GDK_GC_GET_XGC (gc), x, y, width, height, angle1, angle2);
   else
-    XDrawArc (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+    XDrawArc (impl->xdisplay, impl->xid,
 	      GDK_GC_GET_XGC (gc), x, y, width, height, angle1, angle2);
 }
 
@@ -226,7 +270,11 @@ gdk_x11_draw_polygon (GdkDrawable *drawable,
 {
   XPoint *tmp_points;
   gint tmp_npoints, i;
+  GdkDrawableImplX11 *impl;
 
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+
+  
   if (!filled &&
       (points[0].x != points[npoints-1].x || points[0].y != points[npoints-1].y))
     {
@@ -248,10 +296,10 @@ gdk_x11_draw_polygon (GdkDrawable *drawable,
     }
   
   if (filled)
-    XFillPolygon (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+    XFillPolygon (impl->xdisplay, impl->xid,
 		  GDK_GC_GET_XGC (gc), tmp_points, tmp_npoints, Complex, CoordModeOrigin);
   else
-    XDrawLines (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+    XDrawLines (impl->xdisplay, impl->xid,
 		GDK_GC_GET_XGC (gc), tmp_points, tmp_npoints, CoordModeOrigin);
 
   g_free (tmp_points);
@@ -272,25 +320,29 @@ gdk_x11_draw_text (GdkDrawable *drawable,
 		   const gchar *text,
 		   gint         text_length)
 {
+  GdkDrawableImplX11 *impl;
+
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+  
   if (font->type == GDK_FONT_FONT)
     {
       XFontStruct *xfont = (XFontStruct *) GDK_FONT_XFONT (font);
-      XSetFont(GDK_DRAWABLE_XDISPLAY (drawable), GDK_GC_GET_XGC (gc), xfont->fid);
+      XSetFont(impl->xdisplay, GDK_GC_GET_XGC (gc), xfont->fid);
       if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0))
 	{
-	  XDrawString (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+	  XDrawString (impl->xdisplay, impl->xid,
 		       GDK_GC_GET_XGC (gc), x, y, text, text_length);
 	}
       else
 	{
-	  XDrawString16 (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+	  XDrawString16 (impl->xdisplay, impl->xid,
 			 GDK_GC_GET_XGC (gc), x, y, (XChar2b *) text, text_length / 2);
 	}
     }
   else if (font->type == GDK_FONT_FONTSET)
     {
       XFontSet fontset = (XFontSet) GDK_FONT_XFONT (font);
-      XmbDrawString (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+      XmbDrawString (impl->xdisplay, impl->xid,
 		     fontset, GDK_GC_GET_XGC (gc), x, y, text, text_length);
     }
   else
@@ -306,15 +358,19 @@ gdk_x11_draw_text_wc (GdkDrawable    *drawable,
 		      const GdkWChar *text,
 		      gint	      text_length)
 {
+  GdkDrawableImplX11 *impl;
+
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+  
   if (font->type == GDK_FONT_FONT)
     {
       XFontStruct *xfont = (XFontStruct *) GDK_FONT_XFONT (font);
       gchar *text_8bit;
       gint i;
-      XSetFont(GDK_DRAWABLE_XDISPLAY (drawable), GDK_GC_GET_XGC (gc), xfont->fid);
+      XSetFont(impl->xdisplay, GDK_GC_GET_XGC (gc), xfont->fid);
       text_8bit = g_new (gchar, text_length);
       for (i=0; i<text_length; i++) text_8bit[i] = text[i];
-      XDrawString (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+      XDrawString (impl->xdisplay, impl->xid,
                    GDK_GC_GET_XGC (gc), x, y, text_8bit, text_length);
       g_free (text_8bit);
     }
@@ -322,7 +378,7 @@ gdk_x11_draw_text_wc (GdkDrawable    *drawable,
     {
       if (sizeof(GdkWChar) == sizeof(wchar_t))
 	{
-	  XwcDrawString (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+	  XwcDrawString (impl->xdisplay, impl->xid,
 			 (XFontSet) GDK_FONT_XFONT (font),
 			 GDK_GC_GET_XGC (gc), x, y, (wchar_t *)text, text_length);
 	}
@@ -332,7 +388,7 @@ gdk_x11_draw_text_wc (GdkDrawable    *drawable,
 	  gint i;
 	  text_wchar = g_new (wchar_t, text_length);
 	  for (i=0; i<text_length; i++) text_wchar[i] = text[i];
-	  XwcDrawString (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+	  XwcDrawString (impl->xdisplay, impl->xid,
 			 (XFontSet) GDK_FONT_XFONT (font),
 			 GDK_GC_GET_XGC (gc), x, y, text_wchar, text_length);
 	  g_free (text_wchar);
@@ -355,12 +411,15 @@ gdk_x11_draw_drawable (GdkDrawable *drawable,
 {
   int src_depth = gdk_drawable_get_depth (src);
   int dest_depth = gdk_drawable_get_depth (drawable);
+  GdkDrawableImplX11 *impl;
 
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+  
   if (src_depth == 1)
     {
-      XCopyArea (GDK_DRAWABLE_XDISPLAY (drawable),
+      XCopyArea (impl->xdisplay,
 		 GDK_DRAWABLE_XID (src),
-		 GDK_DRAWABLE_XID (drawable),
+		 impl->xid,
 		 GDK_GC_GET_XGC (gc),
 		 xsrc, ysrc,
 		 width, height,
@@ -368,9 +427,9 @@ gdk_x11_draw_drawable (GdkDrawable *drawable,
     }
   else if (dest_depth != 0 && src_depth == dest_depth)
     {
-      XCopyArea (GDK_DRAWABLE_XDISPLAY (drawable),
+      XCopyArea (impl->xdisplay,
 		 GDK_DRAWABLE_XID (src),
-		 GDK_DRAWABLE_XID (drawable),
+		 impl->xid,
 		 GDK_GC_GET_XGC (gc),
 		 xsrc, ysrc,
 		 width, height,
@@ -386,13 +445,18 @@ gdk_x11_draw_points (GdkDrawable *drawable,
 		     GdkPoint    *points,
 		     gint         npoints)
 {
+  GdkDrawableImplX11 *impl;
+
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+
+  
   /* We special-case npoints == 1, because X will merge multiple
    * consecutive XDrawPoint requests into a PolyPoint request
    */
   if (npoints == 1)
     {
-      XDrawPoint (GDK_DRAWABLE_XDISPLAY (drawable),
-		  GDK_DRAWABLE_XID (drawable),
+      XDrawPoint (impl->xdisplay,
+		  impl->xid,
 		  GDK_GC_GET_XGC (gc),
 		  points[0].x, points[0].y);
     }
@@ -407,8 +471,8 @@ gdk_x11_draw_points (GdkDrawable *drawable,
 	  tmp_points[i].y = points[i].y;
 	}
       
-      XDrawPoints (GDK_DRAWABLE_XDISPLAY (drawable),
-		   GDK_DRAWABLE_XID (drawable),
+      XDrawPoints (impl->xdisplay,
+		   impl->xid,
 		   GDK_GC_GET_XGC (gc),
 		   tmp_points,
 		   npoints,
@@ -424,12 +488,17 @@ gdk_x11_draw_segments (GdkDrawable *drawable,
 		       GdkSegment  *segs,
 		       gint         nsegs)
 {
+  GdkDrawableImplX11 *impl;
+
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+
+  
   /* We special-case nsegs == 1, because X will merge multiple
    * consecutive XDrawLine requests into a PolySegment request
    */
   if (nsegs == 1)
     {
-      XDrawLine (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable),
+      XDrawLine (impl->xdisplay, impl->xid,
 		 GDK_GC_GET_XGC (gc), segs[0].x1, segs[0].y1,
 		 segs[0].x2, segs[0].y2);
     }
@@ -446,8 +515,8 @@ gdk_x11_draw_segments (GdkDrawable *drawable,
 	  tmp_segs[i].y2 = segs[i].y2;
 	}
       
-      XDrawSegments (GDK_DRAWABLE_XDISPLAY (drawable),
-		     GDK_DRAWABLE_XID (drawable),
+      XDrawSegments (impl->xdisplay,
+		     impl->xid,
 		     GDK_GC_GET_XGC (gc),
 		     tmp_segs, nsegs);
 
@@ -463,15 +532,19 @@ gdk_x11_draw_lines (GdkDrawable *drawable,
 {
   gint i;
   XPoint *tmp_points = g_new (XPoint, npoints);
+  GdkDrawableImplX11 *impl;
+
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
 
+  
   for (i=0; i<npoints; i++)
     {
       tmp_points[i].x = points[i].x;
       tmp_points[i].y = points[i].y;
     }
       
-  XDrawLines (GDK_DRAWABLE_XDISPLAY (drawable),
-	      GDK_DRAWABLE_XID (drawable),
+  XDrawLines (impl->xdisplay,
+	      impl->xid,
 	      GDK_GC_GET_XGC (gc),
 	      tmp_points, npoints,
 	      CoordModeOrigin);
@@ -487,8 +560,46 @@ gdk_x11_draw_glyphs (GdkDrawable      *drawable,
 		     gint              y,
 		     PangoGlyphString *glyphs)
 {
-  pango_x_render (GDK_DRAWABLE_XDISPLAY (drawable),
-		  GDK_DRAWABLE_XID (drawable),
+  GdkDrawableImplX11 *impl;
+
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+
+  pango_x_render (impl->xdisplay,
+                  impl->xid,
 		  GDK_GC_GET_XGC (gc),
 		  font, glyphs, x, y);
 }
+
+static void
+gdk_x11_draw_image     (GdkDrawable     *drawable,
+                        GdkGC           *gc,
+                        GdkImage        *image,
+                        gint             xsrc,
+                        gint             ysrc,
+                        gint             xdest,
+                        gint             ydest,
+                        gint             width,
+                        gint             height)
+{
+  GdkDrawableImplX11 *impl;
+  
+  impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+
+  if (image->type == GDK_IMAGE_SHARED)
+    XShmPutImage (impl->xdisplay, impl->xid,
+                  GDK_GC_GET_XGC (gc), GDK_IMAGE_XIMAGE (image),
+                  xsrc, ysrc, xdest, ydest, width, height, False);
+  else
+    XPutImage (impl->xdisplay, impl->xid,
+               GDK_GC_GET_XGC (gc), GDK_IMAGE_XIMAGE (image),
+               xsrc, ysrc, xdest, ydest, width, height);
+}
+
+static gint
+gdk_x11_get_depth (GdkDrawable *drawable)
+{
+  /* This is a bit bogus but I'm not sure the other way is better */
+
+  return gdk_drawable_get_depth (GDK_DRAWABLE_IMPL_X11 (drawable)->wrapper);
+}
+
diff --git a/gdk/x11/gdkdrawable-x11.h b/gdk/x11/gdkdrawable-x11.h
new file mode 100644
index 0000000000..d0e3d552e1
--- /dev/null
+++ b/gdk/x11/gdkdrawable-x11.h
@@ -0,0 +1,73 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#ifndef __GDK_DRAWABLE_X11_H__
+#define __GDK_DRAWABLE_X11_H__
+
+#include <gdk/gdkdrawable.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Drawable implementation for X11
+ */
+
+typedef struct _GdkDrawableImplX11 GdkDrawableImplX11;
+typedef struct _GdkDrawableImplX11Class GdkDrawableImplX11Class;
+
+#define GDK_TYPE_DRAWABLE_IMPL_X11              (gdk_drawable_impl_x11_get_type ())
+#define GDK_DRAWABLE_IMPL_X11(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAWABLE_IMPL_X11, GdkDrawableImplX11))
+#define GDK_DRAWABLE_IMPL_X11_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DRAWABLE_IMPL_X11, GdkDrawableImplX11Class))
+#define GDK_IS_DRAWABLE_IMPL_X11(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAWABLE_IMPL_X11))
+#define GDK_IS_DRAWABLE_IMPL_X11_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DRAWABLE_IMPL_X11))
+#define GDK_DRAWABLE_IMPL_X11_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DRAWABLE_IMPL_X11, GdkDrawableImplX11Class))
+
+struct _GdkDrawableImplX11
+{
+  GdkDrawable parent_instance;
+
+  GdkDrawable *wrapper;
+  
+  GdkColormap *colormap;
+  
+  Window xid;
+  Display *xdisplay;
+};
+ 
+struct _GdkDrawableImplX11Class 
+{
+  GdkDrawableClass parent_class;
+
+};
+
+GType gdk_drawable_impl_x11_get_type (void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GDK_DRAWABLE_X11_H__ */
diff --git a/gdk/x11/gdkevents-x11.c b/gdk/x11/gdkevents-x11.c
index 7036b96cec..b9e0285c50 100644
--- a/gdk/x11/gdkevents-x11.c
+++ b/gdk/x11/gdkevents-x11.c
@@ -261,7 +261,7 @@ gdk_event_translate (GdkEvent *event,
 {
   
   GdkWindow *window;
-  GdkWindowPrivate *window_private;
+  GdkWindowObject *window_private;
   static XComposeStatus compose;
   KeySym keysym;
   int charcount;
@@ -297,7 +297,7 @@ gdk_event_translate (GdkEvent *event,
   window = gdk_window_lookup (xevent->xany.window);
   /* FIXME: window might be a GdkPixmap!!! */
   
-  window_private = (GdkWindowPrivate *) window;
+  window_private = (GdkWindowObject *) window;
   
   if (window != NULL)
     gdk_window_ref (window);
@@ -305,10 +305,10 @@ gdk_event_translate (GdkEvent *event,
   event->any.window = window;
   event->any.send_event = xevent->xany.send_event ? TRUE : FALSE;
   
-  if (window_private && GDK_DRAWABLE_DESTROYED (window))
+  if (window_private && GDK_WINDOW_DESTROYED (window))
     {
       if (xevent->type != DestroyNotify)
-	return FALSE;
+        return FALSE;
     }
   else
     {
@@ -329,7 +329,7 @@ gdk_event_translate (GdkEvent *event,
 
 #ifdef USE_XIM
   if (window == NULL && gdk_xim_window && xevent->type == KeyPress &&
-      !GDK_DRAWABLE_DESTROYED (gdk_xim_window))
+      !GDK_WINDOW_DESTROYED (gdk_xim_window))
     {
       /*
        * If user presses a key in Preedit or Status window, keypress event
@@ -344,7 +344,7 @@ gdk_event_translate (GdkEvent *event,
       GdkFilterReturn result;
 
       window = gdk_xim_window;
-      window_private = (GdkWindowPrivate *) window;
+      window_private = (GdkWindowObject *) window;
       gdk_window_ref (window);
       event->any.window = window;
 
@@ -626,7 +626,7 @@ gdk_event_translate (GdkEvent *event,
       
       /* Tell XInput stuff about it if appropriate */
       if (window_private &&
-	  !GDK_DRAWABLE_DESTROYED (window) &&
+	  !GDK_WINDOW_DESTROYED (window) &&
 	  (window_private->extension_events != 0) &&
 	  gdk_input_vtable.enter_event)
 	gdk_input_vtable.enter_event (&xevent->xcrossing, window);
@@ -937,9 +937,9 @@ gdk_event_translate (GdkEvent *event,
       event->any.type = GDK_DESTROY;
       event->any.window = window;
       
-      return_val = window_private && !GDK_DRAWABLE_DESTROYED (window);
+      return_val = window_private && !GDK_WINDOW_DESTROYED (window);
       
-      if (window && GDK_DRAWABLE_XID (window) != GDK_ROOT_WINDOW())
+      if (window && GDK_WINDOW_XID (window) != GDK_ROOT_WINDOW())
 	gdk_window_destroy_notify (window);
       break;
       
@@ -992,16 +992,16 @@ gdk_event_translate (GdkEvent *event,
 			   xevent->xconfigure.override_redirect,
 			   !window
 			   ? " (discarding)"
-			   : GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_CHILD
+			   : GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD
 			   ? " (discarding child)"
 			   : ""));
       if (window &&
-	  !GDK_DRAWABLE_DESTROYED (window) &&
+	  !GDK_WINDOW_DESTROYED (window) &&
 	  (window_private->extension_events != 0) &&
 	  gdk_input_vtable.configure_event)
 	gdk_input_vtable.configure_event (&xevent->xconfigure, window);
 
-      if (!window || GDK_DRAWABLE_TYPE (window) == GDK_WINDOW_CHILD)
+      if (!window || GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
 	return_val = FALSE;
       else
 	{
@@ -1012,7 +1012,7 @@ gdk_event_translate (GdkEvent *event,
 	  
 	  if (!xevent->xconfigure.x &&
 	      !xevent->xconfigure.y &&
-	      !GDK_DRAWABLE_DESTROYED (window))
+	      !GDK_WINDOW_DESTROYED (window))
 	    {
 	      gint tx = 0;
 	      gint ty = 0;
@@ -1042,8 +1042,8 @@ gdk_event_translate (GdkEvent *event,
 	    }
 	  window_private->x = event->configure.x;
 	  window_private->y = event->configure.y;
-	  window_private->drawable.width = xevent->xconfigure.width;
-	  window_private->drawable.height = xevent->xconfigure.height;
+	  GDK_WINDOW_IMPL_X11 (window_private->impl)->width = xevent->xconfigure.width;
+	  GDK_WINDOW_IMPL_X11 (window_private->impl)->height = xevent->xconfigure.height;
 	  if (window_private->resize_count > 1)
 	    window_private->resize_count -= 1;
 	}
@@ -1177,7 +1177,7 @@ gdk_event_translate (GdkEvent *event,
       /* something else - (e.g., a Xinput event) */
       
       if (window_private &&
-	  !window_private->drawable.destroyed &&
+	  !GDK_WINDOW_DESTROYED (window_private) &&
 	  (window_private->extension_events != 0) &&
 	  gdk_input_vtable.other_event)
 	return_val = gdk_input_vtable.other_event(event, xevent, window);
diff --git a/gdk/x11/gdkgc-x11.c b/gdk/x11/gdkgc-x11.c
index e68eaab9a1..80e285f856 100644
--- a/gdk/x11/gdkgc-x11.c
+++ b/gdk/x11/gdkgc-x11.c
@@ -12,8 +12,7 @@ static void gdk_x11_gc_values_to_xvalues (GdkGCValues    *values,
 					  XGCValues      *xvalues,
 					  unsigned long  *xvalues_mask,
 					  gboolean        initial);
-     
-static void gdk_x11_gc_destroy    (GdkGC           *gc);
+
 static void gdk_x11_gc_get_values (GdkGC           *gc,
 				   GdkGCValues     *values);
 static void gdk_x11_gc_set_values (GdkGC           *gc,
@@ -21,15 +20,70 @@ static void gdk_x11_gc_set_values (GdkGC           *gc,
 				   GdkGCValuesMask  values_mask);
 static void gdk_x11_gc_set_dashes (GdkGC           *gc,
 				   gint             dash_offset,
-				   gchar            dash_list[],
+				   gint8            dash_list[],
 				   gint             n);
 
-static GdkGCClass gdk_x11_gc_class = {
-  gdk_x11_gc_destroy,
-  gdk_x11_gc_get_values,
-  gdk_x11_gc_set_values,
-  gdk_x11_gc_set_dashes
-};
+static void gdk_gc_x11_class_init (GdkGCX11Class *klass);
+static void gdk_gc_x11_finalize   (GObject           *object);
+
+static gpointer parent_class = NULL;
+
+GType
+gdk_gc_x11_get_type (void)
+{
+  static GType object_type = 0;
+
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkGCX11Class),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_gc_x11_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkGCX11),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) NULL,
+      };
+      
+      object_type = g_type_register_static (GDK_TYPE_GC,
+                                            "GdkGCX11",
+                                            &object_info);
+    }
+  
+  return object_type;
+}
+
+static void
+gdk_gc_x11_class_init (GdkGCX11Class *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkGCClass *gc_class = GDK_GC_CLASS (klass);
+  
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->finalize = gdk_gc_x11_finalize;
+
+  gc_class->get_values = gdk_x11_gc_get_values;
+  gc_class->set_values = gdk_x11_gc_set_values;
+  gc_class->set_dashes = gdk_x11_gc_set_dashes;
+}
+
+static void
+gdk_gc_x11_finalize (GObject *object)
+{
+  GdkGCX11 *x11_gc = GDK_GC_X11 (object);
+  
+  if (x11_gc->clip_region)
+    gdk_region_destroy (x11_gc->clip_region);
+  
+  XFreeGC (GDK_GC_XDISPLAY (x11_gc), GDK_GC_XGC (x11_gc));
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
 
 GdkGC *
 _gdk_x11_gc_new (GdkDrawable      *drawable,
@@ -37,33 +91,34 @@ _gdk_x11_gc_new (GdkDrawable      *drawable,
 		 GdkGCValuesMask   values_mask)
 {
   GdkGC *gc;
-  GdkGCPrivate *private;
-  GdkGCXData *data;
+  GdkGCX11 *private;
   
   XGCValues xvalues;
   unsigned long xvalues_mask;
 
-  gc = gdk_gc_alloc ();
-  private = (GdkGCPrivate *)gc;
+  /* NOTICE that the drawable here has to be the impl drawable,
+   * not the publically-visible drawables.
+   */
+  g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_X11 (drawable), NULL);
 
-  private->klass = &gdk_x11_gc_class;
-  private->klass_data = data = g_new (GdkGCXData, 1);
+  gc = GDK_GC (g_type_create_instance (gdk_gc_x11_get_type ()));
+  private = GDK_GC_X11 (gc);
 
-  data->dirty_mask = 0;
-  data->clip_region = NULL;
+  private->dirty_mask = 0;
+  private->clip_region = NULL;
     
-  GDK_GC_XDATA (gc)->xdisplay = GDK_DRAWABLE_XDISPLAY (drawable);
+  private->xdisplay = GDK_DRAWABLE_IMPL_X11 (drawable)->xdisplay;
 
   if (values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN))
     {
       values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
-      data->dirty_mask |= GDK_GC_DIRTY_CLIP;
+      private->dirty_mask |= GDK_GC_DIRTY_CLIP;
     }
 
   if (values_mask & (GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN))
     {
       values_mask &= ~(GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN);
-      data->dirty_mask |= GDK_GC_DIRTY_TS;
+      private->dirty_mask |= GDK_GC_DIRTY_TS;
     }
 
   xvalues.function = GXcopy;
@@ -75,62 +130,51 @@ _gdk_x11_gc_new (GdkDrawable      *drawable,
 
   gdk_x11_gc_values_to_xvalues (values, values_mask, &xvalues, &xvalues_mask, TRUE);
   
-  data->xgc = XCreateGC (GDK_GC_XDISPLAY (gc),
-			 GDK_DRAWABLE_XID (drawable),
-			 xvalues_mask, &xvalues);
+  private->xgc = XCreateGC (GDK_GC_XDISPLAY (gc),
+                            GDK_DRAWABLE_IMPL_X11 (drawable)->xid,
+                            xvalues_mask, &xvalues);
 
   return gc;
 }
 
-static void
-gdk_x11_gc_destroy (GdkGC *gc)
-{
-  if (GDK_GC_XDATA (gc)->clip_region)
-    gdk_region_destroy (GDK_GC_XDATA (gc)->clip_region);
-  
-  XFreeGC (GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc));
-  g_free (GDK_GC_XDATA (gc));
-}
-
 GC
 _gdk_x11_gc_flush (GdkGC *gc)
 {
-  GdkGCPrivate *private = (GdkGCPrivate *)gc;
-  GdkGCXData *data = GDK_GC_XDATA (gc);
+  GdkGCX11 *private = GDK_GC_X11 (gc);
 
-  if (data->dirty_mask & GDK_GC_DIRTY_CLIP)
+  if (private->dirty_mask & GDK_GC_DIRTY_CLIP)
     {
-      if (!data->clip_region)
+      if (!private->clip_region)
 	XSetClipOrigin (GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc),
-			private->clip_x_origin, private->clip_y_origin);
+			gc->clip_x_origin, gc->clip_y_origin);
       else
 	{
-	  XRectangle *rectangles = g_new (XRectangle, data->clip_region->numRects);
-	  GdkRegionBox *boxes = data->clip_region->rects;
+	  XRectangle *rectangles = g_new (XRectangle, private->clip_region->numRects);
+	  GdkRegionBox *boxes = private->clip_region->rects;
 	  int i;
 
-	  for (i=0; i<data->clip_region->numRects; i++)
+	  for (i=0; i<private->clip_region->numRects; i++)
 	    {
-	      rectangles[i].x = CLAMP (boxes[i].x1 + private->clip_x_origin, G_MINSHORT, G_MAXSHORT);
-	      rectangles[i].y = CLAMP (boxes[i].y1 + private->clip_y_origin, G_MINSHORT, G_MAXSHORT);
-	      rectangles[i].width = CLAMP (boxes[i].x2 + private->clip_x_origin, G_MINSHORT, G_MAXSHORT) - rectangles[i].x;
-	      rectangles[i].height = CLAMP (boxes[i].y2 + private->clip_y_origin, G_MINSHORT, G_MAXSHORT) - rectangles[i].y;
+	      rectangles[i].x = CLAMP (boxes[i].x1 + gc->clip_x_origin, G_MINSHORT, G_MAXSHORT);
+	      rectangles[i].y = CLAMP (boxes[i].y1 + gc->clip_y_origin, G_MINSHORT, G_MAXSHORT);
+	      rectangles[i].width = CLAMP (boxes[i].x2 + gc->clip_x_origin, G_MINSHORT, G_MAXSHORT) - rectangles[i].x;
+	      rectangles[i].height = CLAMP (boxes[i].y2 + gc->clip_y_origin, G_MINSHORT, G_MAXSHORT) - rectangles[i].y;
 	    }
 	  
 	  XSetClipRectangles(GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc), 0, 0, rectangles,
-			     data->clip_region->numRects, YXBanded);
+			     private->clip_region->numRects, YXBanded);
 
 	  g_free (rectangles);
 	}
     }
 
-  if (data->dirty_mask & GDK_GC_DIRTY_TS)
+  if (private->dirty_mask & GDK_GC_DIRTY_TS)
     {
       XSetTSOrigin (GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc),
-		    private->ts_x_origin, private->ts_y_origin);
+		    gc->ts_x_origin, gc->ts_y_origin);
     }
 
-  data->dirty_mask = 0;
+  private->dirty_mask = 0;
   return GDK_GC_XGC (gc);
 }
 
@@ -286,32 +330,32 @@ gdk_x11_gc_set_values (GdkGC           *gc,
 		       GdkGCValues     *values,
 		       GdkGCValuesMask  values_mask)
 {
-  GdkGCXData *data;
+  GdkGCX11 *x11_gc;
   XGCValues xvalues;
   unsigned long xvalues_mask = 0;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  data = GDK_GC_XDATA (gc);
+  x11_gc = GDK_GC_X11 (gc);
 
   if (values_mask & (GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN))
     {
       values_mask &= ~(GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);
-      data->dirty_mask |= GDK_GC_DIRTY_CLIP;
+      x11_gc->dirty_mask |= GDK_GC_DIRTY_CLIP;
     }
 
   if (values_mask & (GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN))
     {
       values_mask &= ~(GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN);
-      data->dirty_mask |= GDK_GC_DIRTY_TS;
+      x11_gc->dirty_mask |= GDK_GC_DIRTY_TS;
     }
 
   if (values_mask & GDK_GC_CLIP_MASK)
     {
-      if (data->clip_region)
+      if (x11_gc->clip_region)
 	{
-	  gdk_region_destroy (data->clip_region);
-	  data->clip_region = NULL;
+	  gdk_region_destroy (x11_gc->clip_region);
+	  x11_gc->clip_region = NULL;
 	}
     }
 
@@ -326,10 +370,10 @@ gdk_x11_gc_set_values (GdkGC           *gc,
 static void
 gdk_x11_gc_set_dashes (GdkGC *gc,
 		       gint   dash_offset,
-		       gchar  dash_list[],
+		       gint8  dash_list[],
 		       gint   n)
 {
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (dash_list != NULL);
 
   XSetDashes (GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc),
@@ -343,6 +387,17 @@ gdk_x11_gc_values_to_xvalues (GdkGCValues    *values,
 			      unsigned long  *xvalues_mask,
 			      gboolean        initial)
 {
+  if (mask & GDK_GC_EXPOSURES)
+    xvalues->graphics_exposures = values->graphics_exposures;
+  else
+    xvalues->graphics_exposures = False;
+  *xvalues_mask |= GCGraphicsExposures;
+  
+  /* Optimization for the common case (gdk_gc_new()) */
+  if (values == NULL ||
+      mask == 0)
+    return;
+  
   if (mask & GDK_GC_FOREGROUND)
     {
       xvalues->foreground = values->foreground.pixel;
@@ -560,64 +615,62 @@ void
 gdk_gc_set_clip_rectangle (GdkGC	*gc,
 			   GdkRectangle *rectangle)
 {
-  GdkGCPrivate *private = (GdkGCPrivate *)gc;
-  GdkGCXData *data;
+  GdkGCX11 *x11_gc;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  data = GDK_GC_XDATA (gc);
+  x11_gc = GDK_GC_X11 (gc);
 
-  if (data->clip_region)
-    gdk_region_destroy (data->clip_region);
+  if (x11_gc->clip_region)
+    gdk_region_destroy (x11_gc->clip_region);
 
   if (rectangle)
-    data->clip_region = gdk_region_rectangle (rectangle);
+    x11_gc->clip_region = gdk_region_rectangle (rectangle);
   else
     {
-      data->clip_region = NULL;
+      x11_gc->clip_region = NULL;
       XSetClipMask (GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc), None);
     }
 
-  private->clip_x_origin = 0;
-  private->clip_y_origin = 0;
+  gc->clip_x_origin = 0;
+  gc->clip_y_origin = 0;
   
-  data->dirty_mask |= GDK_GC_DIRTY_CLIP;
+  x11_gc->dirty_mask |= GDK_GC_DIRTY_CLIP;
 } 
 
 void
 gdk_gc_set_clip_region (GdkGC	  *gc,
 			GdkRegion *region)
 {
-  GdkGCPrivate *private = (GdkGCPrivate *)gc;
-  GdkGCXData *data;
+  GdkGCX11 *x11_gc;
 
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  data = GDK_GC_XDATA (gc);
+  x11_gc = GDK_GC_X11 (gc);
 
-  if (data->clip_region)
-    gdk_region_destroy (data->clip_region);
+  if (x11_gc->clip_region)
+    gdk_region_destroy (x11_gc->clip_region);
 
   if (region)
-    data->clip_region = gdk_region_copy (region);
+    x11_gc->clip_region = gdk_region_copy (region);
   else
     {
-      data->clip_region = NULL;
+      x11_gc->clip_region = NULL;
       XSetClipMask (GDK_GC_XDISPLAY (gc), GDK_GC_XGC (gc), None);
     }
   
-  private->clip_x_origin = 0;
-  private->clip_y_origin = 0;
+  gc->clip_x_origin = 0;
+  gc->clip_y_origin = 0;
   
-  data->dirty_mask |= GDK_GC_DIRTY_CLIP;
+  x11_gc->dirty_mask |= GDK_GC_DIRTY_CLIP;
 }
 
 
 void
 gdk_gc_copy (GdkGC *dst_gc, GdkGC *src_gc)
 {
-  g_return_if_fail (dst_gc != NULL);
-  g_return_if_fail (src_gc != NULL);
+  g_return_if_fail (GDK_IS_GC_X11 (dst_gc));
+  g_return_if_fail (GDK_IS_GC_X11 (src_gc));
   
   XCopyGC (GDK_GC_XDISPLAY (src_gc), GDK_GC_XGC (src_gc), ~((~1) << GCLastBit),
 	   GDK_GC_XGC (dst_gc));
diff --git a/gdk/x11/gdkgeometry-x11.c b/gdk/x11/gdkgeometry-x11.c
index 8bf26453f3..5cf3129462 100644
--- a/gdk/x11/gdkgeometry-x11.c
+++ b/gdk/x11/gdkgeometry-x11.c
@@ -62,10 +62,10 @@ struct _GdkWindowParentPos
   GdkRectangle clip_rect;
 };
 
-static void gdk_window_compute_position   (GdkWindow          *window,
+static void gdk_window_compute_position   (GdkWindowImplX11      *window,
 					   GdkWindowParentPos *parent_pos,
 					   GdkXPositionInfo   *info);
-static void gdk_window_compute_parent_pos (GdkWindow          *window,
+static void gdk_window_compute_parent_pos (GdkWindowImplX11      *window,
 					   GdkWindowParentPos *parent_pos);
 static void gdk_window_premove            (GdkWindow          *window,
 					   GdkWindowParentPos *parent_pos);
@@ -87,27 +87,26 @@ _gdk_windowing_window_get_offsets (GdkWindow *window,
 				   gint      *x_offset,
 				   gint      *y_offset)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-  GdkWindowXData *data = (GdkWindowXData *)private->drawable.klass_data;
+  GdkWindowImplX11 *impl =
+    GDK_WINDOW_IMPL_X11 (GDK_WINDOW_OBJECT (window)->impl);
 
-  *x_offset = data->position_info.x_offset;
-  *y_offset = data->position_info.y_offset;
+  *x_offset = impl->position_info.x_offset;
+  *y_offset = impl->position_info.y_offset;
 }
 
 void
 _gdk_window_init_position (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-  GdkWindowXData *data;
   GdkWindowParentPos parent_pos;
-
-  g_return_if_fail (window != NULL);
+  GdkWindowImplX11 *impl;
+  
   g_return_if_fail (GDK_IS_WINDOW (window));
-
-  data = (GdkWindowXData *)private->drawable.klass_data;
-
-  gdk_window_compute_parent_pos (window, &parent_pos);
-  gdk_window_compute_position (window, &parent_pos, &data->position_info);
+  
+  impl =
+    GDK_WINDOW_IMPL_X11 (GDK_WINDOW_OBJECT (window)->impl);
+  
+  gdk_window_compute_parent_pos (impl, &parent_pos);
+  gdk_window_compute_position (impl, &parent_pos, &impl->position_info);
 }
 
 /**
@@ -131,33 +130,33 @@ gdk_window_scroll (GdkWindow *window,
 		   gint       dx,
 		   gint       dy)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
   gboolean can_guffaw_scroll = FALSE;
-  GdkWindowXData *data;
+  GdkWindowImplX11 *impl;
+  GdkWindowObject *obj;
   
-  g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  obj = GDK_WINDOW_OBJECT (window);
+  
+  impl = GDK_WINDOW_IMPL_X11 (obj->impl);  
+  
+  if (GDK_WINDOW_DESTROYED (window))
     return;
 
-  data = (GdkWindowXData *)private->drawable.klass_data;
-
   /* We can guffaw scroll if we are a child window, and the parent
    * does not extend beyond our edges.
    */
-
-  if (GDK_DRAWABLE_TYPE (private) == GDK_WINDOW_CHILD)
+  
+  if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
     {
-      GdkWindowPrivate *parent_private = (GdkWindowPrivate *)private->parent;
-      
-      can_guffaw_scroll = (private->x <= 0 &&
-			   private->y <= 0 &&
-			   private->x + private->drawable.width >= parent_private->drawable.width &&
-			   private->y + private->drawable.height >= parent_private->drawable.height);
+      GdkWindowImplX11 *parent_impl = GDK_WINDOW_IMPL_X11 (obj->parent->impl);  
+      can_guffaw_scroll = (obj->x <= 0 &&
+			   obj->y <= 0 &&
+			   obj->x + impl->width >= parent_impl->width &&
+			   obj->y + impl->height >= parent_impl->height);
     }
 
-  if (!private->children || !can_guffaw_scroll)
+  if (!obj->children || !can_guffaw_scroll)
     {
       /* Use XCopyArea, then move any children later
        */
@@ -165,12 +164,12 @@ gdk_window_scroll (GdkWindow *window,
       GdkRegion *invalidate_region;
       GdkRectangle dest_rect;
 
-      invalidate_region = gdk_region_rectangle (&data->position_info.clip_rect);
+      invalidate_region = gdk_region_rectangle (&impl->position_info.clip_rect);
       
-      dest_rect = data->position_info.clip_rect;
+      dest_rect = impl->position_info.clip_rect;
       dest_rect.x += dx;
       dest_rect.y += dy;
-      gdk_rectangle_intersect (&dest_rect, &data->position_info.clip_rect, &dest_rect);
+      gdk_rectangle_intersect (&dest_rect, &impl->position_info.clip_rect, &dest_rect);
 
       if (dest_rect.width > 0 && dest_rect.height > 0)
 	{
@@ -185,29 +184,30 @@ gdk_window_scroll (GdkWindow *window,
 	  gdk_window_queue_translation (window, dx, dy);
 
 	  values.graphics_exposures = True;
-	  gc = XCreateGC (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window),
+	  gc = XCreateGC (GDK_WINDOW_XDISPLAY (window),
+                          GDK_WINDOW_XID (window),
 			  GCGraphicsExposures, &values);
 
-	  XCopyArea (GDK_DRAWABLE_XDISPLAY (window),
-		     GDK_DRAWABLE_XID (window),
-		     GDK_DRAWABLE_XID (window),
+	  XCopyArea (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window),
+		     GDK_WINDOW_XID (window),
 		     gc,
 		     dest_rect.x - dx, dest_rect.y - dy,
 		     dest_rect.width, dest_rect.height,
 		     dest_rect.x, dest_rect.y);
 
-	  XFreeGC (GDK_DRAWABLE_XDISPLAY (window), gc);
+	  XFreeGC (GDK_WINDOW_XDISPLAY (window), gc);
 	}
 
       gdk_window_invalidate_region (window, invalidate_region, TRUE);
       gdk_region_destroy (invalidate_region);
 
-      tmp_list = private->children;
+      tmp_list = obj->children;
       while (tmp_list)
 	{
-	  private = tmp_list->data;
+	  GdkWindow * child = GDK_WINDOW (tmp_list->data);
 	  
-	  gdk_window_move (tmp_list->data, private->x + dx, private->y + dy);
+	  gdk_window_move (child, obj->x + dx, obj->y + dy);
 	  
 	  tmp_list = tmp_list->next;
 	}
@@ -227,10 +227,10 @@ _gdk_window_move_resize_child (GdkWindow *window,
 			       gint       width,
 			       gint       height)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowImplX11 *impl;
+  GdkWindowObject *obj;
   GdkXPositionInfo new_info;
   GdkWindowParentPos parent_pos;
-  GdkWindowXData *data;
   GList *tmp_list;
   
   gint d_xoffset, d_yoffset;
@@ -241,35 +241,36 @@ _gdk_window_move_resize_child (GdkWindow *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  data = (GdkWindowXData *)private->drawable.klass_data;
-
-  dx = x - private->x;
-  dy = y - private->y;
+  impl = GDK_WINDOW_IMPL_X11 (GDK_WINDOW_OBJECT (window)->impl);
+  obj = GDK_WINDOW_OBJECT (window);
+  
+  dx = x - obj->x;
+  dy = y - obj->y;
   
   is_move = dx != 0 || dy != 0;
-  is_resize = private->drawable.width != width || private->drawable.height != height;
+  is_resize = impl->width != width || impl->height != height;
 
   if (!is_move && !is_resize)
     return;
   
-  private->x = x;
-  private->y = y;
-  private->drawable.width = width;
-  private->drawable.height = height;
+  obj->x = x;
+  obj->y = y;
+  impl->width = width;
+  impl->height = height;
 
-  gdk_window_compute_parent_pos (window, &parent_pos);
-  gdk_window_compute_position (window, &parent_pos, &new_info);
+  gdk_window_compute_parent_pos (impl, &parent_pos);
+  gdk_window_compute_position (impl, &parent_pos, &new_info);
 
-  gdk_window_clip_changed (window, &data->position_info.clip_rect, &new_info.clip_rect);
+  gdk_window_clip_changed (window, &impl->position_info.clip_rect, &new_info.clip_rect);
 
-  parent_pos.x += private->x;
-  parent_pos.y += private->y;
+  parent_pos.x += obj->x;
+  parent_pos.y += obj->y;
   parent_pos.x11_x += new_info.x;
   parent_pos.x11_y += new_info.y;
   parent_pos.clip_rect = new_info.clip_rect;
 
-  d_xoffset = new_info.x_offset - data->position_info.x_offset;
-  d_yoffset = new_info.y_offset - data->position_info.y_offset;
+  d_xoffset = new_info.x_offset - impl->position_info.x_offset;
+  d_yoffset = new_info.y_offset - impl->position_info.y_offset;
   
   if (d_xoffset != 0 || d_yoffset != 0)
     {
@@ -282,57 +283,57 @@ _gdk_window_move_resize_child (GdkWindow *window,
 	
       if (d_xoffset < 0)
 	{
-	  new_x0 = data->position_info.x + d_xoffset;
-	  new_x1 = data->position_info.x + data->position_info.width;
+	  new_x0 = impl->position_info.x + d_xoffset;
+	  new_x1 = impl->position_info.x + impl->position_info.width;
 	}
       else
 	{
-	  new_x0 = data->position_info.x;
-	  new_x1 = data->position_info.x + new_info.width + d_xoffset;
+	  new_x0 = impl->position_info.x;
+	  new_x1 = impl->position_info.x + new_info.width + d_xoffset;
 	}
 
       if (d_yoffset < 0)
 	{
-	  new_y0 = data->position_info.y + d_yoffset;
-	  new_y1 = data->position_info.y + data->position_info.height;
+	  new_y0 = impl->position_info.y + d_yoffset;
+	  new_y1 = impl->position_info.y + impl->position_info.height;
 	}
       else
 	{
-	  new_y0 = data->position_info.y;
-	  new_y1 = data->position_info.y + new_info.height + d_yoffset;
+	  new_y0 = impl->position_info.y;
+	  new_y1 = impl->position_info.y + new_info.height + d_yoffset;
 	}
       
-      XMoveResizeWindow (GDK_DRAWABLE_XDISPLAY (window),
-			 GDK_DRAWABLE_XID (window),
+      XMoveResizeWindow (GDK_WINDOW_XDISPLAY (window),
+			 GDK_WINDOW_XID (window),
 			 new_x0, new_y0, new_x1 - new_x0, new_y1 - new_y0);
       
-      tmp_list = private->children;
+      tmp_list = obj->children;
       while (tmp_list)
 	{
 	  gdk_window_premove (tmp_list->data, &parent_pos);
 	  tmp_list = tmp_list->next;
 	}
 
-      XMoveWindow (GDK_DRAWABLE_XDISPLAY (window),
-		   GDK_DRAWABLE_XID (window),
+      XMoveWindow (GDK_WINDOW_XDISPLAY (window),
+		   GDK_WINDOW_XID (window),
 		   new_x0 + dx, new_y0 + dy);
       
       if (d_xoffset > 0 || d_yoffset > 0)
 	gdk_window_queue_translation (window, MAX (d_xoffset, 0), MAX (d_yoffset, 0));
       
-      XMoveResizeWindow (GDK_DRAWABLE_XDISPLAY (window),
-			 GDK_DRAWABLE_XID (window),
+      XMoveResizeWindow (GDK_WINDOW_XDISPLAY (window),
+			 GDK_WINDOW_XID (window),
 			 new_info.x, new_info.y, new_info.width, new_info.height);
       
-      if (data->position_info.no_bg)
+      if (impl->position_info.no_bg)
 	gdk_window_tmp_reset_bg (window);
 
-      if (!data->position_info.mapped && new_info.mapped && private->mapped)
-	XMapWindow (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window));
+      if (!impl->position_info.mapped && new_info.mapped && obj->mapped)
+	XMapWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window));
       
-      data->position_info = new_info;
+      impl->position_info = new_info;
       
-      tmp_list = private->children;
+      tmp_list = obj->children;
       while (tmp_list)
 	{
 	  gdk_window_postmove (tmp_list->data, &parent_pos);
@@ -344,10 +345,10 @@ _gdk_window_move_resize_child (GdkWindow *window,
       if (is_move && is_resize)
 	gdk_window_set_static_gravities (window, FALSE);
 
-      if (data->position_info.mapped && !new_info.mapped)
-	XUnmapWindow (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window));
+      if (impl->position_info.mapped && !new_info.mapped)
+	XUnmapWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window));
       
-      tmp_list = private->children;
+      tmp_list = obj->children;
       while (tmp_list)
 	{
 	  gdk_window_premove (tmp_list->data, &parent_pos);
@@ -355,87 +356,91 @@ _gdk_window_move_resize_child (GdkWindow *window,
 	}
 
       if (is_resize)
-	XMoveResizeWindow (GDK_DRAWABLE_XDISPLAY (window),
-			   GDK_DRAWABLE_XID (window),
+	XMoveResizeWindow (GDK_WINDOW_XDISPLAY (window),
+			   GDK_WINDOW_XID (window),
 			   new_info.x, new_info.y, new_info.width, new_info.height);
       else
-	XMoveWindow (GDK_DRAWABLE_XDISPLAY (window),
-		     GDK_DRAWABLE_XID (window),
+	XMoveWindow (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window),
 		     new_info.x, new_info.y);
 
-      tmp_list = private->children;
+      tmp_list = obj->children;
       while (tmp_list)
 	{
 	  gdk_window_postmove (tmp_list->data, &parent_pos);
 	  tmp_list = tmp_list->next;
 	}
 
-      if (data->position_info.no_bg)
+      if (impl->position_info.no_bg)
 	gdk_window_tmp_reset_bg (window);
 
-      if (!data->position_info.mapped && new_info.mapped && private->mapped)
-	XMapWindow (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window));
+      if (!impl->position_info.mapped && new_info.mapped && obj->mapped)
+	XMapWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window));
 
-      data->position_info = new_info;
+      impl->position_info = new_info;
     }
 }
 
 static void
-gdk_window_compute_position (GdkWindow          *window,
+gdk_window_compute_position (GdkWindowImplX11      *window,
 			     GdkWindowParentPos *parent_pos,
 			     GdkXPositionInfo   *info)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *wrapper;
   int parent_x_offset;
   int parent_y_offset;
+
+  g_return_if_fail (GDK_IS_WINDOW_IMPL_X11 (window));
+
+  wrapper = GDK_WINDOW_OBJECT (GDK_DRAWABLE_IMPL_X11 (window)->wrapper);
   
   info->big = FALSE;
   
-  if (private->drawable.width <= 32768)
+  if (window->width <= 32768)
     {
-      info->width = private->drawable.width;
-      info->x = parent_pos->x + private->x - parent_pos->x11_x;
+      info->width = window->width;
+      info->x = parent_pos->x + wrapper->x - parent_pos->x11_x;
     }
   else
     {
       info->big = TRUE;
       info->width = 32768;
-      if (parent_pos->x + private->x < -16384)
+      if (parent_pos->x + wrapper->x < -16384)
 	{
-	  if (parent_pos->x + private->x + private->drawable.width < 16384)
-	    info->x = parent_pos->x + private->x + private->drawable.width - 32768 - parent_pos->x11_x;
+	  if (parent_pos->x + wrapper->x + window->width < 16384)
+	    info->x = parent_pos->x + wrapper->x + window->width - 32768 - parent_pos->x11_x;
 	  else
 	    info->x = -16384 - parent_pos->x11_y;
 	}
       else
-	info->x = parent_pos->x + private->x - parent_pos->x11_x;
+	info->x = parent_pos->x + wrapper->x - parent_pos->x11_x;
     }
 
-  if (private->drawable.height <= 32768)
+  if (window->height <= 32768)
     {
-      info->height = private->drawable.height;
-      info->y = parent_pos->y + private->y - parent_pos->x11_y;
+      info->height = window->height;
+      info->y = parent_pos->y + wrapper->y - parent_pos->x11_y;
     }
   else
     {
       info->big = TRUE;
       info->height = 32768;
-      if (parent_pos->y + private->y < -16384)
+      if (parent_pos->y + wrapper->y < -16384)
 	{
-	  if (parent_pos->y + private->y + private->drawable.height < 16384)
-	    info->y = parent_pos->y + private->y + private->drawable.height - 32768 - parent_pos->x11_y;
+	  if (parent_pos->y + wrapper->y + window->height < 16384)
+	    info->y = parent_pos->y + wrapper->y + window->height - 32768 - parent_pos->x11_y;
 	  else
 	    info->y = -16384 - parent_pos->x11_y;
 	}
       else
-	info->y = parent_pos->y + private->y - parent_pos->x11_y;
+	info->y = parent_pos->y + wrapper->y - parent_pos->x11_y;
     }
 
   parent_x_offset = parent_pos->x11_x - parent_pos->x;
   parent_y_offset = parent_pos->x11_y - parent_pos->y;
   
-  info->x_offset = parent_x_offset + info->x - private->x;
-  info->y_offset = parent_y_offset + info->y - private->y;
+  info->x_offset = parent_x_offset + info->x - wrapper->x;
+  info->y_offset = parent_y_offset + info->y - wrapper->y;
 
   /* We don't considering the clipping of toplevel windows and their immediate children
    * by their parents, and simply always map those windows.
@@ -446,24 +451,24 @@ gdk_window_compute_position (GdkWindow          *window,
   else if (info->x + parent_x_offset < parent_pos->clip_rect.x + parent_pos->clip_rect.width - 65536 ||
       info->x + info->width + parent_x_offset > parent_pos->clip_rect.x + 65536 ||
       info->y + parent_y_offset < parent_pos->clip_rect.y + parent_pos->clip_rect.height - 65536 ||
-      info->y + info->width + parent_y_offset  > parent_pos->clip_rect.y + 65536)
+      info->y + info->height + parent_y_offset  > parent_pos->clip_rect.y + 65536)
     info->mapped = FALSE;
   else
     info->mapped = TRUE;
 
   info->no_bg = FALSE;
 
-  if (GDK_DRAWABLE_TYPE (private) == GDK_WINDOW_CHILD)
+  if (GDK_WINDOW_TYPE (wrapper) == GDK_WINDOW_CHILD)
     {
-      info->clip_rect.x = private->x;
-      info->clip_rect.y = private->y;
-      info->clip_rect.width = private->drawable.width;
-      info->clip_rect.height = private->drawable.height;
+      info->clip_rect.x = wrapper->x;
+      info->clip_rect.y = wrapper->y;
+      info->clip_rect.width = window->width;
+      info->clip_rect.height = window->height;
       
       gdk_rectangle_intersect (&info->clip_rect, &parent_pos->clip_rect, &info->clip_rect);
 
-      info->clip_rect.x -= private->x;
-      info->clip_rect.y -= private->y;
+      info->clip_rect.x -= wrapper->x;
+      info->clip_rect.y -= wrapper->y;
     }
   else
     {
@@ -475,16 +480,21 @@ gdk_window_compute_position (GdkWindow          *window,
 }
 
 static void
-gdk_window_compute_parent_pos (GdkWindow          *window,
+gdk_window_compute_parent_pos (GdkWindowImplX11      *window,
 			       GdkWindowParentPos *parent_pos)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-  GdkWindowXData *data;
+  GdkWindowObject *wrapper;
+  GdkWindowObject *parent;
   GdkRectangle tmp_clip;
   
   int clip_xoffset = 0;
   int clip_yoffset = 0;
 
+  g_return_if_fail (GDK_IS_WINDOW_IMPL_X11 (window));
+
+  wrapper =
+    GDK_WINDOW_OBJECT (GDK_DRAWABLE_IMPL_X11 (window)->wrapper);
+  
   parent_pos->x = 0;
   parent_pos->y = 0;
   parent_pos->x11_x = 0;
@@ -506,27 +516,27 @@ gdk_window_compute_parent_pos (GdkWindow          *window,
   parent_pos->clip_rect.width = G_MAXINT;
   parent_pos->clip_rect.height = G_MAXINT;
 
-  private = (GdkWindowPrivate *)private->parent;
-  while (private && private->drawable.window_type == GDK_WINDOW_CHILD)
+  parent = (GdkWindowObject *)wrapper->parent;
+  while (parent && parent->window_type == GDK_WINDOW_CHILD)
     {
-      data = (GdkWindowXData *)private->drawable.klass_data;
-
+      GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (parent->impl);
+      
       tmp_clip.x = - clip_xoffset;
       tmp_clip.y = - clip_yoffset;
-      tmp_clip.width = private->drawable.width;
-      tmp_clip.height = private->drawable.height;
+      tmp_clip.width = impl->width;
+      tmp_clip.height = impl->height;
 
       gdk_rectangle_intersect (&parent_pos->clip_rect, &tmp_clip, &parent_pos->clip_rect);
 
-      parent_pos->x += private->x;
-      parent_pos->y += private->y;
-      parent_pos->x11_x += data->position_info.x;
-      parent_pos->x11_y += data->position_info.y;
+      parent_pos->x += parent->x;
+      parent_pos->y += parent->y;
+      parent_pos->x11_x += impl->position_info.x;
+      parent_pos->x11_y += impl->position_info.y;
 
-      clip_xoffset += private->x;
-      clip_yoffset += private->y;
+      clip_xoffset += parent->x;
+      clip_yoffset += parent->y;
 
-      private = (GdkWindowPrivate *)private->parent;
+      parent = (GdkWindowObject *)parent->parent;
     }
 }
 
@@ -534,28 +544,31 @@ static void
 gdk_window_premove (GdkWindow          *window,
 		    GdkWindowParentPos *parent_pos)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-  GdkWindowXData *data = GDK_WINDOW_XDATA (window);
+  GdkWindowImplX11 *impl;
+  GdkWindowObject *obj;
   GdkXPositionInfo new_info;
   GList *tmp_list;
   gint d_xoffset, d_yoffset;
   GdkWindowParentPos this_pos;
+
+  obj = (GdkWindowObject *) window;
+  impl = GDK_WINDOW_IMPL_X11 (obj->impl);
   
-  gdk_window_compute_position (window, parent_pos, &new_info);
+  gdk_window_compute_position (impl, parent_pos, &new_info);
 
-  gdk_window_clip_changed (window, &data->position_info.clip_rect, &new_info.clip_rect);
+  gdk_window_clip_changed (window, &impl->position_info.clip_rect, &new_info.clip_rect);
 
-  this_pos.x = parent_pos->x + private->x;
-  this_pos.y = parent_pos->y + private->y;
+  this_pos.x = parent_pos->x + obj->x;
+  this_pos.y = parent_pos->y + obj->y;
   this_pos.x11_x = parent_pos->x11_x + new_info.x;
   this_pos.x11_y = parent_pos->x11_y + new_info.y;
   this_pos.clip_rect = new_info.clip_rect;
 
-  if (data->position_info.mapped && !new_info.mapped)
+  if (impl->position_info.mapped && !new_info.mapped)
     XUnmapWindow (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window));
 
-  d_xoffset = new_info.x_offset - data->position_info.x_offset;
-  d_yoffset = new_info.y_offset - data->position_info.y_offset;
+  d_xoffset = new_info.x_offset - impl->position_info.x_offset;
+  d_yoffset = new_info.y_offset - impl->position_info.y_offset;
   
   if (d_xoffset != 0 || d_yoffset != 0)
     {
@@ -566,24 +579,24 @@ gdk_window_premove (GdkWindow          *window,
 	
       if (d_xoffset < 0)
 	{
-	  new_x0 = data->position_info.x + d_xoffset;
-	  new_x1 = data->position_info.x + data->position_info.width;
+	  new_x0 = impl->position_info.x + d_xoffset;
+	  new_x1 = impl->position_info.x + impl->position_info.width;
 	}
       else
 	{
-	  new_x0 = data->position_info.x;
-	  new_x1 = data->position_info.x + new_info.width + d_xoffset;
+	  new_x0 = impl->position_info.x;
+	  new_x1 = impl->position_info.x + new_info.width + d_xoffset;
 	}
 
       if (d_yoffset < 0)
 	{
-	  new_y0 = data->position_info.y + d_yoffset;
-	  new_y1 = data->position_info.y + data->position_info.height;
+	  new_y0 = impl->position_info.y + d_yoffset;
+	  new_y1 = impl->position_info.y + impl->position_info.height;
 	}
       else
 	{
-	  new_y0 = data->position_info.y;
-	  new_y1 = data->position_info.y + new_info.height + d_yoffset;
+	  new_y0 = impl->position_info.y;
+	  new_y1 = impl->position_info.y + new_info.height + d_yoffset;
 	}
 
       XMoveResizeWindow (GDK_DRAWABLE_XDISPLAY (window),
@@ -591,7 +604,7 @@ gdk_window_premove (GdkWindow          *window,
 			 new_x0, new_y0, new_x1 - new_x0, new_y1 - new_y0);
     }
 
-  tmp_list = private->children;
+  tmp_list = obj->children;
   while (tmp_list)
     {
       gdk_window_premove (tmp_list->data, &this_pos);
@@ -603,23 +616,26 @@ static void
 gdk_window_postmove (GdkWindow          *window,
 		     GdkWindowParentPos *parent_pos)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-  GdkWindowXData *data = (GdkWindowXData *)private->drawable.klass_data;
+  GdkWindowImplX11 *impl;
+  GdkWindowObject *obj;
   GdkXPositionInfo new_info;
   GList *tmp_list;
   gint d_xoffset, d_yoffset;
   GdkWindowParentPos this_pos;
+
+  obj = (GdkWindowObject *) window;
+  impl = GDK_WINDOW_IMPL_X11 (obj->impl);
   
-  gdk_window_compute_position (window, parent_pos, &new_info);
+  gdk_window_compute_position (impl, parent_pos, &new_info);
 
-  this_pos.x = parent_pos->x + private->x;
-  this_pos.y = parent_pos->y + private->y;
+  this_pos.x = parent_pos->x + obj->x;
+  this_pos.y = parent_pos->y + obj->y;
   this_pos.x11_x = parent_pos->x11_x + new_info.x;
   this_pos.x11_y = parent_pos->x11_y + new_info.y;
   this_pos.clip_rect = new_info.clip_rect;
 
-  d_xoffset = new_info.x_offset - data->position_info.x_offset;
-  d_yoffset = new_info.y_offset - data->position_info.y_offset;
+  d_xoffset = new_info.x_offset - impl->position_info.x_offset;
+  d_yoffset = new_info.y_offset - impl->position_info.y_offset;
   
   if (d_xoffset != 0 || d_yoffset != 0)
     {
@@ -631,15 +647,15 @@ gdk_window_postmove (GdkWindow          *window,
 			 new_info.x, new_info.y, new_info.width, new_info.height);
     }
 
-  if (!data->position_info.mapped && new_info.mapped && private->mapped)
+  if (!impl->position_info.mapped && new_info.mapped && obj->mapped)
     XMapWindow (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window));
 
-  if (data->position_info.no_bg)
+  if (impl->position_info.no_bg)
     gdk_window_tmp_reset_bg (window);
 
-  data->position_info = new_info;
+  impl->position_info = new_info;
 
-  tmp_list = private->children;
+  tmp_list = obj->children;
   while (tmp_list)
     {
       gdk_window_postmove (tmp_list->data, &this_pos);
@@ -684,12 +700,13 @@ _gdk_window_process_expose (GdkWindow    *window,
 			    gulong        serial,
 			    GdkRectangle *area)
 {
-  GdkWindowXData *data = GDK_WINDOW_XDATA (window);
+  GdkWindowImplX11 *impl;
   GdkRegion *invalidate_region = gdk_region_rectangle (area);
   GdkRegion *clip_region;
-
   GSList *tmp_list = translate_queue;
 
+  impl = GDK_WINDOW_IMPL_X11 (GDK_WINDOW_OBJECT (window)->impl);
+  
   while (tmp_list)
     {
       GdkWindowQueueItem *item = tmp_list->data;
@@ -720,7 +737,7 @@ _gdk_window_process_expose (GdkWindow    *window,
 	}
     }
 
-  clip_region = gdk_region_rectangle (&data->position_info.clip_rect);
+  clip_region = gdk_region_rectangle (&impl->position_info.clip_rect);
   gdk_region_intersect (invalidate_region, clip_region);
 
   if (!gdk_region_empty (invalidate_region))
@@ -733,12 +750,15 @@ _gdk_window_process_expose (GdkWindow    *window,
 static void
 gdk_window_tmp_unset_bg (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-  GdkWindowXData *data = GDK_WINDOW_XDATA (window);
+  GdkWindowImplX11 *impl;
+  GdkWindowObject *obj;
+
+  obj = (GdkWindowObject *) window;
+  impl = GDK_WINDOW_IMPL_X11 (obj->impl);
 
-  data->position_info.no_bg = TRUE;
+  impl->position_info.no_bg = TRUE;
 
-  if (private->bg_pixmap != GDK_NO_BG)
+  if (obj->bg_pixmap != GDK_NO_BG)
     XSetWindowBackgroundPixmap (GDK_DRAWABLE_XDISPLAY (window),
 				GDK_DRAWABLE_XID (window), None);
 }
@@ -746,22 +766,25 @@ gdk_window_tmp_unset_bg (GdkWindow *window)
 static void
 gdk_window_tmp_reset_bg (GdkWindow *window)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-  GdkWindowXData *data = GDK_WINDOW_XDATA (window);
+  GdkWindowImplX11 *impl;
+  GdkWindowObject *obj;
 
-  data->position_info.no_bg = FALSE;
+  obj = (GdkWindowObject *) window;
+  impl = GDK_WINDOW_IMPL_X11 (obj->impl);
 
-  if (private->bg_pixmap == GDK_NO_BG)
+  impl->position_info.no_bg = FALSE;
+
+  if (obj->bg_pixmap == GDK_NO_BG)
     return;
   
-  if (private->bg_pixmap)
+  if (obj->bg_pixmap)
     {
       Pixmap xpixmap;
 
-      if (private->bg_pixmap == GDK_PARENT_RELATIVE_BG)
+      if (obj->bg_pixmap == GDK_PARENT_RELATIVE_BG)
 	xpixmap = ParentRelative;
       else 
-	xpixmap = GDK_DRAWABLE_XID (private->bg_pixmap);
+	xpixmap = GDK_DRAWABLE_XID (obj->bg_pixmap);
 
       XSetWindowBackgroundPixmap (GDK_DRAWABLE_XDISPLAY (window),
 				  GDK_DRAWABLE_XID (window), xpixmap);
@@ -770,28 +793,31 @@ gdk_window_tmp_reset_bg (GdkWindow *window)
     {
       XSetWindowBackground (GDK_DRAWABLE_XDISPLAY (window),
 			    GDK_DRAWABLE_XID (window),
-			    private->bg_color.pixel);
+			    obj->bg_color.pixel);
     }
 }
 
 static void
 gdk_window_clip_changed (GdkWindow *window, GdkRectangle *old_clip, GdkRectangle *new_clip)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
+  GdkWindowImplX11 *impl;
+  GdkWindowObject *obj;
   GdkRegion *old_clip_region;
   GdkRegion *new_clip_region;
-
-  if (private->input_only)
+  
+  if (((GdkWindowObject *)window)->input_only)
     return;
-    
+
+  obj = (GdkWindowObject *) window;
+  impl = GDK_WINDOW_IMPL_X11 (obj->impl);
+  
   old_clip_region = gdk_region_rectangle (old_clip);
   new_clip_region = gdk_region_rectangle (new_clip);
 
   /* Trim invalid region of window to new clip rectangle
    */
-  if (private->update_area)
-    gdk_region_intersect (private->update_area, new_clip_region);
+  if (obj->update_area)
+    gdk_region_intersect (obj->update_area, new_clip_region);
 
   /* Invalidate newly exposed portion of window
    */
diff --git a/gdk/x11/gdkglobals-x11.c b/gdk/x11/gdkglobals-x11.c
index 9a3d6c5f95..52d284861c 100644
--- a/gdk/x11/gdkglobals-x11.c
+++ b/gdk/x11/gdkglobals-x11.c
@@ -50,6 +50,6 @@ GdkICPrivate     *gdk_xim_ic;		/* currently using IC */
 #endif /* USE_XIM */
 GdkWindow        *gdk_xim_window;		/* currently using Widow */
 
-GdkWindowPrivate *gdk_xgrab_window = NULL;  /* Window that currently holds the
-					     *	x pointer grab
-					     */
+GdkWindowObject *gdk_xgrab_window = NULL;  /* Window that currently holds the
+                                            *	x pointer grab
+                                            */
diff --git a/gdk/x11/gdkim-x11.c b/gdk/x11/gdkim-x11.c
index 0d309a768d..f07f9b50c6 100644
--- a/gdk/x11/gdkim-x11.c
+++ b/gdk/x11/gdkim-x11.c
@@ -625,7 +625,7 @@ gdk_ic_new (GdkICAttr *attr, GdkICAttributesType mask)
     }
 
   if (attr->client_window == NULL ||
-      GDK_DRAWABLE_DESTROYED (attr->client_window))
+      GDK_WINDOW_DESTROYED (attr->client_window))
     {
       g_warning ("Client_window is null or already destroyed.\n");
       return NULL;
@@ -1084,7 +1084,7 @@ gdk_ic_set_attr (GdkIC *ic,
   if (mask & GDK_IC_PREEDIT_PIXMAP)
     {
       if (attr->preedit_pixmap != NULL &&
-	  GDK_DRAWABLE_DESTROYED (attr->preedit_pixmap))
+	  GDK_WINDOW_DESTROYED (attr->preedit_pixmap))
 	{
 	  g_warning ("Preedit pixmap is already destroyed.\n");
 	  error |= GDK_IC_PREEDIT_PIXMAP;
@@ -1171,7 +1171,7 @@ gdk_ic_set_attr (GdkIC *ic,
   if (mask & GDK_IC_STATUS_PIXMAP)
     {
       if (attr->status_pixmap != NULL &&
-	  GDK_DRAWABLE_DESTROYED (attr->status_pixmap))
+	  GDK_WINDOW_DESTROYED (attr->status_pixmap))
 	{
 	  g_warning ("Preedit pixmap is already destroyed.\n");
 	  error |= GDK_IC_STATUS_PIXMAP;
diff --git a/gdk/x11/gdkimage-x11.c b/gdk/x11/gdkimage-x11.c
index 2972e7a4ee..e9730dba2e 100644
--- a/gdk/x11/gdkimage-x11.c
+++ b/gdk/x11/gdkimage-x11.c
@@ -58,37 +58,70 @@
 #include "gdkprivate.h"
 #include "gdkprivate-x11.h"
 
-static void gdk_x11_image_destroy (GdkImage    *image);
-static void gdk_image_put_normal  (GdkImage    *image,
-				   GdkDrawable *drawable,
-				   GdkGC       *gc,
-				   gint         xsrc,
-				   gint         ysrc,
-				   gint         xdest,
-				   gint         ydest,
-				   gint         width,
-				   gint         height);
-static void gdk_image_put_shared  (GdkImage    *image,
-				   GdkDrawable *drawable,
-				   GdkGC       *gc,
-				   gint         xsrc,
-				   gint         ysrc,
-				   gint         xdest,
-				   gint         ydest,
-				   gint         width,
-				   gint         height);
-
-static GdkImageClass image_class_normal = {
-  gdk_x11_image_destroy,
-  gdk_image_put_normal
-};
-
-static GdkImageClass image_class_shared = {
-  gdk_x11_image_destroy,
-  gdk_image_put_shared
-};
-
 static GList *image_list = NULL;
+static gpointer parent_class = NULL;
+
+static void gdk_x11_image_destroy    (GdkImage      *image);
+static void gdk_image_init       (GdkImage      *image);
+static void gdk_image_class_init (GdkImageClass *klass);
+static void gdk_image_finalize   (GObject       *object);
+
+#define PRIVATE_DATA(image) ((GdkImagePrivateX11 *) GDK_IMAGE (image)->windowing_data)
+
+GType
+gdk_image_get_type (void)
+{
+  static GType object_type = 0;
+
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkImageClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_image_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkImage),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) gdk_image_init,
+      };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "GdkImage",
+                                            &object_info);
+    }
+  
+  return object_type;
+}
+
+static void
+gdk_image_init (GdkImage *image)
+{
+  image->windowing_data = g_new0 (GdkImagePrivateX11, 1);
+  
+}
+
+static void
+gdk_image_class_init (GdkImageClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->finalize = gdk_image_finalize;
+}
+
+static void
+gdk_image_finalize (GObject *object)
+{
+  GdkImage *image = GDK_IMAGE (object);
+
+  gdk_x11_image_destroy (image);
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
 
 
 void
@@ -111,12 +144,10 @@ gdk_image_new_bitmap(GdkVisual *visual, gpointer data, gint w, gint h)
 {
         Visual *xvisual;
         GdkImage *image;
-        GdkImagePrivateX *private;
-        private = g_new(GdkImagePrivateX, 1);
-        image = (GdkImage *) private;
+        GdkImagePrivateX11 *private;
+        image = GDK_IMAGE (g_type_create_instance (gdk_image_get_type ()));
+        private = PRIVATE_DATA (image);
         private->xdisplay = gdk_display;
-        private->base.ref_count = 1;
-        private->base.klass = &image_class_normal;
         image->type = GDK_IMAGE_NORMAL;
         image->visual = visual;
         image->width = w;
@@ -160,7 +191,7 @@ gdk_image_check_xshm(Display *display)
 }
 
 void
-gdk_image_init (void)
+_gdk_windowing_image_init (void)
 {
   if (gdk_use_xshm)
     {
@@ -178,7 +209,7 @@ gdk_image_new (GdkImageType  type,
 	       gint          height)
 {
   GdkImage *image;
-  GdkImagePrivateX *private;
+  GdkImagePrivateX11 *private;
 #ifdef USE_SHM
   XShmSegmentInfo *x_shm_info;
 #endif /* USE_SHM */
@@ -194,10 +225,10 @@ gdk_image_new (GdkImageType  type,
       break;
 
     default:
-      private = g_new (GdkImagePrivateX, 1);
-      image = (GdkImage*) private;
+      image = GDK_IMAGE (g_type_create_instance (gdk_image_get_type ()));
+      
+      private = PRIVATE_DATA (image);
 
-      private->base.ref_count = 1;
       private->xdisplay = gdk_display;
 
       image->type = type;
@@ -214,8 +245,6 @@ gdk_image_new (GdkImageType  type,
 #ifdef USE_SHM
 	  if (gdk_use_xshm)
 	    {
-	      private->base.klass = &image_class_shared;
-
 	      private->x_shm_info = g_new (XShmSegmentInfo, 1);
 	      x_shm_info = private->x_shm_info;
 
@@ -305,8 +334,6 @@ gdk_image_new (GdkImageType  type,
 	  return NULL;
 #endif /* USE_SHM */
 	case GDK_IMAGE_NORMAL:
-	  private->base.klass = &image_class_normal;
-
 	  private->ximage = XCreateImage (private->xdisplay, xvisual, visual->depth,
 					  ZPixmap, 0, 0, width, height, 32, 0);
 
@@ -342,18 +369,16 @@ gdk_image_get (GdkWindow *window,
 	       gint       height)
 {
   GdkImage *image;
-  GdkImagePrivateX *private;
+  GdkImagePrivateX11 *private;
 
-  g_return_val_if_fail (window != NULL, NULL);
+  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return NULL;
 
-  private = g_new (GdkImagePrivateX, 1);
-  image = (GdkImage*) private;
+  image = GDK_IMAGE (g_type_create_instance (gdk_image_get_type ()));
+  private = PRIVATE_DATA (image);
 
-  private->base.ref_count = 1;
-  private->base.klass = &image_class_normal;
   private->xdisplay = gdk_display;
   private->ximage = XGetImage (private->xdisplay,
 			       GDK_DRAWABLE_XID (window),
@@ -387,11 +412,11 @@ gdk_image_get_pixel (GdkImage *image,
 		     gint y)
 {
   guint32 pixel;
-  GdkImagePrivateX *private;
+  GdkImagePrivateX11 *private;
 
-  g_return_val_if_fail (image != NULL, 0);
+  g_return_val_if_fail (GDK_IS_IMAGE (image), 0);
 
-  private = (GdkImagePrivateX *) image;
+  private = PRIVATE_DATA (image);
 
   pixel = XGetPixel (private->ximage, x, y);
 
@@ -404,11 +429,11 @@ gdk_image_put_pixel (GdkImage *image,
 		     gint y,
 		     guint32 pixel)
 {
-  GdkImagePrivateX *private;
+  GdkImagePrivateX11 *private;
 
-  g_return_if_fail (image != NULL);
+  g_return_if_fail (GDK_IS_IMAGE (image));
 
-  private = (GdkImagePrivateX *) image;
+  private = PRIVATE_DATA (image);
 
   pixel = XPutPixel (private->ximage, x, y, pixel);
 }
@@ -416,14 +441,21 @@ gdk_image_put_pixel (GdkImage *image,
 static void
 gdk_x11_image_destroy (GdkImage *image)
 {
-  GdkImagePrivateX *private;
+  GdkImagePrivateX11 *private;
 #ifdef USE_SHM
   XShmSegmentInfo *x_shm_info;
 #endif /* USE_SHM */
 
-  g_return_if_fail (image != NULL);
+  g_return_if_fail (GDK_IS_IMAGE (image));
 
-  private = (GdkImagePrivateX*) image;
+  private = PRIVATE_DATA (image);
+
+  if (private == NULL) /* This means that gdk_image_exit() destroyed the
+                        * image already, and now we're called a second
+                        * time from _finalize()
+                        */
+    return;
+  
   switch (image->type)
     {
     case GDK_IMAGE_NORMAL:
@@ -441,7 +473,8 @@ gdk_x11_image_destroy (GdkImage *image)
       shmdt (x_shm_info->shmaddr);
       
       g_free (private->x_shm_info);
-
+      private->x_shm_info = NULL;
+      
       image_list = g_list_remove (image_list, image);
 #else /* USE_SHM */
       g_error ("trying to destroy shared memory image when gdk was compiled without shared memory support");
@@ -453,65 +486,6 @@ gdk_x11_image_destroy (GdkImage *image)
       g_assert_not_reached ();
     }
 
-  g_free (image);
-}
-
-static void
-gdk_image_put_normal (GdkImage    *image,
-		      GdkDrawable *drawable,
-		      GdkGC       *gc,
-		      gint         xsrc,
-		      gint         ysrc,
-		      gint         xdest,
-		      gint         ydest,
-		      gint         width,
-		      gint         height)
-{
-  GdkImagePrivateX *image_private;
-
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (image != NULL);
-  g_return_if_fail (gc != NULL);
-
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-  image_private = (GdkImagePrivateX*) image;
-
-  g_return_if_fail (image->type == GDK_IMAGE_NORMAL);
-
-  XPutImage (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable), 
-	     GDK_GC_GET_XGC (gc), image_private->ximage,
-	     xsrc, ysrc, xdest, ydest, width, height);
-}
-
-static void
-gdk_image_put_shared (GdkImage    *image,
-		      GdkDrawable *drawable,
-		      GdkGC       *gc,
-		      gint         xsrc,
-		      gint         ysrc,
-		      gint         xdest,
-		      gint         ydest,
-		      gint         width,
-		      gint         height)
-{
-#ifdef USE_SHM
-  GdkImagePrivateX *image_private;
-
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (image != NULL);
-  g_return_if_fail (gc != NULL);
-
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-  image_private = (GdkImagePrivateX*) image;
-
-  g_return_if_fail (image->type == GDK_IMAGE_SHARED);
-
-  XShmPutImage (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable), 
-		GDK_GC_GET_XGC (gc), image_private->ximage,
-		xsrc, ysrc, xdest, ydest, width, height, False);
-#else /* USE_SHM */
-  g_error ("trying to draw shared memory image when gdk was compiled without shared memory support");
-#endif /* USE_SHM */
+  g_free (private);
+  image->windowing_data = NULL;
 }
diff --git a/gdk/x11/gdkinput.c b/gdk/x11/gdkinput.c
index cb2dd269c7..4ee51b3154 100644
--- a/gdk/x11/gdkinput.c
+++ b/gdk/x11/gdkinput.c
@@ -115,7 +115,7 @@ gdk_input_motion_events (GdkWindow *window,
   g_return_val_if_fail (window != NULL, NULL);
   g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
   
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return NULL;
 
   if (deviceid == GDK_CORE_POINTER)
@@ -200,15 +200,15 @@ void
 gdk_input_set_extension_events (GdkWindow *window, gint mask,
 				GdkExtensionMode mode)
 {
-  GdkWindowPrivate *window_private;
+  GdkWindowObject *window_private;
   GList *tmp_list;
   GdkInputWindow *iw;
 
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  window_private = (GdkWindowPrivate*) window;
-  if (GDK_DRAWABLE_DESTROYED (window))
+  window_private = (GdkWindowObject*) window;
+  if (GDK_WINDOW_DESTROYED (window))
     return;
 
   if (mode == GDK_EXTENSION_EVENTS_NONE)
diff --git a/gdk/x11/gdkmain-x11.c b/gdk/x11/gdkmain-x11.c
index 7ce8a3b35d..b266a67e22 100644
--- a/gdk/x11/gdkmain-x11.c
+++ b/gdk/x11/gdkmain-x11.c
@@ -49,6 +49,7 @@
 #include "gdkprivate-x11.h"
 #include "gdkinternals.h"
 #include "gdkinputprivate.h"
+#include <pango/pangox.h>
 
 typedef struct _GdkPredicate  GdkPredicate;
 typedef struct _GdkErrorTrap  GdkErrorTrap;
@@ -246,12 +247,12 @@ gdk_pointer_grab (GdkWindow *	  window,
   
   cursor_private = (GdkCursorPrivate*) cursor;
   
-  xwindow = GDK_DRAWABLE_XID (window);
+  xwindow = GDK_WINDOW_XID (window);
   
-  if (!confine_to || GDK_DRAWABLE_DESTROYED (confine_to))
+  if (!confine_to || GDK_WINDOW_DESTROYED (confine_to))
     xconfine_to = None;
   else
-    xconfine_to = GDK_DRAWABLE_XID (confine_to);
+    xconfine_to = GDK_WINDOW_XID (confine_to);
   
   if (!cursor)
     xcursor = None;
@@ -277,8 +278,8 @@ gdk_pointer_grab (GdkWindow *	  window,
   
   if (return_val == Success)
     {
-      if (!GDK_DRAWABLE_DESTROYED (window))
-	return_val = XGrabPointer (GDK_DRAWABLE_XDISPLAY (window),
+      if (!GDK_WINDOW_DESTROYED (window))
+	return_val = XGrabPointer (GDK_WINDOW_XDISPLAY (window),
 				   xwindow,
 				   owner_events,
 				   xevent_mask,
@@ -291,7 +292,7 @@ gdk_pointer_grab (GdkWindow *	  window,
     }
   
   if (return_val == GrabSuccess)
-    gdk_xgrab_window = (GdkWindowPrivate *)window;
+    gdk_xgrab_window = (GdkWindowObject *)window;
   
   return return_val;
 }
@@ -370,9 +371,9 @@ gdk_keyboard_grab (GdkWindow *	   window,
   g_return_val_if_fail (window != NULL, 0);
   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
-    return XGrabKeyboard (GDK_DRAWABLE_XDISPLAY (window),
-			  GDK_DRAWABLE_XID (window),
+  if (!GDK_WINDOW_DESTROYED (window))
+    return XGrabKeyboard (GDK_WINDOW_XDISPLAY (window),
+			  GDK_WINDOW_XID (window),
 			  owner_events,
 			  GrabModeAsync, GrabModeAsync,
 			  time);
diff --git a/gdk/x11/gdkpixmap-x11.c b/gdk/x11/gdkpixmap-x11.c
index 326d0702be..b8ee30872a 100644
--- a/gdk/x11/gdkpixmap-x11.c
+++ b/gdk/x11/gdkpixmap-x11.c
@@ -32,7 +32,8 @@
 #include <unistd.h>
 #include <X11/Xlib.h>
 
-#include "gdkpixmap.h"
+#include <gdk/gdkpixmap.h>
+#include "gdkpixmap-x11.h"
 #include "gdkprivate-x11.h"
 
 typedef struct
@@ -49,42 +50,92 @@ typedef struct
   gulong pixels[1];
 } _GdkPixmapInfo;
 
-GdkDrawableClass _gdk_x11_pixmap_class;
+static void gdk_pixmap_impl_x11_get_size   (GdkDrawable        *drawable,
+                                        gint               *width,
+                                        gint               *height);
 
-static void
-gdk_x11_pixmap_destroy (GdkPixmap *pixmap)
-{
-  XFreePixmap (GDK_DRAWABLE_XDISPLAY (pixmap), GDK_DRAWABLE_XID (pixmap));
-  gdk_xid_table_remove (GDK_DRAWABLE_XID (pixmap));
+static void gdk_pixmap_impl_x11_init       (GdkPixmapImplX11      *pixmap);
+static void gdk_pixmap_impl_x11_class_init (GdkPixmapImplX11Class *klass);
+static void gdk_pixmap_impl_x11_finalize   (GObject            *object);
 
-  g_free (GDK_DRAWABLE_XDATA (pixmap));
-}
+static gpointer parent_class = NULL;
 
-static GdkDrawable *
-gdk_x11_pixmap_alloc (void)
+GType
+gdk_pixmap_impl_x11_get_type (void)
 {
-  GdkDrawable *drawable;
-  GdkDrawablePrivate *private;
-  
-  static GdkDrawableClass klass;
-  static gboolean initialized = FALSE;
+  static GType object_type = 0;
 
-  if (!initialized)
+  if (!object_type)
     {
-      initialized = TRUE;
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkPixmapImplX11Class),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_pixmap_impl_x11_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkPixmapImplX11),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) gdk_pixmap_impl_x11_init,
+      };
       
-      klass = _gdk_x11_drawable_class;
-      klass.destroy = gdk_x11_pixmap_destroy;
+      object_type = g_type_register_static (GDK_TYPE_DRAWABLE_IMPL_X11,
+                                            "GdkPixmapImplX11",
+                                            &object_info);
     }
+  
+  return object_type;
+}
 
-  drawable = gdk_drawable_alloc ();
-  private = (GdkDrawablePrivate *)drawable;
 
-  private->klass = &klass;
-  private->klass_data = g_new (GdkDrawableXData, 1);
-  private->window_type = GDK_DRAWABLE_PIXMAP;
+GType
+_gdk_pixmap_impl_get_type (void)
+{
+  return gdk_pixmap_impl_x11_get_type ();
+}
+
+static void
+gdk_pixmap_impl_x11_init (GdkPixmapImplX11 *impl)
+{
+  impl->width = 1;
+  impl->height = 1;
+}
+
+static void
+gdk_pixmap_impl_x11_class_init (GdkPixmapImplX11Class *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
+  
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->finalize = gdk_pixmap_impl_x11_finalize;
+
+  drawable_class->get_size = gdk_pixmap_impl_x11_get_size;
+}
+
+static void
+gdk_pixmap_impl_x11_finalize (GObject *object)
+{
+  GdkPixmapImplX11 *impl = GDK_PIXMAP_IMPL_X11 (object);
+  GdkPixmap *wrapper = GDK_PIXMAP (GDK_DRAWABLE_IMPL_X11 (impl)->wrapper);
+  
+  XFreePixmap (GDK_PIXMAP_XDISPLAY (wrapper), GDK_PIXMAP_XID (wrapper));
+  gdk_xid_table_remove (GDK_PIXMAP_XID (wrapper));
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
 
-  return drawable;
+static void
+gdk_pixmap_impl_x11_get_size   (GdkDrawable *drawable,
+                                gint        *width,
+                                gint        *height)
+{
+  if (width)
+    *width = GDK_PIXMAP_IMPL_X11 (drawable)->width;
+  if (height)
+    *height = GDK_PIXMAP_IMPL_X11 (drawable)->height;
 }
 
 GdkPixmap*
@@ -94,8 +145,9 @@ gdk_pixmap_new (GdkWindow *window,
 		gint       depth)
 {
   GdkPixmap *pixmap;
-  GdkDrawablePrivate *private;
-
+  GdkDrawableImplX11 *draw_impl;
+  GdkPixmapImplX11 *pix_impl;
+  
   g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
   g_return_val_if_fail ((window != NULL) || (depth != -1), NULL);
   g_return_val_if_fail ((width != 0) && (height != 0), NULL);
@@ -103,24 +155,27 @@ gdk_pixmap_new (GdkWindow *window,
   if (!window)
     window = gdk_parent_root;
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return NULL;
 
   if (depth == -1)
-    depth = gdk_drawable_get_visual (window)->depth;
+    depth = gdk_drawable_get_depth (GDK_DRAWABLE (window));
 
-  pixmap = gdk_x11_pixmap_alloc ();
-  private = (GdkDrawablePrivate *)pixmap;
-
-  GDK_DRAWABLE_XDATA (private)->xdisplay = GDK_DRAWABLE_XDISPLAY (window);
-  GDK_DRAWABLE_XDATA (private)->xid = XCreatePixmap (GDK_DRAWABLE_XDISPLAY (pixmap),
-						     GDK_DRAWABLE_XID (window),
-						     width, height, depth);
-  private->width = width;
-  private->height = height;
-  private->depth = depth;
+  pixmap = GDK_PIXMAP (g_type_create_instance (gdk_pixmap_get_type ()));
+  draw_impl = GDK_DRAWABLE_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
+  pix_impl = GDK_PIXMAP_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
+  draw_impl->wrapper = GDK_DRAWABLE (pixmap);
+  
+  draw_impl->xdisplay = GDK_WINDOW_XDISPLAY (window);
+  draw_impl->xid = XCreatePixmap (GDK_PIXMAP_XDISPLAY (pixmap),
+                                  GDK_WINDOW_XID (window),
+                                  width, height, depth);
+  
+  pix_impl->width = width;
+  pix_impl->height = height;
+  GDK_PIXMAP_OBJECT (pixmap)->depth = depth;
 
-  gdk_xid_table_insert (&GDK_DRAWABLE_XID (pixmap), pixmap);
+  gdk_xid_table_insert (&GDK_PIXMAP_XID (pixmap), pixmap);
 
   return pixmap;
 }
@@ -132,8 +187,9 @@ gdk_bitmap_create_from_data (GdkWindow   *window,
 			     gint         height)
 {
   GdkPixmap *pixmap;
-  GdkDrawablePrivate *private;
-
+  GdkDrawableImplX11 *draw_impl;
+  GdkPixmapImplX11 *pix_impl;
+  
   g_return_val_if_fail (data != NULL, NULL);
   g_return_val_if_fail ((width != 0) && (height != 0), NULL);
   g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
@@ -141,23 +197,25 @@ gdk_bitmap_create_from_data (GdkWindow   *window,
   if (!window)
     window = gdk_parent_root;
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return NULL;
 
-  pixmap = gdk_x11_pixmap_alloc ();
-  private = (GdkDrawablePrivate *)pixmap;
+  pixmap = GDK_PIXMAP (g_type_create_instance (gdk_pixmap_get_type ()));
+  draw_impl = GDK_DRAWABLE_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
+  pix_impl = GDK_PIXMAP_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
+  draw_impl->wrapper = GDK_DRAWABLE (pixmap);
 
-  private->width = width;
-  private->height = height;
-  private->depth = 1;
+  pix_impl->width = width;
+  pix_impl->height = height;
+  GDK_PIXMAP_OBJECT (pixmap)->depth = 1;
 
-  GDK_DRAWABLE_XDATA (private)->xdisplay = GDK_DRAWABLE_XDISPLAY (window);
-  GDK_DRAWABLE_XDATA (private)->xid = XCreateBitmapFromData (GDK_DRAWABLE_XDISPLAY (window),
-							     GDK_DRAWABLE_XID (window),
-							     (char *)data, width, height);
-
-  gdk_xid_table_insert (&GDK_DRAWABLE_XID (pixmap), pixmap);
+  draw_impl->xdisplay = GDK_WINDOW_XDISPLAY (window);
+  draw_impl->xid = XCreateBitmapFromData (GDK_WINDOW_XDISPLAY (window),
+                                          GDK_WINDOW_XID (window),
+                                          (char *)data, width, height);
 
+  gdk_xid_table_insert (&GDK_PIXMAP_XID (pixmap), pixmap);
+  
   return pixmap;
 }
 
@@ -171,7 +229,8 @@ gdk_pixmap_create_from_data (GdkWindow   *window,
 			     GdkColor    *bg)
 {
   GdkPixmap *pixmap;
-  GdkDrawablePrivate *private;
+  GdkDrawableImplX11 *draw_impl;
+  GdkPixmapImplX11 *pix_impl;
 
   g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
   g_return_val_if_fail (data != NULL, NULL);
@@ -183,26 +242,28 @@ gdk_pixmap_create_from_data (GdkWindow   *window,
   if (!window)
     window = gdk_parent_root;
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return NULL;
 
   if (depth == -1)
     depth = gdk_drawable_get_visual (window)->depth;
 
-  pixmap = gdk_x11_pixmap_alloc ();
-  private = (GdkDrawablePrivate *)pixmap;
-
-  private->width = width;
-  private->height = height;
-  private->depth = depth;
+  pixmap = GDK_PIXMAP (g_type_create_instance (gdk_pixmap_get_type ()));
+  draw_impl = GDK_DRAWABLE_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
+  pix_impl = GDK_PIXMAP_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
+  draw_impl->wrapper = GDK_DRAWABLE (pixmap);
+  
+  pix_impl->width = width;
+  pix_impl->height = height;
+  GDK_PIXMAP_OBJECT (pixmap)->depth = depth;
 
-  GDK_DRAWABLE_XDATA (private)->xdisplay = GDK_DRAWABLE_XDISPLAY (window);
-  GDK_DRAWABLE_XDATA (private)->xid = XCreatePixmapFromBitmapData (GDK_DRAWABLE_XDISPLAY (window),
-								   GDK_DRAWABLE_XID (window),
-								   (char *)data, width, height,
-								   fg->pixel, bg->pixel, depth);
+  draw_impl->xdisplay = GDK_DRAWABLE_XDISPLAY (window);
+  draw_impl->xid = XCreatePixmapFromBitmapData (GDK_WINDOW_XDISPLAY (window),
+                                                GDK_WINDOW_XID (window),
+                                                (char *)data, width, height,
+                                                fg->pixel, bg->pixel, depth);
 
-  gdk_xid_table_insert (&GDK_DRAWABLE_XID (pixmap), pixmap);
+  gdk_xid_table_insert (&GDK_PIXMAP_XID (pixmap), pixmap);
 
   return pixmap;
 }
@@ -483,7 +544,7 @@ _gdk_pixmap_create_from_xpm (GdkWindow  *window,
       visual = gdk_drawable_get_visual (window);
     }
   else
-    visual = ((GdkColormapPrivate *)colormap)->visual;
+    visual = colormap->visual;
   
   buffer = (*get_buf) (op_header, handle);
   if (buffer == NULL)
@@ -779,7 +840,8 @@ GdkPixmap*
 gdk_pixmap_foreign_new (GdkNativeWindow anid)
 {
   GdkPixmap *pixmap;
-  GdkDrawablePrivate *private;
+  GdkDrawableImplX11 *draw_impl;
+  GdkPixmapImplX11 *pix_impl;
   Pixmap xpixmap;
   Window root_return;
   unsigned int x_ret, y_ret, w_ret, h_ret, bw_ret, depth_ret;
@@ -797,18 +859,21 @@ gdk_pixmap_foreign_new (GdkNativeWindow anid)
 		    xpixmap, &root_return,
 		    &x_ret, &y_ret, &w_ret, &h_ret, &bw_ret, &depth_ret))
       return NULL;
-      
-  pixmap = gdk_x11_pixmap_alloc ();
-  private = (GdkDrawablePrivate *)pixmap;
 
-  GDK_DRAWABLE_XDATA (private)->xdisplay = GDK_DISPLAY ();
-  GDK_DRAWABLE_XDATA (private)->xid = xpixmap;
+  pixmap = GDK_PIXMAP (g_type_create_instance (gdk_pixmap_get_type ()));
+  draw_impl = GDK_DRAWABLE_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
+  pix_impl = GDK_PIXMAP_IMPL_X11 (GDK_PIXMAP_OBJECT (pixmap)->impl);
+  draw_impl->wrapper = GDK_DRAWABLE (pixmap);
+  
+
+  draw_impl->xdisplay = GDK_DISPLAY ();
+  draw_impl->xid = xpixmap;
 
-  private->width = w_ret;
-  private->height = h_ret;
-  private->depth = depth_ret;
+  pix_impl->width = w_ret;
+  pix_impl->height = h_ret;
+  GDK_PIXMAP_OBJECT (pixmap)->depth = depth_ret;
   
-  gdk_xid_table_insert(&GDK_DRAWABLE_XID (pixmap), pixmap);
+  gdk_xid_table_insert(&GDK_PIXMAP_XID (pixmap), pixmap);
 
   return pixmap;
 }
diff --git a/gdk/x11/gdkpixmap-x11.h b/gdk/x11/gdkpixmap-x11.h
new file mode 100644
index 0000000000..0087553ba7
--- /dev/null
+++ b/gdk/x11/gdkpixmap-x11.h
@@ -0,0 +1,70 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#ifndef __GDK_PIXMAP_X11_H__
+#define __GDK_PIXMAP_X11_H__
+
+#include <gdk/x11/gdkdrawable-x11.h>
+#include <gdk/gdkpixmap.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Pixmap implementation for X11
+ */
+
+typedef struct _GdkPixmapImplX11 GdkPixmapImplX11;
+typedef struct _GdkPixmapImplX11Class GdkPixmapImplX11Class;
+
+#define GDK_TYPE_PIXMAP_IMPL_X11              (gdk_pixmap_impl_x11_get_type ())
+#define GDK_PIXMAP_IMPL_X11(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXMAP_IMPL_X11, GdkPixmapImplX11))
+#define GDK_PIXMAP_IMPL_X11_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXMAP_IMPL_X11, GdkPixmapImplX11Class))
+#define GDK_IS_PIXMAP_IMPL_X11(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXMAP_IMPL_X11))
+#define GDK_IS_PIXMAP_IMPL_X11_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXMAP_IMPL_X11))
+#define GDK_PIXMAP_IMPL_X11_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXMAP_IMPL_X11, GdkPixmapImplX11Class))
+
+struct _GdkPixmapImplX11
+{
+  GdkDrawableImplX11 parent_instance;
+
+  gint width;
+  gint height;
+};
+ 
+struct _GdkPixmapImplX11Class 
+{
+  GdkDrawableImplX11Class parent_class;
+
+};
+
+GType gdk_pixmap_impl_x11_get_type (void);
+ 
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GDK_PIXMAP_X11_H__ */
diff --git a/gdk/x11/gdkprivate-x11.h b/gdk/x11/gdkprivate-x11.h
index e61e7e28c6..5c84355fd7 100644
--- a/gdk/x11/gdkprivate-x11.h
+++ b/gdk/x11/gdkprivate-x11.h
@@ -63,16 +63,15 @@ Window gdk_window_xid_at_coords (gint      x,
 				 gboolean  excl_child);
 
 /* Routines from gdkgeometry-x11.c */
-
-void _gdk_window_init_position     (GdkWindow    *window);
-void _gdk_window_move_resize_child (GdkWindow    *window,
-				    gint          x,
-				    gint          y,
-				    gint          width,
-				    gint          height);
-void _gdk_window_process_expose    (GdkWindow    *window,
-				    gulong        serial,
-				    GdkRectangle *area);
+void _gdk_window_init_position     (GdkWindow     *window);
+void _gdk_window_move_resize_child (GdkWindow     *window,
+                                    gint           x,
+                                    gint           y,
+                                    gint           width,
+                                    gint           height);
+void _gdk_window_process_expose    (GdkWindow     *window,
+                                    gulong         serial,
+                                    GdkRectangle  *area);
 
 extern GdkDrawableClass  _gdk_x11_drawable_class;
 extern gboolean	         gdk_use_xshm;
@@ -85,9 +84,9 @@ extern gboolean          gdk_null_window_warnings;
 extern const int         gdk_nevent_masks;
 extern const int         gdk_event_mask_table[];
 
-extern GdkWindowPrivate *gdk_xgrab_window;  /* Window that currently holds the
-					     * x pointer grab
-					     */
+extern GdkWindowObject *gdk_xgrab_window;  /* Window that currently holds the
+					    * x pointer grab
+					    */
 
 #ifdef USE_XIM
 extern GdkICPrivate *gdk_xim_ic;		/* currently using IC */
diff --git a/gdk/x11/gdkproperty-x11.c b/gdk/x11/gdkproperty-x11.c
index 58b51a9712..4d338fe95b 100644
--- a/gdk/x11/gdkproperty-x11.c
+++ b/gdk/x11/gdkproperty-x11.c
@@ -117,11 +117,11 @@ gdk_property_get (GdkWindow   *window,
 
   if (window)
     {
-      if (GDK_DRAWABLE_DESTROYED (window))
+      if (GDK_WINDOW_DESTROYED (window))
 	return FALSE;
 
-      xdisplay = GDK_DRAWABLE_XDISPLAY (window);
-      xwindow = GDK_DRAWABLE_XID (window);
+      xdisplay = GDK_WINDOW_XDISPLAY (window);
+      xwindow = GDK_WINDOW_XID (window);
     }
   else
     {
@@ -206,11 +206,11 @@ gdk_property_change (GdkWindow    *window,
 
   if (window)
     {
-      if (GDK_DRAWABLE_DESTROYED (window))
+      if (GDK_WINDOW_DESTROYED (window))
 	return;
 
-      xdisplay = GDK_DRAWABLE_XDISPLAY (window);
-      xwindow = GDK_DRAWABLE_XID (window);
+      xdisplay = GDK_WINDOW_XDISPLAY (window);
+      xwindow = GDK_WINDOW_XID (window);
     }
   else
     {
@@ -234,11 +234,11 @@ gdk_property_delete (GdkWindow *window,
 
   if (window)
     {
-      if (GDK_DRAWABLE_DESTROYED (window))
+      if (GDK_WINDOW_DESTROYED (window))
 	return;
 
-      xdisplay = GDK_DRAWABLE_XDISPLAY (window);
-      xwindow = GDK_DRAWABLE_XID (window);
+      xdisplay = GDK_WINDOW_XDISPLAY (window);
+      xwindow = GDK_WINDOW_XID (window);
     }
   else
     {
diff --git a/gdk/x11/gdkselection-x11.c b/gdk/x11/gdkselection-x11.c
index 31a6eb0b91..f0916db072 100644
--- a/gdk/x11/gdkselection-x11.c
+++ b/gdk/x11/gdkselection-x11.c
@@ -45,11 +45,11 @@ gdk_selection_owner_set (GdkWindow *owner,
 
   if (owner)
     {
-      if (GDK_DRAWABLE_DESTROYED (owner))
+      if (GDK_WINDOW_DESTROYED (owner))
 	return FALSE;
 
-      xdisplay = GDK_DRAWABLE_XDISPLAY (owner);
-      xwindow = GDK_DRAWABLE_XID (owner);
+      xdisplay = GDK_WINDOW_XDISPLAY (owner);
+      xwindow = GDK_WINDOW_XID (owner);
     }
   else
     {
@@ -80,11 +80,11 @@ gdk_selection_convert (GdkWindow *requestor,
 		       GdkAtom    target,
 		       guint32    time)
 {
-  if (GDK_DRAWABLE_DESTROYED (requestor))
+  if (GDK_WINDOW_DESTROYED (requestor))
     return;
 
-  XConvertSelection (GDK_DRAWABLE_XDISPLAY (requestor), selection, target,
-		     gdk_selection_property, GDK_DRAWABLE_XID (requestor), time);
+  XConvertSelection (GDK_WINDOW_XDISPLAY (requestor), selection, target,
+		     gdk_selection_property, GDK_WINDOW_XID (requestor), time);
 }
 
 gint
@@ -107,12 +107,12 @@ gdk_selection_property_get (GdkWindow  *requestor,
      should be) it would be a win to try first with a buffer of
      moderate length, to avoid two round trips to the server */
 
-  if (GDK_DRAWABLE_DESTROYED (requestor))
+  if (GDK_WINDOW_DESTROYED (requestor))
     return 0;
 
   t = NULL;
-  XGetWindowProperty (GDK_DRAWABLE_XDISPLAY (requestor),
-		      GDK_DRAWABLE_XID (requestor),
+  XGetWindowProperty (GDK_WINDOW_XDISPLAY (requestor),
+		      GDK_WINDOW_XID (requestor),
 		      gdk_selection_property, 0, 0, False,
 		      AnyPropertyType, &prop_type, &prop_format,
 		      &nitems, &nbytes, &t);
diff --git a/gdk/x11/gdkwindow-x11.c b/gdk/x11/gdkwindow-x11.c
index fe6da9b237..8f6964101a 100644
--- a/gdk/x11/gdkwindow-x11.c
+++ b/gdk/x11/gdkwindow-x11.c
@@ -37,6 +37,7 @@
 #include "gdkregion.h"
 #include "gdkinternals.h"
 #include "MwmUtil.h"
+#include "gdkwindow-x11.h"
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -79,79 +80,192 @@ static void     gdk_window_set_static_win_gravity (GdkWindow *window,
 						   gboolean   on);
 static gboolean gdk_window_have_shape_ext (void);
 
-GdkDrawableClass _gdk_windowing_window_class;
+static GdkColormap* gdk_window_impl_x11_get_colormap (GdkDrawable *drawable);
+static void         gdk_window_impl_x11_set_colormap (GdkDrawable *drawable,
+                                                  GdkColormap *cmap);
+static void         gdk_window_impl_x11_get_size     (GdkDrawable *drawable,
+                                                  gint *width,
+                                                  gint *height);
+static void gdk_window_impl_x11_init       (GdkWindowImplX11      *window);
+static void gdk_window_impl_x11_class_init (GdkWindowImplX11Class *klass);
+static void gdk_window_impl_x11_finalize   (GObject            *object);
 
-static void
-gdk_x11_window_destroy (GdkDrawable *drawable)
+static gpointer parent_class = NULL;
+
+GType
+gdk_window_impl_x11_get_type (void)
 {
-  if (!GDK_DRAWABLE_DESTROYED (drawable))
+  static GType object_type = 0;
+
+  if (!object_type)
     {
-      if (GDK_DRAWABLE_TYPE (drawable) != GDK_WINDOW_FOREIGN)
-	{
-	  g_warning ("losing last reference to undestroyed window\n");
-	  _gdk_window_destroy (drawable, FALSE);
-	}
-      else
-	/* We use TRUE here, to keep us from actually calling
-	 * XDestroyWindow() on the window
-	 */
-	_gdk_window_destroy (drawable, TRUE);
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkWindowImplX11Class),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_window_impl_x11_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkWindowImplX11),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) gdk_window_impl_x11_init,
+      };
       
-      gdk_xid_table_remove (GDK_DRAWABLE_XID (drawable));
+      object_type = g_type_register_static (GDK_TYPE_DRAWABLE_IMPL_X11,
+                                            "GdkWindowImplX11",
+                                            &object_info);
     }
+  
+  return object_type;
+}
+
+GType
+_gdk_window_impl_get_type (void)
+{
+  return gdk_window_impl_x11_get_type ();
+}
 
-  g_free (GDK_DRAWABLE_XDATA (drawable));
+static void
+gdk_window_impl_x11_init (GdkWindowImplX11 *impl)
+{
+  impl->width = 1;
+  impl->height = 1;
 }
 
-static GdkWindow *
-gdk_x11_window_alloc (void)
+static void
+gdk_window_impl_x11_class_init (GdkWindowImplX11Class *klass)
 {
-  GdkWindow *window;
-  GdkWindowPrivate *private;
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
   
-  static gboolean initialized = FALSE;
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->finalize = gdk_window_impl_x11_finalize;
 
-  if (!initialized)
+  drawable_class->set_colormap = gdk_window_impl_x11_set_colormap;
+  drawable_class->get_colormap = gdk_window_impl_x11_get_colormap;
+  drawable_class->get_size = gdk_window_impl_x11_get_size;
+}
+
+static void
+gdk_window_impl_x11_finalize (GObject *object)
+{
+  GdkWindowObject *wrapper;
+  GdkDrawableImplX11 *draw_impl;
+  GdkWindowImplX11 *window_impl;
+  
+  g_return_if_fail (GDK_IS_WINDOW_IMPL_X11 (object));
+
+  draw_impl = GDK_DRAWABLE_IMPL_X11 (object);
+  window_impl = GDK_WINDOW_IMPL_X11 (object);
+  
+  wrapper = (GdkWindowObject*) draw_impl->wrapper;
+
+  if (!GDK_WINDOW_DESTROYED (wrapper))
     {
-      initialized = TRUE;
+      gdk_xid_table_remove (draw_impl->xid);
+    }
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
 
-      _gdk_windowing_window_class = _gdk_x11_drawable_class;
-      _gdk_windowing_window_class.destroy = gdk_x11_window_destroy;
+static GdkColormap*
+gdk_window_impl_x11_get_colormap (GdkDrawable *drawable)
+{
+  GdkDrawableImplX11 *drawable_impl;
+  GdkWindowImplX11 *window_impl;
+  
+  g_return_val_if_fail (GDK_IS_WINDOW_IMPL_X11 (drawable), NULL);
+
+  drawable_impl = GDK_DRAWABLE_IMPL_X11 (drawable);
+  window_impl = GDK_WINDOW_IMPL_X11 (drawable);
+
+  if (!((GdkWindowObject *) drawable_impl->wrapper)->input_only && 
+      drawable_impl->colormap == NULL)
+    {
+      XWindowAttributes window_attributes;
+      
+      XGetWindowAttributes (drawable_impl->xdisplay,
+                            drawable_impl->xid,
+                            &window_attributes);
+      drawable_impl->colormap =
+        gdk_colormap_lookup (window_attributes.colormap);
     }
+  
+  return drawable_impl->colormap;
+}
+
+static void
+gdk_window_impl_x11_set_colormap (GdkDrawable *drawable,
+                                  GdkColormap *cmap)
+{
+  GdkWindowImplX11 *impl;
+  GdkDrawableImplX11 *draw_impl;
+  
+  g_return_if_fail (GDK_IS_WINDOW_IMPL_X11 (drawable));
+  g_return_if_fail (gdk_colormap_get_visual (cmap) != gdk_drawable_get_visual (drawable));
 
-  window = _gdk_window_alloc ();
-  private = (GdkWindowPrivate *)window;
+  impl = GDK_WINDOW_IMPL_X11 (drawable);
+  draw_impl = GDK_DRAWABLE_IMPL_X11 (drawable);
 
-  private->drawable.klass = &_gdk_window_class;
-  private->drawable.klass_data = g_new (GdkWindowXData, 1);
+  GDK_DRAWABLE_GET_CLASS (draw_impl)->set_colormap (drawable, cmap);
+  
+  XSetWindowColormap (draw_impl->xdisplay,
+                      draw_impl->xid,
+                      GDK_COLORMAP_XCOLORMAP (cmap));
 
-  return window;
+  if (((GdkWindowObject*)draw_impl->wrapper)->window_type !=
+      GDK_WINDOW_TOPLEVEL)
+    gdk_window_add_colormap_windows (GDK_WINDOW (draw_impl->wrapper));
+}
+
+
+static void
+gdk_window_impl_x11_get_size (GdkDrawable *drawable,
+                              gint        *width,
+                              gint        *height)
+{
+  g_return_if_fail (GDK_IS_WINDOW_IMPL_X11 (drawable));
+
+  if (width)
+    *width = GDK_WINDOW_IMPL_X11 (drawable)->width;
+  if (height)
+    *height = GDK_WINDOW_IMPL_X11 (drawable)->height;
 }
 
 void
-gdk_window_init (void)
+_gdk_windowing_window_init (void)
 {
-  GdkWindowPrivate *private;
+  GdkWindowObject *private;
+  GdkWindowImplX11 *impl;
+  GdkDrawableImplX11 *draw_impl;
   XWindowAttributes xattributes;
   unsigned int width;
   unsigned int height;
   unsigned int border_width;
   unsigned int depth;
   int x, y;
+
+  g_assert (gdk_parent_root == NULL);
   
   XGetGeometry (gdk_display, gdk_root_window, &gdk_root_window,
 		&x, &y, &width, &height, &border_width, &depth);
   XGetWindowAttributes (gdk_display, gdk_root_window, &xattributes);
 
-  gdk_parent_root = gdk_x11_window_alloc ();
-  private = (GdkWindowPrivate *)gdk_parent_root;
+  gdk_parent_root = GDK_WINDOW (g_type_create_instance (GDK_TYPE_WINDOW));
+  private = (GdkWindowObject *)gdk_parent_root;
+  impl = GDK_WINDOW_IMPL_X11 (private->impl);
+  draw_impl = GDK_DRAWABLE_IMPL_X11 (private->impl);
   
-  GDK_DRAWABLE_XDATA (gdk_parent_root)->xdisplay = gdk_display;
-  GDK_DRAWABLE_XDATA (gdk_parent_root)->xid = gdk_root_window;
-
-  private->drawable.window_type = GDK_WINDOW_ROOT;
-  private->drawable.width = width;
-  private->drawable.height = height;
+  draw_impl->xdisplay = gdk_display;
+  draw_impl->xid = gdk_root_window;
+  draw_impl->wrapper = GDK_DRAWABLE (private);
+  
+  private->window_type = GDK_WINDOW_ROOT;
+  private->depth = depth;
+  impl->width = width;
+  impl->height = height;
   
   gdk_xid_table_insert (&gdk_root_window, gdk_parent_root);
 }
@@ -164,8 +278,10 @@ gdk_window_new (GdkWindow     *parent,
 		gint           attributes_mask)
 {
   GdkWindow *window;
-  GdkWindowPrivate *private;
-  GdkWindowPrivate *parent_private;
+  GdkWindowObject *private;
+  GdkWindowObject *parent_private;
+  GdkWindowImplX11 *impl;
+  GdkDrawableImplX11 *draw_impl;
   
   GdkVisual *visual;
   Window xparent;
@@ -186,19 +302,24 @@ gdk_window_new (GdkWindow     *parent,
   
   if (!parent)
     parent = gdk_parent_root;
+
+  g_return_val_if_fail (GDK_IS_WINDOW (parent), NULL);
   
-  parent_private = (GdkWindowPrivate*) parent;
-  if (GDK_DRAWABLE_DESTROYED (parent))
+  parent_private = (GdkWindowObject*) parent;
+  if (GDK_WINDOW_DESTROYED (parent))
     return NULL;
   
-  xparent = GDK_DRAWABLE_XID (parent);
+  xparent = GDK_WINDOW_XID (parent);
   
-  window = gdk_x11_window_alloc ();
-  private = (GdkWindowPrivate *)window;
-
-  GDK_DRAWABLE_XDATA (window)->xdisplay = GDK_DRAWABLE_XDISPLAY (parent);
+  window = GDK_WINDOW (g_type_create_instance (GDK_TYPE_WINDOW));
+  private = (GdkWindowObject *)window;
+  impl = GDK_WINDOW_IMPL_X11 (private->impl);
+  draw_impl = GDK_DRAWABLE_IMPL_X11 (private->impl);
+  draw_impl->wrapper = GDK_DRAWABLE (window);
+  
+  draw_impl->xdisplay = GDK_WINDOW_XDISPLAY (parent); 
   
-  private->parent = parent;
+  private->parent = (GdkWindowObject *)parent;
 
   xattributes_mask = 0;
   
@@ -214,12 +335,12 @@ gdk_window_new (GdkWindow     *parent,
   
   private->x = x;
   private->y = y;
-  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;
+  impl->width = (attributes->width > 1) ? (attributes->width) : (1);
+  impl->height = (attributes->height > 1) ? (attributes->height) : (1);
+  private->window_type = attributes->window_type;
 
-  _gdk_window_init_position (window);
-  if (GDK_WINDOW_XDATA (window)->position_info.big)
+  _gdk_window_init_position (GDK_WINDOW (private));
+  if (impl->position_info.big)
     private->guffaw_gravity = TRUE;
   
   if (attributes_mask & GDK_WA_VISUAL)
@@ -259,16 +380,26 @@ gdk_window_new (GdkWindow     *parent,
       depth = visual->depth;
 
       private->input_only = FALSE;
-      private->drawable.depth = depth;
+      private->depth = depth;
       
       if (attributes_mask & GDK_WA_COLORMAP)
-	private->drawable.colormap = attributes->colormap;
+        {
+          draw_impl->colormap = attributes->colormap;
+          gdk_colormap_ref (attributes->colormap);
+        }
       else
 	{
 	  if ((((GdkVisualPrivate*)gdk_visual_get_system ())->xvisual) == xvisual)
-	    private->drawable.colormap = gdk_colormap_get_system ();
+            {
+              draw_impl->colormap =
+                gdk_colormap_get_system ();
+              gdk_colormap_ref (draw_impl->colormap);
+            }
 	  else
-	    private->drawable.colormap = gdk_colormap_new (visual, False);
+            {
+              draw_impl->colormap =
+                gdk_colormap_new (visual, FALSE);
+            }
 	}
       
       private->bg_color.pixel = BlackPixel (gdk_display, gdk_screen);
@@ -286,29 +417,29 @@ gdk_window_new (GdkWindow     *parent,
       
       xattributes_mask |= CWBitGravity;
   
-      switch (private->drawable.window_type)
+      switch (private->window_type)
 	{
 	case GDK_WINDOW_TOPLEVEL:
-	  xattributes.colormap = GDK_COLORMAP_XCOLORMAP (private->drawable.colormap);
+	  xattributes.colormap = GDK_COLORMAP_XCOLORMAP (draw_impl->colormap);
 	  xattributes_mask |= CWColormap;
 	  
 	  xparent = gdk_root_window;
 	  break;
 	  
 	case GDK_WINDOW_CHILD:
-	  xattributes.colormap = GDK_COLORMAP_XCOLORMAP (private->drawable.colormap);
+	  xattributes.colormap = GDK_COLORMAP_XCOLORMAP (draw_impl->colormap);
 	  xattributes_mask |= CWColormap;
 	  break;
 	  
 	case GDK_WINDOW_DIALOG:
-	  xattributes.colormap = GDK_COLORMAP_XCOLORMAP (private->drawable.colormap);
+	  xattributes.colormap = GDK_COLORMAP_XCOLORMAP (draw_impl->colormap);
 	  xattributes_mask |= CWColormap;
 	  
 	  xparent = gdk_root_window;
 	  break;
 	  
 	case GDK_WINDOW_TEMP:
-	  xattributes.colormap = GDK_COLORMAP_XCOLORMAP (private->drawable.colormap);
+	  xattributes.colormap = GDK_COLORMAP_XCOLORMAP (draw_impl->colormap);
 	  xattributes_mask |= CWColormap;
 	  
 	  xparent = gdk_root_window;
@@ -321,29 +452,26 @@ gdk_window_new (GdkWindow     *parent,
 	case GDK_WINDOW_ROOT:
 	  g_error ("cannot make windows of type GDK_WINDOW_ROOT");
 	  break;
-	case GDK_WINDOW_PIXMAP:
-	  g_error ("cannot make windows of type GDK_WINDOW_PIXMAP (use gdk_pixmap_new)");
-	  break;
 	}
     }
   else
     {
       depth = 0;
+      private->depth = 0;
       class = InputOnly;
       private->input_only = TRUE;
-      private->drawable.colormap = NULL;
+      draw_impl->colormap = NULL;
     }
 
-  GDK_DRAWABLE_XDATA (private)->xid = XCreateWindow (GDK_DRAWABLE_XDISPLAY (parent),
-						     xparent,
-						     x, y, private->drawable.width, private->drawable.height,
-						     0, depth, class, xvisual,
-						     xattributes_mask, &xattributes);
+  draw_impl->xid = XCreateWindow (GDK_WINDOW_XDISPLAY (parent),
+                                  xparent,
+                                  x, y,
+                                  impl->width, impl->height,
+                                  0, depth, class, xvisual,
+                                  xattributes_mask, &xattributes);
+
   gdk_drawable_ref (window);
-  gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
-  
-  if (private->drawable.colormap)
-    gdk_colormap_ref (private->drawable.colormap);
+  gdk_xid_table_insert (&GDK_WINDOW_XID (window), window);
   
   gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
 				  (attributes->cursor) :
@@ -352,22 +480,22 @@ gdk_window_new (GdkWindow     *parent,
   if (parent_private)
     parent_private->children = g_list_prepend (parent_private->children, window);
   
-  switch (private->drawable.window_type)
+  switch (GDK_WINDOW_TYPE (private))
     {
     case GDK_WINDOW_DIALOG:
-      XSetTransientForHint (GDK_DRAWABLE_XDISPLAY (window),
-			    GDK_DRAWABLE_XID (window),
+      XSetTransientForHint (GDK_WINDOW_XDISPLAY (window),
+			    GDK_WINDOW_XID (window),
 			    xparent);
     case GDK_WINDOW_TOPLEVEL:
     case GDK_WINDOW_TEMP:
-      XSetWMProtocols (GDK_DRAWABLE_XDISPLAY (window),
-		       GDK_DRAWABLE_XID (window),
+      XSetWMProtocols (GDK_WINDOW_XDISPLAY (window),
+		       GDK_WINDOW_XID (window),
 		       gdk_wm_window_protocols, 2);
       break;
     case GDK_WINDOW_CHILD:
       if ((attributes->wclass == GDK_INPUT_OUTPUT) &&
-	  (private->drawable.colormap != gdk_colormap_get_system ()) &&
-	  (private->drawable.colormap != gdk_window_get_colormap (gdk_window_get_toplevel (window))))
+	  (draw_impl->colormap != gdk_colormap_get_system ()) &&
+	  (draw_impl->colormap != gdk_window_get_colormap (gdk_window_get_toplevel (window))))
 	{
 	  GDK_NOTE (MISC, g_message ("adding colormap window\n"));
 	  gdk_window_add_colormap_windows (window);
@@ -380,8 +508,8 @@ gdk_window_new (GdkWindow     *parent,
     }
   
   size_hints.flags = PSize;
-  size_hints.width = private->drawable.width;
-  size_hints.height = private->drawable.height;
+  size_hints.width = impl->width;
+  size_hints.height = impl->height;
   
   wm_hints.flags = InputHint | StateHint | WindowGroupHint;
   wm_hints.window_group = gdk_leader_window;
@@ -392,19 +520,19 @@ gdk_window_new (GdkWindow     *parent,
    * attention to PSize, and even if they do, is this the
    * correct value???
    */
-  XSetWMNormalHints (GDK_DRAWABLE_XDISPLAY (window),
-		     GDK_DRAWABLE_XID (window),
+  XSetWMNormalHints (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window),
 		     &size_hints);
   
-  XSetWMHints (GDK_DRAWABLE_XDISPLAY (window),
-	       GDK_DRAWABLE_XID (window),
+  XSetWMHints (GDK_WINDOW_XDISPLAY (window),
+	       GDK_WINDOW_XID (window),
 	       &wm_hints);
   
   if (!wm_client_leader_atom)
     wm_client_leader_atom = gdk_atom_intern ("WM_CLIENT_LEADER", FALSE);
   
-  XChangeProperty (GDK_DRAWABLE_XDISPLAY (window),
-		   GDK_DRAWABLE_XID (window),
+  XChangeProperty (GDK_WINDOW_XDISPLAY (window),
+		   GDK_WINDOW_XID (window),
 	   	   wm_client_leader_atom,
 		   XA_WINDOW, 32, PropModeReplace,
 		   (guchar*) &gdk_leader_window, 1);
@@ -414,8 +542,8 @@ gdk_window_new (GdkWindow     *parent,
   else
     title = g_get_prgname ();
   
-  XmbSetWMProperties (GDK_DRAWABLE_XDISPLAY (window),
-		      GDK_DRAWABLE_XID (window),
+  XmbSetWMProperties (GDK_WINDOW_XDISPLAY (window),
+		      GDK_WINDOW_XID (window),
                       title, title,
                       NULL, 0,
                       NULL, NULL, NULL);
@@ -425,8 +553,8 @@ gdk_window_new (GdkWindow     *parent,
       class_hint = XAllocClassHint ();
       class_hint->res_name = attributes->wmclass_name;
       class_hint->res_class = attributes->wmclass_class;
-      XSetClassHint (GDK_DRAWABLE_XDISPLAY (window),
-		     GDK_DRAWABLE_XID (window),
+      XSetClassHint (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window),
 		     class_hint);
       XFree (class_hint);
     }
@@ -438,8 +566,10 @@ GdkWindow *
 gdk_window_foreign_new (GdkNativeWindow anid)
 {
   GdkWindow *window;
-  GdkWindowPrivate *private;
-  GdkWindowPrivate *parent_private;
+  GdkWindowObject *private;
+  GdkWindowObject *parent_private;
+  GdkWindowImplX11 *impl;
+  GdkDrawableImplX11 *draw_impl;
   XWindowAttributes attrs;
   Window root, parent;
   Window *children = NULL;
@@ -461,29 +591,33 @@ gdk_window_foreign_new (GdkNativeWindow anid)
   if (children)
     XFree (children);
   
-  window = gdk_x11_window_alloc ();
-  private = (GdkWindowPrivate *)window;
-
+  window = GDK_WINDOW (g_type_create_instance (GDK_TYPE_WINDOW));
+  private = (GdkWindowObject *)window;
+  impl = GDK_WINDOW_IMPL_X11 (private->impl);
+  draw_impl = GDK_DRAWABLE_IMPL_X11 (private->impl);
+  draw_impl->wrapper = GDK_DRAWABLE (window);
+  
   private->parent = gdk_xid_table_lookup (parent);
   
-  parent_private = (GdkWindowPrivate *)private->parent;
+  parent_private = (GdkWindowObject *)private->parent;
   
   if (parent_private)
     parent_private->children = g_list_prepend (parent_private->children, window);
-  
-  GDK_DRAWABLE_XDATA (window)->xid = anid;
-  GDK_DRAWABLE_XDATA (window)->xdisplay = gdk_display;
+
+  draw_impl->xid = anid;
+  draw_impl->xdisplay = gdk_display;
 
   private->x = attrs.x;
   private->y = attrs.y;
-  private->drawable.width = attrs.width;
-  private->drawable.height = attrs.height;
-  private->drawable.window_type = GDK_WINDOW_FOREIGN;
-  private->drawable.destroyed = FALSE;
+  impl->width = attrs.width;
+  impl->height = attrs.height;
+  private->window_type = GDK_WINDOW_FOREIGN;
+  private->destroyed = FALSE;
   private->mapped = (attrs.map_state != IsUnmapped);
+  private->depth = attrs.depth;
   
   gdk_drawable_ref (window);
-  gdk_xid_table_insert (&GDK_DRAWABLE_XID (window), window);
+  gdk_xid_table_insert (&GDK_WINDOW_XID (window), window);
   
   return window;
 }
@@ -493,12 +627,14 @@ _gdk_windowing_window_destroy (GdkWindow *window,
 			       gboolean   recursing,
 			       gboolean   foreign_destroy)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
 
+  g_return_if_fail (GDK_IS_WINDOW (window));
+  
   if (private->extension_events != 0)
     gdk_input_window_destroy (window);
 
-  if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
+  if (private->window_type == GDK_WINDOW_FOREIGN)
     {
       if (!foreign_destroy && (private->parent != NULL))
 	{
@@ -513,21 +649,21 @@ _gdk_windowing_window_destroy (GdkWindow *window,
 	  gdk_window_reparent (window, NULL, 0, 0);
 	  
 	  xevent.type = ClientMessage;
-	  xevent.window = GDK_DRAWABLE_XID (window);
+	  xevent.window = GDK_WINDOW_XID (window);
 	  xevent.message_type = gdk_wm_protocols;
 	  xevent.format = 32;
 	  xevent.data.l[0] = gdk_wm_delete_window;
 	  xevent.data.l[1] = CurrentTime;
 	  
-	  XSendEvent (GDK_DRAWABLE_XDISPLAY (window),
-		      GDK_DRAWABLE_XID (window),
+	  XSendEvent (GDK_WINDOW_XDISPLAY (window),
+		      GDK_WINDOW_XID (window),
 		      False, 0, (XEvent *)&xevent);
 	  gdk_flush ();
 	  gdk_error_trap_pop ();
 	}
     }
   else if (!recursing && !foreign_destroy)
-    XDestroyWindow (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window));
+    XDestroyWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window));
 }
 
 /* This function is called when the XWindow is really gone.
@@ -537,68 +673,68 @@ gdk_window_destroy_notify (GdkWindow *window)
 {
   g_return_if_fail (window != NULL);
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
+  if (!GDK_WINDOW_DESTROYED (window))
     {
-      if (GDK_DRAWABLE_TYPE(window) != GDK_WINDOW_FOREIGN)
-	g_warning ("GdkWindow %#lx unexpectedly destroyed", GDK_DRAWABLE_XID (window));
+      if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_FOREIGN)
+	g_warning ("GdkWindow %#lx unexpectedly destroyed", GDK_WINDOW_XID (window));
 
       _gdk_window_destroy (window, TRUE);
     }
   
-  gdk_xid_table_remove (GDK_DRAWABLE_XID (window));
+  gdk_xid_table_remove (GDK_WINDOW_XID (window));
   gdk_drawable_unref (window);
 }
 
 void
 gdk_window_show (GdkWindow *window)
 {
-  GdkWindowPrivate *private;
+  GdkWindowObject *private;
   
-  g_return_if_fail (window != NULL);
+  g_return_if_fail (GDK_IS_WINDOW (window));
   
-  private = (GdkWindowPrivate*) window;
-  if (!private->drawable.destroyed)
+  private = (GdkWindowObject*) window;
+  if (!private->destroyed)
     {
       private->mapped = TRUE;
-      XRaiseWindow (GDK_DRAWABLE_XDISPLAY (window),
-		    GDK_DRAWABLE_XID (window));
+      XRaiseWindow (GDK_WINDOW_XDISPLAY (window),
+		    GDK_WINDOW_XID (window));
       
-      if (GDK_WINDOW_XDATA (window)->position_info.mapped)
-	XMapWindow (GDK_DRAWABLE_XDISPLAY (window),
-		    GDK_DRAWABLE_XID (window));
+      if (GDK_WINDOW_IMPL_X11 (private->impl)->position_info.mapped)
+	XMapWindow (GDK_WINDOW_XDISPLAY (window),
+		    GDK_WINDOW_XID (window));
     }
 }
 
 void
 gdk_window_hide (GdkWindow *window)
 {
-  GdkWindowPrivate *private;
+  GdkWindowObject *private;
   
   g_return_if_fail (window != NULL);
 
-  private = (GdkWindowPrivate*) window;
-  if (!private->drawable.destroyed)
+  private = (GdkWindowObject*) window;
+  if (!private->destroyed)
     {
       private->mapped = FALSE;
 
       _gdk_window_clear_update_area (window);
       
-      XUnmapWindow (GDK_DRAWABLE_XDISPLAY (window),
-		    GDK_DRAWABLE_XID (window));
+      XUnmapWindow (GDK_WINDOW_XDISPLAY (window),
+		    GDK_WINDOW_XID (window));
     }
 }
 
 void
 gdk_window_withdraw (GdkWindow *window)
 {
-  GdkWindowPrivate *private;
+  GdkWindowObject *private;
   
   g_return_if_fail (window != NULL);
   
-  private = (GdkWindowPrivate*) window;
-  if (!private->drawable.destroyed)
-    XWithdrawWindow (GDK_DRAWABLE_XDISPLAY (window),
-		     GDK_DRAWABLE_XID (window), 0);
+  private = (GdkWindowObject*) window;
+  if (!private->destroyed)
+    XWithdrawWindow (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window), 0);
 }
 
 void
@@ -606,13 +742,16 @@ gdk_window_move (GdkWindow *window,
 		 gint       x,
 		 gint       y)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-  
+  GdkWindowObject *private = (GdkWindowObject *)window;
+  GdkWindowImplX11 *impl;
+
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
+  impl = GDK_WINDOW_IMPL_X11 (private->impl);
+  
   gdk_window_move_resize (window, x, y,
-			  private->drawable.width, private->drawable.height);
+			  impl->width, impl->height);
 }
 
 void
@@ -620,7 +759,7 @@ gdk_window_resize (GdkWindow *window,
 		   gint       width,
 		   gint       height)
 {
-  GdkWindowPrivate *private;
+  GdkWindowObject *private;
   
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -630,17 +769,17 @@ gdk_window_resize (GdkWindow *window,
   if (height < 1)
     height = 1;
 
-  private = (GdkWindowPrivate*) window;
+  private = (GdkWindowObject*) window;
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
+  if (!GDK_WINDOW_DESTROYED (window))
     {
-      if (GDK_DRAWABLE_TYPE (private) == GDK_WINDOW_CHILD)
+      if (GDK_WINDOW_TYPE (private) == GDK_WINDOW_CHILD)
 	_gdk_window_move_resize_child (window, private->x, private->y,
 				       width, height);
       else
 	{
-	  XResizeWindow (GDK_DRAWABLE_XDISPLAY (window),
-			 GDK_DRAWABLE_XID (window),
+	  XResizeWindow (GDK_WINDOW_XDISPLAY (window),
+			 GDK_WINDOW_XID (window),
 			 width, height);
 	  private->resize_count += 1;
 	}
@@ -654,7 +793,7 @@ gdk_window_move_resize (GdkWindow *window,
 			gint       width,
 			gint       height)
 {
-  GdkWindowPrivate *private;
+  GdkWindowObject *private;
   
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -664,16 +803,16 @@ gdk_window_move_resize (GdkWindow *window,
   if (height < 1)
     height = 1;
   
-  private = (GdkWindowPrivate*) window;
+  private = (GdkWindowObject*) window;
 
-  if (!GDK_DRAWABLE_DESTROYED (window))
+  if (!GDK_WINDOW_DESTROYED (window))
     {
-      if (GDK_DRAWABLE_TYPE (private) == GDK_WINDOW_CHILD)
+      if (GDK_WINDOW_TYPE (private) == GDK_WINDOW_CHILD)
 	_gdk_window_move_resize_child (window, x, y, width, height);
       else
 	{
-	  XMoveResizeWindow (GDK_DRAWABLE_XDISPLAY (window),
-			     GDK_DRAWABLE_XID (window),
+	  XMoveResizeWindow (GDK_WINDOW_XDISPLAY (window),
+			     GDK_WINDOW_XID (window),
 			     x, y, width, height);
 	}
     }
@@ -685,9 +824,9 @@ gdk_window_reparent (GdkWindow *window,
 		     gint       x,
 		     gint       y)
 {
-  GdkWindowPrivate *window_private;
-  GdkWindowPrivate *parent_private;
-  GdkWindowPrivate *old_parent_private;
+  GdkWindowObject *window_private;
+  GdkWindowObject *parent_private;
+  GdkWindowObject *old_parent_private;
   
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
@@ -697,17 +836,17 @@ gdk_window_reparent (GdkWindow *window,
   if (!new_parent)
     new_parent = gdk_parent_root;
   
-  window_private = (GdkWindowPrivate*) window;
-  old_parent_private = (GdkWindowPrivate*)window_private->parent;
-  parent_private = (GdkWindowPrivate*) new_parent;
+  window_private = (GdkWindowObject*) window;
+  old_parent_private = (GdkWindowObject*)window_private->parent;
+  parent_private = (GdkWindowObject*) new_parent;
   
-  if (!GDK_DRAWABLE_DESTROYED (window) && !GDK_DRAWABLE_DESTROYED (new_parent))
-    XReparentWindow (GDK_DRAWABLE_XDISPLAY (window),
-		     GDK_DRAWABLE_XID (window),
-		     GDK_DRAWABLE_XID (new_parent),
+  if (!GDK_WINDOW_DESTROYED (window) && !GDK_WINDOW_DESTROYED (new_parent))
+    XReparentWindow (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window),
+		     GDK_WINDOW_XID (new_parent),
 		     x, y);
   
-  window_private->parent = new_parent;
+  window_private->parent = (GdkWindowObject *)new_parent;
   
   if (old_parent_private)
     old_parent_private->children = g_list_remove (old_parent_private->children, window);
@@ -730,8 +869,8 @@ _gdk_windowing_window_clear_area (GdkWindow *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
-    XClearArea (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window),
+  if (!GDK_WINDOW_DESTROYED (window))
+    XClearArea (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
 		x, y, width, height, False);
 }
 
@@ -745,8 +884,8 @@ _gdk_windowing_window_clear_area_e (GdkWindow *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
-    XClearArea (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window),
+  if (!GDK_WINDOW_DESTROYED (window))
+    XClearArea (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
 		x, y, width, height, True);
 }
 
@@ -756,8 +895,8 @@ gdk_window_raise (GdkWindow *window)
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
-    XRaiseWindow (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window));
+  if (!GDK_WINDOW_DESTROYED (window))
+    XRaiseWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window));
 }
 
 void
@@ -766,8 +905,8 @@ gdk_window_lower (GdkWindow *window)
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
-    XLowerWindow (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window));
+  if (!GDK_WINDOW_DESTROYED (window))
+    XLowerWindow (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window));
 }
 
 void
@@ -785,7 +924,7 @@ gdk_window_set_hints (GdkWindow *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
   size_hints.flags = 0;
@@ -814,8 +953,8 @@ gdk_window_set_hints (GdkWindow *window,
   /* FIXME: Would it be better to delete this property of
    *        flags == 0? It would save space on the server
    */
-  XSetWMNormalHints (GDK_DRAWABLE_XDISPLAY (window),
-		     GDK_DRAWABLE_XID (window),
+  XSetWMNormalHints (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window),
 		     &size_hints);
 }
 
@@ -829,7 +968,7 @@ gdk_window_set_geometry_hints (GdkWindow      *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
   size_hints.flags = 0;
@@ -901,8 +1040,8 @@ gdk_window_set_geometry_hints (GdkWindow      *window,
   /* FIXME: Would it be better to delete this property of
    *        geom_mask == 0? It would save space on the server
    */
-  XSetWMNormalHints (GDK_DRAWABLE_XDISPLAY (window),
-		     GDK_DRAWABLE_XID (window),
+  XSetWMNormalHints (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window),
 		     &size_hints);
 }
 
@@ -913,9 +1052,9 @@ gdk_window_set_title (GdkWindow   *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
-    XmbSetWMProperties (GDK_DRAWABLE_XDISPLAY (window),
-			GDK_DRAWABLE_XID (window),
+  if (!GDK_WINDOW_DESTROYED (window))
+    XmbSetWMProperties (GDK_WINDOW_XDISPLAY (window),
+			GDK_WINDOW_XID (window),
 			title, title, NULL, 0, NULL, NULL, NULL);
 }
 
@@ -926,14 +1065,14 @@ gdk_window_set_role (GdkWindow   *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (!GDK_DRAWABLE_DESTROYED (window))
+  if (!GDK_WINDOW_DESTROYED (window))
     {
       if (role)
-	XChangeProperty (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window),
+	XChangeProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
 			 gdk_atom_intern ("WM_WINDOW_ROLE", FALSE), XA_STRING,
 			 8, PropModeReplace, role, strlen (role));
       else
-	XDeleteProperty (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window),
+	XDeleteProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
 			 gdk_atom_intern ("WM_WINDOW_ROLE", FALSE));
     }
 }
@@ -942,33 +1081,33 @@ void
 gdk_window_set_transient_for (GdkWindow *window, 
 			      GdkWindow *parent)
 {
-  GdkWindowPrivate *private;
-  GdkWindowPrivate *parent_private;
+  GdkWindowObject *private;
+  GdkWindowObject *parent_private;
   
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  private = (GdkWindowPrivate*) window;
-  parent_private = (GdkWindowPrivate*) parent;
+  private = (GdkWindowObject*) window;
+  parent_private = (GdkWindowObject*) parent;
   
-  if (!GDK_DRAWABLE_DESTROYED (window) && !GDK_DRAWABLE_DESTROYED (parent))
-    XSetTransientForHint (GDK_DRAWABLE_XDISPLAY (window), 
-			  GDK_DRAWABLE_XID (window),
-			  GDK_DRAWABLE_XID (parent));
+  if (!GDK_WINDOW_DESTROYED (window) && !GDK_WINDOW_DESTROYED (parent))
+    XSetTransientForHint (GDK_WINDOW_XDISPLAY (window), 
+			  GDK_WINDOW_XID (window),
+			  GDK_WINDOW_XID (parent));
 }
 
 void
 gdk_window_set_background (GdkWindow *window,
 			   GdkColor  *color)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
-    XSetWindowBackground (GDK_DRAWABLE_XDISPLAY (window),
-			  GDK_DRAWABLE_XID (window), color->pixel);
+  if (!GDK_WINDOW_DESTROYED (window))
+    XSetWindowBackground (GDK_WINDOW_XDISPLAY (window),
+			  GDK_WINDOW_XID (window), color->pixel);
 
   private->bg_color = *color;
 
@@ -986,7 +1125,7 @@ gdk_window_set_back_pixmap (GdkWindow *window,
 			    GdkPixmap *pixmap,
 			    gboolean   parent_relative)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   Pixmap xpixmap;
   
   g_return_if_fail (window != NULL);
@@ -1009,7 +1148,7 @@ gdk_window_set_back_pixmap (GdkWindow *window,
 	{
 	  gdk_pixmap_ref (pixmap);
 	  private->bg_pixmap = pixmap;
-	  xpixmap = GDK_DRAWABLE_XID (pixmap);
+	  xpixmap = GDK_PIXMAP_XID (pixmap);
 	}
       else
 	{
@@ -1018,9 +1157,9 @@ gdk_window_set_back_pixmap (GdkWindow *window,
 	}
     }
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
-    XSetWindowBackgroundPixmap (GDK_DRAWABLE_XDISPLAY (window),
-				GDK_DRAWABLE_XID (window), xpixmap);
+  if (!GDK_WINDOW_DESTROYED (window))
+    XSetWindowBackgroundPixmap (GDK_WINDOW_XDISPLAY (window),
+				GDK_WINDOW_XID (window), xpixmap);
 }
 
 void
@@ -1040,9 +1179,9 @@ gdk_window_set_cursor (GdkWindow *window,
   else
     xcursor = cursor_private->xcursor;
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
-    XDefineCursor (GDK_DRAWABLE_XDISPLAY (window),
-		   GDK_DRAWABLE_XID (window),
+  if (!GDK_WINDOW_DESTROYED (window))
+    XDefineCursor (GDK_WINDOW_XDISPLAY (window),
+		   GDK_WINDOW_XID (window),
 		   xcursor);
 }
 
@@ -1067,10 +1206,10 @@ gdk_window_get_geometry (GdkWindow *window,
   if (!window)
     window = gdk_parent_root;
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
+  if (!GDK_WINDOW_DESTROYED (window))
     {
-      XGetGeometry (GDK_DRAWABLE_XDISPLAY (window),
-		    GDK_DRAWABLE_XID (window),
+      XGetGeometry (GDK_WINDOW_XDISPLAY (window),
+		    GDK_WINDOW_XID (window),
 		    &root, &tx, &ty, &twidth, &theight, &tborder_width, &tdepth);
       
       if (x)
@@ -1098,10 +1237,10 @@ gdk_window_get_origin (GdkWindow *window,
   
   g_return_val_if_fail (window != NULL, 0);
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
+  if (!GDK_WINDOW_DESTROYED (window))
     {
-      return_val = XTranslateCoordinates (GDK_DRAWABLE_XDISPLAY (window),
-					  GDK_DRAWABLE_XID (window),
+      return_val = XTranslateCoordinates (GDK_WINDOW_XDISPLAY (window),
+					  GDK_WINDOW_XID (window),
 					  gdk_root_window,
 					  0, 0, &tx, &ty,
 					  &child);
@@ -1136,13 +1275,13 @@ gdk_window_get_deskrelative_origin (GdkWindow *window,
   g_return_val_if_fail (window != NULL, 0);
   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
+  if (!GDK_WINDOW_DESTROYED (window))
     {
       if (!atom)
 	atom = gdk_atom_intern ("ENLIGHTENMENT_DESKTOP", FALSE);
-      win = GDK_DRAWABLE_XID (window);
+      win = GDK_WINDOW_XID (window);
       
-      while (XQueryTree (GDK_DRAWABLE_XDISPLAY (window), win, &root, &parent,
+      while (XQueryTree (GDK_WINDOW_XDISPLAY (window), win, &root, &parent,
 			 &child, (unsigned int *)&num_children))
 	{
 	  if ((child) && (num_children > 0))
@@ -1157,7 +1296,7 @@ gdk_window_get_deskrelative_origin (GdkWindow *window,
 	    break;
 	  
 	  data_return = NULL;
-	  XGetWindowProperty (GDK_DRAWABLE_XDISPLAY (window), win, atom, 0, 0,
+	  XGetWindowProperty (GDK_WINDOW_XDISPLAY (window), win, atom, 0, 0,
 			      False, XA_CARDINAL, &type_return, &format_return,
 			      &number_return, &bytes_after_return, &data_return);
 	  if (type_return == XA_CARDINAL)
@@ -1167,8 +1306,8 @@ gdk_window_get_deskrelative_origin (GdkWindow *window,
 	    }
 	}
       
-      return_val = XTranslateCoordinates (GDK_DRAWABLE_XDISPLAY (window),
-					  GDK_DRAWABLE_XID (window),
+      return_val = XTranslateCoordinates (GDK_WINDOW_XDISPLAY (window),
+					  GDK_WINDOW_XID (window),
 					  win,
 					  0, 0, &tx, &ty,
 					  &root);
@@ -1187,7 +1326,7 @@ gdk_window_get_root_origin (GdkWindow *window,
 			    gint      *x,
 			    gint      *y)
 {
-  GdkWindowPrivate *private;
+  GdkWindowObject *private;
   Window xwindow;
   Window xparent;
   Window root;
@@ -1197,25 +1336,25 @@ gdk_window_get_root_origin (GdkWindow *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  private = (GdkWindowPrivate*) window;
+  private = (GdkWindowObject*) window;
   if (x)
     *x = 0;
   if (y)
     *y = 0;
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
-  while (private->parent && ((GdkWindowPrivate*) private->parent)->parent)
-    private = (GdkWindowPrivate*) private->parent;
-  if (GDK_DRAWABLE_DESTROYED (window))
+  while (private->parent && ((GdkWindowObject*) private->parent)->parent)
+    private = (GdkWindowObject*) private->parent;
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
-  xparent = GDK_DRAWABLE_XID (window);
+  xparent = GDK_WINDOW_XID (window);
   do
     {
       xwindow = xparent;
-      if (!XQueryTree (GDK_DRAWABLE_XDISPLAY (window), xwindow,
+      if (!XQueryTree (GDK_WINDOW_XDISPLAY (window), xwindow,
 		       &root, &xparent,
 		       &children, &nchildren))
 	return;
@@ -1230,7 +1369,7 @@ gdk_window_get_root_origin (GdkWindow *window,
       unsigned int ww, wh, wb, wd;
       int wx, wy;
       
-      if (XGetGeometry (GDK_DRAWABLE_XDISPLAY (window), xwindow, &root, &wx, &wy, &ww, &wh, &wb, &wd))
+      if (XGetGeometry (GDK_WINDOW_XDISPLAY (window), xwindow, &root, &wx, &wy, &ww, &wh, &wb, &wd))
 	{
 	  if (x)
 	    *x = wx;
@@ -1263,9 +1402,9 @@ gdk_window_get_pointer (GdkWindow       *window,
   _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
 
   return_val = NULL;
-  if (!GDK_DRAWABLE_DESTROYED (window) &&
-      XQueryPointer (GDK_DRAWABLE_XDISPLAY (window),
-		     GDK_DRAWABLE_XID (window),
+  if (!GDK_WINDOW_DESTROYED (window) &&
+      XQueryPointer (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window),
 		     &root, &child, &rootx, &rooty, &winx, &winy, &xmask))
     {
       if (child)
@@ -1320,45 +1459,6 @@ gdk_window_at_pointer (gint *win_x,
   return window;
 }
 
-GList*
-gdk_window_get_children (GdkWindow *window)
-{
-  GdkWindow *child;
-  GList *children;
-  Window root;
-  Window parent;
-  Window *xchildren;
-  unsigned int nchildren;
-  unsigned int i;
-  
-  g_return_val_if_fail (window != NULL, NULL);
-  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
-
-  if (GDK_DRAWABLE_DESTROYED (window))
-    return NULL;
-  
-  XQueryTree (GDK_DRAWABLE_XDISPLAY (window),
-	      GDK_DRAWABLE_XID (window),
-	      &root, &parent, &xchildren, &nchildren);
-  
-  children = NULL;
-  
-  if (nchildren > 0)
-    {
-      for (i = 0; i < nchildren; i++)
-	{
-	  child = gdk_window_lookup (xchildren[i]);
-          if (child)
-            children = g_list_prepend (children, child);
-	}
-      
-      if (xchildren)
-	XFree (xchildren);
-    }
-  
-  return children;
-}
-
 GdkEventMask  
 gdk_window_get_events (GdkWindow *window)
 {
@@ -1369,12 +1469,12 @@ gdk_window_get_events (GdkWindow *window)
   g_return_val_if_fail (window != NULL, 0);
   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return 0;
   else
     {
-      XGetWindowAttributes (GDK_DRAWABLE_XDISPLAY (window),
-			    GDK_DRAWABLE_XID (window), 
+      XGetWindowAttributes (GDK_WINDOW_XDISPLAY (window),
+			    GDK_WINDOW_XID (window), 
 			    &attrs);
       
       event_mask = 0;
@@ -1398,7 +1498,7 @@ gdk_window_set_events (GdkWindow       *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
+  if (!GDK_WINDOW_DESTROYED (window))
     {
       xevent_mask = StructureNotifyMask;
       for (i = 0; i < gdk_nevent_masks; i++)
@@ -1407,8 +1507,8 @@ gdk_window_set_events (GdkWindow       *window,
 	    xevent_mask |= gdk_event_mask_table[i];
 	}
       
-      XSelectInput (GDK_DRAWABLE_XDISPLAY (window),
-		    GDK_DRAWABLE_XID (window),
+      XSelectInput (GDK_WINDOW_XDISPLAY (window),
+		    GDK_WINDOW_XID (window),
 		    xevent_mask);
     }
 }
@@ -1425,19 +1525,19 @@ gdk_window_add_colormap_windows (GdkWindow *window)
   g_return_if_fail (GDK_IS_WINDOW (window));
   
   toplevel = gdk_window_get_toplevel (window);
-  if (GDK_DRAWABLE_DESTROYED (toplevel))
+  if (GDK_WINDOW_DESTROYED (toplevel))
     return;
   
   old_windows = NULL;
-  if (!XGetWMColormapWindows (GDK_DRAWABLE_XDISPLAY (toplevel),
-			      GDK_DRAWABLE_XID (toplevel),
+  if (!XGetWMColormapWindows (GDK_WINDOW_XDISPLAY (toplevel),
+			      GDK_WINDOW_XID (toplevel),
 			      &old_windows, &count))
     {
       count = 0;
     }
   
   for (i = 0; i < count; i++)
-    if (old_windows[i] == GDK_DRAWABLE_XID (window))
+    if (old_windows[i] == GDK_WINDOW_XID (window))
       {
 	XFree (old_windows);
 	return;
@@ -1447,10 +1547,10 @@ gdk_window_add_colormap_windows (GdkWindow *window)
   
   for (i = 0; i < count; i++)
     new_windows[i] = old_windows[i];
-  new_windows[count] = GDK_DRAWABLE_XID (window);
+  new_windows[count] = GDK_WINDOW_XID (window);
   
-  XSetWMColormapWindows (GDK_DRAWABLE_XDISPLAY (toplevel),
-			 GDK_DRAWABLE_XID (toplevel),
+  XSetWMColormapWindows (GDK_WINDOW_XDISPLAY (toplevel),
+			 GDK_WINDOW_XID (toplevel),
 			 new_windows, count + 1);
   
   g_free (new_windows);
@@ -1492,14 +1592,14 @@ gdk_window_shape_combine_mask (GdkWindow *window,
   g_return_if_fail (GDK_IS_WINDOW (window));
   
 #ifdef HAVE_SHAPE_EXT
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
   if (gdk_window_have_shape_ext ())
     {
       if (mask)
 	{
-	  pixmap = GDK_DRAWABLE_XID (mask);
+	  pixmap = GDK_PIXMAP_XID (mask);
 	}
       else
 	{
@@ -1508,8 +1608,8 @@ gdk_window_shape_combine_mask (GdkWindow *window,
 	  pixmap = None;
 	}
       
-      XShapeCombineMask (GDK_DRAWABLE_XDISPLAY (window),
-			 GDK_DRAWABLE_XID (window),
+      XShapeCombineMask (GDK_WINDOW_XDISPLAY (window),
+			 GDK_WINDOW_XID (window),
 			 ShapeBounding,
 			 x, y,
 			 pixmap,
@@ -1527,11 +1627,11 @@ gdk_window_set_override_redirect (GdkWindow *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     {
       attr.override_redirect = (override_redirect == FALSE)?False:True;
-      XChangeWindowAttributes (GDK_DRAWABLE_XDISPLAY (window),
-			       GDK_DRAWABLE_XID (window),
+      XChangeWindowAttributes (GDK_WINDOW_XDISPLAY (window),
+			       GDK_WINDOW_XID (window),
 			       CWOverrideRedirect,
 			       &attr);
     }
@@ -1548,34 +1648,34 @@ gdk_window_set_icon (GdkWindow *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
 
-  wm_hints = XGetWMHints (GDK_DRAWABLE_XDISPLAY (window),
-			  GDK_DRAWABLE_XID (window));
+  wm_hints = XGetWMHints (GDK_WINDOW_XDISPLAY (window),
+			  GDK_WINDOW_XID (window));
   if (!wm_hints)
     wm_hints = XAllocWMHints ();
 
   if (icon_window != NULL)
     {
       wm_hints->flags |= IconWindowHint;
-      wm_hints->icon_window = GDK_DRAWABLE_XID (icon_window);
+      wm_hints->icon_window = GDK_WINDOW_XID (icon_window);
     }
   
   if (pixmap != NULL)
     {
       wm_hints->flags |= IconPixmapHint;
-      wm_hints->icon_pixmap = GDK_DRAWABLE_XID (pixmap);
+      wm_hints->icon_pixmap = GDK_PIXMAP_XID (pixmap);
     }
   
   if (mask != NULL)
     {
       wm_hints->flags |= IconMaskHint;
-      wm_hints->icon_mask = GDK_DRAWABLE_XID (mask);
+      wm_hints->icon_mask = GDK_PIXMAP_XID (mask);
     }
 
-  XSetWMHints (GDK_DRAWABLE_XDISPLAY (window),
-	       GDK_DRAWABLE_XID (window), wm_hints);
+  XSetWMHints (GDK_WINDOW_XDISPLAY (window),
+	       GDK_WINDOW_XID (window), wm_hints);
   XFree (wm_hints);
 }
 
@@ -1589,10 +1689,10 @@ gdk_window_set_icon_name (GdkWindow   *window,
   g_return_if_fail (window != NULL);
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
-  res = XmbTextListToTextProperty (GDK_DRAWABLE_XDISPLAY (window),
+  res = XmbTextListToTextProperty (GDK_WINDOW_XDISPLAY (window),
 				   &name, 1, XStdICCTextStyle,
                                	   &property);
   if (res < 0)
@@ -1601,8 +1701,8 @@ gdk_window_set_icon_name (GdkWindow   *window,
       return;
     }
   
-  XSetWMIconName (GDK_DRAWABLE_XDISPLAY (window),
-		  GDK_DRAWABLE_XID (window),
+  XSetWMIconName (GDK_WINDOW_XDISPLAY (window),
+		  GDK_WINDOW_XID (window),
 		  &property);
   
   if (property.value)
@@ -1620,19 +1720,19 @@ gdk_window_set_group (GdkWindow *window,
   g_return_if_fail (leader != NULL);
   g_return_if_fail (GDK_IS_WINDOW (leader));
 
-  if (GDK_DRAWABLE_DESTROYED (window) || GDK_DRAWABLE_DESTROYED (leader))
+  if (GDK_WINDOW_DESTROYED (window) || GDK_WINDOW_DESTROYED (leader))
     return;
   
-  wm_hints = XGetWMHints (GDK_DRAWABLE_XDISPLAY (window),
-			  GDK_DRAWABLE_XID (window));
+  wm_hints = XGetWMHints (GDK_WINDOW_XDISPLAY (window),
+			  GDK_WINDOW_XID (window));
   if (!wm_hints)
     wm_hints = XAllocWMHints ();
 
   wm_hints->flags |= WindowGroupHint;
-  wm_hints->window_group = GDK_DRAWABLE_XID (leader);
+  wm_hints->window_group = GDK_WINDOW_XID (leader);
 
-  XSetWMHints (GDK_DRAWABLE_XDISPLAY (window),
-	       GDK_DRAWABLE_XID (window), wm_hints);
+  XSetWMHints (GDK_WINDOW_XDISPLAY (window),
+	       GDK_WINDOW_XID (window), wm_hints);
   XFree (wm_hints);
 }
 
@@ -1647,14 +1747,14 @@ gdk_window_set_mwm_hints (GdkWindow *window,
   gulong nitems;
   gulong bytes_after;
   
-  if (GDK_DRAWABLE_DESTROYED (window))
+  if (GDK_WINDOW_DESTROYED (window))
     return;
   
   if (!hints_atom)
-    hints_atom = XInternAtom (GDK_DRAWABLE_XDISPLAY (window), 
+    hints_atom = XInternAtom (GDK_WINDOW_XDISPLAY (window), 
 			      _XA_MOTIF_WM_HINTS, FALSE);
   
-  XGetWindowProperty (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window),
+  XGetWindowProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
 		      hints_atom, 0, sizeof (MotifWmHints)/sizeof (long),
 		      False, AnyPropertyType, &type, &format, &nitems,
 		      &bytes_after, (guchar **)&hints);
@@ -1675,7 +1775,7 @@ gdk_window_set_mwm_hints (GdkWindow *window,
 	}
     }
   
-  XChangeProperty (GDK_DRAWABLE_XDISPLAY (window), GDK_DRAWABLE_XID (window),
+  XChangeProperty (GDK_WINDOW_XDISPLAY (window), GDK_WINDOW_XID (window),
 		   hints_atom, hints_atom, 32, PropModeReplace,
 		   (guchar *)hints, sizeof (MotifWmHints)/sizeof (long));
   
@@ -2032,10 +2132,10 @@ gdk_window_set_child_shapes (GdkWindow *window)
   g_return_if_fail (GDK_IS_WINDOW (window));
   
 #ifdef HAVE_SHAPE_EXT
-  if (!GDK_DRAWABLE_DESTROYED (window) &&
+  if (!GDK_WINDOW_DESTROYED (window) &&
       gdk_window_have_shape_ext ())
-    gdk_propagate_shapes (GDK_DRAWABLE_XDISPLAY (window),
-			  GDK_DRAWABLE_XID (window), FALSE);
+    gdk_propagate_shapes (GDK_WINDOW_XDISPLAY (window),
+			  GDK_WINDOW_XID (window), FALSE);
 #endif   
 }
 
@@ -2046,10 +2146,10 @@ gdk_window_merge_child_shapes (GdkWindow *window)
   g_return_if_fail (GDK_IS_WINDOW (window));
   
 #ifdef HAVE_SHAPE_EXT
-  if (!GDK_DRAWABLE_DESTROYED (window) &&
+  if (!GDK_WINDOW_DESTROYED (window) &&
       gdk_window_have_shape_ext ())
-    gdk_propagate_shapes (GDK_DRAWABLE_XDISPLAY (window),
-			  GDK_DRAWABLE_XID (window), TRUE);
+    gdk_propagate_shapes (GDK_WINDOW_XDISPLAY (window),
+			  GDK_WINDOW_XID (window), TRUE);
 #endif   
 }
 
@@ -2125,8 +2225,8 @@ gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
   xattributes.bit_gravity = StaticGravity;
   xattributes_mask |= CWBitGravity;
   xattributes.bit_gravity = on ? StaticGravity : ForgetGravity;
-  XChangeWindowAttributes (GDK_DRAWABLE_XDISPLAY (window),
-			   GDK_DRAWABLE_XID (window),
+  XChangeWindowAttributes (GDK_WINDOW_XDISPLAY (window),
+			   GDK_WINDOW_XID (window),
 			   CWBitGravity,  &xattributes);
 }
 
@@ -2139,8 +2239,8 @@ gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
   
   xattributes.win_gravity = on ? StaticGravity : NorthWestGravity;
   
-  XChangeWindowAttributes (GDK_DRAWABLE_XDISPLAY (window),
-			   GDK_DRAWABLE_XID (window),
+  XChangeWindowAttributes (GDK_WINDOW_XDISPLAY (window),
+			   GDK_WINDOW_XID (window),
 			   CWWinGravity,  &xattributes);
 }
 
@@ -2160,7 +2260,7 @@ gboolean
 gdk_window_set_static_gravities (GdkWindow *window,
 				 gboolean   use_static)
 {
-  GdkWindowPrivate *private = (GdkWindowPrivate *)window;
+  GdkWindowObject *private = (GdkWindowObject *)window;
   GList *tmp_list;
   
   g_return_val_if_fail (window != NULL, FALSE);
@@ -2174,7 +2274,7 @@ gdk_window_set_static_gravities (GdkWindow *window,
   
   private->guffaw_gravity = use_static;
   
-  if (!GDK_DRAWABLE_DESTROYED (window))
+  if (!GDK_WINDOW_DESTROYED (window))
     {
       gdk_window_set_static_bit_gravity (window, use_static);
       
@@ -2262,7 +2362,6 @@ gdk_window_xid_at_coords (gint     x,
 			  gboolean excl_child)
 {
   GdkWindow *window;
-  GdkDrawablePrivate *private;
   Display *xdisplay;
   Window *list = NULL;
   Window root, child = 0, parent_win = 0, root_win = 0;
@@ -2270,9 +2369,8 @@ gdk_window_xid_at_coords (gint     x,
   int i;
 
   window = gdk_parent_root;
-  private = (GdkDrawablePrivate*) window;
-  xdisplay = GDK_DRAWABLE_XDISPLAY (private);
-  root = GDK_DRAWABLE_XID (private);
+  xdisplay = GDK_WINDOW_XDISPLAY (window);
+  root = GDK_WINDOW_XID (window);
   num = g_list_length (excludes);
   
   XGrabServer (xdisplay);
diff --git a/gdk/x11/gdkwindow-x11.h b/gdk/x11/gdkwindow-x11.h
new file mode 100644
index 0000000000..3e35c5a162
--- /dev/null
+++ b/gdk/x11/gdkwindow-x11.h
@@ -0,0 +1,89 @@
+/* GDK - The GIMP Drawing Kit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+#ifndef __GDK_WINDOW_X11_H__
+#define __GDK_WINDOW_X11_H__
+
+#include <gdk/x11/gdkdrawable-x11.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+typedef struct _GdkXPositionInfo    GdkXPositionInfo;
+
+struct _GdkXPositionInfo
+{
+  gint x;
+  gint y;
+  gint width;
+  gint height;
+  gint x_offset;		/* Offsets to add to X coordinates within window */
+  gint y_offset;		/*   to get GDK coodinates within window */
+  gboolean big : 1;
+  gboolean mapped : 1;
+  gboolean no_bg : 1;	        /* Set when the window background is temporarily
+				 * unset during resizing and scaling */
+  GdkRectangle clip_rect;	/* visible rectangle of window */
+};
+
+
+/* Window implementation for X11
+ */
+
+typedef struct _GdkWindowImplX11 GdkWindowImplX11;
+typedef struct _GdkWindowImplX11Class GdkWindowImplX11Class;
+
+#define GDK_TYPE_WINDOW_IMPL_X11              (gdk_window_impl_x11_get_type ())
+#define GDK_WINDOW_IMPL_X11(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW_IMPL_X11, GdkWindowImplX11))
+#define GDK_WINDOW_IMPL_X11_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_IMPL_X11, GdkWindowImplX11Class))
+#define GDK_IS_WINDOW_IMPL_X11(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW_IMPL_X11))
+#define GDK_IS_WINDOW_IMPL_X11_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_IMPL_X11))
+#define GDK_WINDOW_IMPL_X11_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW_IMPL_X11, GdkWindowImplX11Class))
+
+struct _GdkWindowImplX11
+{
+  GdkDrawableImplX11 parent_instance;
+
+  gint width;
+  gint height;
+  
+  GdkXPositionInfo position_info;
+};
+ 
+struct _GdkWindowImplX11Class 
+{
+  GdkDrawableImplX11Class parent_class;
+
+};
+
+GType gdk_window_impl_x11_get_type (void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GDK_WINDOW_X11_H__ */
diff --git a/gdk/x11/gdkx.h b/gdk/x11/gdkx.h
index 29d8e8fb4d..a418e25e27 100644
--- a/gdk/x11/gdkx.h
+++ b/gdk/x11/gdkx.h
@@ -33,59 +33,20 @@
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
-typedef struct _GdkGCXData          GdkGCXData;
-typedef struct _GdkDrawableXData    GdkDrawableXData;
-typedef struct _GdkWindowXData      GdkWindowXData;
-typedef struct _GdkXPositionInfo    GdkXPositionInfo;
-typedef struct _GdkColormapPrivateX GdkColormapPrivateX;
-typedef struct _GdkCursorPrivate    GdkCursorPrivate;
-typedef struct _GdkFontPrivateX     GdkFontPrivateX;
-typedef struct _GdkImagePrivateX    GdkImagePrivateX;
-typedef struct _GdkVisualPrivate    GdkVisualPrivate;
+#include <gdk/x11/gdkwindow-x11.h>
+#include <gdk/x11/gdkpixmap-x11.h>
+
+typedef struct _GdkGCXData             GdkGCXData;
+typedef struct _GdkColormapPrivateX11 GdkColormapPrivateX11;
+typedef struct _GdkCursorPrivate       GdkCursorPrivate;
+typedef struct _GdkFontPrivateX        GdkFontPrivateX;
+typedef struct _GdkImagePrivateX11    GdkImagePrivateX11;
+typedef struct _GdkVisualPrivate       GdkVisualPrivate;
 
 #ifdef USE_XIM
 typedef struct _GdkICPrivate        GdkICPrivate;
 #endif /* USE_XIM */
 
-#define GDK_DRAWABLE_XDATA(win) ((GdkDrawableXData *)(((GdkDrawablePrivate*)(win))->klass_data))
-#define GDK_WINDOW_XDATA(win) ((GdkWindowXData *)(((GdkDrawablePrivate*)(win))->klass_data))
-#define GDK_GC_XDATA(gc) ((GdkGCXData *)(((GdkGCPrivate*)(gc))->klass_data))
-
-struct _GdkGCXData
-{
-  GC xgc;
-  Display *xdisplay;
-  GdkRegion *clip_region;
-  guint dirty_mask;
-};
-
-struct _GdkDrawableXData
-{
-  Window xid;
-  Display *xdisplay;
-};
-
-struct _GdkXPositionInfo
-{
-  gint x;
-  gint y;
-  gint width;
-  gint height;
-  gint x_offset;		/* Offsets to add to X coordinates within window */
-  gint y_offset;		/*   to get GDK coodinates within window */
-  gboolean big : 1;
-  gboolean mapped : 1;
-  gboolean no_bg : 1;	        /* Set when the window background is temporarily
-				 * unset during resizing and scaling */
-  GdkRectangle clip_rect;	/* visible rectangle of window */
-};
-
-struct _GdkWindowXData
-{
-  GdkDrawableXData drawable_data;
-  GdkXPositionInfo position_info;
-};
-
 struct _GdkCursorPrivate
 {
   GdkCursor cursor;
@@ -110,10 +71,8 @@ struct _GdkVisualPrivate
   Visual *xvisual;
 };
 
-struct _GdkColormapPrivateX
+struct _GdkColormapPrivateX11
 {
-  GdkColormapPrivate base;
-
   Colormap xcolormap;
   Display *xdisplay;
   gint private_val;
@@ -123,10 +82,8 @@ struct _GdkColormapPrivateX
   time_t last_sync_time;
 };
 
-struct _GdkImagePrivateX
+struct _GdkImagePrivateX11
 {
-  GdkImagePrivate base;
-  
   XImage *ximage;
   Display *xdisplay;
   gpointer x_shm_info;
@@ -144,25 +101,56 @@ struct _GdkICPrivate
 
 #endif /* USE_XIM */
 
+
+typedef struct _GdkGCX11      GdkGCX11;
+typedef struct _GdkGCX11Class GdkGCX11Class;
+
+#define GDK_TYPE_GC_X11              (gdk_gc_x11_get_type ())
+#define GDK_GC_X11(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_GC_X11, GdkGCX11))
+#define GDK_GC_X11_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_GC_X11, GdkGCX11Class))
+#define GDK_IS_GC_X11(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_GC_X11))
+#define GDK_IS_GC_X11_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_GC_X11))
+#define GDK_GC_X11_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_GC_X11, GdkGCX11Class))
+
+struct _GdkGCX11
+{
+  GdkGC parent_instance;
+  
+  GC xgc;
+  Display *xdisplay;
+  GdkRegion *clip_region;
+  guint dirty_mask;
+};
+
+struct _GdkGCX11Class
+{
+  GdkGCClass parent_class;
+
+};
+
+GType gdk_gc_x11_get_type (void);
+
 #define GDK_ROOT_WINDOW()             gdk_root_window
 #define GDK_ROOT_PARENT()             ((GdkWindow *)gdk_parent_root)
 #define GDK_DISPLAY()                 gdk_display
-#define GDK_DRAWABLE_XDISPLAY(win)    (GDK_DRAWABLE_XDATA(win)->xdisplay)
-#define GDK_DRAWABLE_XID(win)         (GDK_DRAWABLE_XDATA(win)->xid)
-#define GDK_IMAGE_XDISPLAY(image)     (((GdkImagePrivate*) image)->xdisplay)
-#define GDK_IMAGE_XIMAGE(image)       (((GdkImagePrivate*) image)->ximage)
-#define GDK_GC_XDISPLAY(gc)           (GDK_GC_XDATA(gc)->xdisplay)
-#define GDK_COLORMAP_XDISPLAY(cmap)   (((GdkColormapPrivateX *)cmap)->xdisplay)
-#define GDK_COLORMAP_XCOLORMAP(cmap)  (((GdkColormapPrivateX *)cmap)->xcolormap)
-#define GDK_VISUAL_XVISUAL(vis)       (((GdkVisualPrivate*) vis)->xvisual)
-#define GDK_FONT_XDISPLAY(font)       (((GdkFontPrivate*) font)->xdisplay)
+#define GDK_WINDOW_XDISPLAY(win)      (GDK_DRAWABLE_IMPL_X11(((GdkWindowObject *)win)->impl)->xdisplay)
+#define GDK_WINDOW_XID(win)           (GDK_DRAWABLE_IMPL_X11(((GdkWindowObject *)win)->impl)->xid)
+#define GDK_PIXMAP_XDISPLAY(win)      (GDK_DRAWABLE_IMPL_X11(((GdkPixmapObject *)win)->impl)->xdisplay)
+#define GDK_PIXMAP_XID(win)           (GDK_DRAWABLE_IMPL_X11(((GdkPixmapObject *)win)->impl)->xid)
+#define GDK_DRAWABLE_XDISPLAY(win)    (GDK_IS_WINDOW (win) ? GDK_WINDOW_XDISPLAY (win) : GDK_PIXMAP_XDISPLAY (win))
+#define GDK_DRAWABLE_XID(win)         (GDK_IS_WINDOW (win) ? GDK_WINDOW_XID (win) : GDK_PIXMAP_XID (win))
+#define GDK_IMAGE_XDISPLAY(image)     (((GdkImagePrivateX11 *) GDK_IMAGE (image)->windowing_data)->xdisplay)
+#define GDK_IMAGE_XIMAGE(image)       (((GdkImagePrivateX11 *) GDK_IMAGE (image)->windowing_data)->ximage)
+#define GDK_GC_XDISPLAY(gc)           (GDK_GC_X11(gc)->xdisplay)
+#define GDK_COLORMAP_XDISPLAY(cmap)   (((GdkColormapPrivateX11 *)GDK_COLORMAP (cmap)->windowing_data)->xdisplay)
+#define GDK_COLORMAP_XCOLORMAP(cmap)  (((GdkColormapPrivateX11 *)GDK_COLORMAP (cmap)->windowing_data)->xcolormap)
+#define GDK_VISUAL_XVISUAL(vis)       (((GdkVisualPrivate *) vis)->xvisual)
+#define GDK_FONT_XDISPLAY(font)       (((GdkFontPrivate *) font)->xdisplay)
 #define GDK_FONT_XFONT(font)          (((GdkFontPrivateX *)font)->xfont)
 
-#define GDK_GC_XGC(gc)       (GDK_GC_XDATA(gc)->xgc)
-#define GDK_GC_GET_XGC(gc)   (GDK_GC_XDATA(gc)->dirty_mask ? _gdk_x11_gc_flush (gc) : GDK_GC_XGC (gc))
-
-#define GDK_WINDOW_XWINDOW            GDK_DRAWABLE_XID
-#define GDK_WINDOW_XDISPLAY           GDK_DRAWABLE_XDISPLAY
+#define GDK_GC_XGC(gc)       (GDK_GC_X11(gc)->xgc)
+#define GDK_GC_GET_XGC(gc)   (GDK_GC_X11(gc)->dirty_mask ? _gdk_x11_gc_flush (gc) : GDK_GC_XGC (gc))
+#define GDK_WINDOW_XWINDOW    GDK_DRAWABLE_XID
 
 extern Display		*gdk_display;
 extern Window		 gdk_root_window;
diff --git a/gtk/gtk-boxed.defs b/gtk/gtk-boxed.defs
index c36b2fdca2..23f82b65cf 100644
--- a/gtk/gtk-boxed.defs
+++ b/gtk/gtk-boxed.defs
@@ -16,10 +16,6 @@
 (define-boxed GtkSelectionData
 )
 
-(define-boxed GtkStyle
-  gtk_style_ref
-  gtk_style_unref)
-
 (define-boxed GtkCTreeNode
 )
 
@@ -29,10 +25,6 @@
                                         ;  gdk_point_copy
                                         ;  gdk_point_destroy)
 
-(define-boxed GdkColormap
-  gdk_colormap_ref
-  gdk_colormap_unref)
-
 (define-boxed GdkVisual
   gdk_visual_ref
   gdk_visual_unref)
@@ -41,13 +33,6 @@
   gdk_font_ref
   gdk_font_unref)
 
-(define-boxed GdkWindow
-  gdk_window_ref
-  gdk_window_unref)
-
-(define-boxed GdkDragContext
-  gdk_drag_context_ref
-  gdk_drag_context_unref)
 (define-boxed GdkEvent
   gdk_event_copy
   gdk_event_free
diff --git a/gtk/gtkaccellabel.c b/gtk/gtkaccellabel.c
index 4b82736f99..bfe338181a 100644
--- a/gtk/gtkaccellabel.c
+++ b/gtk/gtkaccellabel.c
@@ -247,7 +247,7 @@ gtk_accel_label_size_request (GtkWidget	     *widget,
   pango_layout_get_extents (layout, NULL, &logical_rect);
   
   accel_label->accel_string_width = logical_rect.width / PANGO_SCALE;
-  pango_layout_unref (layout);
+  g_object_unref (G_OBJECT (layout));
 }
 
 static gint
@@ -304,7 +304,7 @@ gtk_accel_label_expose_event (GtkWidget      *widget,
 			   y,
 			   layout);
 
-	  pango_layout_unref (layout);
+          g_object_unref (G_OBJECT (layout));
 	}
       else
 	{
diff --git a/gtk/gtkbutton.c b/gtk/gtkbutton.c
index 2c9113aed7..65684e7580 100644
--- a/gtk/gtkbutton.c
+++ b/gtk/gtkbutton.c
@@ -429,15 +429,15 @@ gtk_button_size_request (GtkWidget      *widget,
   button = GTK_BUTTON (widget);
 
   requisition->width = (GTK_CONTAINER (widget)->border_width + CHILD_SPACING +
-			GTK_WIDGET (widget)->style->klass->xthickness) * 2;
+			GTK_WIDGET (widget)->style->xthickness) * 2;
   requisition->height = (GTK_CONTAINER (widget)->border_width + CHILD_SPACING +
-			 GTK_WIDGET (widget)->style->klass->ythickness) * 2;
+			 GTK_WIDGET (widget)->style->ythickness) * 2;
 
   if (GTK_WIDGET_CAN_DEFAULT (widget))
     {
-      requisition->width += (GTK_WIDGET (widget)->style->klass->xthickness * 2 +
+      requisition->width += (GTK_WIDGET (widget)->style->xthickness * 2 +
 			     DEFAULT_SPACING);
-      requisition->height += (GTK_WIDGET (widget)->style->klass->ythickness * 2 +
+      requisition->height += (GTK_WIDGET (widget)->style->ythickness * 2 +
 			      DEFAULT_SPACING);
     }
 
@@ -478,8 +478,8 @@ gtk_button_size_allocate (GtkWidget     *widget,
 
   if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
     {
-      child_allocation.x = (CHILD_SPACING + GTK_WIDGET (widget)->style->klass->xthickness);
-      child_allocation.y = (CHILD_SPACING + GTK_WIDGET (widget)->style->klass->ythickness);
+      child_allocation.x = (CHILD_SPACING + GTK_WIDGET (widget)->style->xthickness);
+      child_allocation.y = (CHILD_SPACING + GTK_WIDGET (widget)->style->ythickness);
 
       child_allocation.width = MAX (1, (gint)widget->allocation.width - child_allocation.x * 2 -
 	                         border_width * 2);
@@ -488,14 +488,14 @@ gtk_button_size_allocate (GtkWidget     *widget,
 
       if (GTK_WIDGET_CAN_DEFAULT (button))
 	{
-	  child_allocation.x += (GTK_WIDGET (widget)->style->klass->xthickness +
+	  child_allocation.x += (GTK_WIDGET (widget)->style->xthickness +
 				 DEFAULT_LEFT_POS);
-	  child_allocation.y += (GTK_WIDGET (widget)->style->klass->ythickness +
+	  child_allocation.y += (GTK_WIDGET (widget)->style->ythickness +
 				 DEFAULT_TOP_POS);
 	  child_allocation.width =  MAX (1, (gint)child_allocation.width -
-					 (gint)(GTK_WIDGET (widget)->style->klass->xthickness * 2 + DEFAULT_SPACING));
+					 (gint)(GTK_WIDGET (widget)->style->xthickness * 2 + DEFAULT_SPACING));
 	  child_allocation.height = MAX (1, (gint)child_allocation.height -
-					 (gint)(GTK_WIDGET (widget)->style->klass->xthickness * 2 + DEFAULT_SPACING));
+					 (gint)(GTK_WIDGET (widget)->style->xthickness * 2 + DEFAULT_SPACING));
 	}
 
       gtk_widget_size_allocate (GTK_BIN (button)->child, &child_allocation);
@@ -560,8 +560,8 @@ gtk_button_paint (GtkWidget    *widget,
 
       if (GTK_WIDGET_CAN_DEFAULT (widget))
 	{
-	  x += widget->style->klass->xthickness;
-	  y += widget->style->klass->ythickness;
+	  x += widget->style->xthickness;
+	  y += widget->style->ythickness;
 	  width -= 2 * x + DEFAULT_SPACING;
 	  height -= 2 * y + DEFAULT_SPACING;
 	  x += DEFAULT_LEFT_POS;
diff --git a/gtk/gtkcalendar.c b/gtk/gtkcalendar.c
index bc5708dfce..341379051d 100644
--- a/gtk/gtkcalendar.c
+++ b/gtk/gtkcalendar.c
@@ -962,11 +962,11 @@ gtk_calendar_realize_day_names (GtkWidget *widget)
       attributes.colormap = gtk_widget_get_colormap (widget);
       attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
-      attributes.x = (widget->style->klass->xthickness + INNER_BORDER);
-      attributes.y = private_data->header_h + (widget->style->klass->ythickness 
+      attributes.x = (widget->style->xthickness + INNER_BORDER);
+      attributes.y = private_data->header_h + (widget->style->ythickness 
 					   + INNER_BORDER);
       attributes.width = (widget->allocation.width 
-			  - (widget->style->klass->xthickness + INNER_BORDER) 
+			  - (widget->style->xthickness + INNER_BORDER) 
 			  * 2);
       attributes.height = private_data->day_name_h;
       private_data->day_name_win = gdk_window_new (widget->window,
@@ -1007,9 +1007,9 @@ gtk_calendar_realize_week_numbers (GtkWidget *widget)
       attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
       
       attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
-      attributes.x = + (widget->style->klass->xthickness + INNER_BORDER);
+      attributes.x = + (widget->style->xthickness + INNER_BORDER);
       attributes.y = (private_data->header_h + private_data->day_name_h 
-		      + (widget->style->klass->ythickness + INNER_BORDER));
+		      + (widget->style->ythickness + INNER_BORDER));
       attributes.width = private_data->week_width;
       attributes.height = private_data->main_h;
       private_data->week_win = gdk_window_new (widget->window,
@@ -1075,11 +1075,11 @@ gtk_calendar_realize (GtkWidget *widget)
     attributes.x = private_data->week_width;
   else
     attributes.x = 0;
-  attributes.x += (widget->style->klass->xthickness + INNER_BORDER);
+  attributes.x += (widget->style->xthickness + INNER_BORDER);
   attributes.y = (private_data->header_h + private_data->day_name_h 
-		  + (widget->style->klass->ythickness + INNER_BORDER));
+		  + (widget->style->ythickness + INNER_BORDER));
   attributes.width = (widget->allocation.width - attributes.x 
-		      - (widget->style->klass->xthickness + INNER_BORDER));
+		      - (widget->style->xthickness + INNER_BORDER));
   attributes.height = private_data->main_h;
   private_data->main_win = gdk_window_new (widget->window,
 					   &attributes, attributes_mask);
@@ -1262,7 +1262,7 @@ gtk_calendar_size_request (GtkWidget	  *widget,
 		   : 0));
   
   
-  requisition->width = MAX (header_width+4, main_width + (widget->style->klass->xthickness + INNER_BORDER) *2);
+  requisition->width = MAX (header_width+4, main_width + (widget->style->xthickness + INNER_BORDER) *2);
   
   /*
    * Calculate the requisition height for the widget.
@@ -1312,9 +1312,9 @@ gtk_calendar_size_request (GtkWidget	  *widget,
   height = (private_data->header_h + private_data->day_name_h 
 	    + private_data->main_h);
   
-  requisition->height = height + (widget->style->klass->ythickness + INNER_BORDER) * 2;
+  requisition->height = height + (widget->style->ythickness + INNER_BORDER) * 2;
 
-  pango_layout_unref (layout);
+  g_object_unref (G_OBJECT (layout));
 }
 
 static void
@@ -1336,17 +1336,17 @@ gtk_calendar_size_allocate (GtkWidget	  *widget,
   if (calendar->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
     {
       private_data->day_width = (private_data->min_day_width
-			     * ((allocation->width - (widget->style->klass->xthickness + INNER_BORDER) * 2
+			     * ((allocation->width - (widget->style->xthickness + INNER_BORDER) * 2
 				 - (CALENDAR_MARGIN * 2) -  (DAY_XSEP * 7) - CALENDAR_XSEP * 2))
 			     / (7 * private_data->min_day_width + private_data->max_week_char_width * 2));
-      private_data->week_width = ((allocation->width - (widget->style->klass->xthickness + INNER_BORDER) * 2
+      private_data->week_width = ((allocation->width - (widget->style->xthickness + INNER_BORDER) * 2
 			       - (CALENDAR_MARGIN * 2) - (DAY_XSEP * 7) - CALENDAR_XSEP * 2 )
 			      - private_data->day_width * 7 + CALENDAR_MARGIN + CALENDAR_XSEP);
     } 
   else 
     {
       private_data->day_width = (allocation->width
-			     - (widget->style->klass->xthickness + INNER_BORDER) * 2
+			     - (widget->style->xthickness + INNER_BORDER) * 2
 			     - (CALENDAR_MARGIN * 2)
 			     - (DAY_XSEP * 7))/7;
       private_data->week_width = 0;
@@ -1390,25 +1390,25 @@ gtk_calendar_size_allocate (GtkWidget	  *widget,
 				private_data->header_h - 7);
       if (private_data->day_name_win)
 	gdk_window_move_resize (private_data->day_name_win,
-				widget->style->klass->xthickness + INNER_BORDER,
-				private_data->header_h + (widget->style->klass->ythickness + INNER_BORDER),
-				allocation->width - (widget->style->klass->xthickness + INNER_BORDER) * 2,
+				widget->style->xthickness + INNER_BORDER,
+				private_data->header_h + (widget->style->ythickness + INNER_BORDER),
+				allocation->width - (widget->style->xthickness + INNER_BORDER) * 2,
 				private_data->day_name_h);
       if (private_data->week_win)
 	gdk_window_move_resize (private_data->week_win,
-				(widget->style->klass->xthickness + INNER_BORDER),
+				(widget->style->xthickness + INNER_BORDER),
 				private_data->header_h + private_data->day_name_h
-				+ (widget->style->klass->ythickness + INNER_BORDER),
+				+ (widget->style->ythickness + INNER_BORDER),
 				private_data->week_width,
 				private_data->main_h);
       gdk_window_move_resize (private_data->main_win,
 			      (private_data->week_width ? private_data->week_width + CALENDAR_XSEP :0) 
-			      + (widget->style->klass->xthickness + INNER_BORDER),
+			      + (widget->style->xthickness + INNER_BORDER),
 			      private_data->header_h + private_data->day_name_h
-			      + (widget->style->klass->ythickness + INNER_BORDER),
+			      + (widget->style->ythickness + INNER_BORDER),
 			      allocation->width 
 			      - (private_data->week_width ? private_data->week_width + CALENDAR_XSEP :0) 
-			      - (widget->style->klass->xthickness + INNER_BORDER) * 2,
+			      - (widget->style->xthickness + INNER_BORDER) * 2,
 			      private_data->main_h);
     }
 }
@@ -1602,7 +1602,7 @@ gtk_calendar_paint_header (GtkWidget *widget)
   gtk_calendar_paint_arrow (widget, ARROW_YEAR_LEFT);
   gtk_calendar_paint_arrow (widget, ARROW_YEAR_RIGHT);
 
-  pango_layout_unref (layout);
+  g_object_unref (G_OBJECT (layout));
 }
 
 static void
@@ -1690,7 +1690,7 @@ gtk_calendar_paint_day_names (GtkWidget *widget)
 		       layout);
     }
   
-  pango_layout_unref (layout);
+  g_object_unref (G_OBJECT (layout));
 }
 
 static void
@@ -1779,7 +1779,7 @@ gtk_calendar_paint_week_numbers (GtkWidget *widget)
       gdk_draw_layout (private_data->week_win, gc, x_loc, y_loc, layout);
     }
   
-  pango_layout_unref (layout);
+  g_object_unref (G_OBJECT (layout));
 }
 
 static void
@@ -1924,8 +1924,7 @@ gtk_calendar_paint_day (GtkWidget *widget,
 			  private_data->day_width-1, day_height-1);
     }
 
-  pango_layout_unref (layout);
-
+  g_object_unref (G_OBJECT (layout));
 }
 
 
diff --git a/gtk/gtkcheckmenuitem.c b/gtk/gtkcheckmenuitem.c
index d149fdbc09..74afbf104e 100644
--- a/gtk/gtkcheckmenuitem.c
+++ b/gtk/gtkcheckmenuitem.c
@@ -247,7 +247,7 @@ gtk_real_check_menu_item_draw_indicator (GtkCheckMenuItem *check_menu_item,
       width = 8;
       height = 8;
       x = (GTK_CONTAINER (check_menu_item)->border_width +
-	   widget->style->klass->xthickness + 2);
+	   widget->style->xthickness + 2);
       y = (widget->allocation.height - height) / 2;
 
       if (check_menu_item->active ||
diff --git a/gtk/gtkclist.c b/gtk/gtkclist.c
index 84e0b93951..d4f79c012a 100644
--- a/gtk/gtkclist.c
+++ b/gtk/gtkclist.c
@@ -2044,7 +2044,7 @@ new_column_width (GtkCList *clist,
 		  gint      column,
 		  gint     *x)
 {
-  gint xthickness = GTK_WIDGET (clist)->style->klass->xthickness;
+  gint xthickness = GTK_WIDGET (clist)->style->xthickness;
   gint width;
   gint cx;
   gint dx;
@@ -2530,7 +2530,7 @@ _gtk_clist_create_cell_layout (GtkCList       *clist,
 				      GTK_CELL_PIXTEXT (*cell)->text :
 				      GTK_CELL_TEXT (*cell)->text), -1);
       
-      pango_context_unref (context);
+      g_object_unref (G_OBJECT (context));
 
       return layout;
       
@@ -2562,7 +2562,7 @@ cell_size_request (GtkCList       *clist,
       requisition->width = logical_rect.width / PANGO_SCALE;
       requisition->height = logical_rect.height / PANGO_SCALE;
       
-      pango_layout_unref (layout);
+      g_object_unref (G_OBJECT (layout));
     }
   else
     {
@@ -3028,7 +3028,7 @@ gtk_clist_set_row_height (GtkCList *clist,
       
       g_free (lang);
       g_object_unref (G_OBJECT (font));
-      pango_context_unref (context);
+      g_object_unref (G_OBJECT (context));
       
       if (!GTK_CLIST_ROW_HEIGHT_SET(clist))
 	clist->row_height = (metrics.ascent + metrics.descent) / PANGO_SCALE;
@@ -4511,9 +4511,9 @@ gtk_clist_realize (GtkWidget *widget)
 
   /* clist-window */
   attributes.x = (clist->internal_allocation.x +
-		  widget->style->klass->xthickness);
+		  widget->style->xthickness);
   attributes.y = (clist->internal_allocation.y +
-		  widget->style->klass->ythickness +
+		  widget->style->ythickness +
 		  clist->column_title_area.height);
   attributes.width = clist->clist_window_width;
   attributes.height = clist->clist_window_height;
@@ -4801,9 +4801,9 @@ gtk_clist_draw (GtkWidget    *widget,
 		       GTK_STATE_NORMAL, clist->shadow_type,
 		       0, 0, 
 		       clist->clist_window_width +
-		       (2 * widget->style->klass->xthickness),
+		       (2 * widget->style->xthickness),
 		       clist->clist_window_height +
-		       (2 * widget->style->klass->ythickness) +
+		       (2 * widget->style->ythickness) +
 		       clist->column_title_area.height);
 
       gdk_window_clear_area (clist->clist_window, 0, 0, 0, 0);
@@ -4840,9 +4840,9 @@ gtk_clist_expose (GtkWidget      *widget,
 			 GTK_STATE_NORMAL, clist->shadow_type,
 			 0, 0,
 			 clist->clist_window_width +
-			 (2 * widget->style->klass->xthickness),
+			 (2 * widget->style->xthickness),
 			 clist->clist_window_height +
-			 (2 * widget->style->klass->ythickness) +
+			 (2 * widget->style->ythickness) +
 			 clist->column_title_area.height);
 
       /* exposure events on the list */
@@ -5441,11 +5441,11 @@ gtk_clist_size_request (GtkWidget      *widget,
 	    MAX (clist->column_title_area.height,
 		 child_requisition.height);
 	}
-
-  requisition->width += (widget->style->klass->xthickness +
+  
+  requisition->width += (widget->style->xthickness +
 			 GTK_CONTAINER (widget)->border_width) * 2;
   requisition->height += (clist->column_title_area.height +
-			  (widget->style->klass->ythickness +
+			  (widget->style->ythickness +
 			   GTK_CONTAINER (widget)->border_width) * 2);
 
   /* if (!clist->hadjustment) */
@@ -5491,14 +5491,14 @@ gtk_clist_size_allocate (GtkWidget     *widget,
 	
   /* allocate clist window assuming no scrollbars */
   clist_allocation.x = (clist->internal_allocation.x +
-			widget->style->klass->xthickness);
+			widget->style->xthickness);
   clist_allocation.y = (clist->internal_allocation.y +
-			widget->style->klass->ythickness +
+			widget->style->ythickness +
 			clist->column_title_area.height);
   clist_allocation.width = MAX (1, (gint)clist->internal_allocation.width - 
-				(2 * (gint)widget->style->klass->xthickness));
+				(2 * (gint)widget->style->xthickness));
   clist_allocation.height = MAX (1, (gint)clist->internal_allocation.height -
-				 (2 * (gint)widget->style->klass->ythickness) -
+				 (2 * (gint)widget->style->ythickness) -
 				 (gint)clist->column_title_area.height);
   
   clist->clist_window_width = clist_allocation.width;
@@ -5514,8 +5514,8 @@ gtk_clist_size_allocate (GtkWidget     *widget,
     }
   
   /* position the window which holds the column title buttons */
-  clist->column_title_area.x = widget->style->klass->xthickness;
-  clist->column_title_area.y = widget->style->klass->ythickness;
+  clist->column_title_area.x = widget->style->xthickness;
+  clist->column_title_area.y = widget->style->ythickness;
   clist->column_title_area.width = clist_allocation.width;
   
   if (GTK_WIDGET_REALIZED (widget))
@@ -5921,7 +5921,7 @@ draw_row (GtkCList     *clist,
 			       offset,
 			       row_rectangle.y + row_center_offset + clist_row->cell[i].vertical,
 			       layout);
-	      pango_layout_unref (layout);
+              g_object_unref (G_OBJECT (layout));
 	      gdk_gc_set_clip_rectangle (fg_gc, NULL);
 	    }
 	  break;
@@ -6016,7 +6016,7 @@ draw_xor_line (GtkCList *clist)
 
   gdk_draw_line (widget->window, clist->xor_gc,
                  clist->x_drag,
-		 widget->style->klass->ythickness,
+		 widget->style->ythickness,
                  clist->x_drag,
                  clist->column_title_area.height +
 		 clist->clist_window_height + 1);
@@ -7484,7 +7484,7 @@ drag_dest_cell (GtkCList         *clist,
   dest_info->insert_pos = GTK_CLIST_DRAG_NONE;
 
   y -= (GTK_CONTAINER (clist)->border_width +
-	widget->style->klass->ythickness +
+	widget->style->ythickness +
 	clist->column_title_area.height);
 
   dest_info->cell.row = ROW_FROM_YPIXEL (clist, y);
@@ -7495,8 +7495,9 @@ drag_dest_cell (GtkCList         *clist,
     }
   if (dest_info->cell.row < -1)
     dest_info->cell.row = -1;
+  
+  x -= GTK_CONTAINER (widget)->border_width + widget->style->xthickness;
 
-  x -= GTK_CONTAINER (widget)->border_width + widget->style->klass->xthickness;
   dest_info->cell.column = COLUMN_FROM_XPIXEL (clist, x);
 
   if (dest_info->cell.row >= 0)
diff --git a/gtk/gtkcombo.c b/gtk/gtkcombo.c
index fc0f267b01..32b19ae622 100644
--- a/gtk/gtkcombo.c
+++ b/gtk/gtkcombo.c
@@ -325,17 +325,17 @@ gtk_combo_get_pos (GtkCombo * combo, gint * x, gint * y, gint * height, gint * w
     list_requisition.height += EMPTY_LIST_HEIGHT;
   
   alloc_width = (widget->allocation.width -
-		 2 * popwin->child->style->klass->xthickness -
+		 2 * popwin->child->style->xthickness -
 		 2 * GTK_CONTAINER (popwin->child)->border_width -
 		 2 * GTK_CONTAINER (combo->popup)->border_width -
 		 2 * GTK_CONTAINER (GTK_BIN (popup)->child)->border_width - 
-		 2 * GTK_BIN (popup)->child->style->klass->xthickness);
+		 2 * GTK_BIN (popup)->child->style->xthickness);
   
-  work_height = (2 * popwin->child->style->klass->ythickness +
+  work_height = (2 * popwin->child->style->ythickness +
 		 2 * GTK_CONTAINER (popwin->child)->border_width +
 		 2 * GTK_CONTAINER (combo->popup)->border_width +
 		 2 * GTK_CONTAINER (GTK_BIN (popup)->child)->border_width +
-		 2 * GTK_BIN (popup)->child->style->klass->xthickness);
+		 2 * GTK_BIN (popup)->child->style->xthickness);
   
   do 
     {
diff --git a/gtk/gtkcontainer.c b/gtk/gtkcontainer.c
index ec2eca9736..ab2164c5c1 100644
--- a/gtk/gtkcontainer.c
+++ b/gtk/gtkcontainer.c
@@ -59,9 +59,6 @@ struct _GtkChildArgInfo
   guint seq_id;
 };
 
-/* The global list of toplevel windows */
-static GList *toplevel_list = NULL;
-
 static void gtk_container_base_class_init   (GtkContainerClass *klass);
 static void gtk_container_class_init        (GtkContainerClass *klass);
 static void gtk_container_init              (GtkContainer      *container);
diff --git a/gtk/gtkctree.c b/gtk/gtkctree.c
index 91db6ecd58..619959d4df 100644
--- a/gtk/gtkctree.c
+++ b/gtk/gtkctree.c
@@ -1880,7 +1880,7 @@ draw_row (GtkCList     *clist,
 				       row_rectangle.y + row_center_offset + clist_row->cell[i].vertical,
 				       layout);
 		      gdk_gc_set_clip_rectangle (fg_gc, NULL);
-		      pango_layout_unref (layout);
+		      g_object_unref (G_OBJECT (layout));
 		    }
 		  break;
 		default:
@@ -1901,7 +1901,7 @@ draw_row (GtkCList     *clist,
 					    &intersect_rectangle))
 	{
 	  if (layout)
-	    pango_layout_unref (layout);
+            g_object_unref (G_OBJECT (layout));
 	  continue;
 	}
 
@@ -1955,7 +1955,7 @@ draw_row (GtkCList     *clist,
 			   row_rectangle.y + row_center_offset + clist_row->cell[i].vertical,
 			   layout);
 
-	  pango_layout_unref (layout);
+          g_object_unref (G_OBJECT (layout));
 	}
       gdk_gc_set_clip_rectangle (fg_gc, NULL);
     }
@@ -2820,7 +2820,7 @@ cell_size_request (GtkCList       *clist,
       requisition->width = logical_rect.width / PANGO_SCALE;
       requisition->height = logical_rect.height / PANGO_SCALE;
       
-      pango_layout_unref (layout);
+      g_object_unref (G_OBJECT (layout));
     }
   else
     {
@@ -5879,7 +5879,7 @@ drag_dest_cell (GtkCList         *clist,
   dest_info->insert_pos = GTK_CLIST_DRAG_NONE;
 
   y -= (GTK_CONTAINER (widget)->border_width +
-	widget->style->klass->ythickness + clist->column_title_area.height);
+	widget->style->ythickness + clist->column_title_area.height);
   dest_info->cell.row = ROW_FROM_YPIXEL (clist, y);
 
   if (dest_info->cell.row >= clist->rows)
@@ -5889,8 +5889,9 @@ drag_dest_cell (GtkCList         *clist,
     }
   if (dest_info->cell.row < -1)
     dest_info->cell.row = -1;
+  
+  x -= GTK_CONTAINER (widget)->border_width + widget->style->xthickness;
 
-  x -= GTK_CONTAINER (widget)->border_width + widget->style->klass->xthickness;
   dest_info->cell.column = COLUMN_FROM_XPIXEL (clist, x);
 
   if (dest_info->cell.row >= 0)
diff --git a/gtk/gtkdnd.c b/gtk/gtkdnd.c
index 5de66cfa2f..0cd1bf863c 100644
--- a/gtk/gtkdnd.c
+++ b/gtk/gtkdnd.c
@@ -993,8 +993,8 @@ gtk_drag_dest_handle_event (GtkWidget *toplevel,
       info->proxy_data = NULL;
       info->dropped = FALSE;
       info->proxy_drop_wait = FALSE;
-      g_dataset_set_data_full (context,
-			       "gtk-info",
+      g_object_set_qdata_full (G_OBJECT (context),
+			       g_quark_from_static_string ("gtk-info"),
 			       info,
 			       gtk_drag_dest_info_destroy);
     }
@@ -1127,7 +1127,7 @@ gtk_drag_selection_received (GtkWidget        *widget,
   drop_widget = data;
 
   context = gtk_object_get_data (GTK_OBJECT (widget), "drag-context");
-  info = g_dataset_get_data (context, "gtk-info");
+  info = g_object_get_qdata (G_OBJECT (context), g_quark_from_static_string ("gtk-info"));
 
   if (info->proxy_data && 
       info->proxy_data->target == selection_data->target)
@@ -1345,7 +1345,9 @@ gtk_drag_proxy_begin (GtkWidget       *widget,
 
   source_info->proxy_dest = dest_info;
   
-  g_dataset_set_data (source_info->context, "gtk-info", source_info);
+  g_object_set_qdata (G_OBJECT (source_info->context),
+                      g_quark_from_static_string ("gtk-info"),
+                      source_info);
   
   gtk_signal_connect (GTK_OBJECT (source_info->ipc_widget), 
 		      "selection_get",
@@ -1396,7 +1398,8 @@ gtk_drag_dest_leave (GtkWidget      *widget,
 
   if (site->do_proxy)
     {
-      GtkDragDestInfo *info = g_dataset_get_data (context, "gtk-info");
+      GtkDragDestInfo *info = g_object_get_qdata (G_OBJECT (context),
+                                                  g_quark_from_static_string ("gtk-info"));
 
       if (info->proxy_source && !info->dropped)
 	gdk_drag_abort (info->proxy_source->context, time);
@@ -1437,7 +1440,8 @@ gtk_drag_dest_motion (GtkWidget	     *widget,
       GdkWindow *dest_window;
       GdkDragProtocol proto;
 	
-      GtkDragDestInfo *info = g_dataset_get_data (context, "gtk-info");
+      GtkDragDestInfo *info = g_object_get_qdata (G_OBJECT (context),
+                                                 g_quark_from_static_string ("gtk-info"));
 
       if (!info->proxy_source)
 	gtk_drag_proxy_begin (widget, info);
@@ -1534,7 +1538,8 @@ gtk_drag_dest_drop (GtkWidget	     *widget,
   site = gtk_object_get_data (GTK_OBJECT (widget), "gtk-drag-dest");
   g_return_val_if_fail (site != NULL, FALSE);
 
-  info = g_dataset_get_data (context, "gtk-info");
+  info = g_object_get_qdata (G_OBJECT (context),
+                             g_quark_from_static_string ("gtk-info"));
   g_return_val_if_fail (info != NULL, FALSE);
 
   info->drop_x = x;
@@ -1677,7 +1682,8 @@ gtk_drag_begin (GtkWidget         *widget,
   info->context = gdk_drag_begin (info->ipc_widget->window, targets);
   g_list_free (targets);
   
-  g_dataset_set_data (info->context, "gtk-info", info);
+  g_object_set_qdata (G_OBJECT (info->context),
+                     g_quark_from_static_string ("gtk-info"), info);
 
   info->button = button;
   info->target_list = target_list;
@@ -1913,7 +1919,8 @@ gtk_drag_set_icon_window (GdkDragContext *context,
   g_return_if_fail (context != NULL);
   g_return_if_fail (widget != NULL);
 
-  info = g_dataset_get_data (context, "gtk-info");
+  info = g_object_get_qdata (G_OBJECT (context),
+                            g_quark_from_static_string ("gtk-info"));
   gtk_drag_remove_icon (info);
 
   info->icon_window = widget;
@@ -2106,7 +2113,8 @@ gtk_drag_source_handle_event (GtkWidget *widget,
   g_return_if_fail (event != NULL);
 
   context = event->dnd.context;
-  info = g_dataset_get_data (context, "gtk-info");
+  info = g_object_get_qdata (G_OBJECT (context),
+                            g_quark_from_static_string ("gtk-info"));
   if (!info)
     return;
 
@@ -2285,7 +2293,8 @@ gtk_drag_drop_finished (GtkDragSourceInfo *info,
 	  /* Mark the context as dead, so if the destination decides
 	   * to respond really late, we still are OK.
 	   */
-	  g_dataset_set_data (info->context, "gtk-info", NULL);
+	  g_object_set_qdata (G_OBJECT (info->context),
+                             g_quark_from_static_string ("gtk-info"), NULL);
 	  gtk_timeout_add (ANIM_STEP_TIME, gtk_drag_anim_timeout, anim);
 	}
     }
@@ -2419,7 +2428,8 @@ gtk_drag_source_event_cb (GtkWidget      *widget,
 					i, event);
 
 	      
-	      info = g_dataset_get_data (context, "gtk-info");
+	      info = g_object_get_qdata (G_OBJECT (context),
+                                         g_quark_from_static_string ("gtk-info"));
 
 	      if (!info->icon_window)
 		{
@@ -2594,7 +2604,7 @@ gtk_drag_source_info_destroy (gpointer data)
 
   gtk_target_list_unref (info->target_list);
 
-  g_dataset_set_data (info->context, "gtk-info", NULL);
+  g_object_set_qdata (G_OBJECT (info->context), g_quark_from_static_string ("gtk-info"), NULL);
   gdk_drag_context_unref (info->context);
 
   if (info->drop_timeout)
diff --git a/gtk/gtkentry.c b/gtk/gtkentry.c
index 9dfe3e3e2c..25e2dbdc9b 100644
--- a/gtk/gtkentry.c
+++ b/gtk/gtkentry.c
@@ -510,7 +510,7 @@ gtk_entry_finalize (GObject *object)
   entry = GTK_ENTRY (object);
 
   if (entry->layout)
-    pango_layout_unref (entry->layout);
+    g_object_unref (G_OBJECT (entry->layout));
 
   gtk_object_unref (GTK_OBJECT (entry->im_context));
 
@@ -568,8 +568,8 @@ gtk_entry_realize (GtkWidget *widget)
   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
   gdk_window_set_user_data (widget->window, entry);
 
-  attributes.x = widget->style->klass->xthickness;
-  attributes.y = widget->style->klass->ythickness;
+  attributes.x = widget->style->xthickness;
+  attributes.y = widget->style->ythickness;
   attributes.width = widget->allocation.width - attributes.x * 2;
   attributes.height = requisition.height - attributes.y * 2;
   attributes.cursor = entry->cursor = gdk_cursor_new (GDK_XTERM);
@@ -668,12 +668,12 @@ gtk_entry_size_request (GtkWidget      *widget,
   g_return_if_fail (requisition != NULL);
 
   entry = GTK_ENTRY (widget);
-
+  
   /* We do this to deal with direction changes - should that be a signal?
    */
   if (entry->layout)
     {
-      pango_layout_unref (entry->layout);
+      g_object_unref (G_OBJECT (entry->layout));
       entry->layout = NULL;
     }
 
@@ -691,9 +691,9 @@ gtk_entry_size_request (GtkWidget      *widget,
 
   entry->ascent = metrics.ascent;
   
-  requisition->width = MIN_ENTRY_WIDTH + (widget->style->klass->xthickness + INNER_BORDER) * 2;
+  requisition->width = MIN_ENTRY_WIDTH + (widget->style->xthickness + INNER_BORDER) * 2;
   requisition->height = ((metrics.ascent + metrics.descent) / PANGO_SCALE + 
-			 (widget->style->klass->ythickness + INNER_BORDER) * 2);
+			 (widget->style->ythickness + INNER_BORDER) * 2);
 }
 
 static void
@@ -725,10 +725,10 @@ gtk_entry_size_allocate (GtkWidget     *widget,
 			      allocation->y + (allocation->height - requisition.height) / 2,
 			      allocation->width, requisition.height);
       gdk_window_move_resize (entry->text_area,
-			      widget->style->klass->xthickness,
-			      widget->style->klass->ythickness,
-			      allocation->width - widget->style->klass->xthickness * 2,
-			      requisition.height - widget->style->klass->ythickness * 2);
+			      widget->style->xthickness,
+			      widget->style->ythickness,
+			      allocation->width - widget->style->xthickness * 2,
+			      requisition.height - widget->style->ythickness * 2);
 
     }
 
@@ -752,8 +752,8 @@ gtk_entry_draw (GtkWidget    *widget,
     {
       GdkRectangle tmp_area = *area;
 
-      tmp_area.x -= widget->style->klass->xthickness;
-      tmp_area.y -= widget->style->klass->xthickness;
+      tmp_area.x -= widget->style->xthickness;
+      tmp_area.y -= widget->style->xthickness;
       
       gdk_window_begin_paint_rect (entry->text_area, &tmp_area);
       gtk_widget_draw_focus (widget);
@@ -1377,7 +1377,7 @@ entry_adjust_scroll (GtkEntry *entry)
   g_return_if_fail (GTK_IS_ENTRY (entry));
 
   widget = GTK_WIDGET (entry);
-  text_area_width = widget->allocation.width - 2 * (widget->style->klass->xthickness + INNER_BORDER);
+  text_area_width = widget->allocation.width - 2 * (widget->style->xthickness + INNER_BORDER);
 
   if (!entry->layout)
     return;
diff --git a/gtk/gtkfontsel.c b/gtk/gtkfontsel.c
index 90c249268a..34a9f95165 100644
--- a/gtk/gtkfontsel.c
+++ b/gtk/gtkfontsel.c
@@ -348,7 +348,7 @@ gtk_font_selection_finalize (GObject *object)
   
   fontsel = GTK_FONT_SELECTION (object);
 
-  pango_context_unref (fontsel->context);
+  g_object_unref (G_OBJECT (fontsel->context));
   pango_font_description_free (fontsel->font_desc);
 
   if (fontsel->font)
diff --git a/gtk/gtkframe.c b/gtk/gtkframe.c
index 03f1be3fb2..dc58e68f82 100644
--- a/gtk/gtkframe.c
+++ b/gtk/gtkframe.c
@@ -374,10 +374,10 @@ gtk_frame_paint (GtkWidget    *widget,
     {
       frame = GTK_FRAME (widget);
 
-      x = frame->child_allocation.x - widget->style->klass->xthickness;
-      y = frame->child_allocation.y - widget->style->klass->ythickness;
-      width = frame->child_allocation.width + 2 * widget->style->klass->xthickness;
-      height =  frame->child_allocation.height + 2 * widget->style->klass->ythickness;
+      x = frame->child_allocation.x - widget->style->xthickness;
+      y = frame->child_allocation.y - widget->style->ythickness;
+      width = frame->child_allocation.width + 2 * widget->style->xthickness;
+      height =  frame->child_allocation.height + 2 * widget->style->ythickness;
 
       if (frame->label_widget)
 	{
@@ -393,7 +393,7 @@ gtk_frame_paint (GtkWidget    *widget,
 	  else
 	    xalign = 1 - frame->label_xalign;
 
-	  height_extra = MAX (0, child_requisition.height - widget->style->klass->xthickness);
+	  height_extra = MAX (0, child_requisition.height - widget->style->xthickness);
 	  y -= height_extra * (1 - frame->label_yalign);
 	  height += height_extra * (1 - frame->label_yalign);
 	  
@@ -478,7 +478,7 @@ gtk_frame_size_request (GtkWidget      *widget,
 
       requisition->width = child_requisition.width;
       requisition->height =
-	MAX (0, child_requisition.height - GTK_WIDGET (widget)->style->klass->xthickness);
+	MAX (0, child_requisition.height - GTK_WIDGET (widget)->style->xthickness);
     }
   else
     {
@@ -495,9 +495,9 @@ gtk_frame_size_request (GtkWidget      *widget,
     }
 
   requisition->width += (GTK_CONTAINER (widget)->border_width +
-			 GTK_WIDGET (widget)->style->klass->xthickness) * 2;
+			 GTK_WIDGET (widget)->style->xthickness) * 2;
   requisition->height += (GTK_CONTAINER (widget)->border_width +
-			  GTK_WIDGET (widget)->style->klass->xthickness) * 2;
+			  GTK_WIDGET (widget)->style->ythickness) * 2;
 }
 
 static void
@@ -602,19 +602,19 @@ gtk_frame_real_compute_child_allocation (GtkFrame      *frame,
   if (frame->label_widget)
     {
       gtk_widget_get_child_requisition (frame->label_widget, &child_requisition);
-      top_margin = MAX (child_requisition.height, widget->style->klass->ythickness);
+      top_margin = MAX (child_requisition.height, widget->style->ythickness);
     }
   else
-    top_margin = widget->style->klass->ythickness;
+    top_margin = widget->style->ythickness;
   
   child_allocation->x = (GTK_CONTAINER (frame)->border_width +
-			 widget->style->klass->xthickness);
+			 widget->style->xthickness);
   child_allocation->width = MAX(1, (gint)allocation->width - child_allocation->x * 2);
   
   child_allocation->y = (GTK_CONTAINER (frame)->border_width + top_margin);
   child_allocation->height = MAX (1, ((gint)allocation->height - child_allocation->y -
 				      (gint)GTK_CONTAINER (frame)->border_width -
-				      (gint)widget->style->klass->ythickness));
+				      (gint)widget->style->ythickness));
   
   child_allocation->x += allocation->x;
   child_allocation->y += allocation->y;
diff --git a/gtk/gtkhandlebox.c b/gtk/gtkhandlebox.c
index ef2d7ad0c2..3060dfb53c 100644
--- a/gtk/gtkhandlebox.c
+++ b/gtk/gtkhandlebox.c
@@ -515,9 +515,9 @@ gtk_handle_box_size_request (GtkWidget      *widget,
 	{
 	  if (hb->handle_position == GTK_POS_LEFT ||
 	      hb->handle_position == GTK_POS_RIGHT)
-	    requisition->height += widget->style->klass->ythickness;
+	    requisition->height += widget->style->ythickness;
 	  else
-	    requisition->width += widget->style->klass->xthickness;
+	    requisition->width += widget->style->xthickness;
 	}
     }
   else
diff --git a/gtk/gtkhruler.c b/gtk/gtkhruler.c
index 701aeb2139..8ddc5399bd 100644
--- a/gtk/gtkhruler.c
+++ b/gtk/gtkhruler.c
@@ -92,8 +92,8 @@ gtk_hruler_init (GtkHRuler *hruler)
   GtkWidget *widget;
 
   widget = GTK_WIDGET (hruler);
-  widget->requisition.width = widget->style->klass->xthickness * 2 + 1;
-  widget->requisition.height = widget->style->klass->ythickness * 2 + RULER_HEIGHT;
+  widget->requisition.width = widget->style->xthickness * 2 + 1;
+  widget->requisition.height = widget->style->ythickness * 2 + RULER_HEIGHT;
 }
 
 
@@ -166,8 +166,8 @@ gtk_hruler_draw_ticks (GtkRuler *ruler)
   bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
   font = widget->style->font;
 
-  xthickness = widget->style->klass->xthickness;
-  ythickness = widget->style->klass->ythickness;
+  xthickness = widget->style->xthickness;
+  ythickness = widget->style->ythickness;
 
   digit_height = ink_rect.height / PANGO_SCALE + 2;
   digit_offset = ink_rect.y;
@@ -269,7 +269,7 @@ gtk_hruler_draw_ticks (GtkRuler *ruler)
 	}
     }
 
-  pango_layout_unref (layout);
+  g_object_unref (G_OBJECT (layout));
 }
 
 static void
@@ -293,8 +293,8 @@ gtk_hruler_draw_pos (GtkRuler *ruler)
       widget = GTK_WIDGET (ruler);
 
       gc = widget->style->fg_gc[GTK_STATE_NORMAL];
-      xthickness = widget->style->klass->xthickness;
-      ythickness = widget->style->klass->ythickness;
+      xthickness = widget->style->xthickness;
+      ythickness = widget->style->ythickness;
       width = widget->allocation.width;
       height = widget->allocation.height - ythickness * 2;
 
diff --git a/gtk/gtkhscale.c b/gtk/gtkhscale.c
index 30044b8bb2..b1e0f8c8fb 100644
--- a/gtk/gtkhscale.c
+++ b/gtk/gtkhscale.c
@@ -321,10 +321,10 @@ gtk_hscale_size_request (GtkWidget      *widget,
   scale = GTK_SCALE (widget);
   
   requisition->width = (SCALE_CLASS (scale)->slider_length +
-                        widget->style->klass->xthickness) * 2;
+                        widget->style->xthickness) * 2;
   requisition->height = (RANGE_CLASS (scale)->slider_width +
-                         widget->style->klass->ythickness * 2);
-
+                         widget->style->ythickness * 2);
+  
   if (scale->draw_value)
     {
       gint value_width, value_height;
@@ -393,7 +393,7 @@ gtk_hscale_pos_trough (GtkHScale *hscale,
   
   *w = widget->allocation.width;
   *h = (RANGE_CLASS (scale)->slider_width +
-        widget->style->klass->ythickness * 2);
+        widget->style->ythickness * 2);
   
   if (scale->draw_value)
     {
@@ -586,7 +586,7 @@ gtk_hscale_draw_value (GtkScale *scale)
 		       GTK_WIDGET (scale)->style->fg_gc [state_type],
 		       x, y, layout);
 
-      pango_layout_unref (layout);
+      g_object_unref (G_OBJECT (layout));
     }
 }
 
diff --git a/gtk/gtkhscrollbar.c b/gtk/gtkhscrollbar.c
index 95eb6eca3f..73099b558e 100644
--- a/gtk/gtkhscrollbar.c
+++ b/gtk/gtkhscrollbar.c
@@ -165,9 +165,9 @@ gtk_hscrollbar_init (GtkHScrollbar *hscrollbar)
   requisition->width = (RANGE_CLASS (widget)->min_slider_size +
                         RANGE_CLASS (widget)->stepper_size +
                         RANGE_CLASS (widget)->stepper_slider_spacing +
-                        widget->style->klass->xthickness) * 2;
+                        widget->style->xthickness) * 2;
   requisition->height = (RANGE_CLASS (widget)->slider_width +
-                         widget->style->klass->ythickness * 2);
+                         widget->style->ythickness * 2);
 }
 
 GtkWidget*
@@ -217,21 +217,21 @@ gtk_hscrollbar_realize (GtkWidget *widget)
   range->trough = widget->window;
   gdk_window_ref (range->trough);
   
-  attributes.x = widget->style->klass->xthickness;
-  attributes.y = widget->style->klass->ythickness;
+  attributes.x = widget->style->xthickness;
+  attributes.y = widget->style->ythickness;
   attributes.width = RANGE_CLASS (widget)->stepper_size;
   attributes.height = RANGE_CLASS (widget)->stepper_size;
   
   range->step_back = gdk_window_new (range->trough, &attributes, attributes_mask);
   
   attributes.x = (widget->allocation.width -
-                  widget->style->klass->xthickness -
+                  widget->style->xthickness -
                   RANGE_CLASS (widget)->stepper_size);
   
   range->step_forw = gdk_window_new (range->trough, &attributes, attributes_mask);
   
   attributes.x = 0;
-  attributes.y = widget->style->klass->ythickness;
+  attributes.y = widget->style->ythickness;
   attributes.width = RANGE_CLASS (widget)->min_slider_size;
   attributes.height = RANGE_CLASS (widget)->slider_width;
   attributes.event_mask |= (GDK_BUTTON_MOTION_MASK |
@@ -279,16 +279,16 @@ gtk_hscrollbar_size_allocate (GtkWidget     *widget,
                               allocation->y + (allocation->height - widget->requisition.height) / 2,
                               allocation->width, widget->requisition.height);
       gdk_window_move_resize (range->step_back,
-                              widget->style->klass->xthickness,
-                              widget->style->klass->ythickness,
+                              widget->style->xthickness,
+                              widget->style->ythickness,
                               RANGE_CLASS (widget)->stepper_size,
-                              widget->requisition.height - widget->style->klass->ythickness * 2);
+                              widget->requisition.height - widget->style->ythickness * 2);
       gdk_window_move_resize (range->step_forw,
-                              allocation->width - widget->style->klass->xthickness -
+                              allocation->width - widget->style->xthickness -
                               RANGE_CLASS (widget)->stepper_size,
-                              widget->style->klass->ythickness,
+                              widget->style->ythickness,
                               RANGE_CLASS (widget)->stepper_size,
-                              widget->requisition.height - widget->style->klass->ythickness * 2);
+                              widget->requisition.height - widget->style->ythickness * 2);
       
       gtk_range_slider_update (GTK_RANGE (widget));
     }
diff --git a/gtk/gtkhseparator.c b/gtk/gtkhseparator.c
index 7d28457938..7fc9bafd65 100644
--- a/gtk/gtkhseparator.c
+++ b/gtk/gtkhseparator.c
@@ -72,7 +72,7 @@ static void
 gtk_hseparator_init (GtkHSeparator *hseparator)
 {
   GTK_WIDGET (hseparator)->requisition.width = 1;
-  GTK_WIDGET (hseparator)->requisition.height = GTK_WIDGET (hseparator)->style->klass->ythickness;
+  GTK_WIDGET (hseparator)->requisition.height = GTK_WIDGET (hseparator)->style->ythickness;
 }
 
 GtkWidget*
@@ -96,7 +96,7 @@ gtk_hseparator_expose (GtkWidget      *widget,
 		     widget->allocation.x,
 		     widget->allocation.x + widget->allocation.width,
 		     widget->allocation.y + (widget->allocation.height -
-					     widget->style->klass->ythickness) / 2);
+					     widget->style->ythickness) / 2);
 
   return FALSE;
 }
diff --git a/gtk/gtklabel.c b/gtk/gtklabel.c
index 823dcb4970..47b9680639 100644
--- a/gtk/gtklabel.c
+++ b/gtk/gtklabel.c
@@ -265,7 +265,7 @@ gtk_label_set_justify (GtkLabel        *label,
       if (label->layout)
 	{
 	  /* No real need to be this drastic, but easier than duplicating the code */
-	  pango_layout_unref (label->layout);
+          g_object_unref (G_OBJECT (label->layout));
 	  label->layout = NULL;
 	}
       
@@ -313,7 +313,7 @@ gtk_label_finalize (GObject *object)
   g_free (label->pattern);
 
   if (label->layout)
-    pango_layout_unref (label->layout);
+    g_object_unref (G_OBJECT (label->layout));
 
   G_OBJECT_CLASS (parent_class)->finalize (object);
 }
@@ -401,7 +401,7 @@ gtk_label_size_request (GtkWidget      *widget,
       label->layout)
     {
       label->rtl = !label->rtl;
-      pango_layout_unref (label->layout);
+      g_object_unref (G_OBJECT (label->layout));
       label->layout = NULL;
     }
   
@@ -546,7 +546,7 @@ gtk_label_style_set (GtkWidget *widget,
 
   if (previous_style && label->layout)
     {
-      pango_layout_unref (label->layout);
+      g_object_unref (G_OBJECT (label->layout));
       label->layout = NULL;
     }
 }
diff --git a/gtk/gtklistitem.c b/gtk/gtklistitem.c
index 8482cde215..b06aa32aac 100644
--- a/gtk/gtklistitem.c
+++ b/gtk/gtklistitem.c
@@ -403,7 +403,7 @@ gtk_list_item_size_request (GtkWidget      *widget,
   bin = GTK_BIN (widget);
 
   requisition->width = (GTK_CONTAINER (widget)->border_width +
-			widget->style->klass->xthickness) * 2;
+			widget->style->xthickness) * 2;
   requisition->height = GTK_CONTAINER (widget)->border_width * 2;
 
   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
@@ -437,7 +437,7 @@ gtk_list_item_size_allocate (GtkWidget     *widget,
   if (bin->child)
     {
       child_allocation.x = (GTK_CONTAINER (widget)->border_width +
-			    widget->style->klass->xthickness);
+			    widget->style->xthickness);
       child_allocation.y = GTK_CONTAINER (widget)->border_width;
       child_allocation.width = allocation->width - child_allocation.x * 2;
       child_allocation.height = allocation->height - child_allocation.y * 2;
diff --git a/gtk/gtkmenu.c b/gtk/gtkmenu.c
index 7de4f13f30..3362785216 100644
--- a/gtk/gtkmenu.c
+++ b/gtk/gtkmenu.c
@@ -862,9 +862,9 @@ gtk_menu_size_request (GtkWidget      *widget,
   
   requisition->width += max_toggle_size + max_accel_width;
   requisition->width += (GTK_CONTAINER (menu)->border_width +
-			 widget->style->klass->xthickness) * 2;
+			 widget->style->xthickness) * 2;
   requisition->height += (GTK_CONTAINER (menu)->border_width +
-			  widget->style->klass->ythickness) * 2;
+			  widget->style->ythickness) * 2;
   
   children = menu_shell->children;
   while (children)
@@ -903,9 +903,9 @@ gtk_menu_size_allocate (GtkWidget     *widget,
   if (menu_shell->children)
     {
       child_allocation.x = (GTK_CONTAINER (menu)->border_width +
-			    widget->style->klass->xthickness);
+			    widget->style->xthickness);
       child_allocation.y = (GTK_CONTAINER (menu)->border_width +
-			    widget->style->klass->ythickness);
+			    widget->style->ythickness);
       child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
       
       children = menu_shell->children;
diff --git a/gtk/gtkmenubar.c b/gtk/gtkmenubar.c
index ecaeb3a03d..78a1e91532 100644
--- a/gtk/gtkmenubar.c
+++ b/gtk/gtkmenubar.c
@@ -257,10 +257,10 @@ gtk_menu_bar_size_request (GtkWidget      *widget,
 	}
 
       requisition->width += (GTK_CONTAINER (menu_bar)->border_width +
-			     widget->style->klass->xthickness +
+			     widget->style->xthickness +
 			     BORDER_SPACING) * 2;
       requisition->height += (GTK_CONTAINER (menu_bar)->border_width +
-			      widget->style->klass->ythickness +
+			      widget->style->ythickness +
 			      BORDER_SPACING) * 2;
 
       if (nchildren > 0)
@@ -296,12 +296,12 @@ gtk_menu_bar_size_allocate (GtkWidget     *widget,
   if (menu_shell->children)
     {
       child_allocation.x = (GTK_CONTAINER (menu_bar)->border_width +
-			    widget->style->klass->xthickness +
+			    widget->style->xthickness +
 			    BORDER_SPACING);
       offset = child_allocation.x; 	/* Window edge to menubar start */
 
       child_allocation.y = (GTK_CONTAINER (menu_bar)->border_width +
-			    widget->style->klass->ythickness +
+			    widget->style->ythickness +
 			    BORDER_SPACING);
       child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
 
diff --git a/gtk/gtkmenuitem.c b/gtk/gtkmenuitem.c
index c8e0cfd2f0..9459a8d1a4 100644
--- a/gtk/gtkmenuitem.c
+++ b/gtk/gtkmenuitem.c
@@ -348,10 +348,10 @@ gtk_menu_item_size_request (GtkWidget      *widget,
   menu_item = GTK_MENU_ITEM (widget);
 
   requisition->width = (GTK_CONTAINER (widget)->border_width +
-			widget->style->klass->xthickness +
+			widget->style->xthickness +
 			BORDER_SPACING) * 2;
   requisition->height = (GTK_CONTAINER (widget)->border_width +
-			 widget->style->klass->ythickness) * 2;
+			 widget->style->ythickness) * 2;
 
   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
     {
@@ -393,10 +393,10 @@ gtk_menu_item_size_allocate (GtkWidget     *widget,
   if (bin->child)
     {
       child_allocation.x = (GTK_CONTAINER (widget)->border_width +
-                            widget->style->klass->xthickness +
+                            widget->style->xthickness +
 			    BORDER_SPACING);
       child_allocation.y = (GTK_CONTAINER (widget)->border_width +
-			    widget->style->klass->ythickness);
+			    widget->style->ythickness);
       child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
       child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
       child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
diff --git a/gtk/gtknotebook.c b/gtk/gtknotebook.c
index be49dc6ea2..54819e0608 100644
--- a/gtk/gtknotebook.c
+++ b/gtk/gtknotebook.c
@@ -647,8 +647,8 @@ gtk_notebook_size_request (GtkWidget      *widget,
 
   if (notebook->show_border || notebook->show_tabs)
     {
-      widget->requisition.width += widget->style->klass->xthickness * 2;
-      widget->requisition.height += widget->style->klass->ythickness * 2;
+      widget->requisition.width += widget->style->xthickness * 2;
+      widget->requisition.height += widget->style->ythickness * 2;
 
       if (notebook->show_tabs)
 	{
@@ -672,10 +672,10 @@ gtk_notebook_size_request (GtkWidget      *widget,
 
 		  page->requisition.width = 
 		    child_requisition.width +
-		    2 * widget->style->klass->xthickness;
+		    2 * widget->style->xthickness;
 		  page->requisition.height = 
 		    child_requisition.height +
-		    2 * widget->style->klass->ythickness;
+		    2 * widget->style->ythickness;
 		  
 		  switch (notebook->tab_pos)
 		    {
@@ -880,12 +880,12 @@ gtk_notebook_size_allocate (GtkWidget     *widget,
 
       if (notebook->show_tabs || notebook->show_border)
 	{
-	  child_allocation.x += widget->style->klass->xthickness;
-	  child_allocation.y += widget->style->klass->ythickness;
+	  child_allocation.x += widget->style->xthickness;
+	  child_allocation.y += widget->style->ythickness;
 	  child_allocation.width = MAX (1, (gint)child_allocation.width -
-					(gint) widget->style->klass->xthickness * 2);
+					(gint) widget->style->xthickness * 2);
 	  child_allocation.height = MAX (1, (gint)child_allocation.height -
-					 (gint) widget->style->klass->ythickness * 2);
+					 (gint) widget->style->ythickness * 2);
 
 	  if (notebook->show_tabs && notebook->children && notebook->cur_page)
 	    {
@@ -1881,28 +1881,28 @@ gtk_notebook_expose_tabs (GtkNotebook *notebook)
     case GTK_POS_BOTTOM:
       event.area.y = (widget->allocation.height - border -
 		      page->allocation.height -
-		      widget->style->klass->ythickness);
+		      widget->style->ythickness);
       if (page != notebook->cur_page)
-	event.area.y -= widget->style->klass->ythickness;
+	event.area.y -= widget->style->ythickness;
     case GTK_POS_TOP:
       event.area.width = widget->allocation.width - 2 * border;
       event.area.height = (page->allocation.height +
-			   widget->style->klass->ythickness);
+			   widget->style->ythickness);
       if (page != notebook->cur_page)
-	event.area.height += widget->style->klass->ythickness;
+	event.area.height += widget->style->ythickness;
       break;
     case GTK_POS_RIGHT:
       event.area.x = (widget->allocation.width - border -
 		      page->allocation.width -
-		      widget->style->klass->xthickness);
+		      widget->style->xthickness);
       if (page != notebook->cur_page)
-	event.area.x -= widget->style->klass->xthickness;
+	event.area.x -= widget->style->xthickness;
     case GTK_POS_LEFT:
       event.area.width = (page->allocation.width +
-			  widget->style->klass->xthickness);
+			  widget->style->xthickness);
       event.area.height = widget->allocation.height - 2 * border;
       if (page != notebook->cur_page)
-	event.area.width += widget->style->klass->xthickness;
+	event.area.width += widget->style->xthickness;
       break;
     }	     
   gtk_widget_event (widget, (GdkEvent *) &event);
@@ -2238,14 +2238,14 @@ gtk_notebook_paint (GtkWidget    *widget,
       switch (notebook->tab_pos)
 	{
 	case GTK_POS_TOP:
-	  y += page->allocation.height + widget->style->klass->ythickness;
+	  y += page->allocation.height + widget->style->ythickness;
 	case GTK_POS_BOTTOM:
-	  height -= page->allocation.height + widget->style->klass->ythickness;
+	  height -= page->allocation.height + widget->style->ythickness;
 	  break;
 	case GTK_POS_LEFT:
-	  x += page->allocation.width + widget->style->klass->xthickness;
+	  x += page->allocation.width + widget->style->xthickness;
 	case GTK_POS_RIGHT:
-	  width -= page->allocation.width + widget->style->klass->xthickness;
+	  width -= page->allocation.width + widget->style->xthickness;
 	  break;
 	}
       gtk_paint_box (widget->style, widget->window,
@@ -2511,17 +2511,17 @@ gtk_notebook_set_shape (GtkNotebook *notebook)
 	    {
 	    case GTK_POS_TOP:
 	      y += page->allocation.height +
-		widget->style->klass->ythickness;
+		widget->style->ythickness;
 	    case GTK_POS_BOTTOM:
 	      height -= page->allocation.height +
-		widget->style->klass->ythickness;
+		widget->style->ythickness;
 	      break;
 	    case GTK_POS_LEFT:
 	      x += page->allocation.width +
-		widget->style->klass->xthickness;
+		widget->style->xthickness;
 	    case GTK_POS_RIGHT:
 	      width -= page->allocation.width +
-		widget->style->klass->xthickness;
+		widget->style->xthickness;
 	      break;
 	    }
 	}
@@ -2536,11 +2536,11 @@ gtk_notebook_set_shape (GtkNotebook *notebook)
 	    {
 	      if (notebook->tab_pos == GTK_POS_LEFT)
 		{
-		  x -= widget->style->klass->xthickness * 2;
-		  width += widget->style->klass->xthickness * 2;
+		  x -= widget->style->xthickness * 2;
+		  width += widget->style->xthickness * 2;
 		}
 	      else if (notebook->tab_pos == GTK_POS_RIGHT)
-		width += widget->style->klass->xthickness * 2;
+		width += widget->style->xthickness * 2;
 	    }
 	  switch (notebook->tab_pos)
 	    {
@@ -3061,8 +3061,8 @@ gtk_notebook_page_allocate (GtkNotebook     *notebook,
 
   widget = GTK_WIDGET (notebook);
 
-  xthickness = widget->style->klass->xthickness;
-  ythickness = widget->style->klass->ythickness;
+  xthickness = widget->style->xthickness;
+  ythickness = widget->style->ythickness;
 
   /* If the size of the notebook tabs change, we need to queue
    * a redraw on the tab area
diff --git a/gtk/gtkoptionmenu.c b/gtk/gtkoptionmenu.c
index f5cff3bf4d..7bb65919a5 100644
--- a/gtk/gtkoptionmenu.c
+++ b/gtk/gtkoptionmenu.c
@@ -296,13 +296,13 @@ gtk_option_menu_size_request (GtkWidget      *widget,
   option_menu = GTK_OPTION_MENU (widget);
 
   requisition->width = ((GTK_CONTAINER (widget)->border_width +
-			 GTK_WIDGET (widget)->style->klass->xthickness) * 2 +
+			 GTK_WIDGET (widget)->style->xthickness) * 2 +
 			option_menu->width +
 			OPTION_INDICATOR_WIDTH +
 			OPTION_INDICATOR_SPACING * 5 +
 			CHILD_LEFT_SPACING + CHILD_RIGHT_SPACING + 2);
   requisition->height = ((GTK_CONTAINER (widget)->border_width +
-			  GTK_WIDGET (widget)->style->klass->ythickness) * 2 +
+			  GTK_WIDGET (widget)->style->ythickness) * 2 +
 			 option_menu->height +
 			 CHILD_TOP_SPACING + CHILD_BOTTOM_SPACING + 2);
 
@@ -332,9 +332,9 @@ gtk_option_menu_size_allocate (GtkWidget     *widget,
   if (child && GTK_WIDGET_VISIBLE (child))
     {
       child_allocation.x = (GTK_CONTAINER (widget)->border_width +
-			    GTK_WIDGET (widget)->style->klass->xthickness) + 1;
+			    GTK_WIDGET (widget)->style->xthickness) + 1;
       child_allocation.y = (GTK_CONTAINER (widget)->border_width +
-			    GTK_WIDGET (widget)->style->klass->ythickness) + 1;
+			    GTK_WIDGET (widget)->style->ythickness) + 1;
       child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2 -
 				    OPTION_INDICATOR_WIDTH - OPTION_INDICATOR_SPACING * 5 -
 				    CHILD_LEFT_SPACING - CHILD_RIGHT_SPACING - 2);
diff --git a/gtk/gtkplug.c b/gtk/gtkplug.c
index ae6397e51a..000cf6b94f 100644
--- a/gtk/gtkplug.c
+++ b/gtk/gtkplug.c
@@ -212,7 +212,7 @@ gtk_plug_realize (GtkWidget *widget)
       widget->window = gdk_window_new (NULL, &attributes, attributes_mask);
     }
   
-  GDK_DRAWABLE_TYPE (window) = GDK_WINDOW_TOPLEVEL;
+  GDK_WINDOW_TYPE (window) = GDK_WINDOW_TOPLEVEL;
   gdk_window_set_user_data (widget->window, window);
 
   widget->style = gtk_style_attach (widget->style, widget->window);
diff --git a/gtk/gtkprogressbar.c b/gtk/gtkprogressbar.c
index 5fc2971377..a6cdade7d0 100644
--- a/gtk/gtkprogressbar.c
+++ b/gtk/gtkprogressbar.c
@@ -279,19 +279,19 @@ gtk_progress_bar_real_update (GtkProgress *progress)
 		  pbar->activity_pos += pbar->activity_step;
 		  if (pbar->activity_pos + size >=
 		      widget->allocation.width -
-		      widget->style->klass->xthickness)
+		      widget->style->xthickness)
 		    {
 		      pbar->activity_pos = widget->allocation.width -
-			widget->style->klass->xthickness - size;
+			widget->style->xthickness - size;
 		      pbar->activity_dir = 1;
 		    }
 		}
 	      else
 		{
 		  pbar->activity_pos -= pbar->activity_step;
-		  if (pbar->activity_pos <= widget->style->klass->xthickness)
+		  if (pbar->activity_pos <= widget->style->xthickness)
 		    {
-		      pbar->activity_pos = widget->style->klass->xthickness;
+		      pbar->activity_pos = widget->style->xthickness;
 		      pbar->activity_dir = 0;
 		    }
 		}
@@ -305,19 +305,19 @@ gtk_progress_bar_real_update (GtkProgress *progress)
 		  pbar->activity_pos += pbar->activity_step;
 		  if (pbar->activity_pos + size >=
 		      widget->allocation.height -
-		      widget->style->klass->ythickness)
+		      widget->style->ythickness)
 		    {
 		      pbar->activity_pos = widget->allocation.height -
-			widget->style->klass->ythickness - size;
+			widget->style->ythickness - size;
 		      pbar->activity_dir = 1;
 		    }
 		}
 	      else
 		{
 		  pbar->activity_pos -= pbar->activity_step;
-		  if (pbar->activity_pos <= widget->style->klass->ythickness)
+		  if (pbar->activity_pos <= widget->style->ythickness)
 		    {
-		      pbar->activity_pos = widget->style->klass->ythickness;
+		      pbar->activity_pos = widget->style->ythickness;
 		      pbar->activity_dir = 0;
 		    }
 		}
@@ -367,7 +367,7 @@ gtk_progress_bar_size_request (GtkWidget      *widget,
       pango_layout_set_text (layout, buf, -1);
       pango_layout_get_extents (layout, NULL, &logical_rect);
 	  
-      pango_layout_unref (layout);
+      g_object_unref (G_OBJECT (layout));
       g_free (buf);
     }
   
@@ -377,11 +377,11 @@ gtk_progress_bar_size_request (GtkWidget      *widget,
       if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
 	{
 	  requisition->width = MAX (MIN_HORIZONTAL_BAR_WIDTH,
-				    2 * widget->style->klass->xthickness + 3 +
+				    2 * widget->style->xthickness + 3 +
 				    logical_rect.width / PANGO_SCALE + 2 * TEXT_SPACING);
 
 	  requisition->height = MAX (MIN_HORIZONTAL_BAR_HEIGHT,
-				     2 * widget->style->klass->ythickness + 3 +
+				     2 * widget->style->ythickness + 3 +
 				     logical_rect.height / PANGO_SCALE + 2 * TEXT_SPACING);
 	}
       else
@@ -395,11 +395,11 @@ gtk_progress_bar_size_request (GtkWidget      *widget,
       if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
 	{	  
 	  requisition->width = MAX (MIN_VERTICAL_BAR_WIDTH,
-				    2 * widget->style->klass->xthickness + 3 +
+				    2 * widget->style->xthickness + 3 +
 				    logical_rect.width / PANGO_SCALE + 2 * TEXT_SPACING);
 
 	  requisition->height = MAX (MIN_VERTICAL_BAR_HEIGHT,
-				     2 * widget->style->klass->ythickness + 3 +
+				     2 * widget->style->ythickness + 3 +
 				     logical_rect.height / PANGO_SCALE + 2 * TEXT_SPACING);
 	}
       else
@@ -429,14 +429,14 @@ gtk_progress_bar_act_mode_enter (GtkProgress *progress)
 
       if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT)
 	{
-	  pbar->activity_pos = widget->style->klass->xthickness;
+	  pbar->activity_pos = widget->style->xthickness;
 	  pbar->activity_dir = 0;
 	}
       else
 	{
 	  pbar->activity_pos = widget->allocation.width - 
-	    widget->style->klass->xthickness - (widget->allocation.height - 
-		widget->style->klass->ythickness * 2);
+	    widget->style->xthickness - (widget->allocation.height - 
+		widget->style->ythickness * 2);
 	  pbar->activity_dir = 1;
 	}
     }
@@ -446,14 +446,14 @@ gtk_progress_bar_act_mode_enter (GtkProgress *progress)
 
       if (pbar->orientation == GTK_PROGRESS_TOP_TO_BOTTOM)
 	{
-	  pbar->activity_pos = widget->style->klass->ythickness;
+	  pbar->activity_pos = widget->style->ythickness;
 	  pbar->activity_dir = 0;
 	}
       else
 	{
 	  pbar->activity_pos = widget->allocation.height -
-	    widget->style->klass->ythickness - (widget->allocation.width - 
-		widget->style->klass->xthickness * 2);
+	    widget->style->ythickness - (widget->allocation.width - 
+		widget->style->xthickness * 2);
 	  pbar->activity_dir = 1;
 	}
     }
@@ -482,10 +482,10 @@ gtk_progress_bar_paint (GtkProgress *progress)
   if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
       pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
     space = widget->allocation.width -
-      2 * widget->style->klass->xthickness;
+      2 * widget->style->xthickness;
   else
     space = widget->allocation.height -
-      2 * widget->style->klass->ythickness;
+      2 * widget->style->ythickness;
 
   percentage = gtk_progress_get_current_percentage (progress);
 
@@ -511,9 +511,9 @@ gtk_progress_bar_paint (GtkProgress *progress)
 			     GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
 			     NULL, widget, "bar",
 			     pbar->activity_pos,
-			     widget->style->klass->ythickness,
+			     widget->style->ythickness,
 			     size,
-			     widget->allocation.height - widget->style->klass->ythickness * 2);
+			     widget->allocation.height - widget->style->ythickness * 2);
 	      return;
 	    }
 	  else
@@ -524,9 +524,9 @@ gtk_progress_bar_paint (GtkProgress *progress)
 			     progress->offscreen_pixmap,
 			     GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
 			     NULL, widget, "bar",
-			     widget->style->klass->xthickness,
+			     widget->style->xthickness,
 			     pbar->activity_pos,
-			     widget->allocation.width - widget->style->klass->xthickness * 2,
+			     widget->allocation.width - widget->style->xthickness * 2,
 			     size);
 	      return;
 	    }
@@ -547,14 +547,14 @@ gtk_progress_bar_paint (GtkProgress *progress)
 				 progress->offscreen_pixmap,
 				 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
 				 NULL, widget, "bar",
-				 widget->style->klass->xthickness,
-				 widget->style->klass->ythickness,
+				 widget->style->xthickness,
+				 widget->style->ythickness,
 				 amount,
-				 widget->allocation.height - widget->style->klass->ythickness * 2);
+				 widget->allocation.height - widget->style->ythickness * 2);
 		}
 	      else
 		{
-		  x = widget->style->klass->xthickness;
+		  x = widget->style->xthickness;
 		  
 		  for (i = 0; i <= pbar->in_block; i++)
 		    {
@@ -566,9 +566,9 @@ gtk_progress_bar_paint (GtkProgress *progress)
 				     GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
 				     NULL, widget, "bar",
 				     x,
-				     widget->style->klass->ythickness,
+				     widget->style->ythickness,
 				     block_delta,
-				     widget->allocation.height - widget->style->klass->ythickness * 2);
+				     widget->allocation.height - widget->style->ythickness * 2);
 		      
 		      x +=  block_delta;
 		    }
@@ -584,16 +584,16 @@ gtk_progress_bar_paint (GtkProgress *progress)
 				 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
 				 NULL, widget, "bar",
 				 widget->allocation.width - 
-				 widget->style->klass->xthickness - amount,
-				 widget->style->klass->ythickness,
+				 widget->style->xthickness - amount,
+				 widget->style->ythickness,
 				 amount,
 				 widget->allocation.height -
-				 widget->style->klass->ythickness * 2);
+				 widget->style->ythickness * 2);
 		}
 	      else
 		{
 		  x = widget->allocation.width - 
-		    widget->style->klass->xthickness;
+		    widget->style->xthickness;
 		  
 		  for (i = 0; i <= pbar->in_block; i++)
 		    {
@@ -607,10 +607,10 @@ gtk_progress_bar_paint (GtkProgress *progress)
 				     GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
 				     NULL, widget, "bar",
 				     x,
-				     widget->style->klass->ythickness,
+				     widget->style->ythickness,
 				     block_delta,
 				     widget->allocation.height -
-				     widget->style->klass->ythickness * 2);
+				     widget->style->ythickness * 2);
 		    }
 		}
 	      break;
@@ -623,17 +623,17 @@ gtk_progress_bar_paint (GtkProgress *progress)
 				 progress->offscreen_pixmap,
 				 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
 				 NULL, widget, "bar",
-				 widget->style->klass->xthickness,
+				 widget->style->xthickness,
 				 widget->allocation.height - 
-				 widget->style->klass->ythickness - amount,
+				 widget->style->ythickness - amount,
 				 widget->allocation.width -
-				 widget->style->klass->xthickness * 2,
+				 widget->style->xthickness * 2,
 				 amount);
 		}
 	      else
 		{
 		  y = widget->allocation.height - 
-		    widget->style->klass->ythickness;
+		    widget->style->ythickness;
 		  
 		  for (i = 0; i <= pbar->in_block; i++)
 		    {
@@ -646,10 +646,10 @@ gtk_progress_bar_paint (GtkProgress *progress)
 				     progress->offscreen_pixmap,
 				     GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
 				     NULL, widget, "bar",
-				     widget->style->klass->xthickness,
+				     widget->style->xthickness,
 				     y,
 				     widget->allocation.width - 
-				     widget->style->klass->xthickness * 2,
+				     widget->style->xthickness * 2,
 				     block_delta);
 		    }
 		}
@@ -663,15 +663,15 @@ gtk_progress_bar_paint (GtkProgress *progress)
 				 progress->offscreen_pixmap,
 				 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
 				 NULL, widget, "bar",
-				 widget->style->klass->xthickness,
-				 widget->style->klass->ythickness,
+				 widget->style->xthickness,
+				 widget->style->ythickness,
 				 widget->allocation.width -
-				 widget->style->klass->xthickness * 2,
+				 widget->style->xthickness * 2,
 				 amount);
 		}
 	      else
 		{
-		  y = widget->style->klass->ythickness;
+		  y = widget->style->ythickness;
 		  
 		  for (i = 0; i <= pbar->in_block; i++)
 		    {
@@ -683,10 +683,10 @@ gtk_progress_bar_paint (GtkProgress *progress)
 				     progress->offscreen_pixmap,
 				     GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
 				     NULL, widget, "bar",
-				     widget->style->klass->xthickness,
+				     widget->style->xthickness,
 				     y,
 				     widget->allocation.width -
-				     widget->style->klass->xthickness * 2,
+				     widget->style->xthickness * 2,
 				     block_delta);
 		      
 		      y += block_delta;
@@ -714,22 +714,22 @@ gtk_progress_bar_paint (GtkProgress *progress)
 	  pango_layout_set_text (layout, buf, -1);
 	  pango_layout_get_extents (layout, NULL, &logical_rect);
 	  
-	  x = widget->style->klass->xthickness + 1 + 
-	    (widget->allocation.width - 2 * widget->style->klass->xthickness -
+	  x = widget->style->xthickness + 1 + 
+	    (widget->allocation.width - 2 * widget->style->xthickness -
 	     3 - logical_rect.width / PANGO_SCALE)
 	    * progress->x_align; 
 
-	  y = widget->style->klass->ythickness + 1 +
-	    (widget->allocation.height - 2 * widget->style->klass->ythickness -
+	  y = widget->style->ythickness + 1 +
+	    (widget->allocation.height - 2 * widget->style->ythickness -
 	     3 - logical_rect.height / PANGO_SCALE)
 	    * progress->y_align;
 
-	  rect.x = widget->style->klass->xthickness + 1;
-	  rect.y = widget->style->klass->ythickness + 1;
+	  rect.x = widget->style->xthickness + 1;
+	  rect.y = widget->style->ythickness + 1;
 	  rect.width = widget->allocation.width -
-	    2 * widget->style->klass->xthickness - 3;
+	    2 * widget->style->xthickness - 3;
 	  rect.height = widget->allocation.height -
-	    2 * widget->style->klass->ythickness - 3;
+	    2 * widget->style->ythickness - 3;
 
 	  gdk_gc_set_clip_rectangle (widget->style->fg_gc[widget->state],
 				     &rect);
@@ -740,7 +740,7 @@ gtk_progress_bar_paint (GtkProgress *progress)
 
 	  gdk_gc_set_clip_rectangle (widget->style->fg_gc[widget->state],
 				     NULL);
-	  pango_layout_unref (layout);
+          g_object_unref (G_OBJECT (layout));
 	  g_free (buf);
  	}
     }
diff --git a/gtk/gtkradiomenuitem.c b/gtk/gtkradiomenuitem.c
index 4d61ead40a..ed49696ab5 100644
--- a/gtk/gtkradiomenuitem.c
+++ b/gtk/gtkradiomenuitem.c
@@ -284,7 +284,7 @@ gtk_radio_menu_item_draw_indicator (GtkCheckMenuItem *check_menu_item,
       width = 8;
       height = 8;
       x = (GTK_CONTAINER (check_menu_item)->border_width +
-	   widget->style->klass->xthickness + 2);
+	   widget->style->xthickness + 2);
       y = (widget->allocation.height - height) / 2;
 
       if (check_menu_item->active ||
diff --git a/gtk/gtkrange.c b/gtk/gtkrange.c
index 42a59fe160..bd3521634c 100644
--- a/gtk/gtkrange.c
+++ b/gtk/gtkrange.c
@@ -427,7 +427,7 @@ gtk_range_default_hslider_update (GtkRange *range)
       else if (x > right)
 	x = right;
 
-      gdk_window_move (range->slider, x, GTK_WIDGET (range)->style->klass->ythickness);
+      gdk_window_move (range->slider, x, GTK_WIDGET (range)->style->ythickness);
     }
 }
 
@@ -466,7 +466,7 @@ gtk_range_default_vslider_update (GtkRange *range)
       else if (y > bottom)
 	y = bottom;
 
-      gdk_window_move (range->slider, GTK_WIDGET (range)->style->klass->xthickness, y);
+      gdk_window_move (range->slider, GTK_WIDGET (range)->style->xthickness, y);
     }
 }
 
@@ -486,7 +486,7 @@ gtk_range_default_htrough_click (GtkRange *range,
   g_return_val_if_fail (range != NULL, GTK_TROUGH_NONE);
   g_return_val_if_fail (GTK_IS_RANGE (range), GTK_TROUGH_NONE);
 
-  ythickness = GTK_WIDGET (range)->style->klass->ythickness;
+  ythickness = GTK_WIDGET (range)->style->ythickness;
 
   gtk_range_trough_hdims (range, &left, &right);
   gdk_window_get_size (range->slider, &slider_length, NULL);
@@ -532,7 +532,7 @@ gtk_range_default_vtrough_click (GtkRange *range,
   g_return_val_if_fail (range != NULL, GTK_TROUGH_NONE);
   g_return_val_if_fail (GTK_IS_RANGE (range), GTK_TROUGH_NONE);
 
-  xthickness = GTK_WIDGET (range)->style->klass->xthickness;
+  xthickness = GTK_WIDGET (range)->style->xthickness;
 
   gtk_range_trough_vdims (range, &top, &bottom);
   gdk_window_get_size (range->slider, NULL, &slider_length);
@@ -1486,8 +1486,8 @@ gtk_range_trough_hdims (GtkRange *range,
   gdk_window_get_size (range->trough, &trough_width, NULL);
   gdk_window_get_size (range->slider, &slider_length, NULL);
 
-  tleft = GTK_WIDGET (range)->style->klass->xthickness;
-  tright = trough_width - slider_length - GTK_WIDGET (range)->style->klass->xthickness;
+  tleft = GTK_WIDGET (range)->style->xthickness;
+  tright = trough_width - slider_length - GTK_WIDGET (range)->style->xthickness;
 
   if (range->step_back)
     {
@@ -1523,8 +1523,8 @@ gtk_range_trough_vdims (GtkRange *range,
   gdk_window_get_size (range->trough, NULL, &trough_height);
   gdk_window_get_size (range->slider, NULL, &slider_length);
 
-  ttop = GTK_WIDGET (range)->style->klass->ythickness;
-  tbottom = trough_height - slider_length - GTK_WIDGET (range)->style->klass->ythickness;
+  ttop = GTK_WIDGET (range)->style->ythickness;
+  tbottom = trough_height - slider_length - GTK_WIDGET (range)->style->ythickness;
 
   if (range->step_back)
     {
diff --git a/gtk/gtkrc.c b/gtk/gtkrc.c
index 84b7b1d675..f8b8e3870c 100644
--- a/gtk/gtkrc.c
+++ b/gtk/gtkrc.c
@@ -64,7 +64,6 @@
 typedef struct _GtkRcSet    GtkRcSet;
 typedef struct _GtkRcNode   GtkRcNode;
 typedef struct _GtkRcFile   GtkRcFile;
-typedef struct _GtkRcStylePrivate  GtkRcStylePrivate;
 
 struct _GtkRcSet
 {
@@ -80,68 +79,63 @@ struct _GtkRcFile
   gboolean reload;
 };
 
-struct _GtkRcStylePrivate
-{
-  GtkRcStyle style;
-
-  guint ref_count;
-  /* list of RC style lists including this RC style */
-  GSList *rc_style_lists;
-};
-
-static guint	   gtk_rc_style_hash		   (const char   *name);
-static gint	   gtk_rc_style_compare		   (const char   *a,
-						    const char   *b);
-static guint	   gtk_rc_styles_hash		   (const GSList *rc_styles);
-static gint	   gtk_rc_styles_compare	   (const GSList *a,
-						    const GSList *b);
-static GtkRcStyle* gtk_rc_style_find		   (const char   *name);
-static GSList *    gtk_rc_styles_match             (GSList       *rc_styles,
-						    GSList       *sets,
-						    guint         path_length,
-						    gchar        *path,
-						    gchar        *path_reversed);
-static GtkStyle *  gtk_rc_style_to_style           (GtkRcStyle   *rc_style);
-static GtkStyle*   gtk_rc_style_init		   (GSList       *rc_styles);
-static void        gtk_rc_parse_file               (const gchar  *filename,
-						    gboolean      reload);
-
-static void	   gtk_rc_parse_any		   (const gchar  *input_name,
-						    gint	  input_fd,
-						    const gchar  *input_string);
-static guint	   gtk_rc_parse_statement	   (GScanner	 *scanner);
-static guint	   gtk_rc_parse_style		   (GScanner	 *scanner);
-static guint	   gtk_rc_parse_base		   (GScanner	 *scanner,
-						    GtkRcStyle	 *style);
-static guint	   gtk_rc_parse_bg		   (GScanner	 *scanner,
-						    GtkRcStyle	 *style);
-static guint	   gtk_rc_parse_fg		   (GScanner	 *scanner,
-						    GtkRcStyle	 *style);
-static guint	   gtk_rc_parse_text		   (GScanner	 *scanner,
-						    GtkRcStyle	 *style);
-static guint	   gtk_rc_parse_bg_pixmap	   (GScanner	 *scanner,
-						    GtkRcStyle	 *rc_style);
-static guint	   gtk_rc_parse_font		   (GScanner	 *scanner,
-						    GtkRcStyle	 *rc_style);
-static guint	   gtk_rc_parse_fontset		   (GScanner	 *scanner,
-						    GtkRcStyle	 *rc_style);
-static guint	   gtk_rc_parse_font_name	   (GScanner	 *scanner,
-						    GtkRcStyle	 *rc_style);
-static guint	   gtk_rc_parse_engine		   (GScanner	 *scanner,
-						    GtkRcStyle	 *rc_style);
-static guint	   gtk_rc_parse_pixmap_path	   (GScanner	 *scanner);
-static void	   gtk_rc_parse_pixmap_path_string (gchar *pix_path);
-static guint	   gtk_rc_parse_module_path	   (GScanner	 *scanner);
-static void	   gtk_rc_parse_module_path_string (gchar *mod_path);
-static guint	   gtk_rc_parse_path_pattern	   (GScanner     *scanner);
-static void        gtk_rc_clear_hash_node          (gpointer   key, 
-						    gpointer   data, 
-						    gpointer   user_data);
+static guint       gtk_rc_style_hash                 (const char      *name);
+static gint        gtk_rc_style_compare              (const char      *a,
+                                                      const char      *b);
+static guint       gtk_rc_styles_hash                (const GSList    *rc_styles);
+static gint        gtk_rc_styles_compare             (const GSList    *a,
+                                                      const GSList    *b);
+static GtkRcStyle* gtk_rc_style_find                 (const char      *name);
+static GSList *    gtk_rc_styles_match               (GSList          *rc_styles,
+                                                      GSList          *sets,
+                                                      guint            path_length,
+                                                      gchar           *path,
+                                                      gchar           *path_reversed);
+static GtkStyle *  gtk_rc_style_to_style             (GtkRcStyle      *rc_style);
+static GtkStyle*   gtk_rc_init_style                 (GSList          *rc_styles);
+static void        gtk_rc_parse_file                 (const gchar     *filename,
+                                                      gboolean         reload);
+static void        gtk_rc_parse_any                  (const gchar     *input_name,
+                                                      gint             input_fd,
+                                                      const gchar     *input_string);
+static guint       gtk_rc_parse_statement            (GScanner        *scanner);
+static guint       gtk_rc_parse_style                (GScanner        *scanner);
+static guint       gtk_rc_parse_base                 (GScanner        *scanner,
+                                                      GtkRcStyle      *style);
+static guint       gtk_rc_parse_bg                   (GScanner        *scanner,
+                                                      GtkRcStyle      *style);
+static guint       gtk_rc_parse_fg                   (GScanner        *scanner,
+                                                      GtkRcStyle      *style);
+static guint       gtk_rc_parse_text                 (GScanner        *scanner,
+                                                      GtkRcStyle      *style);
+static guint       gtk_rc_parse_bg_pixmap            (GScanner        *scanner,
+                                                      GtkRcStyle      *rc_style);
+static guint       gtk_rc_parse_font                 (GScanner        *scanner,
+                                                      GtkRcStyle      *rc_style);
+static guint       gtk_rc_parse_fontset              (GScanner        *scanner,
+                                                      GtkRcStyle      *rc_style);
+static guint       gtk_rc_parse_font_name            (GScanner        *scanner,
+                                                      GtkRcStyle      *rc_style);
+static guint       gtk_rc_parse_engine               (GScanner        *scanner,
+                                                      GtkRcStyle      *rc_style);
+static guint       gtk_rc_parse_pixmap_path          (GScanner        *scanner);
+static void        gtk_rc_parse_pixmap_path_string   (gchar           *pix_path);
+static guint       gtk_rc_parse_module_path          (GScanner        *scanner);
+static void        gtk_rc_parse_module_path_string   (gchar           *mod_path);
+static guint       gtk_rc_parse_path_pattern         (GScanner        *scanner);
+static void        gtk_rc_clear_hash_node            (gpointer         key,
+                                                      gpointer         data,
+                                                      gpointer         user_data);
 static void        gtk_rc_clear_styles               (void);
 static void        gtk_rc_append_default_pixmap_path (void);
 static void        gtk_rc_append_default_module_path (void);
 static void        gtk_rc_add_initial_default_files  (void);
 
+static void        gtk_rc_style_init                 (GtkRcStyle      *style);
+static void        gtk_rc_style_class_init           (GtkRcStyleClass *klass);
+static void        gtk_rc_style_finalize             (GObject         *object);
+
+static gpointer parent_class = NULL;
 
 static const GScannerConfig	gtk_rc_scanner_config =
 {
@@ -726,23 +720,48 @@ gtk_rc_parse (const gchar *filename)
 
 /* Handling of RC styles */
 
-GtkRcStyle *
-gtk_rc_style_new              (void)
+GType
+gtk_rc_style_get_type (void)
 {
-  GtkRcStylePrivate *new_style;
+  static GType object_type = 0;
 
-  new_style = g_new0 (GtkRcStylePrivate, 1);
-  new_style->ref_count = 1;
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GtkRcStyleClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gtk_rc_style_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GtkRcStyle),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) gtk_rc_style_init,
+      };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "GtkRcStyle",
+                                            &object_info);
+    }
+  
+  return object_type;
+}
 
-  return (GtkRcStyle *)new_style;
+static void
+gtk_rc_style_init (GtkRcStyle *style)
+{
+  
 }
 
-void      
-gtk_rc_style_ref (GtkRcStyle  *rc_style)
+static void
+gtk_rc_style_class_init (GtkRcStyleClass *klass)
 {
-  g_return_if_fail (rc_style != NULL);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  
+  parent_class = g_type_class_peek_parent (klass);
 
-  ((GtkRcStylePrivate *)rc_style)->ref_count++;
+  object_class->finalize = gtk_rc_style_finalize;
 }
 
 /* Like g_slist_remove, but remove all copies of data */
@@ -783,72 +802,91 @@ gtk_rc_slist_remove_all (GSList   *list,
   return list;
 }
 
-void      
-gtk_rc_style_unref (GtkRcStyle  *rc_style)
+static void
+gtk_rc_style_finalize (GObject *object)
 {
-  GtkRcStylePrivate *private = (GtkRcStylePrivate *)rc_style;
   gint i;
+  GSList *tmp_list1, *tmp_list2;
+  GtkRcStyle *rc_style;
 
-  g_return_if_fail (rc_style != NULL);
-  g_return_if_fail (private->ref_count > 0);
-
-  private->ref_count--;
-
-  if (private->ref_count == 0)
+  rc_style = GTK_RC_STYLE (object);
+  
+  if (rc_style->engine)
     {
-      GSList *tmp_list1, *tmp_list2;
-	
-      if (rc_style->engine)
-	{
-	  rc_style->engine->destroy_rc_style (rc_style);
-	  gtk_theme_engine_unref (rc_style->engine);
-	}
+      rc_style->engine->destroy_rc_style (rc_style);
+      gtk_theme_engine_unref (rc_style->engine);
+    }
 
-      if (rc_style->name)
-	g_free (rc_style->name);
-      if (rc_style->font_desc)
-	pango_font_description_free (rc_style->font_desc);
-      
-      for (i=0 ; i<5 ; i++)
-	if (rc_style->bg_pixmap_name[i])
-	  g_free (rc_style->bg_pixmap_name[i]);
+  if (rc_style->name)
+    g_free (rc_style->name);
+  if (rc_style->font_desc)
+    pango_font_description_free (rc_style->font_desc);
       
-      /* Now remove all references to this rc_style from
-       * realized_style_ht
+  for (i=0 ; i<5 ; i++)
+    if (rc_style->bg_pixmap_name[i])
+      g_free (rc_style->bg_pixmap_name[i]);
+  
+  /* Now remove all references to this rc_style from
+   * realized_style_ht
+   */
+  tmp_list1 = rc_style->rc_style_lists;
+  while (tmp_list1)
+    {
+      GSList *rc_styles = tmp_list1->data;
+      GtkStyle *style = g_hash_table_lookup (realized_style_ht, rc_styles);
+      gtk_style_unref (style);
+
+      /* Remove the list of styles from the other rc_styles
+       * in the list
        */
-      tmp_list1 = private->rc_style_lists;
-      while (tmp_list1)
-	{
-	  GSList *rc_styles = tmp_list1->data;
-	  GtkStyle *style = g_hash_table_lookup (realized_style_ht, rc_styles);
-	  gtk_style_unref (style);
+      tmp_list2 = rc_styles;
+      while (tmp_list2)
+        {
+          GtkRcStyle *other_style = tmp_list2->data;
+
+          if (other_style != rc_style)
+            other_style->rc_style_lists =
+              gtk_rc_slist_remove_all (other_style->rc_style_lists, rc_styles);
+		  
+          tmp_list2 = tmp_list2->next;
+        }
 
-	  /* Remove the list of styles from the other rc_styles
-	   * in the list
-	   */
-	  tmp_list2 = rc_styles;
-	  while (tmp_list2)
-	    {
-	      GtkRcStylePrivate *other_style = tmp_list2->data;
+      /* And from the hash table itself
+       */
+      g_hash_table_remove (realized_style_ht, rc_styles);
+      g_slist_free (rc_styles);
 
-	      if (other_style != private)
-		other_style->rc_style_lists =
-		  gtk_rc_slist_remove_all (other_style->rc_style_lists, rc_styles);
-		  
-	      tmp_list2 = tmp_list2->next;
-	    }
+      tmp_list1 = tmp_list1->next;
+    }
+  g_slist_free (rc_style->rc_style_lists);
 
-	  /* And from the hash table itself
-	   */
-	  g_hash_table_remove (realized_style_ht, rc_styles);
-	  g_slist_free (rc_styles);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
 
-	  tmp_list1 = tmp_list1->next;
-	}
-      g_slist_free (private->rc_style_lists);
+GtkRcStyle *
+gtk_rc_style_new              (void)
+{
+  GtkRcStyle *style;
+  
+  style = GTK_RC_STYLE (g_type_create_instance (gtk_rc_style_get_type ()));
+  
+  return style;
+}
 
-      g_free (private);
-    }
+void      
+gtk_rc_style_ref (GtkRcStyle  *rc_style)
+{
+  g_return_if_fail (GTK_IS_RC_STYLE (rc_style));
+
+  g_object_ref (G_OBJECT (rc_style));
+}
+
+void      
+gtk_rc_style_unref (GtkRcStyle  *rc_style)
+{
+  g_return_if_fail (GTK_IS_RC_STYLE (rc_style));
+
+  g_object_unref (G_OBJECT (rc_style));
 }
 
 static void
@@ -1032,7 +1070,7 @@ gtk_rc_get_style (GtkWidget *widget)
     }
   
   if (rc_styles)
-    return gtk_rc_style_init (rc_styles);
+    return gtk_rc_init_style (rc_styles);
 
   return NULL;
 }
@@ -1288,7 +1326,7 @@ gtk_rc_style_to_style (GtkRcStyle *rc_style)
 
 /* Reuses or frees rc_styles */
 static GtkStyle *
-gtk_rc_style_init (GSList *rc_styles)
+gtk_rc_init_style (GSList *rc_styles)
 {
   gint i;
 
@@ -1311,7 +1349,6 @@ gtk_rc_style_init (GSList *rc_styles)
       while (tmp_styles)
 	{
 	  GtkRcStyle *rc_style = tmp_styles->data;
-	  GtkRcStylePrivate *rc_style_private;
 
 	  for (i=0; i<5; i++)
 	    {
@@ -1359,9 +1396,8 @@ gtk_rc_style_init (GSList *rc_styles)
 
 	  /* Point from each rc_style to the list of styles */
 
-	  rc_style_private = (GtkRcStylePrivate *)rc_style;
-	  if (!g_slist_find (rc_style_private->rc_style_lists, rc_styles))
-	    rc_style_private->rc_style_lists = g_slist_prepend (rc_style_private->rc_style_lists, rc_styles);
+	  if (!g_slist_find (rc_style->rc_style_lists, rc_styles))
+	    rc_style->rc_style_lists = g_slist_prepend (rc_style->rc_style_lists, rc_styles);
 
 	  tmp_styles = tmp_styles->next;
 	}
diff --git a/gtk/gtkrc.h b/gtk/gtkrc.h
index 30d623cadd..2991326ca1 100644
--- a/gtk/gtkrc.h
+++ b/gtk/gtkrc.h
@@ -35,6 +35,12 @@
 extern "C" {
 #endif /* __cplusplus */
 
+#define GTK_TYPE_RC_STYLE              (gtk_rc_style_get_type ())
+#define GTK_RC_STYLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_RC_STYLE, GtkRcStyle))
+#define GTK_RC_STYLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RC_STYLE, GtkRcStyleClass))
+#define GTK_IS_RC_STYLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_RC_STYLE))
+#define GTK_IS_RC_STYLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RC_STYLE))
+#define GTK_RC_STYLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RC_STYLE, GtkRcStyleClass))
 
 typedef enum {
   GTK_RC_FG   = 1 << 0,
@@ -43,8 +49,14 @@ typedef enum {
   GTK_RC_BASE = 1 << 3
 } GtkRcFlags;
 
+typedef struct _GtkRcStyleClass GtkRcStyleClass;
+
 struct _GtkRcStyle
 {
+  GObject parent_instance;
+
+  /*< public >*/
+  
   gchar *name;
   gchar *bg_pixmap_name[5];
   PangoFontDescription *font_desc;
@@ -57,6 +69,17 @@ struct _GtkRcStyle
 
   GtkThemeEngine *engine;
   gpointer        engine_data;
+
+  /*< private >*/
+  
+  /* list of RC style lists including this RC style */
+  GSList *rc_style_lists;
+};
+
+struct _GtkRcStyleClass
+{
+  GObjectClass parent_class;
+
 };
 
 void	  gtk_rc_init			(void);
@@ -74,6 +97,7 @@ void	  gtk_rc_add_widget_class_style (GtkRcStyle  *rc_style,
 void	  gtk_rc_add_class_style	(GtkRcStyle  *rc_style,
 					 const gchar *pattern);
 
+GType       gtk_rc_style_get_type         (void);
 GtkRcStyle* gtk_rc_style_new              (void);
 void        gtk_rc_style_ref              (GtkRcStyle  *rc_style);
 void        gtk_rc_style_unref            (GtkRcStyle  *rc_style);
diff --git a/gtk/gtkscale.c b/gtk/gtkscale.c
index e1099d1ca3..dd23790bd3 100644
--- a/gtk/gtkscale.c
+++ b/gtk/gtkscale.c
@@ -332,7 +332,7 @@ gtk_scale_get_value_size (GtkScale *scale,
       if (height)
 	*height = MAX (*height, logical_rect.height / PANGO_SCALE);
 
-      pango_layout_unref (layout);
+      g_object_unref (G_OBJECT (layout));
     }
   else
     {
diff --git a/gtk/gtksocket.c b/gtk/gtksocket.c
index 28ffe4dce5..91bd47ec1e 100644
--- a/gtk/gtksocket.c
+++ b/gtk/gtksocket.c
@@ -150,14 +150,19 @@ void
 gtk_socket_steal (GtkSocket *socket, GdkNativeWindow id)
 {
   GtkWidget *widget;
-
+  gpointer user_data = NULL;
+  
   widget = GTK_WIDGET (socket);
   
   socket->plug_window = gdk_window_lookup (id);
 
   gdk_error_trap_push ();
+
+  if (socket->plug_window)
+    gdk_window_get_user_data (socket->plug_window,
+                              &user_data);
   
-  if (socket->plug_window && socket->plug_window->user_data)
+  if (user_data)      
     {
       /*
 	GtkWidget *child_widget;
diff --git a/gtk/gtkspinbutton.c b/gtk/gtkspinbutton.c
index 3af3a22d71..5bb44643ca 100644
--- a/gtk/gtkspinbutton.c
+++ b/gtk/gtkspinbutton.c
@@ -427,7 +427,7 @@ gtk_spin_button_realize (GtkWidget *widget)
   spin_button = GTK_SPIN_BUTTON (widget);
 
   real_width = widget->allocation.width;
-  widget->allocation.width -= ARROW_SIZE + 2 * widget->style->klass->xthickness;
+  widget->allocation.width -= ARROW_SIZE + 2 * widget->style->xthickness;
   gtk_widget_set_events (widget, gtk_widget_get_events (widget) |
 			 GDK_KEY_RELEASE_MASK);
   GTK_WIDGET_CLASS (parent_class)->realize (widget);
@@ -446,10 +446,10 @@ gtk_spin_button_realize (GtkWidget *widget)
   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 
   attributes.x = (widget->allocation.x + widget->allocation.width - ARROW_SIZE -
-		  2 * widget->style->klass->xthickness);
+		  2 * widget->style->xthickness);
   attributes.y = widget->allocation.y + (widget->allocation.height -
 					 widget->requisition.height) / 2;
-  attributes.width = ARROW_SIZE + 2 * widget->style->klass->xthickness;
+  attributes.width = ARROW_SIZE + 2 * widget->style->xthickness;
   attributes.height = widget->requisition.height;
   
   spin_button->panel = gdk_window_new (gtk_widget_get_parent_window (widget), 
@@ -496,7 +496,7 @@ gtk_spin_button_size_request (GtkWidget      *widget,
   GTK_WIDGET_CLASS (parent_class)->size_request (widget, requisition);
   
   requisition->width = MIN_SPIN_BUTTON_WIDTH + ARROW_SIZE 
-    + 2 * widget->style->klass->xthickness;
+    + 2 * widget->style->xthickness;
 }
 
 static void
@@ -510,11 +510,11 @@ gtk_spin_button_size_allocate (GtkWidget     *widget,
   g_return_if_fail (allocation != NULL);
 
   child_allocation = *allocation;
-  if (child_allocation.width > ARROW_SIZE + 2 * widget->style->klass->xthickness)
-    child_allocation.width -= ARROW_SIZE + 2 * widget->style->klass->xthickness;
+  if (child_allocation.width > ARROW_SIZE + 2 * widget->style->xthickness)
+    child_allocation.width -= ARROW_SIZE + 2 * widget->style->xthickness;
 
   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
-    child_allocation.x += ARROW_SIZE + 2 * widget->style->klass->xthickness;
+    child_allocation.x += ARROW_SIZE + 2 * widget->style->xthickness;
 
   GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, &child_allocation);
 
@@ -522,15 +522,15 @@ gtk_spin_button_size_allocate (GtkWidget     *widget,
 
   if (GTK_WIDGET_REALIZED (widget))
     {
-      child_allocation.width = ARROW_SIZE + 2 * widget->style->klass->xthickness;
+      child_allocation.width = ARROW_SIZE + 2 * widget->style->xthickness;
       child_allocation.height = widget->requisition.height;
 
       if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
 	child_allocation.x = (allocation->x + allocation->width - ARROW_SIZE - 
-			      2 * widget->style->klass->xthickness);
+			      2 * widget->style->xthickness);
       else
-	child_allocation.x = allocation->x;
-      
+	child_allocation.x = allocation->x;      
+
       child_allocation.y = allocation->y + (allocation->height - widget->requisition.height) / 2;
 
       gdk_window_move_resize (GTK_SPIN_BUTTON (widget)->panel, 
@@ -559,7 +559,7 @@ gtk_spin_button_paint (GtkWidget    *widget,
 		       GTK_STATE_NORMAL, spin->shadow_type,
 		       area, widget, "spinbutton",
 		       0, 0, 
-		       ARROW_SIZE + 2 * widget->style->klass->xthickness,
+		       ARROW_SIZE + 2 * widget->style->xthickness,
 		       widget->requisition.height); 
       else
 	 {
@@ -648,31 +648,31 @@ gtk_spin_button_draw_arrow (GtkSpinButton *spin_button,
 	{
 	  if (spin_button->shadow_type != GTK_SHADOW_NONE)
 	    {
-	      x = widget->style->klass->xthickness;
-	      y = widget->style->klass->ythickness;
+	      x = widget->style->xthickness;
+	      y = widget->style->ythickness;
 	    }
 	  else
 	    {
-	      x = widget->style->klass->xthickness - 1;
-	      y = widget->style->klass->ythickness - 1;
+	      x = widget->style->xthickness - 1;
+	      y = widget->style->ythickness - 1;
 	    }
 	  gtk_paint_arrow (widget->style, spin_button->panel,
 			   state_type, shadow_type, 
 			   NULL, widget, "spinbutton",
 			   arrow, TRUE, 
 			   x, y, ARROW_SIZE, widget->requisition.height / 2 
-			   - widget->style->klass->ythickness);
+			   - widget->style->ythickness);
 	}
       else
 	{
 	  if (spin_button->shadow_type != GTK_SHADOW_NONE)
 	    {
-	      x = widget->style->klass->xthickness;
+	      x = widget->style->xthickness;
 	      y = widget->requisition.height / 2;
 	    }
 	  else
 	    {
-	      x = widget->style->klass->xthickness - 1;
+	      x = widget->style->xthickness - 1;
 	      y = widget->requisition.height / 2 + 1;
 	    }
 	  gtk_paint_arrow (widget->style, spin_button->panel,
@@ -680,7 +680,7 @@ gtk_spin_button_draw_arrow (GtkSpinButton *spin_button,
 			   NULL, widget, "spinbutton",
 			   arrow, TRUE, 
 			   x, y, ARROW_SIZE, widget->requisition.height / 2 
-			   - widget->style->klass->ythickness);
+			   - widget->style->ythickness);
 	}
     }
 }
@@ -913,7 +913,7 @@ gtk_spin_button_button_release (GtkWidget      *widget,
 	{
 	  if (event->y >= 0 && event->x >= 0 && 
 	      event->y <= widget->requisition.height &&
-	      event->x <= ARROW_SIZE + 2 * widget->style->klass->xthickness)
+	      event->x <= ARROW_SIZE + 2 * widget->style->xthickness)
 	    {
 	      if (spin->click_child == GTK_ARROW_UP &&
 		  event->y <= widget->requisition.height / 2)
diff --git a/gtk/gtkstyle.c b/gtk/gtkstyle.c
index d2fb0f7150..e30acffd77 100644
--- a/gtk/gtkstyle.c
+++ b/gtk/gtkstyle.c
@@ -44,10 +44,9 @@
 #define M_PI_4  0.78539816339744830962
 #endif /* M_PI_4 */
 
-static void         gtk_style_init         (GtkStyle    *style,
-                                            GdkColormap *colormap,
-                                            gint         depth);
-static void         gtk_style_destroy      (GtkStyle    *style);
+static void         gtk_style_realize (GtkStyle    *style,
+                                       GdkColormap *colormap,
+                                       gint         depth);
 
 static void gtk_default_draw_hline      (GtkStyle        *style,
 					 GdkWindow       *window,
@@ -299,33 +298,6 @@ static void gtk_style_shade (GdkColor *a, GdkColor *b, gdouble k);
 static void rgb_to_hls (gdouble *r, gdouble *g, gdouble *b);
 static void hls_to_rgb (gdouble *h, gdouble *l, gdouble *s);
 
-
-static const GtkStyleClass default_class =
-{
-  2,
-  2,
-  gtk_default_draw_hline,
-  gtk_default_draw_vline,
-  gtk_default_draw_shadow,
-  gtk_default_draw_polygon,
-  gtk_default_draw_arrow,
-  gtk_default_draw_diamond,
-  gtk_default_draw_oval,
-  gtk_default_draw_string,
-  gtk_default_draw_box,
-  gtk_default_draw_flat_box,
-  gtk_default_draw_check,
-  gtk_default_draw_option,
-  gtk_default_draw_cross,
-  gtk_default_draw_ramp,
-  gtk_default_draw_tab,
-  gtk_default_draw_shadow_gap,
-  gtk_default_draw_box_gap,
-  gtk_default_draw_extension,
-  gtk_default_draw_focus,
-  gtk_default_draw_slider,
-  gtk_default_draw_handle
-};
 GdkFont *default_font = NULL;
 
 static GdkColor gtk_default_normal_fg =      { 0,      0,      0,      0 };
@@ -340,69 +312,45 @@ static GdkColor gtk_default_prelight_bg =    { 0, 0xea60, 0xea60, 0xea60 };
 static GdkColor gtk_default_selected_bg =    { 0,      0,      0, 0x9c40 };
 static GdkColor gtk_default_insensitive_bg = { 0, 0xd6d6, 0xd6d6, 0xd6d6 };
 
-GtkStyle*
-gtk_style_copy (GtkStyle *style)
+static gpointer parent_class = NULL;
+
+static void gtk_style_init       (GtkStyle      *style);
+static void gtk_style_class_init (GtkStyleClass *klass);
+static void gtk_style_finalize   (GObject       *object);
+
+GType
+gtk_style_get_type (void)
 {
-  GtkStyle *new_style;
-  guint i;
-  
-  g_return_val_if_fail (style != NULL, NULL);
-  
-  new_style = gtk_style_new ();
-  
-  for (i = 0; i < 5; i++)
-    {
-      new_style->fg[i] = style->fg[i];
-      new_style->bg[i] = style->bg[i];
-      new_style->text[i] = style->text[i];
-      new_style->base[i] = style->base[i];
-      
-      new_style->bg_pixmap[i] = style->bg_pixmap[i];
-    }
-  
-  gdk_font_unref (new_style->font);
-  new_style->font = style->font;
-  gdk_font_ref (new_style->font);
+  static GType object_type = 0;
 
-  if (style->rc_style)
+  if (!object_type)
     {
-      new_style->rc_style = style->rc_style;
-      gtk_rc_style_ref (style->rc_style);
+      static const GTypeInfo object_info =
+      {
+        sizeof (GtkStyleClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gtk_style_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GtkStyle),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) gtk_style_init,
+      };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "GtkStyle",
+                                            &object_info);
     }
   
-  if (style->engine)
-    {
-      new_style->engine = style->engine;
-      gtk_theme_engine_ref (new_style->engine);
-      new_style->engine->duplicate_style (new_style, style);
-    }
-
-  return new_style;
+  return object_type;
 }
 
-static GtkStyle*
-gtk_style_duplicate (GtkStyle *style)
-{
-  GtkStyle *new_style;
-  
-  g_return_val_if_fail (style != NULL, NULL);
-  
-  new_style = gtk_style_copy (style);
-  
-  style->styles = g_slist_append (style->styles, new_style);
-  new_style->styles = style->styles;  
-  
-  return new_style;
-}
-
-GtkStyle*
-gtk_style_new (void)
+static void
+gtk_style_init (GtkStyle *style)
 {
-  GtkStyle *style;
   gint i;
   
-  style = g_new0 (GtkStyle, 1);
-  
   style->font_desc = pango_font_description_from_string ("Sans 10");
 
   if (!default_font)
@@ -416,11 +364,9 @@ gtk_style_new (void)
   style->font = default_font;
   gdk_font_ref (style->font);
 
-  style->ref_count = 1;
   style->attach_count = 0;
   style->colormap = NULL;
   style->depth = -1;
-  style->klass = (GtkStyleClass *)&default_class;
   
   style->black.red = 0;
   style->black.green = 0;
@@ -472,6 +418,147 @@ gtk_style_new (void)
       style->text_gc[i] = NULL;
       style->base_gc[i] = NULL;
     }
+
+  style->xthickness = 2;
+  style->ythickness = 2;
+}
+
+static void
+gtk_style_class_init (GtkStyleClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->finalize = gtk_style_finalize;
+
+  klass->draw_hline = gtk_default_draw_hline;
+  klass->draw_vline = gtk_default_draw_vline;
+  klass->draw_shadow = gtk_default_draw_shadow;
+  klass->draw_polygon = gtk_default_draw_polygon;
+  klass->draw_arrow = gtk_default_draw_arrow;
+  klass->draw_diamond = gtk_default_draw_diamond;
+  klass->draw_oval = gtk_default_draw_oval;
+  klass->draw_string = gtk_default_draw_string;
+  klass->draw_box = gtk_default_draw_box;
+  klass->draw_flat_box = gtk_default_draw_flat_box;
+  klass->draw_check = gtk_default_draw_check;
+  klass->draw_option = gtk_default_draw_option;
+  klass->draw_cross = gtk_default_draw_cross;
+  klass->draw_ramp = gtk_default_draw_ramp;
+  klass->draw_tab = gtk_default_draw_tab;
+  klass->draw_shadow_gap = gtk_default_draw_shadow_gap;
+  klass->draw_box_gap = gtk_default_draw_box_gap;
+  klass->draw_extension = gtk_default_draw_extension;
+  klass->draw_focus = gtk_default_draw_focus;
+  klass->draw_slider = gtk_default_draw_slider;
+  klass->draw_handle = gtk_default_draw_handle;
+}
+
+static void
+gtk_style_finalize (GObject *object)
+{
+  GtkStyle *style = GTK_STYLE (object);
+
+  g_return_if_fail (style->attach_count == 0);
+  
+  if (style->styles)
+    {
+      if (style->styles->data != style)
+        g_slist_remove (style->styles, style);
+      else
+        {
+          GSList *tmp_list = style->styles->next;
+	  
+          while (tmp_list)
+            {
+              ((GtkStyle*) tmp_list->data)->styles = style->styles->next;
+              tmp_list = tmp_list->next;
+            }
+          g_slist_free_1 (style->styles);
+        }
+    }
+  
+  if (style->engine)
+    {
+      style->engine->destroy_style (style);
+      gtk_theme_engine_unref (style->engine);
+    }
+  
+  gdk_font_unref (style->font);
+  pango_font_description_free (style->font_desc);
+  
+  if (style->rc_style)
+    gtk_rc_style_unref (style->rc_style);
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+
+GtkStyle*
+gtk_style_copy (GtkStyle *style)
+{
+  GtkStyle *new_style;
+  guint i;
+  
+  g_return_val_if_fail (style != NULL, NULL);
+  
+  new_style = gtk_style_new ();
+  
+  for (i = 0; i < 5; i++)
+    {
+      new_style->fg[i] = style->fg[i];
+      new_style->bg[i] = style->bg[i];
+      new_style->text[i] = style->text[i];
+      new_style->base[i] = style->base[i];
+      
+      new_style->bg_pixmap[i] = style->bg_pixmap[i];
+    }
+  
+  gdk_font_unref (new_style->font);
+  new_style->font = style->font;
+  gdk_font_ref (new_style->font);
+
+  pango_font_description_free (new_style->font_desc);
+  new_style->font_desc = pango_font_description_copy (style->font_desc);
+  
+  if (style->rc_style)
+    {
+      new_style->rc_style = style->rc_style;
+      gtk_rc_style_ref (style->rc_style);
+    }
+  
+  if (style->engine)
+    {
+      new_style->engine = style->engine;
+      gtk_theme_engine_ref (new_style->engine);
+      new_style->engine->duplicate_style (new_style, style);
+    }
+
+  return new_style;
+}
+
+static GtkStyle*
+gtk_style_duplicate (GtkStyle *style)
+{
+  GtkStyle *new_style;
+  
+  g_return_val_if_fail (style != NULL, NULL);
+  
+  new_style = gtk_style_copy (style);
+  
+  style->styles = g_slist_append (style->styles, new_style);
+  new_style->styles = style->styles;  
+  
+  return new_style;
+}
+
+GtkStyle*
+gtk_style_new (void)
+{
+  GtkStyle *style;
+  
+  style = GTK_STYLE (g_type_create_instance (gtk_style_get_type ()));
   
   return style;
 }
@@ -534,7 +621,7 @@ gtk_style_attach (GtkStyle  *style,
       
       if (new_style->attach_count == 0)
         {
-          gtk_style_init (new_style, colormap, depth);
+          gtk_style_realize (new_style, colormap, depth);
           break;
         }
       else if (new_style->colormap == colormap &&
@@ -548,7 +635,7 @@ gtk_style_attach (GtkStyle  *style,
   if (!new_style)
     {
       new_style = gtk_style_duplicate (style);
-      gtk_style_init (new_style, colormap, depth);
+      gtk_style_realize (new_style, colormap, depth);
     }
 
   /* A style gets a refcount from being attached */
@@ -601,28 +688,19 @@ gtk_style_detach (GtkStyle *style)
 GtkStyle*
 gtk_style_ref (GtkStyle *style)
 {
-  g_return_val_if_fail (style != NULL, NULL);
-  g_return_val_if_fail (style->ref_count > 0, NULL);
-  
-  style->ref_count += 1;
-  return style;
+  return (GtkStyle *) g_object_ref (G_OBJECT (style));
 }
 
 void
 gtk_style_unref (GtkStyle *style)
 {
-  g_return_if_fail (style != NULL);
-  g_return_if_fail (style->ref_count > 0);
-  
-  style->ref_count -= 1;
-  if (style->ref_count == 0)
-    gtk_style_destroy (style);
+  g_object_unref (G_OBJECT (style));
 }
 
 static void
-gtk_style_init (GtkStyle    *style,
-                GdkColormap *colormap,
-                gint         depth)
+gtk_style_realize (GtkStyle    *style,
+                   GdkColormap *colormap,
+                   gint         depth)
 {
   GdkGCValues gc_values;
   GdkGCValuesMask gc_values_mask;
@@ -717,43 +795,6 @@ gtk_style_init (GtkStyle    *style,
     style->engine->realize_style (style);
 }
 
-static void
-gtk_style_destroy (GtkStyle *style)
-{
-  g_return_if_fail (style->attach_count == 0);
-  
-  if (style->styles)
-    {
-      if (style->styles->data != style)
-        g_slist_remove (style->styles, style);
-      else
-        {
-          GSList *tmp_list = style->styles->next;
-	  
-          while (tmp_list)
-            {
-              ((GtkStyle*) tmp_list->data)->styles = style->styles->next;
-              tmp_list = tmp_list->next;
-            }
-          g_slist_free_1 (style->styles);
-        }
-    }
-  
-  if (style->engine)
-    {
-      style->engine->destroy_style (style);
-      gtk_theme_engine_unref (style->engine);
-    }
-  
-  gdk_font_unref (style->font);
-  pango_font_description_free (style->font_desc);
-  
-  if (style->rc_style)
-    gtk_rc_style_unref (style->rc_style);
-
-  g_free (style);
-}
-
 void
 gtk_draw_hline (GtkStyle     *style,
                 GdkWindow    *window,
@@ -763,10 +804,9 @@ gtk_draw_hline (GtkStyle     *style,
                 gint          y)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_hline != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_hline != NULL);
   
-  style->klass->draw_hline (style, window, state_type, NULL, NULL, NULL, x1, x2, y);
+  GTK_STYLE_GET_CLASS (style)->draw_hline (style, window, state_type, NULL, NULL, NULL, x1, x2, y);
 }
 
 
@@ -779,10 +819,9 @@ gtk_draw_vline (GtkStyle     *style,
                 gint          x)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_vline != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_vline != NULL);
   
-  style->klass->draw_vline (style, window, state_type, NULL, NULL, NULL, y1, y2, x);
+  GTK_STYLE_GET_CLASS (style)->draw_vline (style, window, state_type, NULL, NULL, NULL, y1, y2, x);
 }
 
 
@@ -797,10 +836,9 @@ gtk_draw_shadow (GtkStyle      *style,
                  gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_shadow != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow != NULL);
   
-  style->klass->draw_shadow (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_shadow (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 }
 
 void
@@ -813,10 +851,9 @@ gtk_draw_polygon (GtkStyle      *style,
                   gboolean       fill)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_polygon != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_polygon != NULL);
   
-  style->klass->draw_polygon (style, window, state_type, shadow_type, NULL, NULL, NULL, points, npoints, fill);
+  GTK_STYLE_GET_CLASS (style)->draw_polygon (style, window, state_type, shadow_type, NULL, NULL, NULL, points, npoints, fill);
 }
 
 void
@@ -832,10 +869,9 @@ gtk_draw_arrow (GtkStyle      *style,
                 gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_arrow != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_arrow != NULL);
   
-  style->klass->draw_arrow (style, window, state_type, shadow_type, NULL, NULL, NULL, arrow_type, fill, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_arrow (style, window, state_type, shadow_type, NULL, NULL, NULL, arrow_type, fill, x, y, width, height);
 }
 
 
@@ -850,10 +886,9 @@ gtk_draw_diamond (GtkStyle      *style,
                   gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_diamond != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_diamond != NULL);
   
-  style->klass->draw_diamond (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_diamond (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 }
 
 
@@ -868,10 +903,9 @@ gtk_draw_oval (GtkStyle      *style,
                gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_oval != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_oval != NULL);
   
-  style->klass->draw_oval (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_oval (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 }
 
 void
@@ -883,10 +917,9 @@ gtk_draw_string (GtkStyle      *style,
                  const gchar   *string)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_string != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_string != NULL);
   
-  style->klass->draw_string (style, window, state_type, NULL, NULL, NULL, x, y, string);
+  GTK_STYLE_GET_CLASS (style)->draw_string (style, window, state_type, NULL, NULL, NULL, x, y, string);
 }
 
 void
@@ -900,10 +933,9 @@ gtk_draw_box (GtkStyle      *style,
               gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_box != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_box != NULL);
   
-  style->klass->draw_box (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_box (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 }
 
 void
@@ -917,10 +949,9 @@ gtk_draw_flat_box (GtkStyle      *style,
                    gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_flat_box != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_flat_box != NULL);
   
-  style->klass->draw_flat_box (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_flat_box (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 }
 
 void
@@ -934,10 +965,9 @@ gtk_draw_check (GtkStyle      *style,
                 gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_check != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_check != NULL);
   
-  style->klass->draw_check (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_check (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 }
 
 void
@@ -951,10 +981,9 @@ gtk_draw_option (GtkStyle      *style,
 		 gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_option != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_option != NULL);
   
-  style->klass->draw_option (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_option (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 }
 
 void
@@ -968,10 +997,9 @@ gtk_draw_cross (GtkStyle      *style,
 		gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_cross != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_cross != NULL);
   
-  style->klass->draw_cross (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_cross (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 }
 
 void
@@ -986,10 +1014,9 @@ gtk_draw_ramp (GtkStyle      *style,
 	       gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_ramp != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_ramp != NULL);
   
-  style->klass->draw_ramp (style, window, state_type, shadow_type, NULL, NULL, NULL, arrow_type, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_ramp (style, window, state_type, shadow_type, NULL, NULL, NULL, arrow_type, x, y, width, height);
 }
 
 void
@@ -1003,10 +1030,9 @@ gtk_draw_tab (GtkStyle      *style,
 	      gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_tab != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_tab != NULL);
   
-  style->klass->draw_tab (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_tab (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
 }
 
 void
@@ -1023,10 +1049,9 @@ gtk_draw_shadow_gap (GtkStyle       *style,
                      gint            gap_width)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_shadow_gap != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow_gap != NULL);
   
-  style->klass->draw_shadow_gap (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side, gap_x, gap_width);
+  GTK_STYLE_GET_CLASS (style)->draw_shadow_gap (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side, gap_x, gap_width);
 }
 
 void
@@ -1043,10 +1068,9 @@ gtk_draw_box_gap (GtkStyle       *style,
                   gint            gap_width)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_box_gap != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_box_gap != NULL);
   
-  style->klass->draw_box_gap (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side, gap_x, gap_width);
+  GTK_STYLE_GET_CLASS (style)->draw_box_gap (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side, gap_x, gap_width);
 }
 
 void
@@ -1061,10 +1085,9 @@ gtk_draw_extension (GtkStyle       *style,
                     GtkPositionType gap_side)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_extension != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_extension != NULL);
   
-  style->klass->draw_extension (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side);
+  GTK_STYLE_GET_CLASS (style)->draw_extension (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side);
 }
 
 void
@@ -1076,10 +1099,9 @@ gtk_draw_focus (GtkStyle      *style,
 		gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_focus != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_focus != NULL);
   
-  style->klass->draw_focus (style, window, NULL, NULL, NULL, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_focus (style, window, NULL, NULL, NULL, x, y, width, height);
 }
 
 void 
@@ -1094,10 +1116,9 @@ gtk_draw_slider (GtkStyle      *style,
 		 GtkOrientation orientation)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_slider != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_slider != NULL);
   
-  style->klass->draw_slider (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, orientation);
+  GTK_STYLE_GET_CLASS (style)->draw_slider (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, orientation);
 }
 
 void 
@@ -1112,10 +1133,9 @@ gtk_draw_handle (GtkStyle      *style,
 		 GtkOrientation orientation)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_handle != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_handle != NULL);
   
-  style->klass->draw_handle (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, orientation);
+  GTK_STYLE_GET_CLASS (style)->draw_handle (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, orientation);
 }
 
 void
@@ -1189,7 +1209,7 @@ gtk_style_apply_default_background (GtkStyle     *style,
     }
   
   if (!style->bg_pixmap[state_type] ||
-      gdk_window_get_type (window) == GDK_WINDOW_PIXMAP ||
+      GDK_IS_PIXMAP (window) ||
       (!set_bg && style->bg_pixmap[state_type] != (GdkPixmap*) GDK_PARENT_RELATIVE))
     {
       GdkGC *gc = style->bg_gc[state_type];
@@ -1239,8 +1259,8 @@ gtk_default_draw_hline (GtkStyle     *style,
   g_return_if_fail (style != NULL);
   g_return_if_fail (window != NULL);
   
-  thickness_light = style->klass->ythickness / 2;
-  thickness_dark = style->klass->ythickness - thickness_light;
+  thickness_light = style->ythickness / 2;
+  thickness_dark = style->ythickness - thickness_light;
   
   if (area)
     {
@@ -1296,8 +1316,8 @@ gtk_default_draw_vline (GtkStyle     *style,
   g_return_if_fail (style != NULL);
   g_return_if_fail (window != NULL);
   
-  thickness_light = style->klass->xthickness / 2;
-  thickness_dark = style->klass->xthickness - thickness_light;
+  thickness_light = style->xthickness / 2;
+  thickness_dark = style->xthickness - thickness_light;
   
   if (area)
     {
@@ -2189,7 +2209,7 @@ gtk_default_draw_box (GtkStyle      *style,
     gdk_window_get_size (window, NULL, &height);
   
   if (!style->bg_pixmap[state_type] || 
-      gdk_window_get_type (window) == GDK_WINDOW_PIXMAP)
+      GDK_IS_PIXMAP (window))
     {
       if (area)
 	gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
@@ -2248,7 +2268,7 @@ gtk_default_draw_flat_box (GtkStyle      *style,
     gc1 = style->bg_gc[state_type];
   
   if (!style->bg_pixmap[state_type] || gc1 != style->bg_gc[state_type] ||
-      gdk_window_get_type (window) == GDK_WINDOW_PIXMAP)
+      GDK_IS_PIXMAP (window))
     {
       if (area)
 	gdk_gc_set_clip_rectangle (gc1, area);
@@ -2893,10 +2913,10 @@ gtk_default_draw_extension (GtkStyle       *style,
           gtk_style_apply_default_background (style, window,
                                               widget && !GTK_WIDGET_NO_WINDOW (widget),
                                               state_type, area,
-                                              x + style->klass->xthickness, 
+                                              x + style->xthickness, 
                                               y, 
-                                              width - (2 * style->klass->xthickness), 
-                                              height - (style->klass->ythickness));
+                                              width - (2 * style->xthickness), 
+                                              height - (style->ythickness));
           gdk_draw_line (window, gc1,
                          x, y, x, y + height - 2);
           gdk_draw_line (window, gc2,
@@ -2915,10 +2935,10 @@ gtk_default_draw_extension (GtkStyle       *style,
           gtk_style_apply_default_background (style, window,
                                               widget && !GTK_WIDGET_NO_WINDOW (widget),
                                               state_type, area,
-                                              x + style->klass->xthickness, 
-                                              y + style->klass->ythickness, 
-                                              width - (2 * style->klass->xthickness), 
-                                              height - (style->klass->ythickness));
+                                              x + style->xthickness, 
+                                              y + style->ythickness, 
+                                              width - (2 * style->xthickness), 
+                                              height - (style->ythickness));
           gdk_draw_line (window, gc1,
                          x + 1, y, x + width - 2, y);
           gdk_draw_line (window, gc1,
@@ -2938,9 +2958,9 @@ gtk_default_draw_extension (GtkStyle       *style,
                                               widget && !GTK_WIDGET_NO_WINDOW (widget),
                                               state_type, area,
                                               x, 
-                                              y + style->klass->ythickness, 
-                                              width - (style->klass->xthickness), 
-                                              height - (2 * style->klass->ythickness));
+                                              y + style->ythickness, 
+                                              width - (style->xthickness), 
+                                              height - (2 * style->ythickness));
           gdk_draw_line (window, gc1,
                          x, y, x + width - 2, y);
           gdk_draw_line (window, gc2,
@@ -2959,10 +2979,10 @@ gtk_default_draw_extension (GtkStyle       *style,
           gtk_style_apply_default_background (style, window,
                                               widget && !GTK_WIDGET_NO_WINDOW (widget),
                                               state_type, area,
-                                              x + style->klass->xthickness, 
-                                              y + style->klass->ythickness, 
-                                              width - (style->klass->xthickness), 
-                                              height - (2 * style->klass->ythickness));
+                                              x + style->xthickness, 
+                                              y + style->ythickness, 
+                                              width - (style->xthickness), 
+                                              height - (2 * style->ythickness));
           gdk_draw_line (window, gc1,
                          x + 1, y, x + width - 1, y);
           gdk_draw_line (window, gc1,
@@ -3074,12 +3094,12 @@ gtk_default_draw_slider (GtkStyle      *style,
 
   if (orientation == GTK_ORIENTATION_HORIZONTAL)
     gtk_paint_vline (style, window, state_type, area, widget, detail, 
-                     style->klass->ythickness, 
-                     height - style->klass->ythickness - 1, width / 2);
+                     style->ythickness, 
+                     height - style->ythickness - 1, width / 2);
   else
     gtk_paint_hline (style, window, state_type, area, widget, detail, 
-                     style->klass->xthickness, 
-                     width - style->klass->xthickness - 1, height / 2);
+                     style->xthickness, 
+                     width - style->xthickness - 1, height / 2);
 }
 
 static void
@@ -3155,8 +3175,8 @@ gtk_default_draw_handle (GtkStyle      *style,
     }
   else
     {
-      xthick = style->klass->xthickness;
-      ythick = style->klass->ythickness;
+      xthick = style->xthickness;
+      ythick = style->ythickness;
 
       light_gc = style->light_gc[state_type];
       dark_gc = style->dark_gc[state_type];
@@ -3405,10 +3425,9 @@ gtk_paint_hline (GtkStyle      *style,
                  gint          y)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_hline != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_hline != NULL);
   
-  style->klass->draw_hline (style, window, state_type, area, widget, detail, x1, x2, y);
+  GTK_STYLE_GET_CLASS (style)->draw_hline (style, window, state_type, area, widget, detail, x1, x2, y);
 }
 
 void
@@ -3423,10 +3442,9 @@ gtk_paint_vline (GtkStyle      *style,
                  gint          x)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_vline != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_vline != NULL);
   
-  style->klass->draw_vline (style, window, state_type, area, widget, detail, y1, y2, x);
+  GTK_STYLE_GET_CLASS (style)->draw_vline (style, window, state_type, area, widget, detail, y1, y2, x);
 }
 
 void
@@ -3443,10 +3461,9 @@ gtk_paint_shadow (GtkStyle     *style,
                   gint          height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_shadow != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow != NULL);
   
-  style->klass->draw_shadow (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_shadow (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
 }
 
 void
@@ -3462,10 +3479,9 @@ gtk_paint_polygon (GtkStyle      *style,
                    gboolean       fill)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_shadow != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow != NULL);
   
-  style->klass->draw_polygon (style, window, state_type, shadow_type, area, widget, detail, points, npoints, fill);
+  GTK_STYLE_GET_CLASS (style)->draw_polygon (style, window, state_type, shadow_type, area, widget, detail, points, npoints, fill);
 }
 
 void
@@ -3484,10 +3500,9 @@ gtk_paint_arrow (GtkStyle      *style,
                  gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_arrow != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_arrow != NULL);
   
-  style->klass->draw_arrow (style, window, state_type, shadow_type, area, widget, detail, arrow_type, fill, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_arrow (style, window, state_type, shadow_type, area, widget, detail, arrow_type, fill, x, y, width, height);
 }
 
 void
@@ -3504,10 +3519,9 @@ gtk_paint_diamond (GtkStyle      *style,
                    gint        height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_diamond != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_diamond != NULL);
   
-  style->klass->draw_diamond (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_diamond (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
 }
 
 void
@@ -3524,10 +3538,9 @@ gtk_paint_oval (GtkStyle      *style,
                 gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_oval != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_oval != NULL);
   
-  style->klass->draw_oval (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_oval (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
 }
 
 void
@@ -3542,10 +3555,9 @@ gtk_paint_string (GtkStyle      *style,
                   const gchar   *string)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_string != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_string != NULL);
   
-  style->klass->draw_string (style, window, state_type, area, widget, detail, x, y, string);
+  GTK_STYLE_GET_CLASS (style)->draw_string (style, window, state_type, area, widget, detail, x, y, string);
 }
 
 void
@@ -3562,10 +3574,9 @@ gtk_paint_box (GtkStyle      *style,
                gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_box != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_box != NULL);
   
-  style->klass->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
 }
 
 void
@@ -3582,10 +3593,9 @@ gtk_paint_flat_box (GtkStyle      *style,
                     gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_flat_box != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_flat_box != NULL);
   
-  style->klass->draw_flat_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_flat_box (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
 }
 
 void
@@ -3602,10 +3612,9 @@ gtk_paint_check (GtkStyle      *style,
                  gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_check != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_check != NULL);
   
-  style->klass->draw_check (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_check (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
 }
 
 void
@@ -3622,10 +3631,9 @@ gtk_paint_option (GtkStyle      *style,
                   gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_option != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_option != NULL);
   
-  style->klass->draw_option (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_option (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
 }
 
 void
@@ -3642,10 +3650,9 @@ gtk_paint_cross (GtkStyle      *style,
                  gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_cross != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_cross != NULL);
   
-  style->klass->draw_cross (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_cross (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
 }
 
 void
@@ -3663,10 +3670,9 @@ gtk_paint_ramp (GtkStyle      *style,
                 gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_ramp != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_ramp != NULL);
   
-  style->klass->draw_ramp (style, window, state_type, shadow_type, area, widget, detail, arrow_type, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_ramp (style, window, state_type, shadow_type, area, widget, detail, arrow_type, x, y, width, height);
 }
 
 void
@@ -3683,10 +3689,9 @@ gtk_paint_tab (GtkStyle      *style,
                gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_tab != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_tab != NULL);
   
-  style->klass->draw_tab (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_tab (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
 }
 
 void
@@ -3706,10 +3711,9 @@ gtk_paint_shadow_gap (GtkStyle       *style,
                       gint            gap_width)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_shadow_gap != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_shadow_gap != NULL);
   
-  style->klass->draw_shadow_gap (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
+  GTK_STYLE_GET_CLASS (style)->draw_shadow_gap (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
 }
 
 
@@ -3730,10 +3734,9 @@ gtk_paint_box_gap (GtkStyle       *style,
                    gint            gap_width)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_box_gap != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_box_gap != NULL);
   
-  style->klass->draw_box_gap (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
+  GTK_STYLE_GET_CLASS (style)->draw_box_gap (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
 }
 
 void
@@ -3751,10 +3754,9 @@ gtk_paint_extension (GtkStyle       *style,
                      GtkPositionType gap_side)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_extension != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_extension != NULL);
   
-  style->klass->draw_extension (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side);
+  GTK_STYLE_GET_CLASS (style)->draw_extension (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side);
 }
 
 void
@@ -3769,10 +3771,9 @@ gtk_paint_focus (GtkStyle      *style,
                  gint           height)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_focus != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_focus != NULL);
   
-  style->klass->draw_focus (style, window, area, widget, detail, x, y, width, height);
+  GTK_STYLE_GET_CLASS (style)->draw_focus (style, window, area, widget, detail, x, y, width, height);
 }
 
 void
@@ -3790,10 +3791,9 @@ gtk_paint_slider (GtkStyle      *style,
                   GtkOrientation orientation)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_slider != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_slider != NULL);
   
-  style->klass->draw_slider (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
+  GTK_STYLE_GET_CLASS (style)->draw_slider (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
 }
 
 void
@@ -3811,8 +3811,7 @@ gtk_paint_handle (GtkStyle      *style,
                   GtkOrientation orientation)
 {
   g_return_if_fail (style != NULL);
-  g_return_if_fail (style->klass != NULL);
-  g_return_if_fail (style->klass->draw_handle != NULL);
+  g_return_if_fail (GTK_STYLE_GET_CLASS (style)->draw_handle != NULL);
   
-  style->klass->draw_handle (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
+  GTK_STYLE_GET_CLASS (style)->draw_handle (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
 }
diff --git a/gtk/gtkstyle.h b/gtk/gtkstyle.h
index fca8c21edd..45e028eacc 100644
--- a/gtk/gtkstyle.h
+++ b/gtk/gtkstyle.h
@@ -39,6 +39,13 @@ extern "C" {
 typedef struct _GtkStyle       GtkStyle;
 typedef struct _GtkStyleClass  GtkStyleClass;
 
+#define GTK_TYPE_STYLE              (gtk_style_get_type ())
+#define GTK_STYLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_STYLE, GtkStyle))
+#define GTK_STYLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STYLE, GtkStyleClass))
+#define GTK_IS_STYLE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_STYLE))
+#define GTK_IS_STYLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STYLE))
+#define GTK_STYLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STYLE, GtkStyleClass))
+
 /* Some forward declarations needed to rationalize the header
  * files.
  */
@@ -60,8 +67,10 @@ typedef struct _GtkWidget      GtkWidget;
 
 struct _GtkStyle
 {
-  GtkStyleClass *klass;
+  GObject parent_instance;
 
+  /*< public >*/
+  
   GdkColor fg[5];
   GdkColor bg[5];
   GdkColor light[5];
@@ -86,10 +95,12 @@ struct _GtkStyle
   GdkGC *white_gc;
   
   GdkPixmap *bg_pixmap[5];
+
+  gint xthickness;
+  gint ythickness;
   
-  /* private */
+  /*< private >*/
   
-  gint ref_count;
   gint attach_count;
   
   gint depth;
@@ -107,8 +118,7 @@ struct _GtkStyle
 
 struct _GtkStyleClass
 {
-  gint xthickness;
-  gint ythickness;
+  GObjectClass parent_class;
   
   void (*draw_hline)		(GtkStyle		*style,
 				 GdkWindow		*window,
@@ -346,6 +356,7 @@ struct _GtkStyleClass
 				 GtkOrientation		 orientation);
 };
 
+GType     gtk_style_get_type                 (void);
 GtkStyle* gtk_style_new			     (void);
 GtkStyle* gtk_style_copy		     (GtkStyle	    *style);
 GtkStyle* gtk_style_attach		     (GtkStyle	    *style,
diff --git a/gtk/gtktearoffmenuitem.c b/gtk/gtktearoffmenuitem.c
index ac775cd6cb..5af1baf2f5 100644
--- a/gtk/gtktearoffmenuitem.c
+++ b/gtk/gtktearoffmenuitem.c
@@ -108,10 +108,10 @@ gtk_tearoff_menu_item_size_request (GtkWidget      *widget,
   tearoff = GTK_TEAROFF_MENU_ITEM (widget);
   
   requisition->width = (GTK_CONTAINER (widget)->border_width +
-			widget->style->klass->xthickness +
+			widget->style->xthickness +
 			BORDER_SPACING) * 2;
   requisition->height = (GTK_CONTAINER (widget)->border_width +
-			 widget->style->klass->ythickness) * 2;
+			 widget->style->ythickness) * 2;
 
   if (tearoff->torn_off)
     {
@@ -119,7 +119,7 @@ gtk_tearoff_menu_item_size_request (GtkWidget      *widget,
     }
   else
     {
-      requisition->height += widget->style->klass->ythickness;
+      requisition->height += widget->style->ythickness;
     }
 }
 
@@ -188,7 +188,7 @@ gtk_tearoff_menu_item_paint (GtkWidget   *widget,
 	{
 	  gtk_draw_hline (widget->style, widget->window, GTK_STATE_NORMAL,
 			  x, MIN (x+TEAR_LENGTH, right_max),
-			  y + (height - widget->style->klass->ythickness)/2);
+			  y + (height - widget->style->ythickness)/2);
 	  x += 2 * TEAR_LENGTH;
 	}
     }
diff --git a/gtk/gtktext.c b/gtk/gtktext.c
index 3b6bfd2aef..341e3b0dff 100644
--- a/gtk/gtktext.c
+++ b/gtk/gtktext.c
@@ -1309,8 +1309,8 @@ gtk_text_realize (GtkWidget *widget)
   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
   gdk_window_set_user_data (widget->window, text);
   
-  attributes.x = (widget->style->klass->xthickness + TEXT_BORDER_ROOM);
-  attributes.y = (widget->style->klass->ythickness + TEXT_BORDER_ROOM);
+  attributes.x = (widget->style->xthickness + TEXT_BORDER_ROOM);
+  attributes.y = (widget->style->ythickness + TEXT_BORDER_ROOM);
   attributes.width = MAX (1, (gint)widget->allocation.width - (gint)attributes.x * 2);
   attributes.height = MAX (1, (gint)widget->allocation.height - (gint)attributes.y * 2);
   
@@ -1508,8 +1508,8 @@ clear_focus_area (GtkText *text, gint area_x, gint area_y, gint area_width, gint
 {
   GtkWidget *widget = GTK_WIDGET (text);
   
-  gint ythick = TEXT_BORDER_ROOM + widget->style->klass->ythickness;
-  gint xthick = TEXT_BORDER_ROOM + widget->style->klass->xthickness;
+  gint ythick = TEXT_BORDER_ROOM + widget->style->ythickness;
+  gint xthick = TEXT_BORDER_ROOM + widget->style->xthickness;
   
   gint width, height;
   
@@ -1537,8 +1537,8 @@ gtk_text_draw_focus (GtkWidget *widget)
   
   if (GTK_WIDGET_DRAWABLE (widget))
     {
-      gint ythick = widget->style->klass->ythickness;
-      gint xthick = widget->style->klass->xthickness;
+      gint ythick = widget->style->ythickness;
+      gint xthick = widget->style->xthickness;
       gint xextra = TEXT_BORDER_ROOM;
       gint yextra = TEXT_BORDER_ROOM;
       
@@ -1608,8 +1608,8 @@ gtk_text_size_request (GtkWidget      *widget,
   g_return_if_fail (GTK_IS_TEXT (widget));
   g_return_if_fail (requisition != NULL);
   
-  xthickness = widget->style->klass->xthickness + TEXT_BORDER_ROOM;
-  ythickness = widget->style->klass->ythickness + TEXT_BORDER_ROOM;
+  xthickness = widget->style->xthickness + TEXT_BORDER_ROOM;
+  ythickness = widget->style->ythickness + TEXT_BORDER_ROOM;
   
   char_height = MIN_TEXT_HEIGHT_LINES * (widget->style->font->ascent +
 					 widget->style->font->descent);
@@ -1645,11 +1645,11 @@ gtk_text_size_allocate (GtkWidget     *widget,
 			      allocation->width, allocation->height);
       
       gdk_window_move_resize (text->text_area,
-			      widget->style->klass->xthickness + TEXT_BORDER_ROOM,
-			      widget->style->klass->ythickness + TEXT_BORDER_ROOM,
-			      MAX (1, (gint)widget->allocation.width - (gint)(widget->style->klass->xthickness +
+			      widget->style->xthickness + TEXT_BORDER_ROOM,
+			      widget->style->ythickness + TEXT_BORDER_ROOM,
+			      MAX (1, (gint)widget->allocation.width - (gint)(widget->style->xthickness +
 							  (gint)TEXT_BORDER_ROOM) * 2),
-			      MAX (1, (gint)widget->allocation.height - (gint)(widget->style->klass->ythickness +
+			      MAX (1, (gint)widget->allocation.height - (gint)(widget->style->ythickness +
 							   (gint)TEXT_BORDER_ROOM) * 2));
       
 #ifdef USE_XIM
diff --git a/gtk/gtktextlayout.c b/gtk/gtktextlayout.c
index a6bb822c6e..82a8e83c57 100644
--- a/gtk/gtktextlayout.c
+++ b/gtk/gtktextlayout.c
@@ -209,12 +209,12 @@ gtk_text_layout_destroy (GtkObject *object)
 
   if (layout->ltr_context)
     {
-      pango_context_unref (layout->ltr_context);
+      g_object_unref (G_OBJECT (layout->ltr_context));
       layout->ltr_context = NULL;
     }
   if (layout->rtl_context)
     {
-      pango_context_unref (layout->rtl_context);
+      g_object_unref (G_OBJECT (layout->rtl_context));
       layout->rtl_context = NULL;
     }
   
@@ -298,16 +298,16 @@ gtk_text_layout_set_contexts (GtkTextLayout *layout,
   g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
 
   if (layout->ltr_context)
-    pango_context_unref (ltr_context);
+    g_object_unref (G_OBJECT (ltr_context));
 
   layout->ltr_context = ltr_context;
-  pango_context_ref (ltr_context);
+  g_object_ref (G_OBJECT (ltr_context));
   
   if (layout->rtl_context)
-    pango_context_unref (rtl_context);
+    g_object_unref (G_OBJECT (rtl_context));
 
   layout->rtl_context = rtl_context;
-  pango_context_ref (rtl_context);
+  g_object_ref (G_OBJECT (rtl_context));
   
   gtk_text_layout_invalidate_all (layout);
 }
@@ -1359,7 +1359,7 @@ gtk_text_layout_free_line_display (GtkTextLayout      *layout,
 {
   if (display != layout->one_display_cache)
     {
-      pango_layout_unref (display->layout);
+      g_object_unref (G_OBJECT (display->layout));
 
       if (display->cursors)
 	{
diff --git a/gtk/gtktexttag.c b/gtk/gtktexttag.c
index 0caf021be6..e7f89a35fb 100644
--- a/gtk/gtktexttag.c
+++ b/gtk/gtktexttag.c
@@ -174,11 +174,11 @@ gtk_text_tag_class_init (GtkTextTagClass *klass)
                            GTK_ARG_READWRITE, ARG_BACKGROUND_GDK);
   gtk_object_add_arg_type ("GtkTextTag::foreground_gdk", GTK_TYPE_GDK_COLOR,
                            GTK_ARG_READWRITE, ARG_FOREGROUND_GDK);
-  /* FIXME should be GTK_TYPE_GDK_BITMAP but that doesn't exist? */
-  gtk_object_add_arg_type ("GtkTextTag::background_stipple", GTK_TYPE_GDK_WINDOW,
+  gtk_object_add_arg_type ("GtkTextTag::background_stipple",
+                           GDK_TYPE_PIXMAP,
                            GTK_ARG_READWRITE, ARG_BACKGROUND_STIPPLE);
-  /* FIXME GDK_BITMAP */
-  gtk_object_add_arg_type ("GtkTextTag::foreground_stipple", GTK_TYPE_GDK_WINDOW,
+  gtk_object_add_arg_type ("GtkTextTag::foreground_stipple",
+                           GDK_TYPE_PIXMAP,
                            GTK_ARG_READWRITE, ARG_FOREGROUND_STIPPLE);
   gtk_object_add_arg_type ("GtkTextTag::font", GTK_TYPE_STRING,
                            GTK_ARG_READWRITE, ARG_FONT);
diff --git a/gtk/gtktextview.c b/gtk/gtktextview.c
index 96318efc2c..778442538a 100644
--- a/gtk/gtktextview.c
+++ b/gtk/gtktextview.c
@@ -2403,8 +2403,8 @@ gtk_text_view_ensure_layout (GtkTextView *text_view)
 
       gtk_text_layout_set_contexts (text_view->layout, ltr_context, rtl_context);
 
-      pango_context_unref (ltr_context);
-      pango_context_unref (rtl_context);
+      g_object_unref (G_OBJECT (ltr_context));
+      g_object_unref (G_OBJECT (rtl_context));
 
       style = gtk_text_view_style_values_new ();
 
diff --git a/gtk/gtktogglebutton.c b/gtk/gtktogglebutton.c
index 788ac67009..9ae77e89cb 100644
--- a/gtk/gtktogglebutton.c
+++ b/gtk/gtktogglebutton.c
@@ -344,8 +344,8 @@ gtk_toggle_button_paint (GtkWidget    *widget,
 
       if (GTK_WIDGET_CAN_DEFAULT (widget))
         {
-          x += widget->style->klass->xthickness;
-          y += widget->style->klass->ythickness;
+          x += widget->style->xthickness;
+          y += widget->style->ythickness;
           width -= 2 * x + DEFAULT_SPACING;
           height -= 2 * y + DEFAULT_SPACING;
           x += DEFAULT_LEFT_POS;
diff --git a/gtk/gtktoolbar.c b/gtk/gtktoolbar.c
index 3001cb57f3..d53fbec919 100644
--- a/gtk/gtktoolbar.c
+++ b/gtk/gtktoolbar.c
@@ -391,7 +391,7 @@ gtk_toolbar_paint_space_line (GtkWidget       *widget,
 		     SPACE_LINE_END / SPACE_LINE_DIVISION,
 		     child_space->alloc_x +
 		     (toolbar->space_size -
-		      widget->style->klass->xthickness) / 2);
+		      widget->style->xthickness) / 2);
   else
     gtk_paint_hline (widget->style, widget->window,
 		     GTK_WIDGET_STATE (widget), area, widget,
@@ -402,7 +402,7 @@ gtk_toolbar_paint_space_line (GtkWidget       *widget,
 		     SPACE_LINE_END / SPACE_LINE_DIVISION,
 		     child_space->alloc_y +
 		     (toolbar->space_size -
-		      widget->style->klass->ythickness) / 2);
+		      widget->style->ythickness) / 2);
 }
 
 static void
diff --git a/gtk/gtktreeitem.c b/gtk/gtktreeitem.c
index 63e2d77203..06900650fb 100644
--- a/gtk/gtktreeitem.c
+++ b/gtk/gtktreeitem.c
@@ -499,7 +499,7 @@ gtk_tree_item_size_request (GtkWidget      *widget,
   item = GTK_TREE_ITEM(widget);
 
   requisition->width = (GTK_CONTAINER (widget)->border_width +
-			widget->style->klass->xthickness) * 2;
+			widget->style->xthickness) * 2;
   requisition->height = GTK_CONTAINER (widget)->border_width * 2;
 
   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
@@ -546,7 +546,7 @@ gtk_tree_item_size_allocate (GtkWidget     *widget,
   if (bin->child)
     {
       border_width = (GTK_CONTAINER (widget)->border_width +
-		      widget->style->klass->xthickness);
+		      widget->style->xthickness);
 
       child_allocation.x = border_width + GTK_TREE(widget->parent)->current_indent;
       child_allocation.y = GTK_CONTAINER (widget)->border_width;
diff --git a/gtk/gtkviewport.c b/gtk/gtkviewport.c
index 481f59425a..ef18bacc74 100644
--- a/gtk/gtkviewport.c
+++ b/gtk/gtkviewport.c
@@ -449,8 +449,8 @@ gtk_viewport_realize (GtkWidget *widget)
 
   if (viewport->shadow_type != GTK_SHADOW_NONE)
     {
-      attributes.x = widget->style->klass->xthickness;
-      attributes.y = widget->style->klass->ythickness;
+      attributes.x = widget->style->xthickness;
+      attributes.y = widget->style->ythickness;
     }
   else
     {
@@ -564,8 +564,8 @@ gtk_viewport_draw (GtkWidget    *widget,
       
       gtk_viewport_paint (widget, &tmp_area);
 
-      tmp_area.x += viewport->hadjustment->value - widget->style->klass->xthickness;
-      tmp_area.y += viewport->vadjustment->value - widget->style->klass->ythickness;
+      tmp_area.x += viewport->hadjustment->value - widget->style->xthickness;
+      tmp_area.y += viewport->vadjustment->value - widget->style->ythickness;
       
       gtk_paint_flat_box(widget->style, viewport->bin_window, 
 			 GTK_STATE_NORMAL, GTK_SHADOW_NONE,
@@ -654,10 +654,10 @@ gtk_viewport_size_request (GtkWidget      *widget,
   bin = GTK_BIN (widget);
 
   requisition->width = (GTK_CONTAINER (widget)->border_width +
-			GTK_WIDGET (widget)->style->klass->xthickness) * 2 + 5;
+			GTK_WIDGET (widget)->style->xthickness) * 2 + 5;
 
   requisition->height = (GTK_CONTAINER (widget)->border_width * 2 +
-			 GTK_WIDGET (widget)->style->klass->ythickness) * 2 + 5;
+			 GTK_WIDGET (widget)->style->ythickness) * 2 + 5;
 
   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
     {
@@ -698,8 +698,8 @@ gtk_viewport_size_allocate (GtkWidget     *widget,
 
   if (viewport->shadow_type != GTK_SHADOW_NONE)
     {
-      child_allocation.x = GTK_WIDGET (viewport)->style->klass->xthickness;
-      child_allocation.y = GTK_WIDGET (viewport)->style->klass->ythickness;
+      child_allocation.x = GTK_WIDGET (viewport)->style->xthickness;
+      child_allocation.y = GTK_WIDGET (viewport)->style->ythickness;
     }
 
   child_allocation.width = MAX (1, allocation->width - child_allocation.x * 2 - border_width * 2);
diff --git a/gtk/gtkvruler.c b/gtk/gtkvruler.c
index 65aa54204c..655f71e883 100644
--- a/gtk/gtkvruler.c
+++ b/gtk/gtkvruler.c
@@ -92,8 +92,8 @@ gtk_vruler_init (GtkVRuler *vruler)
   GtkWidget *widget;
 
   widget = GTK_WIDGET (vruler);
-  widget->requisition.width = widget->style->klass->xthickness * 2 + RULER_WIDTH;
-  widget->requisition.height = widget->style->klass->ythickness * 2 + 1;
+  widget->requisition.width = widget->style->xthickness * 2 + RULER_WIDTH;
+  widget->requisition.height = widget->style->ythickness * 2 + 1;
 }
 
 GtkWidget*
@@ -163,8 +163,9 @@ gtk_vruler_draw_ticks (GtkRuler *ruler)
 
   gc = widget->style->fg_gc[GTK_STATE_NORMAL];
   bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
-  xthickness = widget->style->klass->xthickness;
-  ythickness = widget->style->klass->ythickness;
+
+  xthickness = widget->style->xthickness;
+  ythickness = widget->style->ythickness;
 
   layout = gtk_widget_create_pango_layout (widget);
   pango_layout_set_text (layout, "012456789", -1);
@@ -266,7 +267,7 @@ gtk_vruler_draw_ticks (GtkRuler *ruler)
 	}
     }
 
-  pango_layout_unref (layout);
+  g_object_unref (G_OBJECT (layout));
 }
 
 
@@ -291,8 +292,8 @@ gtk_vruler_draw_pos (GtkRuler *ruler)
       widget = GTK_WIDGET (ruler);
 
       gc = widget->style->fg_gc[GTK_STATE_NORMAL];
-      xthickness = widget->style->klass->xthickness;
-      ythickness = widget->style->klass->ythickness;
+      xthickness = widget->style->xthickness;
+      ythickness = widget->style->ythickness;
       width = widget->allocation.width - xthickness * 2;
       height = widget->allocation.height;
 
diff --git a/gtk/gtkvscale.c b/gtk/gtkvscale.c
index 490b383fba..0432e83eec 100644
--- a/gtk/gtkvscale.c
+++ b/gtk/gtkvscale.c
@@ -326,9 +326,9 @@ gtk_vscale_size_request (GtkWidget      *widget,
   scale = GTK_SCALE (widget);
 
   requisition->width = (RANGE_CLASS (scale)->slider_width +
-                        widget->style->klass->ythickness * 2);
+                        widget->style->ythickness * 2);
   requisition->height = (SCALE_CLASS (scale)->slider_length +
-                         widget->style->klass->xthickness) * 2;
+                         widget->style->xthickness) * 2;
   
   if (scale->draw_value)
     {
@@ -396,7 +396,7 @@ gtk_vscale_pos_trough (GtkVScale *vscale,
   scale = GTK_SCALE (vscale);
   
   *w = (RANGE_CLASS (scale)->slider_width +
-        widget->style->klass->xthickness * 2);
+        widget->style->xthickness * 2);
   *h = widget->allocation.height;
   
   if (scale->draw_value)
@@ -590,7 +590,7 @@ gtk_vscale_draw_value (GtkScale *scale)
 		       GTK_WIDGET (scale)->style->fg_gc [state_type],
 		       x, y, layout);
 
-      pango_layout_unref (layout);
+      g_object_unref (G_OBJECT (layout));
     }
 }
 
diff --git a/gtk/gtkvscrollbar.c b/gtk/gtkvscrollbar.c
index af4824353a..ae66d529de 100644
--- a/gtk/gtkvscrollbar.c
+++ b/gtk/gtkvscrollbar.c
@@ -163,11 +163,11 @@ gtk_vscrollbar_init (GtkVScrollbar *vscrollbar)
   requisition = &widget->requisition;
   
   requisition->width = (RANGE_CLASS (widget)->slider_width +
-                        widget->style->klass->xthickness * 2);
+                        widget->style->xthickness * 2);
   requisition->height = (RANGE_CLASS (widget)->min_slider_size +
                          RANGE_CLASS (widget)->stepper_size +
                          RANGE_CLASS (widget)->stepper_slider_spacing +
-                         widget->style->klass->ythickness) * 2;
+                         widget->style->ythickness) * 2;
 }
 
 GtkWidget*
@@ -217,20 +217,20 @@ gtk_vscrollbar_realize (GtkWidget *widget)
   range->trough = widget->window;
   gdk_window_ref (range->trough);
   
-  attributes.x = widget->style->klass->xthickness;
-  attributes.y = widget->style->klass->ythickness;
+  attributes.x = widget->style->xthickness;
+  attributes.y = widget->style->ythickness;
   attributes.width = RANGE_CLASS (widget)->stepper_size;
   attributes.height = RANGE_CLASS (widget)->stepper_size;
   
   range->step_back = gdk_window_new (range->trough, &attributes, attributes_mask);
   
   attributes.y = (widget->allocation.height -
-                  widget->style->klass->ythickness -
+                  widget->style->ythickness -
                   RANGE_CLASS (widget)->stepper_size);
   
   range->step_forw = gdk_window_new (range->trough, &attributes, attributes_mask);
   
-  attributes.x = widget->style->klass->ythickness;
+  attributes.x = widget->style->ythickness;
   attributes.y = 0;
   attributes.width = RANGE_CLASS (widget)->slider_width;
   attributes.height = RANGE_CLASS (widget)->min_slider_size;
@@ -279,15 +279,15 @@ gtk_vscrollbar_size_allocate (GtkWidget     *widget,
                               allocation->y,
                               widget->requisition.width, allocation->height);
       gdk_window_move_resize (range->step_back,
-                              widget->style->klass->xthickness,
-                              widget->style->klass->ythickness,
-                              widget->requisition.width - widget->style->klass->xthickness * 2,
+                              widget->style->xthickness,
+                              widget->style->ythickness,
+                              widget->requisition.width - widget->style->xthickness * 2,
                               RANGE_CLASS (widget)->stepper_size);
       gdk_window_move_resize (range->step_forw,
-                              widget->style->klass->xthickness,
-                              allocation->height - widget->style->klass->ythickness -
+                              widget->style->xthickness,
+                              allocation->height - widget->style->ythickness -
                               RANGE_CLASS (widget)->stepper_size,
-                              widget->requisition.width - widget->style->klass->xthickness * 2,
+                              widget->requisition.width - widget->style->xthickness * 2,
                               RANGE_CLASS (widget)->stepper_size);
       
       gtk_range_slider_update (GTK_RANGE (widget));
diff --git a/gtk/gtkvseparator.c b/gtk/gtkvseparator.c
index f74bdce463..bf537a1bb0 100644
--- a/gtk/gtkvseparator.c
+++ b/gtk/gtkvseparator.c
@@ -71,7 +71,7 @@ gtk_vseparator_class_init (GtkVSeparatorClass *klass)
 static void
 gtk_vseparator_init (GtkVSeparator *vseparator)
 {
-  GTK_WIDGET (vseparator)->requisition.width = GTK_WIDGET (vseparator)->style->klass->xthickness;
+  GTK_WIDGET (vseparator)->requisition.width = GTK_WIDGET (vseparator)->style->xthickness;
   GTK_WIDGET (vseparator)->requisition.height = 1;
 }
 
@@ -96,7 +96,7 @@ gtk_vseparator_expose (GtkWidget      *widget,
 		     widget->allocation.y,
 		     widget->allocation.y + widget->allocation.height,
 		     widget->allocation.x + (widget->allocation.width -
-					     widget->style->klass->xthickness) / 2);
+					     widget->style->xthickness) / 2);
 
   return FALSE;
 }
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index ab7a9fd628..1e15a26a8c 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -679,7 +679,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_leave),
 		    gtk_marshal_NONE__POINTER_UINT,
 		    GTK_TYPE_NONE, 2,
-		    GTK_TYPE_GDK_DRAG_CONTEXT,
+		    GDK_TYPE_DRAG_CONTEXT,
 		    GTK_TYPE_UINT);
   widget_signals[DRAG_BEGIN] =
     gtk_signal_new ("drag_begin",
@@ -688,7 +688,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_begin),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
-		    GTK_TYPE_GDK_DRAG_CONTEXT);
+		    GDK_TYPE_DRAG_CONTEXT);
   widget_signals[DRAG_END] =
     gtk_signal_new ("drag_end",
 		    GTK_RUN_LAST,
@@ -696,7 +696,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_end),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
-		    GTK_TYPE_GDK_DRAG_CONTEXT);
+		    GDK_TYPE_DRAG_CONTEXT);
   widget_signals[DRAG_DATA_DELETE] =
     gtk_signal_new ("drag_data_delete",
 		    GTK_RUN_LAST,
@@ -704,7 +704,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_delete),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
-		    GTK_TYPE_GDK_DRAG_CONTEXT);
+		    GDK_TYPE_DRAG_CONTEXT);
   widget_signals[DRAG_MOTION] =
     gtk_signal_new ("drag_motion",
 		    GTK_RUN_LAST,
@@ -712,7 +712,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_motion),
 		    gtk_marshal_BOOL__POINTER_INT_INT_UINT,
 		    GTK_TYPE_BOOL, 4,
-		    GTK_TYPE_GDK_DRAG_CONTEXT,
+		    GDK_TYPE_DRAG_CONTEXT,
 		    GTK_TYPE_INT,
 		    GTK_TYPE_INT,
 		    GTK_TYPE_UINT);
@@ -723,7 +723,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_drop),
 		    gtk_marshal_BOOL__POINTER_INT_INT_UINT,
 		    GTK_TYPE_BOOL, 4,
-		    GTK_TYPE_GDK_DRAG_CONTEXT,
+		    GDK_TYPE_DRAG_CONTEXT,
 		    GTK_TYPE_INT,
 		    GTK_TYPE_INT,
 		    GTK_TYPE_UINT);
@@ -734,7 +734,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_get),
 		    gtk_marshal_NONE__POINTER_POINTER_UINT_UINT,
 		    GTK_TYPE_NONE, 4,
-		    GTK_TYPE_GDK_DRAG_CONTEXT,
+		    GDK_TYPE_DRAG_CONTEXT,
 		    GTK_TYPE_SELECTION_DATA,
 		    GTK_TYPE_UINT,
 		    GTK_TYPE_UINT);
@@ -745,7 +745,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_received),
 		    gtk_marshal_NONE__POINTER_INT_INT_POINTER_UINT_UINT,
 		    GTK_TYPE_NONE, 6,
-		    GTK_TYPE_GDK_DRAG_CONTEXT,
+		    GDK_TYPE_DRAG_CONTEXT,
 		    GTK_TYPE_INT,
 		    GTK_TYPE_INT,
 		    GTK_TYPE_SELECTION_DATA,
@@ -3250,7 +3250,7 @@ gtk_widget_create_pango_layout (GtkWidget *widget)
 
   context = gtk_widget_create_pango_context (widget);
   layout = pango_layout_new (context);
-  pango_context_unref (context);
+  g_object_unref (G_OBJECT (context));
 
   return layout;
 }
@@ -4499,18 +4499,15 @@ static void
 gtk_reset_shapes_recurse (GtkWidget *widget,
 			  GdkWindow *window)
 {
-  GdkWindowPrivate *private;
   gpointer data;
   GList *list;
 
-  private = (GdkWindowPrivate*) window;
-
   gdk_window_get_user_data (window, &data);
   if (data != widget)
     return;
 
   gdk_window_shape_combine_mask (window, NULL, 0, 0);
-  for (list = private->children; list; list = list->next)
+  for (list = gdk_window_peek_children (window); list; list = list->next)
     gtk_reset_shapes_recurse (widget, list->data);
 }
 
diff --git a/modules/linux-fb/Makefile.am b/modules/linux-fb/Makefile.am
index 9289cfbfee..dbfae2dfbe 100644
--- a/modules/linux-fb/Makefile.am
+++ b/modules/linux-fb/Makefile.am
@@ -21,14 +21,17 @@ LDFLAGS = @STRIP_BEGIN@ \
 	-lm		\
 @STRIP_END@
 
-moduledir = $(libdir)/pango/modules
-module_LTLIBRARIES = fb-basic.la
+fb_basic_la_SOURCES = basic.c
 
 fb_basic_la_LDFLAGS = -export-dynamic -avoid-version -module
 fb_basic_la_LIBADD = $(PANGO_LIBS) -L$(top_builddir)/gdk/.libs -lgdk-linux-fb
-fb_basic_la_SOURCES = $(sources)
 
-fb_basic_la_SOURCES = basic.c
+if USE_LINUX_FB
+
+moduledir = $(libdir)/pango/modules
+module_LTLIBRARIES = fb-basic.la
+
+endif
 
 EXTRA_DIST =            \
         tables-big.i    \