documented necessary changes for 1.4 transition.

Fri May 12 17:13:32 2000  Tim Janik  <timj@gtk.org>

	* docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.

	* gtk/gtktext.c: made the adjustments no-construct args, simply
	provide default adjustments.
	(gtk_text_destroy): release adjustments.

	* gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
	adjustment argument non-construct.

	* gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
	instead of in finalize.
	(gtk_progress_get_text_from_value):
	(gtk_progress_get_current_text):
	(gtk_progress_set_value):
	(gtk_progress_get_percentage_from_value):
	(gtk_progress_get_current_percentage):
	(gtk_progress_set_percentage):
	(gtk_progress_configure): ensure an adjustment is present.

Thu May 11 01:24:08 2000  Tim Janik  <timj@gtk.org>

	* gtk/gtkcolorsel.[hc]:
	* gtk/gtkcolorseldialog.[hc]:
	* gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
	their parent implementation, use bit fields for boolean values, don't
	create unused widgets, usage of glib types, braces go on their own
	lines, function argument alignment, #include directives etc. etc. etc..

	* gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.

Wed May 10 23:29:52 2000  Tim Janik  <timj@gtk.org>

	* gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.

	* gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
	of NULL.

	* gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
	to freed data.
	(gtk_combo_destroy): don't keep a pointer to a destroyed window.

	* gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
	to NULL when the toplevel is getting destroyed.
	(gtk_menu_set_tearoff_state): same here for the tearoff_window.
	(gtk_menu_destroy):
	(gtk_menu_init): store the information of whether we have to
	readd the initial child ref_count during destruction in a new
	GtkMenu field needs_destruction_ref_count.

	* gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
	here, those reading: learn from my mistake! ;)
	in order for set_?adjustment to support a default adjustemnt if
	invoked with an adjustment pointer of NULL, the code read (pseudo):
	if (v->adjustment) unref (v->adjustment);
	if (!adjustment) adjustment = adjustment_new ();
	if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
	now imagine the first unref to actually free the old adjustment and
	adjustment_new() creating a new adjustment from the very same memory
	portion. here, the latter comparision will unintendedly fail, and
	all hell breaks loose.
	(gtk_viewport_set_hadjustment):
	(gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
	after unreferencing it.

	* gtk/gtkcontainer.[hc]: removed toplevel registration
	functions: gtk_container_register_toplevel(),
	gtk_container_unregister_toplevel() and
	gtk_container_get_toplevels() which had wrong semantics
	anyways: it didn't reference and copy the list.

	* gtk/gtkwindow.c: we take over the container toplevel registration
	bussiness now. windows are registered across multiple destructions,
	untill they are finalized. the initial implicit reference count
	users are holding on windows is removed with the first destruction
	though.
	(gtk_window_init): ref & sink and set has_user_ref_count, got
	rid of gtk_container_register_toplevel() call. add window to
	toplevel_list.
	(gtk_window_destroy): unref the window if has_user_ref_count
	is still set, got rid of call to
	gtk_container_unregister_toplevel().
	(gtk_window_finalize): remove window from toplevel list.
	(gtk_window_list_toplevels): new function to return a newly
	created list with referenced toplevels.
	(gtk_window_read_rcfiles): use gtk_window_list_toplevels().

	* gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
	adjustment a non-construct arg.
	* gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
	* gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
	* gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.

	* gtk/gtkrange.c: added some realized checks.
	(gtk_range_destroy): get rid of the h/v adjustments in the
	destroy handler instead of finalize. remove timer.
	(gtk_range_get_adjustment): demand create adjustment.

	* gtk/gtkviewport.c: made h/v adjustment non-construct args.
	we simply create them on demand now and get rid of them in
	the destroy handler.
	(gtk_viewport_destroy): get rid of the h/v adjustments in the
	destroy handler instead of finalize.
	(gtk_viewport_get_hadjustment):
	(gtk_viewport_get_vadjustment):
	(gtk_viewport_size_allocate): demand create h/v adjustment
	if required.

	* gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
	gtk_widget_real_destroy () functionality.
	(gtk_widget_real_destroy): reinitialize with a new style, instead
	of setting widget->style to NULL.

Fri May  5 13:02:09 2000  Tim Janik  <timj@gtk.org>

	* gtk/gtkcalendar.c:
	* gtk/gtkbutton.c: ported _get_type() implementation over to
	GType, either to preserve memchunks allocation facilities,
	or because Gtk+ 1.0 GtkTypeInfo was still being used.

	* gtk/gtkobject.[hc]: derive from GObject. ported various functions
	over. prepare for ::destroy to be emitted multiple times.
	removed reference tracer magic. chain into GObjectClass.shutdown()
	to emit ::destroy signal.

	* gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
	fundamental.

	* gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
	cludge.

	* gtk/gtksocket.c:
	* gtk/gtkplug.c:
	* gtk/gtklayout.c:
	* gtk/gtklabel.c:
	* gtk/gtkargcollector.c:
	* gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
	not being a fundamental anymore, and to work with the new
	type system (nuked fundamental type varargs clutter).

	* gtk/*.c: install finalize handlers in the GObjectClass
	part of the class structure.
	changed direct GTK_OBJECT()->klass accesses to
	GTK_*_GET_CLASS().
	changed direct object_class->type accesses to GTK_CLASS_TYPE().

	* gtktypeutils.[hc]: use the reserved fundamental ids provided by
	GType. made most of the GTK_*() type macros and Gtk* typedefs
	simple wrappers around macros and types provided by GType.
	most notably, a significant portion of the old API vanished:
	GTK_TYPE_MAKE(),
	GTK_TYPE_SEQNO(),
	GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
	GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
	GTK_TYPE_ARGS,
	GTK_TYPE_CALLBACK,
	GTK_TYPE_C_CALLBACK,
	GTK_TYPE_FOREIGN,
	GtkTypeQuery,
	gtk_type_query(),
	gtk_type_set_varargs_type(),
	gtk_type_get_varargs_type(),
	gtk_type_check_object_cast(),
	gtk_type_check_class_cast(),
	gtk_type_describe_tree(),
	gtk_type_describe_heritage(),
	gtk_type_free(),
	gtk_type_children_types(),
	gtk_type_set_chunk_alloc(),
	gtk_type_register_enum(),
	gtk_type_register_flags(),
	gtk_type_parent_class().
	replacements, where available are described in ../docs/Changes-1.4.txt.
	implemented compatibility functions for the remaining API.

	* configure.in: depend on glib 1.3.1, use gobject module.

94 files changed, 5965 insertions, 5624 deletions

diff --git a/ChangeLog b/ChangeLog
index d9c253216..89b764f45 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,181 @@
+Fri May 12 17:13:32 2000  Tim Janik  <timj@gtk.org>
+
+	* docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+	* gtk/gtktext.c: made the adjustments no-construct args, simply
+	provide default adjustments.
+	(gtk_text_destroy): release adjustments.
+
+	* gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+	adjustment argument non-construct.
+
+	* gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+	instead of in finalize.
+	(gtk_progress_get_text_from_value): 
+	(gtk_progress_get_current_text): 
+	(gtk_progress_set_value): 
+	(gtk_progress_get_percentage_from_value): 
+	(gtk_progress_get_current_percentage): 
+	(gtk_progress_set_percentage): 
+	(gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcolorsel.[hc]:
+	* gtk/gtkcolorseldialog.[hc]:
+	* gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+	their parent implementation, use bit fields for boolean values, don't
+	create unused widgets, usage of glib types, braces go on their own
+	lines, function argument alignment, #include directives etc. etc. etc..
+
+	* gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+	* gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+	of NULL.
+
+	* gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+	to freed data.
+	(gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+	* gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+	to NULL when the toplevel is getting destroyed.
+	(gtk_menu_set_tearoff_state): same here for the tearoff_window.
+	(gtk_menu_destroy): 
+	(gtk_menu_init): store the information of whether we have to
+	readd the initial child ref_count during destruction in a new
+	GtkMenu field needs_destruction_ref_count.
+
+	* gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+	here, those reading: learn from my mistake! ;)
+	in order for set_?adjustment to support a default adjustemnt if
+	invoked with an adjustment pointer of NULL, the code read (pseudo):
+	if (v->adjustment) unref (v->adjustment);
+	if (!adjustment) adjustment = adjustment_new ();
+	if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+	now imagine the first unref to actually free the old adjustment and
+	adjustment_new() creating a new adjustment from the very same memory
+	portion. here, the latter comparision will unintendedly fail, and
+	all hell breaks loose.
+	(gtk_viewport_set_hadjustment):
+	(gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+	after unreferencing it.
+
+	* gtk/gtkcontainer.[hc]: removed toplevel registration
+	functions: gtk_container_register_toplevel(),
+	gtk_container_unregister_toplevel() and
+	gtk_container_get_toplevels() which had wrong semantics
+	anyways: it didn't reference and copy the list.
+
+	* gtk/gtkwindow.c: we take over the container toplevel registration
+	bussiness now. windows are registered across multiple destructions,
+	untill they are finalized. the initial implicit reference count
+	users are holding on windows is removed with the first destruction
+	though.
+	(gtk_window_init): ref & sink and set has_user_ref_count, got
+	rid of gtk_container_register_toplevel() call. add window to
+	toplevel_list.
+	(gtk_window_destroy): unref the window if has_user_ref_count
+	is still set, got rid of call to
+	gtk_container_unregister_toplevel().
+	(gtk_window_finalize): remove window from toplevel list.
+	(gtk_window_list_toplevels): new function to return a newly
+	created list with referenced toplevels.
+	(gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+	* gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+	adjustment a non-construct arg.
+	* gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+	* gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+	* gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+	* gtk/gtkrange.c: added some realized checks.
+	(gtk_range_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize. remove timer.
+	(gtk_range_get_adjustment): demand create adjustment.
+
+	* gtk/gtkviewport.c: made h/v adjustment non-construct args.
+	we simply create them on demand now and get rid of them in
+	the destroy handler.
+	(gtk_viewport_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize.
+	(gtk_viewport_get_hadjustment): 
+	(gtk_viewport_get_vadjustment): 
+	(gtk_viewport_size_allocate): demand create h/v adjustment
+	if required.
+
+	* gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+	gtk_widget_real_destroy () functionality.
+	(gtk_widget_real_destroy): reinitialize with a new style, instead
+	of setting widget->style to NULL.
+
+Fri May  5 13:02:09 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcalendar.c:
+	* gtk/gtkbutton.c: ported _get_type() implementation over to
+	GType, either to preserve memchunks allocation facilities,
+	or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+	* gtk/gtkobject.[hc]: derive from GObject. ported various functions
+	over. prepare for ::destroy to be emitted multiple times.
+	removed reference tracer magic. chain into GObjectClass.shutdown()
+	to emit ::destroy signal.
+
+	* gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+	fundamental.
+
+	* gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+	cludge.
+
+	* gtk/gtksocket.c:
+	* gtk/gtkplug.c:
+	* gtk/gtklayout.c:
+	* gtk/gtklabel.c:
+	* gtk/gtkargcollector.c:
+	* gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+	not being a fundamental anymore, and to work with the new
+	type system (nuked fundamental type varargs clutter).
+
+	* gtk/*.c: install finalize handlers in the GObjectClass
+	part of the class structure.
+	changed direct GTK_OBJECT()->klass accesses to
+	GTK_*_GET_CLASS().
+	changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+	* gtktypeutils.[hc]: use the reserved fundamental ids provided by
+	GType. made most of the GTK_*() type macros and Gtk* typedefs
+	simple wrappers around macros and types provided by GType.
+	most notably, a significant portion of the old API vanished:
+	GTK_TYPE_MAKE(),
+	GTK_TYPE_SEQNO(),
+	GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+	GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+	GTK_TYPE_ARGS,
+	GTK_TYPE_CALLBACK,
+	GTK_TYPE_C_CALLBACK,
+	GTK_TYPE_FOREIGN,
+	GtkTypeQuery,
+	gtk_type_query(),
+	gtk_type_set_varargs_type(),
+	gtk_type_get_varargs_type(),
+	gtk_type_check_object_cast(),
+	gtk_type_check_class_cast(),
+	gtk_type_describe_tree(),
+	gtk_type_describe_heritage(),
+	gtk_type_free(),
+	gtk_type_children_types(),
+	gtk_type_set_chunk_alloc(),
+	gtk_type_register_enum(),
+	gtk_type_register_flags(),
+	gtk_type_parent_class().
+	replacements, where available are described in ../docs/Changes-1.4.txt.
+	implemented compatibility functions for the remaining API.
+
+	* configure.in: depend on glib 1.3.1, use gobject module.
+
 Thu May 11 12:39:50 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* TODO.xml: Various updates to current status.
diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0
index d9c253216..89b764f45 100644
--- a/ChangeLog.pre-2-0
+++ b/ChangeLog.pre-2-0
@@ -1,3 +1,181 @@
+Fri May 12 17:13:32 2000  Tim Janik  <timj@gtk.org>
+
+	* docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+	* gtk/gtktext.c: made the adjustments no-construct args, simply
+	provide default adjustments.
+	(gtk_text_destroy): release adjustments.
+
+	* gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+	adjustment argument non-construct.
+
+	* gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+	instead of in finalize.
+	(gtk_progress_get_text_from_value): 
+	(gtk_progress_get_current_text): 
+	(gtk_progress_set_value): 
+	(gtk_progress_get_percentage_from_value): 
+	(gtk_progress_get_current_percentage): 
+	(gtk_progress_set_percentage): 
+	(gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcolorsel.[hc]:
+	* gtk/gtkcolorseldialog.[hc]:
+	* gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+	their parent implementation, use bit fields for boolean values, don't
+	create unused widgets, usage of glib types, braces go on their own
+	lines, function argument alignment, #include directives etc. etc. etc..
+
+	* gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+	* gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+	of NULL.
+
+	* gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+	to freed data.
+	(gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+	* gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+	to NULL when the toplevel is getting destroyed.
+	(gtk_menu_set_tearoff_state): same here for the tearoff_window.
+	(gtk_menu_destroy): 
+	(gtk_menu_init): store the information of whether we have to
+	readd the initial child ref_count during destruction in a new
+	GtkMenu field needs_destruction_ref_count.
+
+	* gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+	here, those reading: learn from my mistake! ;)
+	in order for set_?adjustment to support a default adjustemnt if
+	invoked with an adjustment pointer of NULL, the code read (pseudo):
+	if (v->adjustment) unref (v->adjustment);
+	if (!adjustment) adjustment = adjustment_new ();
+	if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+	now imagine the first unref to actually free the old adjustment and
+	adjustment_new() creating a new adjustment from the very same memory
+	portion. here, the latter comparision will unintendedly fail, and
+	all hell breaks loose.
+	(gtk_viewport_set_hadjustment):
+	(gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+	after unreferencing it.
+
+	* gtk/gtkcontainer.[hc]: removed toplevel registration
+	functions: gtk_container_register_toplevel(),
+	gtk_container_unregister_toplevel() and
+	gtk_container_get_toplevels() which had wrong semantics
+	anyways: it didn't reference and copy the list.
+
+	* gtk/gtkwindow.c: we take over the container toplevel registration
+	bussiness now. windows are registered across multiple destructions,
+	untill they are finalized. the initial implicit reference count
+	users are holding on windows is removed with the first destruction
+	though.
+	(gtk_window_init): ref & sink and set has_user_ref_count, got
+	rid of gtk_container_register_toplevel() call. add window to
+	toplevel_list.
+	(gtk_window_destroy): unref the window if has_user_ref_count
+	is still set, got rid of call to
+	gtk_container_unregister_toplevel().
+	(gtk_window_finalize): remove window from toplevel list.
+	(gtk_window_list_toplevels): new function to return a newly
+	created list with referenced toplevels.
+	(gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+	* gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+	adjustment a non-construct arg.
+	* gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+	* gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+	* gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+	* gtk/gtkrange.c: added some realized checks.
+	(gtk_range_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize. remove timer.
+	(gtk_range_get_adjustment): demand create adjustment.
+
+	* gtk/gtkviewport.c: made h/v adjustment non-construct args.
+	we simply create them on demand now and get rid of them in
+	the destroy handler.
+	(gtk_viewport_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize.
+	(gtk_viewport_get_hadjustment): 
+	(gtk_viewport_get_vadjustment): 
+	(gtk_viewport_size_allocate): demand create h/v adjustment
+	if required.
+
+	* gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+	gtk_widget_real_destroy () functionality.
+	(gtk_widget_real_destroy): reinitialize with a new style, instead
+	of setting widget->style to NULL.
+
+Fri May  5 13:02:09 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcalendar.c:
+	* gtk/gtkbutton.c: ported _get_type() implementation over to
+	GType, either to preserve memchunks allocation facilities,
+	or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+	* gtk/gtkobject.[hc]: derive from GObject. ported various functions
+	over. prepare for ::destroy to be emitted multiple times.
+	removed reference tracer magic. chain into GObjectClass.shutdown()
+	to emit ::destroy signal.
+
+	* gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+	fundamental.
+
+	* gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+	cludge.
+
+	* gtk/gtksocket.c:
+	* gtk/gtkplug.c:
+	* gtk/gtklayout.c:
+	* gtk/gtklabel.c:
+	* gtk/gtkargcollector.c:
+	* gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+	not being a fundamental anymore, and to work with the new
+	type system (nuked fundamental type varargs clutter).
+
+	* gtk/*.c: install finalize handlers in the GObjectClass
+	part of the class structure.
+	changed direct GTK_OBJECT()->klass accesses to
+	GTK_*_GET_CLASS().
+	changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+	* gtktypeutils.[hc]: use the reserved fundamental ids provided by
+	GType. made most of the GTK_*() type macros and Gtk* typedefs
+	simple wrappers around macros and types provided by GType.
+	most notably, a significant portion of the old API vanished:
+	GTK_TYPE_MAKE(),
+	GTK_TYPE_SEQNO(),
+	GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+	GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+	GTK_TYPE_ARGS,
+	GTK_TYPE_CALLBACK,
+	GTK_TYPE_C_CALLBACK,
+	GTK_TYPE_FOREIGN,
+	GtkTypeQuery,
+	gtk_type_query(),
+	gtk_type_set_varargs_type(),
+	gtk_type_get_varargs_type(),
+	gtk_type_check_object_cast(),
+	gtk_type_check_class_cast(),
+	gtk_type_describe_tree(),
+	gtk_type_describe_heritage(),
+	gtk_type_free(),
+	gtk_type_children_types(),
+	gtk_type_set_chunk_alloc(),
+	gtk_type_register_enum(),
+	gtk_type_register_flags(),
+	gtk_type_parent_class().
+	replacements, where available are described in ../docs/Changes-1.4.txt.
+	implemented compatibility functions for the remaining API.
+
+	* configure.in: depend on glib 1.3.1, use gobject module.
+
 Thu May 11 12:39:50 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* TODO.xml: Various updates to current status.
diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10
index d9c253216..89b764f45 100644
--- a/ChangeLog.pre-2-10
+++ b/ChangeLog.pre-2-10
@@ -1,3 +1,181 @@
+Fri May 12 17:13:32 2000  Tim Janik  <timj@gtk.org>
+
+	* docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+	* gtk/gtktext.c: made the adjustments no-construct args, simply
+	provide default adjustments.
+	(gtk_text_destroy): release adjustments.
+
+	* gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+	adjustment argument non-construct.
+
+	* gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+	instead of in finalize.
+	(gtk_progress_get_text_from_value): 
+	(gtk_progress_get_current_text): 
+	(gtk_progress_set_value): 
+	(gtk_progress_get_percentage_from_value): 
+	(gtk_progress_get_current_percentage): 
+	(gtk_progress_set_percentage): 
+	(gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcolorsel.[hc]:
+	* gtk/gtkcolorseldialog.[hc]:
+	* gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+	their parent implementation, use bit fields for boolean values, don't
+	create unused widgets, usage of glib types, braces go on their own
+	lines, function argument alignment, #include directives etc. etc. etc..
+
+	* gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+	* gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+	of NULL.
+
+	* gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+	to freed data.
+	(gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+	* gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+	to NULL when the toplevel is getting destroyed.
+	(gtk_menu_set_tearoff_state): same here for the tearoff_window.
+	(gtk_menu_destroy): 
+	(gtk_menu_init): store the information of whether we have to
+	readd the initial child ref_count during destruction in a new
+	GtkMenu field needs_destruction_ref_count.
+
+	* gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+	here, those reading: learn from my mistake! ;)
+	in order for set_?adjustment to support a default adjustemnt if
+	invoked with an adjustment pointer of NULL, the code read (pseudo):
+	if (v->adjustment) unref (v->adjustment);
+	if (!adjustment) adjustment = adjustment_new ();
+	if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+	now imagine the first unref to actually free the old adjustment and
+	adjustment_new() creating a new adjustment from the very same memory
+	portion. here, the latter comparision will unintendedly fail, and
+	all hell breaks loose.
+	(gtk_viewport_set_hadjustment):
+	(gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+	after unreferencing it.
+
+	* gtk/gtkcontainer.[hc]: removed toplevel registration
+	functions: gtk_container_register_toplevel(),
+	gtk_container_unregister_toplevel() and
+	gtk_container_get_toplevels() which had wrong semantics
+	anyways: it didn't reference and copy the list.
+
+	* gtk/gtkwindow.c: we take over the container toplevel registration
+	bussiness now. windows are registered across multiple destructions,
+	untill they are finalized. the initial implicit reference count
+	users are holding on windows is removed with the first destruction
+	though.
+	(gtk_window_init): ref & sink and set has_user_ref_count, got
+	rid of gtk_container_register_toplevel() call. add window to
+	toplevel_list.
+	(gtk_window_destroy): unref the window if has_user_ref_count
+	is still set, got rid of call to
+	gtk_container_unregister_toplevel().
+	(gtk_window_finalize): remove window from toplevel list.
+	(gtk_window_list_toplevels): new function to return a newly
+	created list with referenced toplevels.
+	(gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+	* gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+	adjustment a non-construct arg.
+	* gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+	* gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+	* gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+	* gtk/gtkrange.c: added some realized checks.
+	(gtk_range_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize. remove timer.
+	(gtk_range_get_adjustment): demand create adjustment.
+
+	* gtk/gtkviewport.c: made h/v adjustment non-construct args.
+	we simply create them on demand now and get rid of them in
+	the destroy handler.
+	(gtk_viewport_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize.
+	(gtk_viewport_get_hadjustment): 
+	(gtk_viewport_get_vadjustment): 
+	(gtk_viewport_size_allocate): demand create h/v adjustment
+	if required.
+
+	* gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+	gtk_widget_real_destroy () functionality.
+	(gtk_widget_real_destroy): reinitialize with a new style, instead
+	of setting widget->style to NULL.
+
+Fri May  5 13:02:09 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcalendar.c:
+	* gtk/gtkbutton.c: ported _get_type() implementation over to
+	GType, either to preserve memchunks allocation facilities,
+	or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+	* gtk/gtkobject.[hc]: derive from GObject. ported various functions
+	over. prepare for ::destroy to be emitted multiple times.
+	removed reference tracer magic. chain into GObjectClass.shutdown()
+	to emit ::destroy signal.
+
+	* gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+	fundamental.
+
+	* gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+	cludge.
+
+	* gtk/gtksocket.c:
+	* gtk/gtkplug.c:
+	* gtk/gtklayout.c:
+	* gtk/gtklabel.c:
+	* gtk/gtkargcollector.c:
+	* gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+	not being a fundamental anymore, and to work with the new
+	type system (nuked fundamental type varargs clutter).
+
+	* gtk/*.c: install finalize handlers in the GObjectClass
+	part of the class structure.
+	changed direct GTK_OBJECT()->klass accesses to
+	GTK_*_GET_CLASS().
+	changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+	* gtktypeutils.[hc]: use the reserved fundamental ids provided by
+	GType. made most of the GTK_*() type macros and Gtk* typedefs
+	simple wrappers around macros and types provided by GType.
+	most notably, a significant portion of the old API vanished:
+	GTK_TYPE_MAKE(),
+	GTK_TYPE_SEQNO(),
+	GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+	GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+	GTK_TYPE_ARGS,
+	GTK_TYPE_CALLBACK,
+	GTK_TYPE_C_CALLBACK,
+	GTK_TYPE_FOREIGN,
+	GtkTypeQuery,
+	gtk_type_query(),
+	gtk_type_set_varargs_type(),
+	gtk_type_get_varargs_type(),
+	gtk_type_check_object_cast(),
+	gtk_type_check_class_cast(),
+	gtk_type_describe_tree(),
+	gtk_type_describe_heritage(),
+	gtk_type_free(),
+	gtk_type_children_types(),
+	gtk_type_set_chunk_alloc(),
+	gtk_type_register_enum(),
+	gtk_type_register_flags(),
+	gtk_type_parent_class().
+	replacements, where available are described in ../docs/Changes-1.4.txt.
+	implemented compatibility functions for the remaining API.
+
+	* configure.in: depend on glib 1.3.1, use gobject module.
+
 Thu May 11 12:39:50 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* TODO.xml: Various updates to current status.
diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2
index d9c253216..89b764f45 100644
--- a/ChangeLog.pre-2-2
+++ b/ChangeLog.pre-2-2
@@ -1,3 +1,181 @@
+Fri May 12 17:13:32 2000  Tim Janik  <timj@gtk.org>
+
+	* docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+	* gtk/gtktext.c: made the adjustments no-construct args, simply
+	provide default adjustments.
+	(gtk_text_destroy): release adjustments.
+
+	* gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+	adjustment argument non-construct.
+
+	* gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+	instead of in finalize.
+	(gtk_progress_get_text_from_value): 
+	(gtk_progress_get_current_text): 
+	(gtk_progress_set_value): 
+	(gtk_progress_get_percentage_from_value): 
+	(gtk_progress_get_current_percentage): 
+	(gtk_progress_set_percentage): 
+	(gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcolorsel.[hc]:
+	* gtk/gtkcolorseldialog.[hc]:
+	* gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+	their parent implementation, use bit fields for boolean values, don't
+	create unused widgets, usage of glib types, braces go on their own
+	lines, function argument alignment, #include directives etc. etc. etc..
+
+	* gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+	* gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+	of NULL.
+
+	* gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+	to freed data.
+	(gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+	* gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+	to NULL when the toplevel is getting destroyed.
+	(gtk_menu_set_tearoff_state): same here for the tearoff_window.
+	(gtk_menu_destroy): 
+	(gtk_menu_init): store the information of whether we have to
+	readd the initial child ref_count during destruction in a new
+	GtkMenu field needs_destruction_ref_count.
+
+	* gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+	here, those reading: learn from my mistake! ;)
+	in order for set_?adjustment to support a default adjustemnt if
+	invoked with an adjustment pointer of NULL, the code read (pseudo):
+	if (v->adjustment) unref (v->adjustment);
+	if (!adjustment) adjustment = adjustment_new ();
+	if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+	now imagine the first unref to actually free the old adjustment and
+	adjustment_new() creating a new adjustment from the very same memory
+	portion. here, the latter comparision will unintendedly fail, and
+	all hell breaks loose.
+	(gtk_viewport_set_hadjustment):
+	(gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+	after unreferencing it.
+
+	* gtk/gtkcontainer.[hc]: removed toplevel registration
+	functions: gtk_container_register_toplevel(),
+	gtk_container_unregister_toplevel() and
+	gtk_container_get_toplevels() which had wrong semantics
+	anyways: it didn't reference and copy the list.
+
+	* gtk/gtkwindow.c: we take over the container toplevel registration
+	bussiness now. windows are registered across multiple destructions,
+	untill they are finalized. the initial implicit reference count
+	users are holding on windows is removed with the first destruction
+	though.
+	(gtk_window_init): ref & sink and set has_user_ref_count, got
+	rid of gtk_container_register_toplevel() call. add window to
+	toplevel_list.
+	(gtk_window_destroy): unref the window if has_user_ref_count
+	is still set, got rid of call to
+	gtk_container_unregister_toplevel().
+	(gtk_window_finalize): remove window from toplevel list.
+	(gtk_window_list_toplevels): new function to return a newly
+	created list with referenced toplevels.
+	(gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+	* gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+	adjustment a non-construct arg.
+	* gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+	* gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+	* gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+	* gtk/gtkrange.c: added some realized checks.
+	(gtk_range_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize. remove timer.
+	(gtk_range_get_adjustment): demand create adjustment.
+
+	* gtk/gtkviewport.c: made h/v adjustment non-construct args.
+	we simply create them on demand now and get rid of them in
+	the destroy handler.
+	(gtk_viewport_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize.
+	(gtk_viewport_get_hadjustment): 
+	(gtk_viewport_get_vadjustment): 
+	(gtk_viewport_size_allocate): demand create h/v adjustment
+	if required.
+
+	* gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+	gtk_widget_real_destroy () functionality.
+	(gtk_widget_real_destroy): reinitialize with a new style, instead
+	of setting widget->style to NULL.
+
+Fri May  5 13:02:09 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcalendar.c:
+	* gtk/gtkbutton.c: ported _get_type() implementation over to
+	GType, either to preserve memchunks allocation facilities,
+	or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+	* gtk/gtkobject.[hc]: derive from GObject. ported various functions
+	over. prepare for ::destroy to be emitted multiple times.
+	removed reference tracer magic. chain into GObjectClass.shutdown()
+	to emit ::destroy signal.
+
+	* gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+	fundamental.
+
+	* gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+	cludge.
+
+	* gtk/gtksocket.c:
+	* gtk/gtkplug.c:
+	* gtk/gtklayout.c:
+	* gtk/gtklabel.c:
+	* gtk/gtkargcollector.c:
+	* gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+	not being a fundamental anymore, and to work with the new
+	type system (nuked fundamental type varargs clutter).
+
+	* gtk/*.c: install finalize handlers in the GObjectClass
+	part of the class structure.
+	changed direct GTK_OBJECT()->klass accesses to
+	GTK_*_GET_CLASS().
+	changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+	* gtktypeutils.[hc]: use the reserved fundamental ids provided by
+	GType. made most of the GTK_*() type macros and Gtk* typedefs
+	simple wrappers around macros and types provided by GType.
+	most notably, a significant portion of the old API vanished:
+	GTK_TYPE_MAKE(),
+	GTK_TYPE_SEQNO(),
+	GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+	GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+	GTK_TYPE_ARGS,
+	GTK_TYPE_CALLBACK,
+	GTK_TYPE_C_CALLBACK,
+	GTK_TYPE_FOREIGN,
+	GtkTypeQuery,
+	gtk_type_query(),
+	gtk_type_set_varargs_type(),
+	gtk_type_get_varargs_type(),
+	gtk_type_check_object_cast(),
+	gtk_type_check_class_cast(),
+	gtk_type_describe_tree(),
+	gtk_type_describe_heritage(),
+	gtk_type_free(),
+	gtk_type_children_types(),
+	gtk_type_set_chunk_alloc(),
+	gtk_type_register_enum(),
+	gtk_type_register_flags(),
+	gtk_type_parent_class().
+	replacements, where available are described in ../docs/Changes-1.4.txt.
+	implemented compatibility functions for the remaining API.
+
+	* configure.in: depend on glib 1.3.1, use gobject module.
+
 Thu May 11 12:39:50 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* TODO.xml: Various updates to current status.
diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4
index d9c253216..89b764f45 100644
--- a/ChangeLog.pre-2-4
+++ b/ChangeLog.pre-2-4
@@ -1,3 +1,181 @@
+Fri May 12 17:13:32 2000  Tim Janik  <timj@gtk.org>
+
+	* docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+	* gtk/gtktext.c: made the adjustments no-construct args, simply
+	provide default adjustments.
+	(gtk_text_destroy): release adjustments.
+
+	* gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+	adjustment argument non-construct.
+
+	* gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+	instead of in finalize.
+	(gtk_progress_get_text_from_value): 
+	(gtk_progress_get_current_text): 
+	(gtk_progress_set_value): 
+	(gtk_progress_get_percentage_from_value): 
+	(gtk_progress_get_current_percentage): 
+	(gtk_progress_set_percentage): 
+	(gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcolorsel.[hc]:
+	* gtk/gtkcolorseldialog.[hc]:
+	* gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+	their parent implementation, use bit fields for boolean values, don't
+	create unused widgets, usage of glib types, braces go on their own
+	lines, function argument alignment, #include directives etc. etc. etc..
+
+	* gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+	* gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+	of NULL.
+
+	* gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+	to freed data.
+	(gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+	* gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+	to NULL when the toplevel is getting destroyed.
+	(gtk_menu_set_tearoff_state): same here for the tearoff_window.
+	(gtk_menu_destroy): 
+	(gtk_menu_init): store the information of whether we have to
+	readd the initial child ref_count during destruction in a new
+	GtkMenu field needs_destruction_ref_count.
+
+	* gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+	here, those reading: learn from my mistake! ;)
+	in order for set_?adjustment to support a default adjustemnt if
+	invoked with an adjustment pointer of NULL, the code read (pseudo):
+	if (v->adjustment) unref (v->adjustment);
+	if (!adjustment) adjustment = adjustment_new ();
+	if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+	now imagine the first unref to actually free the old adjustment and
+	adjustment_new() creating a new adjustment from the very same memory
+	portion. here, the latter comparision will unintendedly fail, and
+	all hell breaks loose.
+	(gtk_viewport_set_hadjustment):
+	(gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+	after unreferencing it.
+
+	* gtk/gtkcontainer.[hc]: removed toplevel registration
+	functions: gtk_container_register_toplevel(),
+	gtk_container_unregister_toplevel() and
+	gtk_container_get_toplevels() which had wrong semantics
+	anyways: it didn't reference and copy the list.
+
+	* gtk/gtkwindow.c: we take over the container toplevel registration
+	bussiness now. windows are registered across multiple destructions,
+	untill they are finalized. the initial implicit reference count
+	users are holding on windows is removed with the first destruction
+	though.
+	(gtk_window_init): ref & sink and set has_user_ref_count, got
+	rid of gtk_container_register_toplevel() call. add window to
+	toplevel_list.
+	(gtk_window_destroy): unref the window if has_user_ref_count
+	is still set, got rid of call to
+	gtk_container_unregister_toplevel().
+	(gtk_window_finalize): remove window from toplevel list.
+	(gtk_window_list_toplevels): new function to return a newly
+	created list with referenced toplevels.
+	(gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+	* gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+	adjustment a non-construct arg.
+	* gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+	* gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+	* gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+	* gtk/gtkrange.c: added some realized checks.
+	(gtk_range_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize. remove timer.
+	(gtk_range_get_adjustment): demand create adjustment.
+
+	* gtk/gtkviewport.c: made h/v adjustment non-construct args.
+	we simply create them on demand now and get rid of them in
+	the destroy handler.
+	(gtk_viewport_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize.
+	(gtk_viewport_get_hadjustment): 
+	(gtk_viewport_get_vadjustment): 
+	(gtk_viewport_size_allocate): demand create h/v adjustment
+	if required.
+
+	* gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+	gtk_widget_real_destroy () functionality.
+	(gtk_widget_real_destroy): reinitialize with a new style, instead
+	of setting widget->style to NULL.
+
+Fri May  5 13:02:09 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcalendar.c:
+	* gtk/gtkbutton.c: ported _get_type() implementation over to
+	GType, either to preserve memchunks allocation facilities,
+	or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+	* gtk/gtkobject.[hc]: derive from GObject. ported various functions
+	over. prepare for ::destroy to be emitted multiple times.
+	removed reference tracer magic. chain into GObjectClass.shutdown()
+	to emit ::destroy signal.
+
+	* gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+	fundamental.
+
+	* gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+	cludge.
+
+	* gtk/gtksocket.c:
+	* gtk/gtkplug.c:
+	* gtk/gtklayout.c:
+	* gtk/gtklabel.c:
+	* gtk/gtkargcollector.c:
+	* gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+	not being a fundamental anymore, and to work with the new
+	type system (nuked fundamental type varargs clutter).
+
+	* gtk/*.c: install finalize handlers in the GObjectClass
+	part of the class structure.
+	changed direct GTK_OBJECT()->klass accesses to
+	GTK_*_GET_CLASS().
+	changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+	* gtktypeutils.[hc]: use the reserved fundamental ids provided by
+	GType. made most of the GTK_*() type macros and Gtk* typedefs
+	simple wrappers around macros and types provided by GType.
+	most notably, a significant portion of the old API vanished:
+	GTK_TYPE_MAKE(),
+	GTK_TYPE_SEQNO(),
+	GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+	GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+	GTK_TYPE_ARGS,
+	GTK_TYPE_CALLBACK,
+	GTK_TYPE_C_CALLBACK,
+	GTK_TYPE_FOREIGN,
+	GtkTypeQuery,
+	gtk_type_query(),
+	gtk_type_set_varargs_type(),
+	gtk_type_get_varargs_type(),
+	gtk_type_check_object_cast(),
+	gtk_type_check_class_cast(),
+	gtk_type_describe_tree(),
+	gtk_type_describe_heritage(),
+	gtk_type_free(),
+	gtk_type_children_types(),
+	gtk_type_set_chunk_alloc(),
+	gtk_type_register_enum(),
+	gtk_type_register_flags(),
+	gtk_type_parent_class().
+	replacements, where available are described in ../docs/Changes-1.4.txt.
+	implemented compatibility functions for the remaining API.
+
+	* configure.in: depend on glib 1.3.1, use gobject module.
+
 Thu May 11 12:39:50 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* TODO.xml: Various updates to current status.
diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6
index d9c253216..89b764f45 100644
--- a/ChangeLog.pre-2-6
+++ b/ChangeLog.pre-2-6
@@ -1,3 +1,181 @@
+Fri May 12 17:13:32 2000  Tim Janik  <timj@gtk.org>
+
+	* docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+	* gtk/gtktext.c: made the adjustments no-construct args, simply
+	provide default adjustments.
+	(gtk_text_destroy): release adjustments.
+
+	* gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+	adjustment argument non-construct.
+
+	* gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+	instead of in finalize.
+	(gtk_progress_get_text_from_value): 
+	(gtk_progress_get_current_text): 
+	(gtk_progress_set_value): 
+	(gtk_progress_get_percentage_from_value): 
+	(gtk_progress_get_current_percentage): 
+	(gtk_progress_set_percentage): 
+	(gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcolorsel.[hc]:
+	* gtk/gtkcolorseldialog.[hc]:
+	* gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+	their parent implementation, use bit fields for boolean values, don't
+	create unused widgets, usage of glib types, braces go on their own
+	lines, function argument alignment, #include directives etc. etc. etc..
+
+	* gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+	* gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+	of NULL.
+
+	* gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+	to freed data.
+	(gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+	* gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+	to NULL when the toplevel is getting destroyed.
+	(gtk_menu_set_tearoff_state): same here for the tearoff_window.
+	(gtk_menu_destroy): 
+	(gtk_menu_init): store the information of whether we have to
+	readd the initial child ref_count during destruction in a new
+	GtkMenu field needs_destruction_ref_count.
+
+	* gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+	here, those reading: learn from my mistake! ;)
+	in order for set_?adjustment to support a default adjustemnt if
+	invoked with an adjustment pointer of NULL, the code read (pseudo):
+	if (v->adjustment) unref (v->adjustment);
+	if (!adjustment) adjustment = adjustment_new ();
+	if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+	now imagine the first unref to actually free the old adjustment and
+	adjustment_new() creating a new adjustment from the very same memory
+	portion. here, the latter comparision will unintendedly fail, and
+	all hell breaks loose.
+	(gtk_viewport_set_hadjustment):
+	(gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+	after unreferencing it.
+
+	* gtk/gtkcontainer.[hc]: removed toplevel registration
+	functions: gtk_container_register_toplevel(),
+	gtk_container_unregister_toplevel() and
+	gtk_container_get_toplevels() which had wrong semantics
+	anyways: it didn't reference and copy the list.
+
+	* gtk/gtkwindow.c: we take over the container toplevel registration
+	bussiness now. windows are registered across multiple destructions,
+	untill they are finalized. the initial implicit reference count
+	users are holding on windows is removed with the first destruction
+	though.
+	(gtk_window_init): ref & sink and set has_user_ref_count, got
+	rid of gtk_container_register_toplevel() call. add window to
+	toplevel_list.
+	(gtk_window_destroy): unref the window if has_user_ref_count
+	is still set, got rid of call to
+	gtk_container_unregister_toplevel().
+	(gtk_window_finalize): remove window from toplevel list.
+	(gtk_window_list_toplevels): new function to return a newly
+	created list with referenced toplevels.
+	(gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+	* gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+	adjustment a non-construct arg.
+	* gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+	* gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+	* gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+	* gtk/gtkrange.c: added some realized checks.
+	(gtk_range_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize. remove timer.
+	(gtk_range_get_adjustment): demand create adjustment.
+
+	* gtk/gtkviewport.c: made h/v adjustment non-construct args.
+	we simply create them on demand now and get rid of them in
+	the destroy handler.
+	(gtk_viewport_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize.
+	(gtk_viewport_get_hadjustment): 
+	(gtk_viewport_get_vadjustment): 
+	(gtk_viewport_size_allocate): demand create h/v adjustment
+	if required.
+
+	* gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+	gtk_widget_real_destroy () functionality.
+	(gtk_widget_real_destroy): reinitialize with a new style, instead
+	of setting widget->style to NULL.
+
+Fri May  5 13:02:09 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcalendar.c:
+	* gtk/gtkbutton.c: ported _get_type() implementation over to
+	GType, either to preserve memchunks allocation facilities,
+	or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+	* gtk/gtkobject.[hc]: derive from GObject. ported various functions
+	over. prepare for ::destroy to be emitted multiple times.
+	removed reference tracer magic. chain into GObjectClass.shutdown()
+	to emit ::destroy signal.
+
+	* gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+	fundamental.
+
+	* gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+	cludge.
+
+	* gtk/gtksocket.c:
+	* gtk/gtkplug.c:
+	* gtk/gtklayout.c:
+	* gtk/gtklabel.c:
+	* gtk/gtkargcollector.c:
+	* gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+	not being a fundamental anymore, and to work with the new
+	type system (nuked fundamental type varargs clutter).
+
+	* gtk/*.c: install finalize handlers in the GObjectClass
+	part of the class structure.
+	changed direct GTK_OBJECT()->klass accesses to
+	GTK_*_GET_CLASS().
+	changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+	* gtktypeutils.[hc]: use the reserved fundamental ids provided by
+	GType. made most of the GTK_*() type macros and Gtk* typedefs
+	simple wrappers around macros and types provided by GType.
+	most notably, a significant portion of the old API vanished:
+	GTK_TYPE_MAKE(),
+	GTK_TYPE_SEQNO(),
+	GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+	GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+	GTK_TYPE_ARGS,
+	GTK_TYPE_CALLBACK,
+	GTK_TYPE_C_CALLBACK,
+	GTK_TYPE_FOREIGN,
+	GtkTypeQuery,
+	gtk_type_query(),
+	gtk_type_set_varargs_type(),
+	gtk_type_get_varargs_type(),
+	gtk_type_check_object_cast(),
+	gtk_type_check_class_cast(),
+	gtk_type_describe_tree(),
+	gtk_type_describe_heritage(),
+	gtk_type_free(),
+	gtk_type_children_types(),
+	gtk_type_set_chunk_alloc(),
+	gtk_type_register_enum(),
+	gtk_type_register_flags(),
+	gtk_type_parent_class().
+	replacements, where available are described in ../docs/Changes-1.4.txt.
+	implemented compatibility functions for the remaining API.
+
+	* configure.in: depend on glib 1.3.1, use gobject module.
+
 Thu May 11 12:39:50 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* TODO.xml: Various updates to current status.
diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8
index d9c253216..89b764f45 100644
--- a/ChangeLog.pre-2-8
+++ b/ChangeLog.pre-2-8
@@ -1,3 +1,181 @@
+Fri May 12 17:13:32 2000  Tim Janik  <timj@gtk.org>
+
+	* docs/Changes-1.4.txt: documented necessary changes for 1.4 transition.
+
+	* gtk/gtktext.c: made the adjustments no-construct args, simply
+	provide default adjustments.
+	(gtk_text_destroy): release adjustments.
+
+	* gtk/gtkprogressbar.c (gtk_progress_bar_class_init): made the
+	adjustment argument non-construct.
+
+	* gtk/gtkprogress.c (gtk_progress_destroy): release adjustment here,
+	instead of in finalize.
+	(gtk_progress_get_text_from_value): 
+	(gtk_progress_get_current_text): 
+	(gtk_progress_set_value): 
+	(gtk_progress_get_percentage_from_value): 
+	(gtk_progress_get_current_percentage): 
+	(gtk_progress_set_percentage): 
+	(gtk_progress_configure): ensure an adjustment is present.
+
+Thu May 11 01:24:08 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcolorsel.[hc]:
+	* gtk/gtkcolorseldialog.[hc]:
+	* gtk/gtkhsv.[hc]: major code cleanups, destroy handlers need to chain
+	their parent implementation, use bit fields for boolean values, don't
+	create unused widgets, usage of glib types, braces go on their own
+	lines, function argument alignment, #include directives etc. etc. etc..
+
+	* gtk/Makefile.am (gtk_public_h_sources): install gtkhsv.h.
+
+Wed May 10 23:29:52 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtktoolbar.c (gtk_toolbar_destroy): don't unref a NULL tooltips.
+
+	* gtk/gtkfilesel.c (gtk_file_selection_destroy): don't free a cmpl_state
+	of NULL.
+
+	* gtk/gtkcombo.c (gtk_combo_item_destroy): don#t keep references
+	to freed data.
+	(gtk_combo_destroy): don't keep a pointer to a destroyed window.
+
+	* gtk/gtkmenu.c (gtk_menu_init): reset the menu's toplevel pointer
+	to NULL when the toplevel is getting destroyed.
+	(gtk_menu_set_tearoff_state): same here for the tearoff_window.
+	(gtk_menu_destroy): 
+	(gtk_menu_init): store the information of whether we have to
+	readd the initial child ref_count during destruction in a new
+	GtkMenu field needs_destruction_ref_count.
+
+	* gtk/gtkviewport.c: SHAME! ok this one is tricky, so i note it
+	here, those reading: learn from my mistake! ;)
+	in order for set_?adjustment to support a default adjustemnt if
+	invoked with an adjustment pointer of NULL, the code read (pseudo):
+	if (v->adjustment) unref (v->adjustment);
+	if (!adjustment) adjustment = adjustment_new ();
+	if (v->adjustment != adjustment) v->adjustment = ref (adjustment);
+	now imagine the first unref to actually free the old adjustment and
+	adjustment_new() creating a new adjustment from the very same memory
+	portion. here, the latter comparision will unintendedly fail, and
+	all hell breaks loose.
+	(gtk_viewport_set_hadjustment):
+	(gtk_viewport_set_vadjustment): reset viewport->?adjustment to NULL
+	after unreferencing it.
+
+	* gtk/gtkcontainer.[hc]: removed toplevel registration
+	functions: gtk_container_register_toplevel(),
+	gtk_container_unregister_toplevel() and
+	gtk_container_get_toplevels() which had wrong semantics
+	anyways: it didn't reference and copy the list.
+
+	* gtk/gtkwindow.c: we take over the container toplevel registration
+	bussiness now. windows are registered across multiple destructions,
+	untill they are finalized. the initial implicit reference count
+	users are holding on windows is removed with the first destruction
+	though.
+	(gtk_window_init): ref & sink and set has_user_ref_count, got
+	rid of gtk_container_register_toplevel() call. add window to
+	toplevel_list.
+	(gtk_window_destroy): unref the window if has_user_ref_count
+	is still set, got rid of call to
+	gtk_container_unregister_toplevel().
+	(gtk_window_finalize): remove window from toplevel list.
+	(gtk_window_list_toplevels): new function to return a newly
+	created list with referenced toplevels.
+	(gtk_window_read_rcfiles): use gtk_window_list_toplevels().
+
+	* gtk/gtkhscale.c (gtk_hscale_class_init): made the GtkRange
+	adjustment a non-construct arg.
+	* gtk/gtkvscale.c (gtk_vscale_class_init): likewise.
+	* gtk/gtkhscrollbar.c (gtk_vscrollbar_class_init): likewise.
+	* gtk/gtkvscrollbar.c (gtk_vscrollbar_class_init): likewise.
+
+	* gtk/gtkrange.c: added some realized checks.
+	(gtk_range_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize. remove timer.
+	(gtk_range_get_adjustment): demand create adjustment.
+
+	* gtk/gtkviewport.c: made h/v adjustment non-construct args.
+	we simply create them on demand now and get rid of them in
+	the destroy handler.
+	(gtk_viewport_destroy): get rid of the h/v adjustments in the
+	destroy handler instead of finalize.
+	(gtk_viewport_get_hadjustment): 
+	(gtk_viewport_get_vadjustment): 
+	(gtk_viewport_size_allocate): demand create h/v adjustment
+	if required.
+
+	* gtk/gtkwidget.c (gtk_widget_finalize): duplicate part of the
+	gtk_widget_real_destroy () functionality.
+	(gtk_widget_real_destroy): reinitialize with a new style, instead
+	of setting widget->style to NULL.
+
+Fri May  5 13:02:09 2000  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcalendar.c:
+	* gtk/gtkbutton.c: ported _get_type() implementation over to
+	GType, either to preserve memchunks allocation facilities,
+	or because Gtk+ 1.0 GtkTypeInfo was still being used.
+
+	* gtk/gtkobject.[hc]: derive from GObject. ported various functions
+	over. prepare for ::destroy to be emitted multiple times.
+	removed reference tracer magic. chain into GObjectClass.shutdown()
+	to emit ::destroy signal.
+
+	* gtk/gtksignal.c: removed assumptions about GTK_TYPE_OBJECT being
+	fundamental.
+
+	* gtk/gtkmain.c: removed gtk_object_post_arg_parsing_init()
+	cludge.
+
+	* gtk/gtksocket.c:
+	* gtk/gtkplug.c:
+	* gtk/gtklayout.c:
+	* gtk/gtklabel.c:
+	* gtk/gtkargcollector.c:
+	* gtk/gtkarg.c: various fixups to work with GTK_TYPE_OBJECT
+	not being a fundamental anymore, and to work with the new
+	type system (nuked fundamental type varargs clutter).
+
+	* gtk/*.c: install finalize handlers in the GObjectClass
+	part of the class structure.
+	changed direct GTK_OBJECT()->klass accesses to
+	GTK_*_GET_CLASS().
+	changed direct object_class->type accesses to GTK_CLASS_TYPE().
+
+	* gtktypeutils.[hc]: use the reserved fundamental ids provided by
+	GType. made most of the GTK_*() type macros and Gtk* typedefs
+	simple wrappers around macros and types provided by GType.
+	most notably, a significant portion of the old API vanished:
+	GTK_TYPE_MAKE(),
+	GTK_TYPE_SEQNO(),
+	GTK_TYPE_FLAT_FIRST, GTK_TYPE_FLAT_LAST,
+	GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST,
+	GTK_TYPE_ARGS,
+	GTK_TYPE_CALLBACK,
+	GTK_TYPE_C_CALLBACK,
+	GTK_TYPE_FOREIGN,
+	GtkTypeQuery,
+	gtk_type_query(),
+	gtk_type_set_varargs_type(),
+	gtk_type_get_varargs_type(),
+	gtk_type_check_object_cast(),
+	gtk_type_check_class_cast(),
+	gtk_type_describe_tree(),
+	gtk_type_describe_heritage(),
+	gtk_type_free(),
+	gtk_type_children_types(),
+	gtk_type_set_chunk_alloc(),
+	gtk_type_register_enum(),
+	gtk_type_register_flags(),
+	gtk_type_parent_class().
+	replacements, where available are described in ../docs/Changes-1.4.txt.
+	implemented compatibility functions for the remaining API.
+
+	* configure.in: depend on glib 1.3.1, use gobject module.
+
 Thu May 11 12:39:50 2000  Owen Taylor  <otaylor@redhat.com>
 
 	* TODO.xml: Various updates to current status.
diff --git a/configure.in b/configure.in
index da5127cad..da0742b5c 100644
--- a/configure.in
+++ b/configure.in
@@ -252,16 +252,16 @@ fi
 if test x$with_glib = x ; then 
   # Look for separately installed glib
 
-  AM_PATH_GLIB(1.3.0,,
+  AM_PATH_GLIB(1.3.1,,
     AC_MSG_ERROR([
 *** GLIB 1.3.0 or better is required. The latest version of GLIB
 *** is always available from ftp://ftp.gtk.org/.]),
-    gmodule gthread)
+    gobject gmodule gthread)
 
   # we do not want to make all gtk progs to link to thread libraries.
-  glib_cflags=`$GLIB_CONFIG glib gmodule --cflags`
+  glib_cflags=`$GLIB_CONFIG glib gobject gmodule --cflags`
   glib_thread_cflags="$GLIB_CFLAGS"
-  glib_libs=`$GLIB_CONFIG glib gmodule --libs`
+  glib_libs=`$GLIB_CONFIG glib gobject gmodule --libs`
   glib_thread_libs="$GLIB_LIBS"
   GLIB_LIBS="$glib_libs"
   GLIB_DEPLIBS="$glib_libs"
diff --git a/docs/Changes-1.4.txt b/docs/Changes-1.4.txt
index f86091d92..1392394c7 100644
--- a/docs/Changes-1.4.txt
+++ b/docs/Changes-1.4.txt
@@ -1,26 +1,101 @@
 Incompatible Changes from GTK+-1.2 to GTK+-1.4:
 
-- The gdk_time* functions have been removed. This functionality
+* The gdk_time* functions have been removed. This functionality
   has been unused since the main loop was moved into GLib
   prior to 1.2. 
 
-- The signature for GtkPrintFunc (used for gtk_item_factory_dump_items)
+* The signature for GtkPrintFunc (used for gtk_item_factory_dump_items)
   has been changed to take a 'const gchar *' instead of 'gchar *', to
   match what we do for glib, and other similar cases.
 
-- The detail arguments in the GtkStyleClass structure are now 'const gchar *'.
+* The detail arguments in the GtkStyleClass structure are now 'const gchar *'.
 
-- gtk_paned_set_gutter_size() has been removed, since the small handle tab
+* gtk_paned_set_gutter_size() has been removed, since the small handle tab
   has been changed to include the entire area previously occupied by
   the gutter.
 
-- GDK no longer selects OwnerGrabButtonMask for button presses. This means  
+* GDK no longer selects OwnerGrabButtonMask for button presses. This means  
   that the automatic grab that occurs when the user presses a button
   will have owner_events = FALSE, so all events are redirected to the
   grab window, even events that would normally go to  other windows of the
   window's owner.
 
-- The detail arguments in the GtkStyleClass structure are now 'const gchar *'.
+* GtkColorSelectionDialog has now been moved into it's own set of files,
+  gtkcolorseldialog.c and gtkcolorseldialog.h.
 
-- GtkColorSelectionDialog has now been moved into it's own set of files,
-gtkcolorseldialog.c and gtkcolorseldialog.h. 
+* Type system changes:
+  - GTK_TYPE_OBJECT is not a fundamental type anymore. Type checks of the
+    style (GTK_FUNDAMENTAL_TYPE (some_type) == GTK_TYPE_OBJECT)
+    will not work anymore. As a replacement, (GTK_TYPE_IS_OBJECT (some_type))
+    can be used now.
+  - The following types vanished: GTK_TYPE_ARGS, GTK_TYPE_CALLBACK,
+    GTK_TYPE_C_CALLBACK, GTK_TYPE_FOREIGN. With them, the corresponding GtkARg
+    fields and field access macros vanished as well.
+  - The following type aliases vanished: GTK_TYPE_FLAT_FIRST,
+    GTK_TYPE_FLAT_LAST, GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST.
+  - The type macros GTK_TYPE_MAKE() and GTK_TYPE_SEQNO() vanished, use of
+    GTK_FUNDAMENTAL_TYPE() is discouraged. Instead, the corresponding GType
+    API should be used: G_TYPE_FUNDAMENTAL(), G_TYPE_DERIVE_ID(),
+    G_TYPE_BRANCH_SEQNO(). Note that the GLib type system doesn't build new
+    type ids based on a global incremental sequential number anymore, but
+    numbers new type ids sequentially per fundamental type branch.
+  - The following type functions vanished/were replaced:
+    Old Function		 Replacement
+    gtk_type_query()		 - being investigated -
+    gtk_type_set_varargs_type()	 -
+    gtk_type_get_varargs_type()	 -
+    gtk_type_check_object_cast() g_type_check_instance_cast()
+    gtk_type_check_class_cast()	 g_type_check_class_cast()
+    gtk_type_describe_tree()	 -
+    gtk_type_describe_heritage() -
+    gtk_type_free()		 -
+    gtk_type_children_types()	 g_type_children()
+    gtk_type_set_chunk_alloc()	 GTypeInfo.n_preallocs
+    gtk_type_register_enum()	 g_enum_register_static()
+    gtk_type_register_flags()	 g_flags_register_static()
+    gtk_type_parent_class()	 g_type_parent() / g_type_class_peek_parent()
+    Use of g_type_class_ref() / g_type_class_unref() and g_type_class_peek()
+    is recommended over usage of gtk_type_class().
+    Use of g_type_register_static() / g_type_register_dynamic() is recommended
+    over usage of gtk_type_unique().
+
+* Object system changes:
+  GtkObject derives from GObject, it is not the basic object type anymore.
+  This imposes the following source incompatible changes:
+  - GtkObject has no klass field anymore, an object's class can be retrived
+    with the object's coresponding GTK_<OBJECT>_GET_CLASS (object) macro.
+  - GtkObjectClass has no type field anymore, a class's type can be retrived
+    with the GTK_CLASS_TYPE (class) macro.
+  - GtkObjectClass does not introduce the finalize() or shutdown() method
+    anymore. While shutdown() is intended for Gtk internal use only, finalize()
+    is required by a variety of object implementations. GObjectClass.finalize
+    should be overriden here, e.g.:
+    static void gtk_label_finalize (GObject *gobject)
+    {
+      GtkLabel *label = GTK_LABEL (gobject);
+      
+      G_OBJECT_CLASS (parent_class)->finalize (object);
+    }
+    static void gtk_label_class_init (GtkLabelClass *class)
+    {
+      GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+      
+      gobject_class->finalize = gtk_label_finalize;
+    }
+  - the GtkObject::destroy signal can be emitted multiple times on an object
+    now. ::destroy implementations have to take this into account by
+    conditionalising freeing/release of assorted resources, e.g.:
+    if (object->foo_data)
+      {
+        g_free (object->foo_data);
+        object->foo_data = NULL;
+      }
+    Also, ::destroy implementations have to release peding object references,
+    that is, code portions commonly found in finalize implementations like:
+    if (object->adjustment)
+      {
+        gtk_object_unref (object->adjustment);
+        object->adjustment = NULL;
+      }
+    have to be moved into the ::destroy implementations.
+    This is required to break object reference cycles at destruction time.
diff --git a/gtk/Makefile.am b/gtk/Makefile.am
index 6c2a2d6ad..278825aeb 100644
--- a/gtk/Makefile.am
+++ b/gtk/Makefile.am
@@ -92,6 +92,7 @@ gtk_public_h_sources = @STRIP_BEGIN@ \
 	gtkhscale.h		\
 	gtkhscrollbar.h		\
 	gtkhseparator.h		\
+	gtkhsv.h		\
 	gtkimage.h		\
 	gtkinputdialog.h	\
 	gtkinvisible.h		\
diff --git a/gtk/genmarshal.pl b/gtk/genmarshal.pl
index 067afd3fb..cfde7948b 100755
--- a/gtk/genmarshal.pl
+++ b/gtk/genmarshal.pl
@@ -13,11 +13,7 @@
 	   "OBJECT"=>"gpointer",
 
 # complex types. These need special handling.
-		"FOREIGN"=>"FOREIGN",
-		"C_CALLBACK"=>"C_CALLBACK",
-		"SIGNAL"=>"SIGNAL",
-		"ARGS"=>"ARGS",
-		"CALLBACK"=>"CALLBACK"
+		"SIGNAL"=>"SIGNAL"
 		);
 
 if ($#ARGV != 2) {
@@ -106,24 +102,7 @@ EOT
   print OS "typedef $trans{$retval} (*GtkSignal_$funcname) (GtkObject *object, \n";
   $argn = 1;
   for (@params) { 
-	if($_ eq "C_CALLBACK") {
-		print OS "gpointer arg".$argn."a,\n";
-		print OS "gpointer arg".$argn."b,\n";
-		$argn++;
-	} elsif($_ eq "SIGNAL") {
-		print OS "gpointer arg".$argn."a,\n";
-		print OS "gpointer arg".$argn."b,\n";
-		$argn++;
-	} elsif($_ eq "ARGS") {
-		print OS "gpointer arg".$argn."a,\n";
-		print OS "gpointer arg".$argn."b,\n";
-		$argn++;
-	} elsif($_ eq "CALLBACK") {
-		print OS "gpointer arg".$argn."a,\n";
-		print OS "gpointer arg".$argn."b,\n";
-		print OS "gpointer arg".$argn."c,\n";
-		$argn++;
-	} elsif($_ eq "FOREIGN") {
+	if($_ eq "SIGNAL") {
 		print OS "gpointer arg".$argn."a,\n";
 		print OS "gpointer arg".$argn."b,\n";
 		$argn++;
@@ -153,27 +132,11 @@ EOT
   print OS                  " (* rfunc) (object,\n";
 
   for($i = 0; $i < (scalar @params); $i++) {
-      if($params[$i] eq "C_CALLBACK") {
-	print OS <<EOT;
-GTK_VALUE_C_CALLBACK(args[$i]).func,
-GTK_VALUE_C_CALLBACK(args[$i]).func_data,
-EOT
-      } elsif ($params[$i] eq "SIGNAL") {
+      if ($params[$i] eq "SIGNAL") {
 	print OS <<EOT;
 GTK_VALUE_SIGNAL(args[$i]).f,
 GTK_VALUE_SIGNAL(args[$i]).d,
 EOT
-      } elsif ($params[$i] eq "CALLBACK") {
-	print OS <<EOT;
-GTK_VALUE_CALLBACK(args[$i]).marshal,
-GTK_VALUE_CALLBACK(args[$i]).data,
-GTK_VALUE_CALLBACK(args[$i]).notify,
-EOT
-      } elsif ($params[$i] eq "FOREIGN") {
-	print OS <<EOT;
-GTK_VALUE_FOREIGN(args[$i]).data,
-GTK_VALUE_FOREIGN(args[$i]).notify,
-EOT
       } elsif ($params[$i] eq "NONE") {
       } else {
 	print OS "                      GTK_VALUE_$params[$i](args[$i]),\n";
diff --git a/gtk/gtk.def b/gtk/gtk.def
index 5cc80d511..40be976e4 100755
--- a/gtk/gtk.def
+++ b/gtk/gtk.def
@@ -685,8 +685,6 @@ EXPORTS
 	gtk_marshal_INT__POINTER
 	gtk_marshal_INT__POINTER_CHAR_CHAR
 	gtk_marshal_NONE__BOOL
-	gtk_marshal_NONE__C_CALLBACK
-	gtk_marshal_NONE__C_CALLBACK_C_CALLBACK
 	gtk_marshal_NONE__INT
 	gtk_marshal_NONE__INT_FLOAT
 	gtk_marshal_NONE__INT_FLOAT_BOOL
diff --git a/gtk/gtkaccelgroup.c b/gtk/gtkaccelgroup.c
index ddf6510a6..04dbfd0d6 100644
--- a/gtk/gtkaccelgroup.c
+++ b/gtk/gtkaccelgroup.c
@@ -656,7 +656,7 @@ gtk_accel_group_create_add (GtkType          class_type,
 			    GtkSignalRunType signal_flags,
 			    guint            handler_offset)
 {
-  g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_OBJECT), 0);
+  g_return_val_if_fail (GTK_TYPE_IS_OBJECT (class_type), 0);
 
   return gtk_signal_new ("add-accelerator",
 			 signal_flags,
@@ -676,7 +676,7 @@ gtk_accel_group_create_remove (GtkType          class_type,
 			       GtkSignalRunType signal_flags,
 			       guint            handler_offset)
 {
-  g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_OBJECT), 0);
+  g_return_val_if_fail (GTK_TYPE_IS_OBJECT (class_type), 0);
 
   return gtk_signal_new ("remove-accelerator",
 			 signal_flags,
diff --git a/gtk/gtkaccellabel.c b/gtk/gtkaccellabel.c
index 6861c2987..665396aa2 100644
--- a/gtk/gtkaccellabel.c
+++ b/gtk/gtkaccellabel.c
@@ -48,7 +48,7 @@ static void gtk_accel_label_get_arg	 (GtkObject      *object,
 					  GtkArg	 *arg,
 					  guint		  arg_id);
 static void gtk_accel_label_destroy	 (GtkObject	 *object);
-static void gtk_accel_label_finalize	 (GtkObject	 *object);
+static void gtk_accel_label_finalize	 (GObject	 *object);
 static void gtk_accel_label_size_request (GtkWidget	 *widget,
 					  GtkRequisition *requisition);
 static gint gtk_accel_label_expose_event (GtkWidget	 *widget,
@@ -87,6 +87,7 @@ gtk_accel_label_get_type (void)
 static void
 gtk_accel_label_class_init (GtkAccelLabelClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkMiscClass *misc_class;
@@ -102,10 +103,11 @@ gtk_accel_label_class_init (GtkAccelLabelClass *class)
   
   gtk_object_add_arg_type ("GtkAccelLabel::accel_widget", GTK_TYPE_WIDGET, GTK_ARG_READWRITE, ARG_ACCEL_WIDGET);
 
+  gobject_class->finalize = gtk_accel_label_finalize;
+
   object_class->set_arg = gtk_accel_label_set_arg;
   object_class->get_arg = gtk_accel_label_get_arg;
   object_class->destroy = gtk_accel_label_destroy;
-  object_class->finalize = gtk_accel_label_finalize;
   
   widget_class->size_request = gtk_accel_label_size_request;
   widget_class->expose_event = gtk_accel_label_expose_event;
@@ -200,18 +202,17 @@ gtk_accel_label_destroy (GtkObject *object)
 }
 
 static void
-gtk_accel_label_finalize (GtkObject *object)
+gtk_accel_label_finalize (GObject *object)
 {
   GtkAccelLabel *accel_label;
   
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_ACCEL_LABEL (object));
   
   accel_label = GTK_ACCEL_LABEL (object);
   
   g_free (accel_label->accel_string);
   
-  GTK_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 guint
@@ -376,7 +377,7 @@ gtk_accel_label_refetch (GtkAccelLabel *accel_label)
   g_return_val_if_fail (accel_label != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_ACCEL_LABEL (accel_label), FALSE);
 
-  class = GTK_ACCEL_LABEL_CLASS (GTK_OBJECT (accel_label)->klass);
+  class = GTK_ACCEL_LABEL_GET_CLASS (accel_label);
   
   g_free (accel_label->accel_string);
   accel_label->accel_string = NULL;
diff --git a/gtk/gtkadjustment.c b/gtk/gtkadjustment.c
index 31173ae0e..d33f32897 100644
--- a/gtk/gtkadjustment.c
+++ b/gtk/gtkadjustment.c
@@ -77,14 +77,14 @@ gtk_adjustment_class_init (GtkAdjustmentClass *class)
   adjustment_signals[CHANGED] =
     gtk_signal_new ("changed",
                     GTK_RUN_FIRST | GTK_RUN_NO_RECURSE,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkAdjustmentClass, changed),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   adjustment_signals[VALUE_CHANGED] =
     gtk_signal_new ("value_changed",
                     GTK_RUN_FIRST | GTK_RUN_NO_RECURSE,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkAdjustmentClass, value_changed),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
diff --git a/gtk/gtkarg.c b/gtk/gtkarg.c
index bdd7003c0..105df1626 100644
--- a/gtk/gtkarg.c
+++ b/gtk/gtkarg.c
@@ -65,7 +65,7 @@ gtk_arg_type_new_static (GtkType      base_class_type,
   gchar *p;
 
   g_return_val_if_fail (arg_name != NULL, NULL);
-  g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (base_class_type) == GTK_TYPE_OBJECT, NULL);
+  g_return_val_if_fail (GTK_TYPE_IS_OBJECT (base_class_type), NULL);
   g_return_val_if_fail (class_n_args_offset != 0, NULL);
   g_return_val_if_fail (arg_info_hash_table != NULL, NULL);
   g_return_val_if_fail (arg_type > GTK_TYPE_NONE, NULL);
@@ -214,7 +214,7 @@ gtk_arg_get_info (GtkType       object_type,
   else
     {
       otype = object_type;
-      while (!*info_p && GTK_FUNDAMENTAL_TYPE (otype) == GTK_TYPE_OBJECT)
+      while (!*info_p && GTK_TYPE_IS_OBJECT (otype))
 	{
 	  GtkArgInfo info;
 	  
@@ -440,12 +440,6 @@ gtk_arg_reset (GtkArg *arg)
   g_return_if_fail (arg != NULL);
 
   fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type);
-  if (fundamental_type > GTK_TYPE_FUNDAMENTAL_LAST)
-    {
-      fundamental_type = gtk_type_get_varargs_type (fundamental_type);
-      if (!fundamental_type)
-        fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type);
-    }
 
   if (fundamental_type == GTK_TYPE_STRING)
     {
@@ -503,12 +497,6 @@ gtk_arg_values_equal (const GtkArg *arg1,
 			GTK_FUNDAMENTAL_TYPE (arg2->type), FALSE);
   
   fundamental_type = GTK_FUNDAMENTAL_TYPE (arg1->type);
-  if (fundamental_type > GTK_TYPE_FUNDAMENTAL_LAST)
-    {
-      fundamental_type = gtk_type_get_varargs_type (fundamental_type);
-      if (!fundamental_type)
-        fundamental_type = GTK_FUNDAMENTAL_TYPE (arg1->type);
-    }
   
   switch (fundamental_type)
     {
@@ -555,20 +543,7 @@ gtk_arg_values_equal (const GtkArg *arg1,
     case GTK_TYPE_BOXED:
       equal = GTK_VALUE_BOXED (*arg1) == GTK_VALUE_BOXED (*arg2);
       break;
-    case GTK_TYPE_FOREIGN:
-      equal = (GTK_VALUE_FOREIGN (*arg1).data == GTK_VALUE_FOREIGN (*arg2).data &&
-	       GTK_VALUE_FOREIGN (*arg1).notify == GTK_VALUE_FOREIGN (*arg2).notify);
-      break;
-    case GTK_TYPE_CALLBACK:
-      equal = (GTK_VALUE_CALLBACK (*arg1).marshal == GTK_VALUE_CALLBACK (*arg2).marshal &&
-	       GTK_VALUE_CALLBACK (*arg1).data == GTK_VALUE_CALLBACK (*arg2).data &&
-	       GTK_VALUE_CALLBACK (*arg1).notify == GTK_VALUE_CALLBACK (*arg2).notify);
-      break;
-    case GTK_TYPE_ARGS:
-      equal = (GTK_VALUE_ARGS (*arg1).n_args == GTK_VALUE_ARGS (*arg2).n_args &&
-	       GTK_VALUE_ARGS (*arg1).args == GTK_VALUE_ARGS (*arg2).args);
-      break;
-    case GTK_TYPE_OBJECT:
+    case G_TYPE_OBJECT:
       equal = GTK_VALUE_OBJECT (*arg1) == GTK_VALUE_OBJECT (*arg2);
       break;
     case GTK_TYPE_POINTER:
@@ -578,10 +553,6 @@ gtk_arg_values_equal (const GtkArg *arg1,
       equal = (GTK_VALUE_SIGNAL (*arg1).f == GTK_VALUE_SIGNAL (*arg2).f &&
 	       GTK_VALUE_SIGNAL (*arg1).d == GTK_VALUE_SIGNAL (*arg2).d);
       break;
-    case GTK_TYPE_C_CALLBACK:
-      equal = (GTK_VALUE_C_CALLBACK (*arg1).func == GTK_VALUE_C_CALLBACK (*arg2).func &&
-	       GTK_VALUE_C_CALLBACK (*arg1).func_data == GTK_VALUE_C_CALLBACK (*arg2).func_data);
-      break;
     default:
       g_warning ("gtk_arg_values_equal() used with unknown type `%s'", gtk_type_name (arg1->type));
       equal = FALSE;
@@ -601,12 +572,6 @@ gtk_arg_to_valueloc (GtkArg  *arg,
   g_return_if_fail (value_pointer != NULL);
   
   fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type);
-  if (fundamental_type > GTK_TYPE_FUNDAMENTAL_LAST)
-    {
-      fundamental_type = gtk_type_get_varargs_type (fundamental_type);
-      if (!fundamental_type)
-        fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type);
-    }
   
   switch (fundamental_type)
     {
@@ -661,15 +626,11 @@ gtk_arg_to_valueloc (GtkArg  *arg,
     case GTK_TYPE_STRING:
     case GTK_TYPE_POINTER:
     case GTK_TYPE_BOXED:
-    case GTK_TYPE_OBJECT:
+    case G_TYPE_OBJECT:
       p_pointer = value_pointer;
       *p_pointer = GTK_VALUE_POINTER (*arg);
       break;
     case GTK_TYPE_SIGNAL:
-    case GTK_TYPE_ARGS:
-    case GTK_TYPE_FOREIGN:
-    case GTK_TYPE_CALLBACK:
-    case GTK_TYPE_C_CALLBACK:
     case GTK_TYPE_NONE:
     case GTK_TYPE_INVALID:
       /* it doesn't make much sense to retrive these values,
diff --git a/gtk/gtkargcollector.c b/gtk/gtkargcollector.c
index e92316d6c..4ec3d6ad5 100644
--- a/gtk/gtkargcollector.c
+++ b/gtk/gtkargcollector.c
@@ -38,13 +38,7 @@ G_STMT_START { \
   GtkType fundamental_type; \
   \
   fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type); \
-  if (fundamental_type > GTK_TYPE_FUNDAMENTAL_LAST) \
-    { \
-      fundamental_type = gtk_type_get_varargs_type (fundamental_type); \
-      if (!fundamental_type) \
-        fundamental_type = GTK_FUNDAMENTAL_TYPE (arg->type); \
-    } \
- \
+  \
   error_msg = NULL; \
   switch (fundamental_type) \
     { \
@@ -124,42 +118,25 @@ G_STMT_START { \
       GTK_VALUE_SIGNAL (*arg).f = va_arg (var_args, GtkSignalFunc); \
       GTK_VALUE_SIGNAL (*arg).d = va_arg (var_args, gpointer); \
       break; \
-    case GTK_TYPE_ARGS: \
-      GTK_VALUE_ARGS (*arg).n_args = va_arg (var_args, gint); \
-      GTK_VALUE_ARGS (*arg).args = va_arg (var_args, GtkArg*); \
-      break; \
-    case GTK_TYPE_FOREIGN: \
-      GTK_VALUE_FOREIGN (*arg).data = va_arg (var_args, gpointer); \
-      GTK_VALUE_FOREIGN (*arg).notify = va_arg (var_args, GtkDestroyNotify); \
-      break; \
-    case GTK_TYPE_CALLBACK: \
-      GTK_VALUE_CALLBACK (*arg).marshal = va_arg (var_args, GtkCallbackMarshal); \
-      GTK_VALUE_CALLBACK (*arg).data = va_arg (var_args, gpointer); \
-      GTK_VALUE_CALLBACK (*arg).notify = va_arg (var_args, GtkDestroyNotify); \
-      break; \
-    case GTK_TYPE_C_CALLBACK: \
-      GTK_VALUE_C_CALLBACK (*arg).func = va_arg (var_args, GtkFunction); \
-      GTK_VALUE_C_CALLBACK (*arg).func_data = va_arg (var_args, gpointer); \
-      break; \
  \
       /* we do some extra sanity checking when collecting objects, \
        * i.e. if the object pointer is not NULL, we check whether we \
        * actually got an object pointer within the desired class branch. \
        */ \
-    case GTK_TYPE_OBJECT: \
+    case G_TYPE_OBJECT: \
       GTK_VALUE_OBJECT (*arg) = va_arg (var_args, GtkObject*); \
       if (GTK_VALUE_OBJECT (*arg) != NULL) \
 	{ \
 	  register GtkObject *object = GTK_VALUE_OBJECT (*arg); \
 	   \
-	  if (object->klass == NULL) \
+	  if (((GTypeInstance*) object)->g_class == NULL) \
 	    error_msg = g_strconcat ("invalid unclassed object pointer for argument type `", \
 				     gtk_type_name (arg->type), \
 				     "'", \
 				     NULL); \
 	  else if (!gtk_type_is_a (GTK_OBJECT_TYPE (object), arg->type)) \
 	    error_msg = g_strconcat ("invalid object `", \
-				     gtk_type_name (GTK_OBJECT_TYPE (object)), \
+				     gtk_type_name (G_OBJECT_TYPE (object)), \
 				     "' for argument type `", \
 				     gtk_type_name (arg->type), \
 				     "'", \
diff --git a/gtk/gtkbindings.c b/gtk/gtkbindings.c
index 13d7dfb4c..09a151e52 100644
--- a/gtk/gtkbindings.c
+++ b/gtk/gtkbindings.c
@@ -458,10 +458,10 @@ gtk_binding_set_by_class (gpointer object_class)
   if (binding_set)
     return binding_set;
 
-  binding_set = gtk_binding_set_new (gtk_type_name (class->type));
+  binding_set = gtk_binding_set_new (gtk_type_name (GTK_CLASS_TYPE (class)));
   gtk_binding_set_add_path (binding_set,
 			    GTK_PATH_CLASS,
-			    gtk_type_name (class->type),
+			    gtk_type_name (GTK_CLASS_TYPE (class)),
 			    GTK_PATH_PRIO_GTK);
   g_dataset_id_set_data (class, key_id_class_binding_set, binding_set);
 
diff --git a/gtk/gtkbutton.c b/gtk/gtkbutton.c
index 1e5a36208..3f0e4ff62 100644
--- a/gtk/gtkbutton.c
+++ b/gtk/gtkbutton.c
@@ -108,20 +108,20 @@ gtk_button_get_type (void)
 
   if (!button_type)
     {
-      static const GtkTypeInfo button_info =
+      static const GTypeInfo button_info =
       {
-	"GtkButton",
-	sizeof (GtkButton),
 	sizeof (GtkButtonClass),
-	(GtkClassInitFunc) gtk_button_class_init,
-	(GtkObjectInitFunc) gtk_button_init,
-        /* reserved_1 */ NULL,
-	/* reserved_2 */ NULL,
-	(GtkClassInitFunc) NULL,
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) gtk_button_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkButton),
+	16,		/* n_preallocs */
+	(GInstanceInitFunc) gtk_button_init,
       };
 
-      button_type = gtk_type_unique (GTK_TYPE_BIN, &button_info);
-      gtk_type_set_chunk_alloc (button_type, 16);
+      button_type = g_type_register_static (GTK_TYPE_BIN, "GtkButton", &button_info);
     }
 
   return button_type;
@@ -146,35 +146,35 @@ gtk_button_class_init (GtkButtonClass *klass)
   button_signals[PRESSED] =
     gtk_signal_new ("pressed",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkButtonClass, pressed),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   button_signals[RELEASED] =
     gtk_signal_new ("released",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkButtonClass, released),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   button_signals[CLICKED] =
     gtk_signal_new ("clicked",
                     GTK_RUN_FIRST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkButtonClass, clicked),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   button_signals[ENTER] =
     gtk_signal_new ("enter",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkButtonClass, enter),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   button_signals[LEAVE] =
     gtk_signal_new ("leave",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkButtonClass, leave),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
diff --git a/gtk/gtkcalendar.c b/gtk/gtkcalendar.c
index 96cad9e03..1f220bda4 100644
--- a/gtk/gtkcalendar.c
+++ b/gtk/gtkcalendar.c
@@ -324,18 +324,20 @@ gtk_calendar_get_type (void)
   
   if (!calendar_type)
     {
-      static const GtkTypeInfo calendar_info =
+      static const GTypeInfo calendar_info =
       {
-	"GtkCalendar",
-	sizeof (GtkCalendar),
 	sizeof (GtkCalendarClass),
-	(GtkClassInitFunc) gtk_calendar_class_init,
-	(GtkObjectInitFunc) gtk_calendar_init,
-	(GtkArgSetFunc) NULL,
-	(GtkArgGetFunc) NULL,
+	NULL,           /* base_init */
+	NULL,           /* base_finalize */
+	(GClassInitFunc) gtk_calendar_class_init,
+	NULL,           /* class_finalize */
+	NULL,           /* class_data */
+	sizeof (GtkCalendar),
+	16,             /* n_preallocs */
+	(GInstanceInitFunc) gtk_calendar_init,
       };
-      
-      calendar_type = gtk_type_unique (GTK_TYPE_WIDGET, &calendar_info);
+
+      calendar_type = g_type_register_static (GTK_TYPE_WIDGET, "GtkCalendar", &calendar_info);
     }
   
   return calendar_type;
@@ -371,37 +373,37 @@ gtk_calendar_class_init (GtkCalendarClass *class)
   
   gtk_calendar_signals[MONTH_CHANGED_SIGNAL] =
     gtk_signal_new ("month_changed",
-		    GTK_RUN_FIRST, object_class->type,
+		    GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCalendarClass, month_changed),
 		    gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
   gtk_calendar_signals[DAY_SELECTED_SIGNAL] =
     gtk_signal_new ("day_selected",
-		    GTK_RUN_FIRST, object_class->type,
+		    GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCalendarClass, day_selected),
 		    gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
   gtk_calendar_signals[DAY_SELECTED_DOUBLE_CLICK_SIGNAL] =
     gtk_signal_new ("day_selected_double_click",
-		    GTK_RUN_FIRST, object_class->type,
+		    GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCalendarClass, day_selected_double_click),
 		    gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
   gtk_calendar_signals[PREV_MONTH_SIGNAL] =
     gtk_signal_new ("prev_month",
-		    GTK_RUN_FIRST, object_class->type,
+		    GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCalendarClass, prev_month),
 		    gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
   gtk_calendar_signals[NEXT_MONTH_SIGNAL] =
     gtk_signal_new ("next_month",
-		    GTK_RUN_FIRST, object_class->type,
+		    GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCalendarClass, next_month),
 		    gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
   gtk_calendar_signals[PREV_YEAR_SIGNAL] =
     gtk_signal_new ("prev_year",
-		    GTK_RUN_FIRST, object_class->type,
+		    GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCalendarClass, prev_year),
 		    gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
   gtk_calendar_signals[NEXT_YEAR_SIGNAL] =
     gtk_signal_new ("next_year",
-		    GTK_RUN_FIRST, object_class->type,
+		    GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCalendarClass, next_year),
 		    gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
   
diff --git a/gtk/gtkcheckbutton.c b/gtk/gtkcheckbutton.c
index 19de8a8bf..c9d88bc5f 100644
--- a/gtk/gtkcheckbutton.c
+++ b/gtk/gtkcheckbutton.c
@@ -31,8 +31,6 @@
 #define INDICATOR_SIZE     10
 #define INDICATOR_SPACING  2
 
-#define CHECK_BUTTON_CLASS(w)  GTK_CHECK_BUTTON_CLASS (GTK_OBJECT (w)->klass)
-
 
 static void gtk_check_button_class_init          (GtkCheckButtonClass *klass);
 static void gtk_check_button_init                (GtkCheckButton      *check_button);
@@ -229,11 +227,11 @@ gtk_check_button_size_request (GtkWidget      *widget,
   
   if (toggle_button->draw_indicator)
     {
-      requisition->width += (CHECK_BUTTON_CLASS (widget)->indicator_size +
-			     CHECK_BUTTON_CLASS (widget)->indicator_spacing * 3 + 2);
+      requisition->width += (GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size +
+			     GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing * 3 + 2);
       
-      temp = (CHECK_BUTTON_CLASS (widget)->indicator_size +
-	      CHECK_BUTTON_CLASS (widget)->indicator_spacing * 2);
+      temp = (GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size +
+	      GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing * 2);
       requisition->height = MAX (requisition->height, temp) + 2;
     }
 }
@@ -267,15 +265,15 @@ gtk_check_button_size_allocate (GtkWidget     *widget,
       if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
 	{
 	  child_allocation.x = (GTK_CONTAINER (widget)->border_width +
-				CHECK_BUTTON_CLASS (widget)->indicator_size +
-				CHECK_BUTTON_CLASS (widget)->indicator_spacing * 3 + 1 +
+				GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size +
+				GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing * 3 + 1 +
 				widget->allocation.x);
 	  child_allocation.y = GTK_CONTAINER (widget)->border_width + 1 +
 	    widget->allocation.y;
 	  child_allocation.width = MAX (1, allocation->width - 
 					(GTK_CONTAINER (widget)->border_width +
-					 CHECK_BUTTON_CLASS (widget)->indicator_size +
-					 CHECK_BUTTON_CLASS (widget)->indicator_spacing * 3 + 1)  -
+					 GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size +
+					 GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing * 3 + 1)  -
 					GTK_CONTAINER (widget)->border_width - 1);
 	  child_allocation.height = MAX (1, allocation->height - (GTK_CONTAINER (widget)->border_width + 1) * 2);
 	  
@@ -337,7 +335,7 @@ gtk_check_button_draw_indicator (GtkCheckButton *check_button,
   g_return_if_fail (check_button != NULL);
   g_return_if_fail (GTK_IS_CHECK_BUTTON (check_button));
   
-  class = CHECK_BUTTON_CLASS (check_button);
+  class = GTK_CHECK_BUTTON_GET_CLASS (check_button);
   
   if (class->draw_indicator)
     (* class->draw_indicator) (check_button, area);
@@ -387,10 +385,10 @@ gtk_real_check_button_draw_indicator (GtkCheckButton *check_button,
 				new_area.width, new_area.height);
 	}
       
-      x = widget->allocation.x + CHECK_BUTTON_CLASS (widget)->indicator_spacing + GTK_CONTAINER (widget)->border_width;
-      y = widget->allocation.y + (widget->allocation.height - CHECK_BUTTON_CLASS (widget)->indicator_size) / 2;
-      width = CHECK_BUTTON_CLASS (widget)->indicator_size;
-      height = CHECK_BUTTON_CLASS (widget)->indicator_size;
+      x = widget->allocation.x + GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing + GTK_CONTAINER (widget)->border_width;
+      y = widget->allocation.y + (widget->allocation.height - GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size) / 2;
+      width = GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size;
+      height = GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size;
       
       if (GTK_TOGGLE_BUTTON (widget)->active)
 	{
diff --git a/gtk/gtkcheckmenuitem.c b/gtk/gtkcheckmenuitem.c
index 852a7ba0e..d149fdbc0 100644
--- a/gtk/gtkcheckmenuitem.c
+++ b/gtk/gtkcheckmenuitem.c
@@ -29,8 +29,6 @@
 #include "gtksignal.h"
 
 
-#define CHECK_MENU_ITEM_CLASS(w)  GTK_CHECK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
-
 
 enum {
   TOGGLED,
@@ -106,7 +104,7 @@ gtk_check_menu_item_class_init (GtkCheckMenuItemClass *klass)
   check_menu_item_signals[TOGGLED] =
     gtk_signal_new ("toggled",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkCheckMenuItemClass, toggled),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
@@ -223,10 +221,10 @@ gtk_check_menu_item_draw_indicator (GtkCheckMenuItem *check_menu_item,
 {
   g_return_if_fail (check_menu_item != NULL);
   g_return_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item));
-  g_return_if_fail (CHECK_MENU_ITEM_CLASS (check_menu_item) != NULL);
+  g_return_if_fail (GTK_CHECK_MENU_ITEM_GET_CLASS (check_menu_item) != NULL);
 
-  if (CHECK_MENU_ITEM_CLASS (check_menu_item)->draw_indicator)
-    (* CHECK_MENU_ITEM_CLASS (check_menu_item)->draw_indicator) (check_menu_item, area);
+  if (GTK_CHECK_MENU_ITEM_GET_CLASS (check_menu_item)->draw_indicator)
+    (* GTK_CHECK_MENU_ITEM_GET_CLASS (check_menu_item)->draw_indicator) (check_menu_item, area);
 }
 
 static void
diff --git a/gtk/gtkclist.c b/gtk/gtkclist.c
index c01095a23..15c249942 100644
--- a/gtk/gtkclist.c
+++ b/gtk/gtkclist.c
@@ -78,17 +78,17 @@ COLUMN_FROM_XPIXEL (GtkCList * clist,
 		    gint x)
 {
   gint i, cx;
-
+  
   for (i = 0; i < clist->columns; i++)
     if (clist->column[i].visible)
       {
 	cx = clist->column[i].area.x + clist->hoffset;
-
+	
 	if (x >= (cx - (COLUMN_INSET + CELL_SPACING)) &&
 	    x <= (cx + clist->column[i].area.width + COLUMN_INSET))
 	  return i;
       }
-
+  
   /* no match */
   return -1;
 }
@@ -111,10 +111,10 @@ static inline gint
 LIST_WIDTH (GtkCList * clist) 
 {
   gint last_column;
-
+  
   for (last_column = clist->columns - 1;
        last_column >= 0 && !clist->column[last_column].visible; last_column--);
-
+  
   if (last_column >= 0)
     return (clist->column[last_column].area.x +
 	    clist->column[last_column].area.width +
@@ -128,13 +128,11 @@ LIST_WIDTH (GtkCList * clist)
 				 g_list_nth ((clist)->row_list, (row)))
 
 
-#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (((GtkObject*) (_widget_))->klass)
-
 /* redraw the list if it's not frozen */
 #define CLIST_UNFROZEN(clist)     (((GtkCList*) (clist))->freeze_count == 0)
 #define	CLIST_REFRESH(clist)	G_STMT_START { \
   if (CLIST_UNFROZEN (clist)) \
-    GTK_CLIST_CLASS_FW (clist)->refresh ((GtkCList*) (clist)); \
+    GTK_CLIST_GET_CLASS (clist)->refresh ((GtkCList*) (clist)); \
 } G_STMT_END
 
 
@@ -182,7 +180,7 @@ static void gtk_clist_init       (GtkCList      *clist);
 
 /* GtkObject Methods */
 static void gtk_clist_destroy  (GtkObject *object);
-static void gtk_clist_finalize (GtkObject *object);
+static void gtk_clist_finalize (GObject   *object);
 static void gtk_clist_set_arg  (GtkObject *object,
 				GtkArg    *arg,
 				guint      arg_id);
@@ -399,7 +397,7 @@ static void draw_drag_highlight (GtkCList        *clist,
 				 GtkCListRow     *dest_row,
 				 gint             dest_row_number,
 				 GtkCListDragPos  drag_pos);
-     
+
 /* Size Allocation / Requisition */
 static void size_allocate_title_buttons (GtkCList *clist);
 static void size_allocate_columns       (GtkCList *clist,
@@ -466,7 +464,7 @@ GtkType
 gtk_clist_get_type (void)
 {
   static GtkType clist_type = 0;
-
+  
   if (!clist_type)
     {
       static const GtkTypeInfo clist_info =
@@ -480,27 +478,34 @@ gtk_clist_get_type (void)
 	/* reserved_2 */ NULL,
 	(GtkClassInitFunc) NULL,
       };
-
+      
       clist_type = gtk_type_unique (GTK_TYPE_CONTAINER, &clist_info);
     }
-
+  
   return clist_type;
 }
 
 static void
 gtk_clist_class_init (GtkCListClass *klass)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;
   GtkBindingSet *binding_set;
-
+  
   object_class = (GtkObjectClass *) klass;
   widget_class = (GtkWidgetClass *) klass;
   container_class = (GtkContainerClass *) klass;
-
+  
   parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
-
+  
+  gobject_class->finalize = gtk_clist_finalize;
+  
+  object_class->set_arg = gtk_clist_set_arg;
+  object_class->get_arg = gtk_clist_get_arg;
+  object_class->destroy = gtk_clist_destroy;
+  
   gtk_object_add_arg_type ("GtkCList::n_columns",
 			   GTK_TYPE_UINT,
 			   GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
@@ -533,24 +538,19 @@ gtk_clist_class_init (GtkCListClass *klass)
 			   GTK_TYPE_SORT_TYPE,
 			   GTK_ARG_READWRITE,
 			   ARG_SORT_TYPE);  
-  object_class->set_arg = gtk_clist_set_arg;
-  object_class->get_arg = gtk_clist_get_arg;
-  object_class->destroy = gtk_clist_destroy;
-  object_class->finalize = gtk_clist_finalize;
-
-
+  
   widget_class->set_scroll_adjustments_signal =
     gtk_signal_new ("set_scroll_adjustments",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCListClass, set_scroll_adjustments),
 		    gtk_marshal_NONE__POINTER_POINTER,
 		    GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
-
+  
   clist_signals[SELECT_ROW] =
     gtk_signal_new ("select_row",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCListClass, select_row),
 		    gtk_marshal_NONE__INT_INT_POINTER,
 		    GTK_TYPE_NONE, 3,
@@ -560,7 +560,7 @@ gtk_clist_class_init (GtkCListClass *klass)
   clist_signals[UNSELECT_ROW] =
     gtk_signal_new ("unselect_row",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCListClass, unselect_row),
 		    gtk_marshal_NONE__INT_INT_POINTER,
 		    GTK_TYPE_NONE, 3, GTK_TYPE_INT,
@@ -568,78 +568,78 @@ gtk_clist_class_init (GtkCListClass *klass)
   clist_signals[ROW_MOVE] =
     gtk_signal_new ("row_move",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCListClass, row_move),
 		    gtk_marshal_NONE__INT_INT,
 		    GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
   clist_signals[CLICK_COLUMN] =
     gtk_signal_new ("click_column",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCListClass, click_column),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1, GTK_TYPE_INT);
   clist_signals[RESIZE_COLUMN] =
     gtk_signal_new ("resize_column",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCListClass, resize_column),
 		    gtk_marshal_NONE__INT_INT,
 		    GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT);
-
+  
   clist_signals[TOGGLE_FOCUS_ROW] =
     gtk_signal_new ("toggle_focus_row",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkCListClass, toggle_focus_row),
                     gtk_marshal_NONE__NONE,
                     GTK_TYPE_NONE, 0);
   clist_signals[SELECT_ALL] =
     gtk_signal_new ("select_all",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkCListClass, select_all),
                     gtk_marshal_NONE__NONE,
                     GTK_TYPE_NONE, 0);
   clist_signals[UNSELECT_ALL] =
     gtk_signal_new ("unselect_all",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkCListClass, unselect_all),
                     gtk_marshal_NONE__NONE,
                     GTK_TYPE_NONE, 0);
   clist_signals[UNDO_SELECTION] =
     gtk_signal_new ("undo_selection",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCListClass, undo_selection),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   clist_signals[START_SELECTION] =
     gtk_signal_new ("start_selection",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCListClass, start_selection),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   clist_signals[END_SELECTION] =
     gtk_signal_new ("end_selection",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCListClass, end_selection),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   clist_signals[TOGGLE_ADD_MODE] =
     gtk_signal_new ("toggle_add_mode",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCListClass, toggle_add_mode),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   clist_signals[EXTEND_SELECTION] =
     gtk_signal_new ("extend_selection",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkCListClass, extend_selection),
                     gtk_marshal_NONE__ENUM_FLOAT_BOOL,
                     GTK_TYPE_NONE, 3,
@@ -647,26 +647,26 @@ gtk_clist_class_init (GtkCListClass *klass)
   clist_signals[SCROLL_VERTICAL] =
     gtk_signal_new ("scroll_vertical",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkCListClass, scroll_vertical),
                     gtk_marshal_NONE__ENUM_FLOAT,
                     GTK_TYPE_NONE, 2, GTK_TYPE_SCROLL_TYPE, GTK_TYPE_FLOAT);
   clist_signals[SCROLL_HORIZONTAL] =
     gtk_signal_new ("scroll_horizontal",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkCListClass, scroll_horizontal),
                     gtk_marshal_NONE__ENUM_FLOAT,
                     GTK_TYPE_NONE, 2, GTK_TYPE_SCROLL_TYPE, GTK_TYPE_FLOAT);
   clist_signals[ABORT_COLUMN_RESIZE] =
     gtk_signal_new ("abort_column_resize",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkCListClass, abort_column_resize),
                     gtk_marshal_NONE__NONE,
                     GTK_TYPE_NONE, 0);
   gtk_object_class_add_signals (object_class, clist_signals, LAST_SIGNAL);
-
+  
   widget_class->realize = gtk_clist_realize;
   widget_class->unrealize = gtk_clist_unrealize;
   widget_class->map = gtk_clist_map;
@@ -690,14 +690,14 @@ gtk_clist_class_init (GtkCListClass *klass)
   widget_class->drag_drop = gtk_clist_drag_drop;
   widget_class->drag_data_get = gtk_clist_drag_data_get;
   widget_class->drag_data_received = gtk_clist_drag_data_received;
-
+  
   /* container_class->add = NULL; use the default GtkContainerClass warning */
   /* container_class->remove=NULL; use the default GtkContainerClass warning */
-
+  
   container_class->forall = gtk_clist_forall;
   container_class->focus = gtk_clist_focus;
   container_class->set_focus_child = gtk_clist_set_focus_child;
-
+  
   klass->set_scroll_adjustments = gtk_clist_set_scroll_adjustments;
   klass->refresh = clist_refresh;
   klass->select_row = real_select_row;
@@ -727,7 +727,7 @@ gtk_clist_class_init (GtkCListClass *klass)
   klass->abort_column_resize = abort_column_resize;
   klass->set_cell_contents = set_cell_contents;
   klass->cell_size_request = cell_size_request;
-
+  
   binding_set = gtk_binding_set_by_class (klass);
   gtk_binding_entry_add_signal (binding_set, GDK_Up, 0,
 				"scroll_vertical", 2,
@@ -753,7 +753,7 @@ gtk_clist_class_init (GtkCListClass *klass)
 				"scroll_vertical", 2,
 				GTK_TYPE_ENUM, GTK_SCROLL_JUMP,
 				GTK_TYPE_FLOAT, 1.0);
-
+  
   gtk_binding_entry_add_signal (binding_set, GDK_Up, GDK_SHIFT_MASK,
 				"extend_selection", 3,
 				GTK_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
@@ -780,7 +780,7 @@ gtk_clist_class_init (GtkCListClass *klass)
 				"extend_selection", 3,
 				GTK_TYPE_ENUM, GTK_SCROLL_JUMP,
 				GTK_TYPE_FLOAT, 1.0, GTK_TYPE_BOOL, TRUE);
-
+  
   gtk_binding_entry_add_signal (binding_set, GDK_Left, 0,
 				"scroll_horizontal", 2,
 				GTK_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
@@ -797,7 +797,7 @@ gtk_clist_class_init (GtkCListClass *klass)
 				"scroll_horizontal", 2,
 				GTK_TYPE_ENUM, GTK_SCROLL_JUMP,
 				GTK_TYPE_FLOAT, 1.0);
-
+  
   gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,
 				"undo_selection", 0);
   gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,
@@ -832,9 +832,9 @@ gtk_clist_set_arg (GtkObject      *object,
 		   guint           arg_id)
 {
   GtkCList *clist;
-
+  
   clist = GTK_CLIST (object);
-
+  
   switch (arg_id)
     {
     case ARG_N_COLUMNS: /* construct-only arg, only set when !GTK_CONSTRUCTED */
@@ -873,13 +873,13 @@ gtk_clist_get_arg (GtkObject      *object,
 		   guint           arg_id)
 {
   GtkCList *clist;
-
+  
   clist = GTK_CLIST (object);
-
+  
   switch (arg_id)
     {
       guint i;
-
+      
     case ARG_N_COLUMNS:
       GTK_VALUE_UINT (*arg) = clist->columns;
       break;
@@ -921,73 +921,73 @@ static void
 gtk_clist_init (GtkCList *clist)
 {
   clist->flags = 0;
-
+  
   GTK_WIDGET_UNSET_FLAGS (clist, GTK_NO_WINDOW);
   GTK_WIDGET_SET_FLAGS (clist, GTK_CAN_FOCUS);
   GTK_CLIST_SET_FLAG (clist, CLIST_CHILD_HAS_FOCUS);
   GTK_CLIST_SET_FLAG (clist, CLIST_DRAW_DRAG_LINE);
   GTK_CLIST_SET_FLAG (clist, CLIST_USE_DRAG_ICONS);
-
+  
   clist->row_mem_chunk = NULL;
   clist->cell_mem_chunk = NULL;
-
+  
   clist->freeze_count = 0;
-
+  
   clist->rows = 0;
   clist->row_center_offset = 0;
   clist->row_height = 0;
   clist->row_list = NULL;
   clist->row_list_end = NULL;
-
+  
   clist->columns = 0;
-
+  
   clist->title_window = NULL;
   clist->column_title_area.x = 0;
   clist->column_title_area.y = 0;
   clist->column_title_area.width = 1;
   clist->column_title_area.height = 1;
-
+  
   clist->clist_window = NULL;
   clist->clist_window_width = 1;
   clist->clist_window_height = 1;
-
+  
   clist->hoffset = 0;
   clist->voffset = 0;
-
+  
   clist->shadow_type = GTK_SHADOW_IN;
   clist->vadjustment = NULL;
   clist->hadjustment = NULL;
-
+  
   clist->button_actions[0] = GTK_BUTTON_SELECTS | GTK_BUTTON_DRAGS;
   clist->button_actions[1] = GTK_BUTTON_IGNORED;
   clist->button_actions[2] = GTK_BUTTON_IGNORED;
   clist->button_actions[3] = GTK_BUTTON_IGNORED;
   clist->button_actions[4] = GTK_BUTTON_IGNORED;
-
+  
   clist->cursor_drag = NULL;
   clist->xor_gc = NULL;
   clist->fg_gc = NULL;
   clist->bg_gc = NULL;
   clist->x_drag = 0;
-
+  
   clist->selection_mode = GTK_SELECTION_SINGLE;
   clist->selection = NULL;
   clist->selection_end = NULL;
   clist->undo_selection = NULL;
   clist->undo_unselection = NULL;
-
+  
   clist->focus_row = -1;
   clist->undo_anchor = -1;
-
+  
   clist->anchor = -1;
   clist->anchor_state = GTK_STATE_SELECTED;
   clist->drag_pos = -1;
   clist->htimer = 0;
   clist->vtimer = 0;
-
+  
   clist->click_cell.row = -1;
   clist->click_cell.column = -1;
-
+  
   clist->compare = default_compare;
   clist->sort_type = GTK_SORT_ASCENDING;
   clist->sort_column = 0;
@@ -1003,10 +1003,10 @@ gtk_clist_construct (GtkCList *clist,
   g_return_if_fail (GTK_IS_CLIST (clist));
   g_return_if_fail (columns > 0);
   g_return_if_fail (GTK_OBJECT_CONSTRUCTED (clist) == FALSE);
-
+  
   /* mark the object as constructed */
   gtk_object_constructed (GTK_OBJECT (clist));
-
+  
   /* initalize memory chunks, if this has not been done by any
    * possibly derived widget
    */
@@ -1016,23 +1016,23 @@ gtk_clist_construct (GtkCList *clist,
 					    sizeof (GtkCListRow) *
 					    CLIST_OPTIMUM_SIZE, 
 					    G_ALLOC_AND_FREE);
-
+  
   if (!clist->cell_mem_chunk)
     clist->cell_mem_chunk = g_mem_chunk_new ("clist cell mem chunk",
 					     sizeof (GtkCell) * columns,
 					     sizeof (GtkCell) * columns *
 					     CLIST_OPTIMUM_SIZE, 
 					     G_ALLOC_AND_FREE);
-
+  
   /* set number of columns, allocate memory */
   clist->columns = columns;
   clist->column = columns_new (clist);
-
+  
   /* there needs to be at least one column button 
    * because there is alot of code that will break if it
    * isn't there*/
   column_button_create (clist, 0);
-
+  
   if (titles)
     {
       guint i;
@@ -1064,16 +1064,16 @@ gtk_clist_new (gint columns)
 {
   return gtk_clist_new_with_titles (columns, NULL);
 }
- 
+
 GtkWidget*
 gtk_clist_new_with_titles (gint   columns,
 			   gchar *titles[])
 {
   GtkWidget *widget;
-
+  
   widget = gtk_type_new (GTK_TYPE_CLIST);
   gtk_clist_construct (GTK_CLIST (widget), columns, titles);
-
+  
   return widget;
 }
 
@@ -1082,7 +1082,7 @@ gtk_clist_set_hadjustment (GtkCList      *clist,
 			   GtkAdjustment *adjustment)
 {
   GtkAdjustment *old_adjustment;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
   if (adjustment)
@@ -1092,20 +1092,20 @@ gtk_clist_set_hadjustment (GtkCList      *clist,
     return;
   
   old_adjustment = clist->hadjustment;
-
+  
   if (clist->hadjustment)
     {
       gtk_signal_disconnect_by_data (GTK_OBJECT (clist->hadjustment), clist);
       gtk_object_unref (GTK_OBJECT (clist->hadjustment));
     }
-
+  
   clist->hadjustment = adjustment;
-
+  
   if (clist->hadjustment)
     {
       gtk_object_ref (GTK_OBJECT (clist->hadjustment));
       gtk_object_sink (GTK_OBJECT (clist->hadjustment));
-
+      
       gtk_signal_connect (GTK_OBJECT (clist->hadjustment), "changed",
 			  (GtkSignalFunc) hadjustment_changed,
 			  (gpointer) clist);
@@ -1113,7 +1113,7 @@ gtk_clist_set_hadjustment (GtkCList      *clist,
 			  (GtkSignalFunc) hadjustment_value_changed,
 			  (gpointer) clist);
     }
-
+  
   if (!clist->hadjustment || !old_adjustment)
     gtk_widget_queue_resize (GTK_WIDGET (clist));
 }
@@ -1123,7 +1123,7 @@ gtk_clist_get_hadjustment (GtkCList *clist)
 {
   g_return_val_if_fail (clist != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+  
   return clist->hadjustment;
 }
 
@@ -1132,30 +1132,30 @@ gtk_clist_set_vadjustment (GtkCList      *clist,
 			   GtkAdjustment *adjustment)
 {
   GtkAdjustment *old_adjustment;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
   if (adjustment)
     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
-
+  
   if (clist->vadjustment == adjustment)
     return;
   
   old_adjustment = clist->vadjustment;
-
+  
   if (clist->vadjustment)
     {
       gtk_signal_disconnect_by_data (GTK_OBJECT (clist->vadjustment), clist);
       gtk_object_unref (GTK_OBJECT (clist->vadjustment));
     }
-
+  
   clist->vadjustment = adjustment;
-
+  
   if (clist->vadjustment)
     {
       gtk_object_ref (GTK_OBJECT (clist->vadjustment));
       gtk_object_sink (GTK_OBJECT (clist->vadjustment));
-
+      
       gtk_signal_connect (GTK_OBJECT (clist->vadjustment), "changed",
 			  (GtkSignalFunc) vadjustment_changed,
 			  (gpointer) clist);
@@ -1163,7 +1163,7 @@ gtk_clist_set_vadjustment (GtkCList      *clist,
 			  (GtkSignalFunc) vadjustment_value_changed,
 			  (gpointer) clist);
     }
-
+  
   if (!clist->vadjustment || !old_adjustment)
     gtk_widget_queue_resize (GTK_WIDGET (clist));
 }
@@ -1173,7 +1173,7 @@ gtk_clist_get_vadjustment (GtkCList *clist)
 {
   g_return_val_if_fail (clist != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+  
   return clist->vadjustment;
 }
 
@@ -1194,9 +1194,9 @@ gtk_clist_set_shadow_type (GtkCList      *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   clist->shadow_type = type;
-
+  
   if (GTK_WIDGET_VISIBLE (clist))
     gtk_widget_queue_resize (GTK_WIDGET (clist));
 }
@@ -1207,21 +1207,21 @@ gtk_clist_set_selection_mode (GtkCList         *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (mode == clist->selection_mode)
     return;
-
+  
   clist->selection_mode = mode;
   clist->anchor = -1;
   clist->anchor_state = GTK_STATE_SELECTED;
   clist->drag_pos = -1;
   clist->undo_anchor = clist->focus_row;
-
+  
   g_list_free (clist->undo_selection);
   g_list_free (clist->undo_unselection);
   clist->undo_selection = NULL;
   clist->undo_unselection = NULL;
-
+  
   switch (mode)
     {
     case GTK_SELECTION_MULTIPLE:
@@ -1239,7 +1239,7 @@ gtk_clist_freeze (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   clist->freeze_count++;
 }
 
@@ -1248,7 +1248,7 @@ gtk_clist_thaw (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (clist->freeze_count)
     {
       clist->freeze_count--;
@@ -1280,7 +1280,7 @@ gtk_clist_column_titles_show (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (!GTK_CLIST_SHOW_TITLES(clist))
     {
       GTK_CLIST_SET_FLAG (clist, CLIST_SHOW_TITLES);
@@ -1295,7 +1295,7 @@ gtk_clist_column_titles_hide (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (GTK_CLIST_SHOW_TITLES(clist))
     {
       GTK_CLIST_UNSET_FLAG (clist, CLIST_SHOW_TITLES);
@@ -1311,18 +1311,18 @@ gtk_clist_column_title_active (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
   if (!clist->column[column].button || !clist->column[column].button_passive)
     return;
-
+  
   clist->column[column].button_passive = FALSE;
-
+  
   gtk_signal_disconnect_by_func (GTK_OBJECT (clist->column[column].button),
 				 (GtkSignalFunc) column_title_passive_func,
 				 NULL);
-
+  
   GTK_WIDGET_SET_FLAGS (clist->column[column].button, GTK_CAN_FOCUS);
   if (GTK_WIDGET_VISIBLE (clist))
     gtk_widget_queue_draw (clist->column[column].button);
@@ -1333,27 +1333,27 @@ gtk_clist_column_title_passive (GtkCList *clist,
 				gint      column)
 {
   GtkButton *button;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
   if (!clist->column[column].button || clist->column[column].button_passive)
     return;
-
+  
   button = GTK_BUTTON (clist->column[column].button);
-
+  
   clist->column[column].button_passive = TRUE;
-
+  
   if (button->button_down)
     gtk_button_released (button);
   if (button->in_button)
     gtk_button_leave (button);
-
+  
   gtk_signal_connect (GTK_OBJECT (clist->column[column].button), "event",
 		      (GtkSignalFunc) column_title_passive_func, NULL);
-
+  
   GTK_WIDGET_UNSET_FLAGS (clist->column[column].button, GTK_CAN_FOCUS);
   if (GTK_WIDGET_VISIBLE (clist))
     gtk_widget_queue_draw (clist->column[column].button);
@@ -1363,13 +1363,13 @@ void
 gtk_clist_column_titles_active (GtkCList *clist)
 {
   gint i;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (!GTK_CLIST_SHOW_TITLES(clist))
     return;
-
+  
   for (i = 0; i < clist->columns; i++)
     gtk_clist_column_title_active (clist, i);
 }
@@ -1378,13 +1378,13 @@ void
 gtk_clist_column_titles_passive (GtkCList *clist)
 {
   gint i;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (!GTK_CLIST_SHOW_TITLES(clist))
     return;
-
+  
   for (i = 0; i < clist->columns; i++)
     gtk_clist_column_title_passive (clist, i);
 }
@@ -1398,13 +1398,13 @@ gtk_clist_set_column_title (GtkCList    *clist,
   GtkWidget *old_widget;
   GtkWidget *alignment = NULL;
   GtkWidget *label;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
-
+  
   /* if the column button doesn't currently exist,
    * it has to be created first */
   if (!clist->column[column].button)
@@ -1412,34 +1412,34 @@ gtk_clist_set_column_title (GtkCList    *clist,
       column_button_create (clist, column);
       new_button = 1;
     }
-
+  
   column_title_new (clist, column, title);
-
+  
   /* remove and destroy the old widget */
   old_widget = GTK_BIN (clist->column[column].button)->child;
   if (old_widget)
     gtk_container_remove (GTK_CONTAINER (clist->column[column].button), old_widget);
-
+  
   /* create new alignment based no column justification */
   switch (clist->column[column].justification)
     {
     case GTK_JUSTIFY_LEFT:
       alignment = gtk_alignment_new (0.0, 0.5, 0.0, 0.0);
       break;
-
+      
     case GTK_JUSTIFY_RIGHT:
       alignment = gtk_alignment_new (1.0, 0.5, 0.0, 0.0);
       break;
-
+      
     case GTK_JUSTIFY_CENTER:
       alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
       break;
-
+      
     case GTK_JUSTIFY_FILL:
       alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
       break;
     }
-
+  
   gtk_widget_push_composite_child ();
   label = gtk_label_new (clist->column[column].title);
   gtk_widget_pop_composite_child ();
@@ -1447,7 +1447,7 @@ gtk_clist_set_column_title (GtkCList    *clist,
   gtk_container_add (GTK_CONTAINER (clist->column[column].button), alignment);
   gtk_widget_show (label);
   gtk_widget_show (alignment);
-
+  
   /* if this button didn't previously exist, then the
    * column button positions have to be re-computed */
   if (GTK_WIDGET_VISIBLE (clist) && new_button)
@@ -1460,10 +1460,10 @@ gtk_clist_get_column_title (GtkCList *clist,
 {
   g_return_val_if_fail (clist != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+  
   if (column < 0 || column >= clist->columns)
     return NULL;
-
+  
   return clist->column[column].title;
 }
 
@@ -1474,13 +1474,13 @@ gtk_clist_set_column_widget (GtkCList  *clist,
 {
   gint new_button = 0;
   GtkWidget *old_widget;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
-
+  
   /* if the column button doesn't currently exist,
    * it has to be created first */
   if (!clist->column[column].button)
@@ -1488,22 +1488,22 @@ gtk_clist_set_column_widget (GtkCList  *clist,
       column_button_create (clist, column);
       new_button = 1;
     }
-
+  
   column_title_new (clist, column, NULL);
-
+  
   /* remove and destroy the old widget */
   old_widget = GTK_BIN (clist->column[column].button)->child;
   if (old_widget)
     gtk_container_remove (GTK_CONTAINER (clist->column[column].button),
 			  old_widget);
-
+  
   /* add and show the widget */
   if (widget)
     {
       gtk_container_add (GTK_CONTAINER (clist->column[column].button), widget);
       gtk_widget_show (widget);
     }
-
+  
   /* if this button didn't previously exist, then the
    * column button positions have to be re-computed */
   if (GTK_WIDGET_VISIBLE (clist) && new_button)
@@ -1516,13 +1516,13 @@ gtk_clist_get_column_widget (GtkCList *clist,
 {
   g_return_val_if_fail (clist != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+  
   if (column < 0 || column >= clist->columns)
     return NULL;
-
+  
   if (clist->column[column].button)
     return GTK_BUTTON (clist->column[column].button)->child;
-
+  
   return NULL;
 }
 
@@ -1532,44 +1532,44 @@ gtk_clist_set_column_justification (GtkCList         *clist,
 				    GtkJustification  justification)
 {
   GtkWidget *alignment;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
-
+  
   clist->column[column].justification = justification;
-
+  
   /* change the alinment of the button title if it's not a
    * custom widget */
   if (clist->column[column].title)
     {
       alignment = GTK_BIN (clist->column[column].button)->child;
-
+      
       switch (clist->column[column].justification)
 	{
 	case GTK_JUSTIFY_LEFT:
 	  gtk_alignment_set (GTK_ALIGNMENT (alignment), 0.0, 0.5, 0.0, 0.0);
 	  break;
-
+	  
 	case GTK_JUSTIFY_RIGHT:
 	  gtk_alignment_set (GTK_ALIGNMENT (alignment), 1.0, 0.5, 0.0, 0.0);
 	  break;
-
+	  
 	case GTK_JUSTIFY_CENTER:
 	  gtk_alignment_set (GTK_ALIGNMENT (alignment), 0.5, 0.5, 0.0, 0.0);
 	  break;
-
+	  
 	case GTK_JUSTIFY_FILL:
 	  gtk_alignment_set (GTK_ALIGNMENT (alignment), 0.5, 0.5, 0.0, 0.0);
 	  break;
-
+	  
 	default:
 	  break;
 	}
     }
-
+  
   if (CLIST_UNFROZEN (clist))
     draw_rows (clist, NULL);
 }
@@ -1581,28 +1581,28 @@ gtk_clist_set_column_visibility (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
   if (clist->column[column].visible == visible)
     return;
-
+  
   /* don't hide last visible column */
   if (!visible)
     {
       gint i;
       gint vis_columns = 0;
-
+      
       for (i = 0, vis_columns = 0; i < clist->columns && vis_columns < 2; i++)
 	if (clist->column[i].visible)
 	  vis_columns++;
-
+      
       if (vis_columns < 2)
 	return;
     }
-
+  
   clist->column[column].visible = visible;
-
+  
   if (clist->column[column].button)
     {
       if (visible)
@@ -1621,16 +1621,16 @@ gtk_clist_set_column_resizeable (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
   if (clist->column[column].resizeable == resizeable)
     return;
-
+  
   clist->column[column].resizeable = resizeable;
   if (resizeable)
     clist->column[column].auto_resize = FALSE;
-
+  
   if (GTK_WIDGET_VISIBLE (clist))
     size_allocate_title_buttons (clist);
 }
@@ -1642,12 +1642,12 @@ gtk_clist_set_column_auto_resize (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
   if (clist->column[column].auto_resize == auto_resize)
     return;
-
+  
   clist->column[column].auto_resize = auto_resize;
   if (auto_resize)
     {
@@ -1655,12 +1655,12 @@ gtk_clist_set_column_auto_resize (GtkCList *clist,
       if (!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
 	{
 	  gint width;
-
+	  
 	  width = gtk_clist_optimal_column_width (clist, column);
 	  gtk_clist_set_column_width (clist, column, width);
 	}
     }
-
+  
   if (GTK_WIDGET_VISIBLE (clist))
     size_allocate_title_buttons (clist);
 }
@@ -1670,20 +1670,20 @@ gtk_clist_columns_autosize (GtkCList *clist)
 {
   gint i;
   gint width;
-
+  
   g_return_val_if_fail (clist != NULL, 0);
   g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+  
   gtk_clist_freeze (clist);
   width = 0;
   for (i = 0; i < clist->columns; i++)
     {
       gtk_clist_set_column_width (clist, i,
 				  gtk_clist_optimal_column_width (clist, i));
-
+      
       width += clist->column[i].width;
     }
-
+  
   gtk_clist_thaw (clist);
   return width;
 }
@@ -1695,66 +1695,66 @@ gtk_clist_optimal_column_width (GtkCList *clist,
   GtkRequisition requisition;
   GList *list;
   gint width;
-
+  
   g_return_val_if_fail (clist != NULL, 0);
   g_return_val_if_fail (GTK_CLIST (clist), 0);
-
+  
   if (column < 0 || column > clist->columns)
     return 0;
-
+  
   if (GTK_CLIST_SHOW_TITLES(clist) && clist->column[column].button)
     width = (clist->column[column].button->requisition.width)
 #if 0
-	     (CELL_SPACING + (2 * COLUMN_INSET)))
+      (CELL_SPACING + (2 * COLUMN_INSET)))
 #endif
-		;
-  else
-    width = 0;
+     ;
+     else
+     width = 0;
 
-  for (list = clist->row_list; list; list = list->next)
-    {
-      GTK_CLIST_CLASS_FW (clist)->cell_size_request
-	(clist, GTK_CLIST_ROW (list), column, &requisition);
-      width = MAX (width, requisition.width);
-    }
+for (list = clist->row_list; list; list = list->next)
+{
+  GTK_CLIST_GET_CLASS (clist)->cell_size_request
+    (clist, GTK_CLIST_ROW (list), column, &requisition);
+  width = MAX (width, requisition.width);
+}
 
-  return width;
+return width;
 }
 
 void
 gtk_clist_set_column_width (GtkCList *clist,
-			    gint      column,
-			    gint      width)
+  gint      column,
+  gint      width)
 {
-  g_return_if_fail (clist != NULL);
-  g_return_if_fail (GTK_IS_CLIST (clist));
+g_return_if_fail (clist != NULL);
+g_return_if_fail (GTK_IS_CLIST (clist));
 
-  if (column < 0 || column >= clist->columns)
-    return;
-
-  gtk_signal_emit (GTK_OBJECT (clist), clist_signals[RESIZE_COLUMN],
-		   column, width);
-}
+if (column < 0 || column >= clist->columns)
+     return;
+     
+     gtk_signal_emit (GTK_OBJECT (clist), clist_signals[RESIZE_COLUMN],
+      column, width);
+     }
 
 void
 gtk_clist_set_column_min_width (GtkCList *clist,
-				gint      column,
-				gint      min_width)
+      gint      column,
+      gint      min_width)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
   if (clist->column[column].min_width == min_width)
     return;
-
+  
   if (clist->column[column].max_width >= 0  &&
       clist->column[column].max_width < min_width)
     clist->column[column].min_width = clist->column[column].max_width;
   else
     clist->column[column].min_width = min_width;
-
+  
   if (clist->column[column].area.width < clist->column[column].min_width)
     gtk_clist_set_column_width (clist, column,clist->column[column].min_width);
 }
@@ -1766,12 +1766,12 @@ gtk_clist_set_column_max_width (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
   if (clist->column[column].max_width == max_width)
     return;
-
+  
   if (clist->column[column].min_width >= 0 && max_width >= 0 &&
       clist->column[column].min_width > max_width)
     clist->column[column].max_width = clist->column[column].min_width;
@@ -1802,17 +1802,17 @@ column_auto_resize (GtkCList    *clist,
 {
   /* resize column if needed for auto_resize */
   GtkRequisition requisition;
-
+  
   if (!clist->column[column].auto_resize ||
       GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
     return;
-
+  
   if (clist_row)
-    GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
-						   column, &requisition);
+    GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+						    column, &requisition);
   else
     requisition.width = 0;
-
+  
   if (requisition.width > clist->column[column].width)
     gtk_clist_set_column_width (clist, column, requisition.width);
   else if (requisition.width < old_width &&
@@ -1820,7 +1820,7 @@ column_auto_resize (GtkCList    *clist,
     {
       GList *list;
       gint new_width = 0;
-
+      
       /* run a "gtk_clist_optimal_column_width" but break, if
        * the column doesn't shrink */
       if (GTK_CLIST_SHOW_TITLES(clist) && clist->column[column].button)
@@ -1828,10 +1828,10 @@ column_auto_resize (GtkCList    *clist,
 		     (CELL_SPACING + (2 * COLUMN_INSET)));
       else
 	new_width = 0;
-
+      
       for (list = clist->row_list; list; list = list->next)
 	{
-	  GTK_CLIST_CLASS_FW (clist)->cell_size_request
+	  GTK_CLIST_GET_CLASS (clist)->cell_size_request
 	    (clist, GTK_CLIST_ROW (list), column, &requisition);
 	  new_width = MAX (new_width, requisition.width);
 	  if (new_width == clist->column[column].width)
@@ -1850,7 +1850,7 @@ real_resize_column (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
   
@@ -1859,17 +1859,17 @@ real_resize_column (GtkCList *clist,
   if (clist->column[column].max_width >= 0 &&
       width > clist->column[column].max_width)
     width = clist->column[column].max_width;
-
+  
   clist->column[column].width = width;
   clist->column[column].width_set = TRUE;
-
+  
   /* FIXME: this is quite expensive to do if the widget hasn't
    *        been size_allocated yet, and pointless. Should
    *        a flag be kept
    */
   size_allocate_columns (clist, TRUE);
   size_allocate_title_buttons (clist);
-
+  
   CLIST_REFRESH (clist);
 }
 
@@ -1878,18 +1878,18 @@ abort_column_resize (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (!GTK_CLIST_IN_DRAG(clist))
     return;
-
+  
   GTK_CLIST_UNSET_FLAG (clist, CLIST_IN_DRAG);
   gtk_grab_remove (GTK_WIDGET (clist));
   gdk_pointer_ungrab (GDK_CURRENT_TIME);
   clist->drag_pos = -1;
-
+  
   if (clist->x_drag >= 0 && clist->x_drag <= clist->clist_window_width - 1)
     draw_xor_line (clist);
-
+  
   if (GTK_CLIST_ADD_MODE(clist))
     {
       gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_ON_OFF_DASH, 0,0);
@@ -1904,20 +1904,20 @@ size_allocate_title_buttons (GtkCList *clist)
   gint last_column;
   gint last_button = 0;
   gint i;
-
+  
   if (!GTK_WIDGET_REALIZED (clist))
     return;
-
+  
   button_allocation.x = clist->hoffset;
   button_allocation.y = 0;
   button_allocation.width = 0;
   button_allocation.height = clist->column_title_area.height;
-
+  
   /* find last visible column */
   for (last_column = clist->columns - 1; last_column >= 0; last_column--)
     if (clist->column[last_column].visible)
       break;
-
+  
   for (i = 0; i < last_column; i++)
     {
       if (!clist->column[i].visible)
@@ -1926,21 +1926,21 @@ size_allocate_title_buttons (GtkCList *clist)
 	  gdk_window_hide (clist->column[i].window);
 	  continue;
 	}
-
+      
       button_allocation.width += (clist->column[i].area.width +
 				  CELL_SPACING + 2 * COLUMN_INSET);
-
+      
       if (!clist->column[i + 1].button)
 	{
 	  gdk_window_hide (clist->column[i].window);
 	  continue;
 	}
-
+      
       gtk_widget_size_allocate (clist->column[last_button].button,
 				&button_allocation);
       button_allocation.x += button_allocation.width;
       button_allocation.width = 0;
-
+      
       if (clist->column[last_button].resizeable)
 	{
 	  gdk_window_show (clist->column[last_button].window);
@@ -1951,19 +1951,19 @@ size_allocate_title_buttons (GtkCList *clist)
 	}
       else
 	gdk_window_hide (clist->column[last_button].window);
-
+      
       last_button = i + 1;
     }
-
+  
   button_allocation.width += (clist->column[last_column].area.width +
 			      2 * (CELL_SPACING + COLUMN_INSET));
   gtk_widget_size_allocate (clist->column[last_button].button,
 			    &button_allocation);
-
+  
   if (clist->column[last_button].resizeable)
     {
       button_allocation.x += button_allocation.width;
-
+      
       gdk_window_show (clist->column[last_button].window);
       gdk_window_move_resize (clist->column[last_button].window,
 			      button_allocation.x - (DRAG_WIDTH / 2), 
@@ -1980,14 +1980,14 @@ size_allocate_columns (GtkCList *clist,
   gint xoffset = CELL_SPACING + COLUMN_INSET;
   gint last_column;
   gint i;
-
+  
   /* find last visible column and calculate correct column width */
   for (last_column = clist->columns - 1;
        last_column >= 0 && !clist->column[last_column].visible; last_column--);
-
+  
   if (last_column < 0)
     return;
-
+  
   for (i = 0; i <= last_column; i++)
     {
       if (!clist->column[i].visible)
@@ -1999,14 +1999,14 @@ size_allocate_columns (GtkCList *clist,
 	      clist->column[i].auto_resize && clist->column[i].button)
 	    {
 	      gint width;
-
+	      
 	      width = (clist->column[i].button->requisition.width -
 		       (CELL_SPACING + (2 * COLUMN_INSET)));
-
+	      
 	      if (width > clist->column[i].width)
 		gtk_clist_set_column_width (clist, i, width);
 	    }
-
+	  
 	  clist->column[i].area.width = clist->column[i].width;
 	  xoffset += clist->column[i].width + CELL_SPACING + (2* COLUMN_INSET);
 	}
@@ -2018,7 +2018,7 @@ size_allocate_columns (GtkCList *clist,
 	  xoffset += clist->column[i].button->requisition.width;
 	}
     }
-
+  
   clist->column[last_column].area.width = clist->column[last_column].area.width
     + MAX (0, clist->clist_window_width + COLUMN_INSET - xoffset);
 }
@@ -2028,18 +2028,18 @@ list_requisition_width (GtkCList *clist)
 {
   gint width = CELL_SPACING;
   gint i;
-
+  
   for (i = clist->columns - 1; i >= 0; i--)
     {
       if (!clist->column[i].visible)
 	continue;
-
+      
       if (clist->column[i].width_set)
 	width += clist->column[i].width + CELL_SPACING + (2 * COLUMN_INSET);
       else if (GTK_CLIST_SHOW_TITLES(clist) && clist->column[i].button)
 	width += clist->column[i].button->requisition.width;
     }
-
+  
   return width;
 }
 
@@ -2056,20 +2056,20 @@ new_column_width (GtkCList *clist,
   gint cx;
   gint dx;
   gint last_column;
-
+  
   /* first translate the x position from widget->window
    * to clist->clist_window */
   cx = *x - xthickness;
-
+  
   for (last_column = clist->columns - 1;
        last_column >= 0 && !clist->column[last_column].visible; last_column--);
-
+  
   /* calculate new column width making sure it doesn't end up
    * less than the minimum width */
   dx = (COLUMN_LEFT_XPIXEL (clist, column) + COLUMN_INSET +
 	(column < last_column) * CELL_SPACING);
   width = cx - dx;
-
+  
   if (width < MAX (COLUMN_MIN_WIDTH, clist->column[column].min_width))
     {
       width = MAX (COLUMN_MIN_WIDTH, clist->column[column].min_width);
@@ -2083,10 +2083,10 @@ new_column_width (GtkCList *clist,
       cx = dx + clist->column[column].max_width;
       *x = cx + xthickness;
     }      
-
+  
   if (cx < 0 || cx > clist->clist_window_width)
     *x = -1;
-
+  
   return width;
 }
 
@@ -2095,16 +2095,16 @@ column_button_create (GtkCList *clist,
 		      gint      column)
 {
   GtkWidget *button;
-
+  
   gtk_widget_push_composite_child ();
   button = clist->column[column].button = gtk_button_new ();
   gtk_widget_pop_composite_child ();
-
+  
   if (GTK_WIDGET_REALIZED (clist) && clist->title_window)
     gtk_widget_set_parent_window (clist->column[column].button,
 				  clist->title_window);
   gtk_widget_set_parent (button, GTK_WIDGET (clist));
-
+  
   gtk_signal_connect (GTK_OBJECT (button), "clicked",
 		      (GtkSignalFunc) column_button_clicked,
 		      (gpointer) clist);
@@ -2117,17 +2117,17 @@ column_button_clicked (GtkWidget *widget,
 {
   gint i;
   GtkCList *clist;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (data));
-
+  
   clist = GTK_CLIST (data);
-
+  
   /* find the column who's button was pressed */
   for (i = 0; i < clist->columns; i++)
     if (clist->column[i].button == widget)
       break;
-
+  
   gtk_signal_emit (GTK_OBJECT (clist), clist_signals[CLICK_COLUMN], i);
 }
 
@@ -2171,17 +2171,17 @@ gtk_clist_get_cell_type (GtkCList *clist,
 			 gint      column)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_val_if_fail (clist != NULL, -1);
   g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
-
+  
   if (row < 0 || row >= clist->rows)
     return -1;
   if (column < 0 || column >= clist->columns)
     return -1;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   return clist_row->cell[column].type;
 }
 
@@ -2192,26 +2192,26 @@ gtk_clist_set_text (GtkCList    *clist,
 		    const gchar *text)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
   if (column < 0 || column >= clist->columns)
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   /* if text is null, then the cell is empty */
-  GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+  GTK_CLIST_GET_CLASS (clist)->set_cell_contents
     (clist, clist_row, column, GTK_CELL_TEXT, text, 0, NULL, NULL);
-
+  
   /* redraw the list if it's not frozen */
   if (CLIST_UNFROZEN (clist))
     {
       if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
-	GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+	GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
     }
 }
 
@@ -2222,23 +2222,23 @@ gtk_clist_get_text (GtkCList  *clist,
 		    gchar    **text)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_val_if_fail (clist != NULL, 0);
   g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+  
   if (row < 0 || row >= clist->rows)
     return 0;
   if (column < 0 || column >= clist->columns)
     return 0;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (clist_row->cell[column].type != GTK_CELL_TEXT)
     return 0;
-
+  
   if (text)
     *text = GTK_CELL_TEXT (clist_row->cell[column])->text;
-
+  
   return 1;
 }
 
@@ -2250,29 +2250,29 @@ gtk_clist_set_pixmap (GtkCList  *clist,
 		      GdkBitmap *mask)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
   if (column < 0 || column >= clist->columns)
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
   
   gdk_pixmap_ref (pixmap);
   
   if (mask) gdk_pixmap_ref (mask);
   
-  GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+  GTK_CLIST_GET_CLASS (clist)->set_cell_contents
     (clist, clist_row, column, GTK_CELL_PIXMAP, NULL, 0, pixmap, mask);
-
+  
   /* redraw the list if it's not frozen */
   if (CLIST_UNFROZEN (clist))
     {
       if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
-	GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+	GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
     }
 }
 
@@ -2284,27 +2284,27 @@ gtk_clist_get_pixmap (GtkCList   *clist,
 		      GdkBitmap **mask)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_val_if_fail (clist != NULL, 0);
   g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+  
   if (row < 0 || row >= clist->rows)
     return 0;
   if (column < 0 || column >= clist->columns)
     return 0;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (clist_row->cell[column].type != GTK_CELL_PIXMAP)
     return 0;
-
+  
   if (pixmap)
-  {
-    *pixmap = GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap;
-    /* mask can be NULL */
-    *mask = GTK_CELL_PIXMAP (clist_row->cell[column])->mask;
-  }
-
+    {
+      *pixmap = GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap;
+      /* mask can be NULL */
+      *mask = GTK_CELL_PIXMAP (clist_row->cell[column])->mask;
+    }
+  
   return 1;
 }
 
@@ -2318,27 +2318,27 @@ gtk_clist_set_pixtext (GtkCList    *clist,
 		       GdkBitmap   *mask)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
   if (column < 0 || column >= clist->columns)
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
   
   gdk_pixmap_ref (pixmap);
   if (mask) gdk_pixmap_ref (mask);
-  GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+  GTK_CLIST_GET_CLASS (clist)->set_cell_contents
     (clist, clist_row, column, GTK_CELL_PIXTEXT, text, spacing, pixmap, mask);
-
+  
   /* redraw the list if it's not frozen */
   if (CLIST_UNFROZEN (clist))
     {
       if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
-	GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+	GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
     }
 }
 
@@ -2352,30 +2352,30 @@ gtk_clist_get_pixtext (GtkCList   *clist,
 		       GdkBitmap **mask)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_val_if_fail (clist != NULL, 0);
   g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+  
   if (row < 0 || row >= clist->rows)
     return 0;
   if (column < 0 || column >= clist->columns)
     return 0;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (clist_row->cell[column].type != GTK_CELL_PIXTEXT)
     return 0;
-
+  
   if (text)
     *text = GTK_CELL_PIXTEXT (clist_row->cell[column])->text;
   if (spacing)
     *spacing = GTK_CELL_PIXTEXT (clist_row->cell[column])->spacing;
   if (pixmap)
     *pixmap = GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap;
-
+  
   /* mask can be NULL */
   *mask = GTK_CELL_PIXTEXT (clist_row->cell[column])->mask;
-
+  
   return 1;
 }
 
@@ -2388,29 +2388,29 @@ gtk_clist_set_shift (GtkCList *clist,
 {
   GtkRequisition requisition = { 0 };
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
   if (column < 0 || column >= clist->columns)
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (clist->column[column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
-    GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
-						   column, &requisition);
-
+    GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+						    column, &requisition);
+  
   clist_row->cell[column].vertical = vertical;
   clist_row->cell[column].horizontal = horizontal;
-
+  
   column_auto_resize (clist, clist_row, column, requisition.width);
-
+  
   if (CLIST_UNFROZEN (clist) && gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
-    GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+    GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
 }
 
 /* PRIVATE CELL FUNCTIONS
@@ -2428,16 +2428,16 @@ set_cell_contents (GtkCList    *clist,
 		   GdkBitmap   *mask)
 {
   GtkRequisition requisition;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
   g_return_if_fail (clist_row != NULL);
-
+  
   if (clist->column[column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
-    GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
-						   column, &requisition);
-
+    GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+						    column, &requisition);
+  
   switch (clist_row->cell[column].type)
     {
     case GTK_CELL_EMPTY:
@@ -2462,9 +2462,9 @@ set_cell_contents (GtkCList    *clist,
     default:
       break;
     }
-
+  
   clist_row->cell[column].type = GTK_CELL_EMPTY;
-
+  
   switch (type)
     {
     case GTK_CELL_TEXT:
@@ -2496,7 +2496,7 @@ set_cell_contents (GtkCList    *clist,
     default:
       break;
     }
-
+  
   if (clist->column[column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
     column_auto_resize (clist, clist_row, column, requisition.width);
@@ -2511,14 +2511,14 @@ cell_size_request (GtkCList       *clist,
   GtkStyle *style;
   gint width;
   gint height;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
   g_return_if_fail (requisition != NULL);
-
+  
   get_cell_style (clist, clist_row, GTK_STATE_NORMAL, column, &style,
 		  NULL, NULL);
-
+  
   switch (clist_row->cell[column].type)
     {
     case GTK_CELL_TEXT:
@@ -2534,7 +2534,7 @@ cell_size_request (GtkCList       *clist,
 	GTK_CELL_PIXTEXT (clist_row->cell[column])->spacing +
 	gdk_string_width (style->font,
 			  GTK_CELL_TEXT (clist_row->cell[column])->text);
-
+      
       requisition->height = MAX (style->font->ascent + style->font->descent,
 				 height);
       break;
@@ -2549,7 +2549,7 @@ cell_size_request (GtkCList       *clist,
       requisition->height = 0;
       break;
     }
-
+  
   requisition->width  += clist_row->cell[column].horizontal;
   requisition->height += clist_row->cell[column].vertical;
 }
@@ -2568,8 +2568,8 @@ gtk_clist_prepend (GtkCList    *clist,
   g_return_val_if_fail (clist != NULL, -1);
   g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
   g_return_val_if_fail (text != NULL, -1);
-
-  return GTK_CLIST_CLASS_FW (clist)->insert_row (clist, 0, text);
+  
+  return GTK_CLIST_GET_CLASS (clist)->insert_row (clist, 0, text);
 }
 
 gint
@@ -2579,8 +2579,8 @@ gtk_clist_append (GtkCList    *clist,
   g_return_val_if_fail (clist != NULL, -1);
   g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
   g_return_val_if_fail (text != NULL, -1);
-
-  return GTK_CLIST_CLASS_FW (clist)->insert_row (clist, clist->rows, text);
+  
+  return GTK_CLIST_GET_CLASS (clist)->insert_row (clist, clist->rows, text);
 }
 
 gint
@@ -2591,18 +2591,18 @@ gtk_clist_insert (GtkCList    *clist,
   g_return_val_if_fail (clist != NULL, -1);
   g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
   g_return_val_if_fail (text != NULL, -1);
-
+  
   if (row < 0 || row > clist->rows)
     row = clist->rows;
-
-  return GTK_CLIST_CLASS_FW (clist)->insert_row (clist, row, text);
+  
+  return GTK_CLIST_GET_CLASS (clist)->insert_row (clist, row, text);
 }
 
 void
 gtk_clist_remove (GtkCList *clist,
 		  gint      row)
 {
-  GTK_CLIST_CLASS_FW (clist)->remove_row (clist, row);
+  GTK_CLIST_GET_CLASS (clist)->remove_row (clist, row);
 }
 
 void
@@ -2611,7 +2611,7 @@ gtk_clist_clear (GtkCList *clist)
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
   
-  GTK_CLIST_CLASS_FW (clist)->clear (clist);
+  GTK_CLIST_GET_CLASS (clist)->clear (clist);
 }
 
 /* PRIVATE INSERT/REMOVE ROW FUNCTIONS
@@ -2627,24 +2627,24 @@ real_insert_row (GtkCList *clist,
 {
   gint i;
   GtkCListRow *clist_row;
-
+  
   g_return_val_if_fail (clist != NULL, -1);
   g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
   g_return_val_if_fail (text != NULL, -1);
-
+  
   /* return if out of bounds */
   if (row < 0 || row > clist->rows)
     return -1;
-
+  
   /* create the row */
   clist_row = row_new (clist);
-
+  
   /* set the text in the row's columns */
   for (i = 0; i < clist->columns; i++)
     if (text[i])
-      GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+      GTK_CLIST_GET_CLASS (clist)->set_cell_contents
 	(clist, clist_row, i, GTK_CELL_TEXT, text[i], 0, NULL ,NULL);
-
+  
   if (!clist->rows)
     {
       clist->row_list = g_list_append (clist->row_list, clist_row);
@@ -2687,32 +2687,32 @@ real_insert_row (GtkCList *clist,
 					      clist_row))->next;
       else
 	clist->row_list = g_list_insert (clist->row_list, clist_row, row);
-
+      
     }
   clist->rows++;
-
+  
   if (row < ROW_FROM_YPIXEL (clist, 0))
     clist->voffset -= (clist->row_height + CELL_SPACING);
-
+  
   /* syncronize the selection list */
   sync_selection (clist, row, SYNC_INSERT);
-
+  
   if (clist->rows == 1)
     {
       clist->focus_row = 0;
       if (clist->selection_mode == GTK_SELECTION_BROWSE)
 	gtk_clist_select_row (clist, 0, -1);
     }
-
+  
   /* redraw the list if it isn't frozen */
   if (CLIST_UNFROZEN (clist))
     {
       adjust_adjustments (clist, FALSE);
-
+      
       if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
 	draw_rows (clist, NULL);
     }
-
+  
   return row;
 }
 
@@ -2723,22 +2723,22 @@ real_remove_row (GtkCList *clist,
   gint was_visible, was_selected;
   GList *list;
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   /* return if out of bounds */
   if (row < 0 || row > (clist->rows - 1))
     return;
-
+  
   was_visible = (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE);
   was_selected = 0;
-
+  
   /* get the row we're going to delete */
   list = ROW_ELEMENT (clist, row);
   g_assert (list != NULL);
   clist_row = list->data;
-
+  
   /* if we're removing a selected row, we have to make sure
    * it's properly unselected, and then sync up the clist->selected
    * list to reflect the deincrimented indexies of rows after the
@@ -2746,7 +2746,7 @@ real_remove_row (GtkCList *clist,
   if (clist_row->state == GTK_STATE_SELECTED)
     gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW],
 		     row, -1, NULL);
-
+  
   /* reset the row end pointer if we're removing at the end of the list */
   clist->rows--;
   if (clist->row_list == list)
@@ -2754,29 +2754,29 @@ real_remove_row (GtkCList *clist,
   if (clist->row_list_end == list)
     clist->row_list_end = g_list_previous (list);
   g_list_remove (list, clist_row);
-
+  
   /*if (clist->focus_row >=0 &&
-      (row <= clist->focus_row || clist->focus_row >= clist->rows))
-      clist->focus_row--;*/
-
+    (row <= clist->focus_row || clist->focus_row >= clist->rows))
+    clist->focus_row--;*/
+  
   if (row < ROW_FROM_YPIXEL (clist, 0))
     clist->voffset += clist->row_height + CELL_SPACING;
-
+  
   sync_selection (clist, row, SYNC_REMOVE);
-
+  
   if (clist->selection_mode == GTK_SELECTION_BROWSE && !clist->selection &&
       clist->focus_row >= 0)
     gtk_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW],
 		     clist->focus_row, -1, NULL);
-
+  
   /* toast the row */
   row_delete (clist, clist_row);
-
+  
   /* redraw the row if it isn't frozen */
   if (CLIST_UNFROZEN (clist))
     {
       adjust_adjustments (clist, FALSE);
-
+      
       if (was_visible)
 	draw_rows (clist, NULL);
     }
@@ -2788,15 +2788,15 @@ real_clear (GtkCList *clist)
   GList *list;
   GList *free_list;
   gint i;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   /* free up the selection list */
   g_list_free (clist->selection);
   g_list_free (clist->undo_selection);
   g_list_free (clist->undo_unselection);
-
+  
   clist->selection = NULL;
   clist->selection_end = NULL;
   clist->undo_selection = NULL;
@@ -2807,7 +2807,7 @@ real_clear (GtkCList *clist)
   clist->undo_anchor = -1;
   clist->anchor_state = GTK_STATE_SELECTED;
   clist->drag_pos = -1;
-
+  
   /* remove all the rows */
   GTK_CLIST_SET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
   free_list = clist->row_list;
@@ -2847,33 +2847,33 @@ real_row_move (GtkCList *clist,
   GList *list;
   gint first, last;
   gint d;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (GTK_CLIST_AUTO_SORT(clist))
     return;
-
+  
   if (source_row < 0 || source_row >= clist->rows ||
       dest_row   < 0 || dest_row   >= clist->rows ||
       source_row == dest_row)
     return;
-
+  
   gtk_clist_freeze (clist);
-
+  
   /* unlink source row */
   clist_row = ROW_ELEMENT (clist, source_row)->data;
   if (source_row == clist->rows - 1)
     clist->row_list_end = clist->row_list_end->prev;
   clist->row_list = g_list_remove (clist->row_list, clist_row);
   clist->rows--;
-
+  
   /* relink source row */
   clist->row_list = g_list_insert (clist->row_list, clist_row, dest_row);
   if (dest_row == clist->rows)
     clist->row_list_end = clist->row_list_end->next;
   clist->rows++;
-
+  
   /* sync selection */
   if (source_row > dest_row)
     {
@@ -2887,7 +2887,7 @@ real_row_move (GtkCList *clist,
       last  = dest_row;
       d = -1;
     }
-
+  
   for (list = clist->selection; list; list = list->next)
     {
       if (list->data == GINT_TO_POINTER (source_row))
@@ -2901,7 +2901,7 @@ real_row_move (GtkCList *clist,
     clist->focus_row = dest_row;
   else if (clist->focus_row > first)
     clist->focus_row += d;
-
+  
   gtk_clist_thaw (clist);
 }
 
@@ -2927,20 +2927,20 @@ gtk_clist_moveto (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < -1 || row >= clist->rows)
     return;
   if (column < -1 || column >= clist->columns)
     return;
-
+  
   row_align = CLAMP (row_align, 0, 1);
   col_align = CLAMP (col_align, 0, 1);
-
+  
   /* adjust horizontal scrollbar */
   if (clist->hadjustment && column >= 0)
     {
       gint x;
-
+      
       x = (COLUMN_LEFT (clist, column) - CELL_SPACING - COLUMN_INSET -
 	   (col_align * (clist->clist_window_width - 2 * COLUMN_INSET -
 			 CELL_SPACING - clist->column[column].area.width)));
@@ -2952,7 +2952,7 @@ gtk_clist_moveto (GtkCList *clist,
       else
 	gtk_adjustment_set_value (clist->hadjustment, x);
     }
-
+  
   /* adjust vertical scrollbar */
   if (clist->vadjustment && row >= 0)
     move_vertical (clist, row, row_align);
@@ -2963,12 +2963,12 @@ gtk_clist_set_row_height (GtkCList *clist,
 			  guint     height)
 {
   GtkWidget *widget;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   widget = GTK_WIDGET (clist);
-
+  
   if (height > 0)
     {
       clist->row_height = height;
@@ -2979,7 +2979,7 @@ gtk_clist_set_row_height (GtkCList *clist,
       GTK_CLIST_UNSET_FLAG (clist, CLIST_ROW_HEIGHT_SET);
       clist->row_height = 0;
     }
-
+  
   if (GTK_WIDGET_REALIZED (clist))
     {
       if (!GTK_CLIST_ROW_HEIGHT_SET(clist))
@@ -2993,7 +2993,7 @@ gtk_clist_set_row_height (GtkCList *clist,
 					  widget->style->font->ascent -
 					  widget->style->font->descent - 1) / 2;
     }
-      
+  
   CLIST_REFRESH (clist);
 }
 
@@ -3012,15 +3012,15 @@ gtk_clist_set_row_data_full (GtkCList         *clist,
 			     GtkDestroyNotify  destroy)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row > (clist->rows - 1))
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (clist_row->destroy)
     clist_row->destroy (clist_row->data);
   
@@ -3033,13 +3033,13 @@ gtk_clist_get_row_data (GtkCList *clist,
 			gint      row)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_val_if_fail (clist != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+  
   if (row < 0 || row > (clist->rows - 1))
     return NULL;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
   return clist_row->data;
 }
@@ -3050,14 +3050,14 @@ gtk_clist_find_row_from_data (GtkCList *clist,
 {
   GList *list;
   gint n;
-
+  
   g_return_val_if_fail (clist != NULL, -1);
   g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
-
+  
   for (n = 0, list = clist->row_list; list; n++, list = list->next)
     if (GTK_CLIST_ROW (list)->data == data)
       return n;
-
+  
   return -1;
 }
 
@@ -3067,19 +3067,19 @@ gtk_clist_swap_rows (GtkCList *clist,
 		     gint      row2)
 {
   gint first, last;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
   g_return_if_fail (row1 != row2);
-
+  
   if (GTK_CLIST_AUTO_SORT(clist))
     return;
-
+  
   gtk_clist_freeze (clist);
-
+  
   first = MIN (row1, row2);
   last  = MAX (row1, row2);
-
+  
   gtk_clist_row_move (clist, last, first);
   gtk_clist_row_move (clist, first + 1, last);
   
@@ -3093,15 +3093,15 @@ gtk_clist_row_move (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (GTK_CLIST_AUTO_SORT(clist))
     return;
-
+  
   if (source_row < 0 || source_row >= clist->rows ||
       dest_row   < 0 || dest_row   >= clist->rows ||
       source_row == dest_row)
     return;
-
+  
   gtk_signal_emit (GTK_OBJECT (clist), clist_signals[ROW_MOVE],
 		   source_row, dest_row);
 }
@@ -3111,28 +3111,28 @@ gtk_clist_row_is_visible (GtkCList *clist,
 			  gint      row)
 {
   gint top;
-
+  
   g_return_val_if_fail (clist != NULL, 0);
   g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+  
   if (row < 0 || row >= clist->rows)
     return GTK_VISIBILITY_NONE;
-
+  
   if (clist->row_height == 0)
     return GTK_VISIBILITY_NONE;
-
+  
   if (row < ROW_FROM_YPIXEL (clist, 0))
     return GTK_VISIBILITY_NONE;
-
+  
   if (row > ROW_FROM_YPIXEL (clist, clist->clist_window_height))
     return GTK_VISIBILITY_NONE;
-
+  
   top = ROW_TOP_YPIXEL (clist, row);
-
+  
   if ((top < 0)
       || ((top + clist->row_height) >= clist->clist_window_height))
     return GTK_VISIBILITY_PARTIAL;
-
+  
   return GTK_VISIBILITY_FULL;
 }
 
@@ -3142,15 +3142,15 @@ gtk_clist_set_foreground (GtkCList *clist,
 			  GdkColor *color)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (color)
     {
       clist_row->foreground = *color;
@@ -3161,9 +3161,9 @@ gtk_clist_set_foreground (GtkCList *clist,
     }
   else
     clist_row->fg_set = FALSE;
-
+  
   if (CLIST_UNFROZEN (clist) && gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
-    GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+    GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
 }
 
 void
@@ -3172,15 +3172,15 @@ gtk_clist_set_background (GtkCList *clist,
 			  GdkColor *color)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (color)
     {
       clist_row->background = *color;
@@ -3191,10 +3191,10 @@ gtk_clist_set_background (GtkCList *clist,
     }
   else
     clist_row->bg_set = FALSE;
-
+  
   if (CLIST_UNFROZEN (clist)
       && (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
-    GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+    GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
 }
 
 /* PUBLIC ROW/CELL STYLE FUNCTIONS
@@ -3211,34 +3211,34 @@ gtk_clist_set_cell_style (GtkCList *clist,
 {
   GtkRequisition requisition = { 0 };
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
   if (column < 0 || column >= clist->columns)
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (clist_row->cell[column].style == style)
     return;
-
+  
   if (clist->column[column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
-    GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
-						   column, &requisition);
-
+    GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+						    column, &requisition);
+  
   if (clist_row->cell[column].style)
     {
       if (GTK_WIDGET_REALIZED (clist))
         gtk_style_detach (clist_row->cell[column].style);
       gtk_style_unref (clist_row->cell[column].style);
     }
-
+  
   clist_row->cell[column].style = style;
-
+  
   if (clist_row->cell[column].style)
     {
       gtk_style_ref (clist_row->cell[column].style);
@@ -3248,14 +3248,14 @@ gtk_clist_set_cell_style (GtkCList *clist,
 	  gtk_style_attach (clist_row->cell[column].style,
 			    clist->clist_window);
     }
-
+  
   column_auto_resize (clist, clist_row, column, requisition.width);
-
+  
   /* redraw the list if it's not frozen */
   if (CLIST_UNFROZEN (clist))
     {
       if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
-	GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+	GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
     }
 }
 
@@ -3265,15 +3265,15 @@ gtk_clist_get_cell_style (GtkCList *clist,
 			  gint      column)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_val_if_fail (clist != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+  
   if (row < 0 || row >= clist->rows || column < 0 || column >= clist->columns)
     return NULL;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   return clist_row->cell[column].style;
 }
 
@@ -3286,40 +3286,40 @@ gtk_clist_set_row_style (GtkCList *clist,
   GtkCListRow *clist_row;
   gint *old_width;
   gint i;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (clist_row->style == style)
     return;
-
+  
   old_width = g_new (gint, clist->columns);
-
+  
   if (!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
     {
       for (i = 0; i < clist->columns; i++)
 	if (clist->column[i].auto_resize)
 	  {
-	    GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
-							   i, &requisition);
+	    GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+							    i, &requisition);
 	    old_width[i] = requisition.width;
 	  }
     }
-
+  
   if (clist_row->style)
     {
       if (GTK_WIDGET_REALIZED (clist))
         gtk_style_detach (clist_row->style);
       gtk_style_unref (clist_row->style);
     }
-
+  
   clist_row->style = style;
-
+  
   if (clist_row->style)
     {
       gtk_style_ref (clist_row->style);
@@ -3328,18 +3328,18 @@ gtk_clist_set_row_style (GtkCList *clist,
         clist_row->style = gtk_style_attach (clist_row->style,
 					     clist->clist_window);
     }
-
+  
   if (GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
     for (i = 0; i < clist->columns; i++)
       column_auto_resize (clist, clist_row, i, old_width[i]);
-
+  
   g_free (old_width);
-
+  
   /* redraw the list if it's not frozen */
   if (CLIST_UNFROZEN (clist))
     {
       if (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
-	GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+	GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
     }
 }
 
@@ -3348,15 +3348,15 @@ gtk_clist_get_row_style (GtkCList *clist,
 			 gint      row)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_val_if_fail (clist != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CLIST (clist), NULL);
-
+  
   if (row < 0 || row >= clist->rows)
     return NULL;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   return clist_row->style;
 }
 
@@ -3375,20 +3375,20 @@ gtk_clist_set_selectable (GtkCList *clist,
 			  gboolean  selectable)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (selectable == clist_row->selectable)
     return;
-
+  
   clist_row->selectable = selectable;
-
+  
   if (!selectable && clist_row->state == GTK_STATE_SELECTED)
     {
       if (clist->anchor >= 0 &&
@@ -3396,7 +3396,7 @@ gtk_clist_set_selectable (GtkCList *clist,
 	{
 	  clist->drag_button = 0;
 	  remove_grab (clist);
-	  GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+	  GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
 	}
       gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW],
 		       row, -1, NULL);
@@ -3409,10 +3409,10 @@ gtk_clist_get_selectable (GtkCList *clist,
 {
   g_return_val_if_fail (clist != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (clist), FALSE);
-
+  
   if (row < 0 || row >= clist->rows)
     return FALSE;
-
+  
   return GTK_CLIST_ROW (ROW_ELEMENT (clist, row))->selectable;
 }
 
@@ -3423,12 +3423,12 @@ gtk_clist_select_row (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
   if (column < -1 || column >= clist->columns)
     return;
-
+  
   gtk_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW],
 		   row, column, NULL);
 }
@@ -3440,12 +3440,12 @@ gtk_clist_unselect_row (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row >= clist->rows)
     return;
   if (column < -1 || column >= clist->columns)
     return;
-
+  
   gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW],
 		   row, column, NULL);
 }
@@ -3455,8 +3455,8 @@ gtk_clist_select_all (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
-  GTK_CLIST_CLASS_FW (clist)->select_all (clist);
+  
+  GTK_CLIST_GET_CLASS (clist)->select_all (clist);
 }
 
 void
@@ -3464,8 +3464,8 @@ gtk_clist_unselect_all (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
-  GTK_CLIST_CLASS_FW (clist)->unselect_all (clist);
+  
+  GTK_CLIST_GET_CLASS (clist)->unselect_all (clist);
 }
 
 void
@@ -3473,7 +3473,7 @@ gtk_clist_undo_selection (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (clist->selection_mode == GTK_SELECTION_EXTENDED &&
       (clist->undo_selection || clist->undo_unselection))
     gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNDO_SELECTION]);
@@ -3514,17 +3514,17 @@ toggle_row (GtkCList *clist,
 	    GdkEvent *event)
 {
   GtkCListRow *clist_row;
-
+  
   switch (clist->selection_mode)
     {
     case GTK_SELECTION_EXTENDED:
     case GTK_SELECTION_MULTIPLE:
     case GTK_SELECTION_SINGLE:
       clist_row = ROW_ELEMENT (clist, row)->data;
-
+      
       if (!clist_row)
 	return;
-
+      
       if (clist_row->state == GTK_STATE_SELECTED)
 	{
 	  gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW],
@@ -3543,9 +3543,9 @@ fake_toggle_row (GtkCList *clist,
 		 gint      row)
 {
   GList *work;
-
+  
   work = ROW_ELEMENT (clist, row);
-
+  
   if (!work || !GTK_CLIST_ROW (work)->selectable)
     return;
   
@@ -3556,8 +3556,8 @@ fake_toggle_row (GtkCList *clist,
   
   if (CLIST_UNFROZEN (clist) &&
       gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
-    GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row,
-					  GTK_CLIST_ROW (work));
+    GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row,
+					   GTK_CLIST_ROW (work));
 }
 
 static void
@@ -3565,11 +3565,11 @@ toggle_focus_row (GtkCList *clist)
 {
   g_return_if_fail (clist != 0);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
       clist->focus_row < 0 || clist->focus_row >= clist->rows)
     return;
-
+  
   switch (clist->selection_mode)
     {
     case  GTK_SELECTION_SINGLE:
@@ -3581,7 +3581,7 @@ toggle_focus_row (GtkCList *clist)
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
-
+      
       clist->anchor = clist->focus_row;
       clist->drag_pos = clist->focus_row;
       clist->undo_anchor = clist->focus_row;
@@ -3589,9 +3589,9 @@ toggle_focus_row (GtkCList *clist)
       if (GTK_CLIST_ADD_MODE(clist))
 	fake_toggle_row (clist, clist->focus_row);
       else
-	GTK_CLIST_CLASS_FW (clist)->fake_unselect_all (clist,clist->focus_row);
-
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+	GTK_CLIST_GET_CLASS (clist)->fake_unselect_all (clist,clist->focus_row);
+      
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
       break;
     default:
       break;
@@ -3607,7 +3607,7 @@ toggle_add_mode (GtkCList *clist)
   if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
       clist->selection_mode != GTK_SELECTION_EXTENDED)
     return;
-
+  
   gtk_clist_draw_focus (GTK_WIDGET (clist));
   if (!GTK_CLIST_ADD_MODE(clist))
     {
@@ -3635,45 +3635,45 @@ real_select_row (GtkCList *clist,
   GList *list;
   gint sel_row;
   gboolean row_selected;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row > (clist->rows - 1))
     return;
-
+  
   switch (clist->selection_mode)
     {
     case GTK_SELECTION_SINGLE:
     case GTK_SELECTION_BROWSE:
-
+      
       row_selected = FALSE;
       list = clist->selection;
-
+      
       while (list)
 	{
 	  sel_row = GPOINTER_TO_INT (list->data);
 	  list = list->next;
-
+	  
 	  if (row == sel_row)
 	    row_selected = TRUE;
 	  else
 	    gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW], 
 			     sel_row, column, event);
 	}
-
+      
       if (row_selected)
 	return;
       
     default:
       break;
     }
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (clist_row->state != GTK_STATE_NORMAL || !clist_row->selectable)
     return;
-
+  
   clist_row->state = GTK_STATE_SELECTED;
   if (!clist->selection)
     {
@@ -3687,7 +3687,7 @@ real_select_row (GtkCList *clist,
   
   if (CLIST_UNFROZEN (clist)
       && (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
-    GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+    GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
 }
 
 static void
@@ -3697,29 +3697,29 @@ real_unselect_row (GtkCList *clist,
 		   GdkEvent *event)
 {
   GtkCListRow *clist_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (row < 0 || row > (clist->rows - 1))
     return;
-
+  
   clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   if (clist_row->state == GTK_STATE_SELECTED)
     {
       clist_row->state = GTK_STATE_NORMAL;
-
+      
       if (clist->selection_end && 
 	  clist->selection_end->data == GINT_TO_POINTER (row))
 	clist->selection_end = clist->selection_end->prev;
-
+      
       clist->selection = g_list_remove (clist->selection,
 					GINT_TO_POINTER (row));
       
       if (CLIST_UNFROZEN (clist)
 	  && (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE))
-	GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row, clist_row);
+	GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row, clist_row);
     }
 }
 
@@ -3728,38 +3728,38 @@ real_select_all (GtkCList *clist)
 {
   GList *list;
   gint i;
- 
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
     return;
-
+  
   switch (clist->selection_mode)
     {
     case GTK_SELECTION_SINGLE:
     case GTK_SELECTION_BROWSE:
       return;
-
+      
     case GTK_SELECTION_EXTENDED:
       g_list_free (clist->undo_selection);
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
-	  
+      
       if (clist->rows &&
 	  ((GtkCListRow *) (clist->row_list->data))->state !=
 	  GTK_STATE_SELECTED)
 	fake_toggle_row (clist, 0);
-
+      
       clist->anchor_state =  GTK_STATE_SELECTED;
       clist->anchor = 0;
       clist->drag_pos = 0;
       clist->undo_anchor = clist->focus_row;
       update_extended_selection (clist, clist->rows);
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
       return;
-
+      
     case GTK_SELECTION_MULTIPLE:
       for (i = 0, list = clist->row_list; list; i++, list = list->next)
 	{
@@ -3776,13 +3776,13 @@ real_unselect_all (GtkCList *clist)
 {
   GList *list;
   gint i;
- 
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
     return;
-
+  
   switch (clist->selection_mode)
     {
     case GTK_SELECTION_BROWSE:
@@ -3799,7 +3799,7 @@ real_unselect_all (GtkCList *clist)
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
-
+      
       clist->anchor = -1;
       clist->drag_pos = -1;
       clist->undo_anchor = clist->focus_row;
@@ -3807,7 +3807,7 @@ real_unselect_all (GtkCList *clist)
     default:
       break;
     }
-
+  
   list = clist->selection;
   while (list)
     {
@@ -3825,7 +3825,7 @@ fake_unselect_all (GtkCList *clist,
   GList *list;
   GList *work;
   gint i;
-
+  
   if (row >= 0 && (work = ROW_ELEMENT (clist, row)))
     {
       if (GTK_CLIST_ROW (work)->state == GTK_STATE_NORMAL &&
@@ -3835,26 +3835,26 @@ fake_unselect_all (GtkCList *clist,
 	  
 	  if (CLIST_UNFROZEN (clist) &&
 	      gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
-	    GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row,
-						  GTK_CLIST_ROW (work));
+	    GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row,
+						   GTK_CLIST_ROW (work));
 	}  
     }
-
+  
   clist->undo_selection = clist->selection;
   clist->selection = NULL;
   clist->selection_end = NULL;
-
+  
   for (list = clist->undo_selection; list; list = list->next)
     {
       if ((i = GPOINTER_TO_INT (list->data)) == row ||
 	  !(work = g_list_nth (clist->row_list, i)))
 	continue;
-
+      
       GTK_CLIST_ROW (work)->state = GTK_STATE_NORMAL;
       if (CLIST_UNFROZEN (clist) &&
 	  gtk_clist_row_is_visible (clist, i) != GTK_VISIBILITY_NONE)
-	GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, i,
-					      GTK_CLIST_ROW (work));
+	GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, i,
+					       GTK_CLIST_ROW (work));
     }
 }
 
@@ -3862,33 +3862,33 @@ static void
 real_undo_selection (GtkCList *clist)
 {
   GList *work;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
       clist->selection_mode != GTK_SELECTION_EXTENDED)
     return;
-
-  GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
-
+  
+  GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
+  
   if (!(clist->undo_selection || clist->undo_unselection))
     {
       gtk_clist_unselect_all (clist);
       return;
     }
-
+  
   for (work = clist->undo_selection; work; work = work->next)
     gtk_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW],
 		     GPOINTER_TO_INT (work->data), -1, NULL);
-
+  
   for (work = clist->undo_unselection; work; work = work->next)
     {
       /* g_print ("unselect %d\n",GPOINTER_TO_INT (work->data)); */
       gtk_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW], 
 		       GPOINTER_TO_INT (work->data), -1, NULL);
     }
-
+  
   if (GTK_WIDGET_HAS_FOCUS(clist) && clist->focus_row != clist->undo_anchor)
     {
       gtk_clist_draw_focus (GTK_WIDGET (clist));
@@ -3899,12 +3899,12 @@ real_undo_selection (GtkCList *clist)
     clist->focus_row = clist->undo_anchor;
   
   clist->undo_anchor = -1;
- 
+  
   g_list_free (clist->undo_selection);
   g_list_free (clist->undo_unselection);
   clist->undo_selection = NULL;
   clist->undo_unselection = NULL;
-
+  
   if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
       clist->clist_window_height)
     gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
@@ -3923,20 +3923,20 @@ set_anchor (GtkCList *clist,
   
   if (clist->selection_mode != GTK_SELECTION_EXTENDED || clist->anchor >= 0)
     return;
-
+  
   g_list_free (clist->undo_selection);
   g_list_free (clist->undo_unselection);
   clist->undo_selection = NULL;
   clist->undo_unselection = NULL;
-
+  
   if (add_mode)
     fake_toggle_row (clist, anchor);
   else
     {
-      GTK_CLIST_CLASS_FW (clist)->fake_unselect_all (clist, anchor);
+      GTK_CLIST_GET_CLASS (clist)->fake_unselect_all (clist, anchor);
       clist->anchor_state = GTK_STATE_SELECTED;
     }
-
+  
   clist->anchor = anchor;
   clist->drag_pos = anchor;
   clist->undo_anchor = undo_anchor;
@@ -3951,18 +3951,18 @@ resync_selection (GtkCList *clist,
   gint row;
   GList *list;
   GtkCListRow *clist_row;
-
+  
   if (clist->selection_mode != GTK_SELECTION_EXTENDED)
     return;
-
+  
   if (clist->anchor < 0 || clist->drag_pos < 0)
     return;
-
+  
   gtk_clist_freeze (clist);
-
+  
   i = MIN (clist->anchor, clist->drag_pos);
   e = MAX (clist->anchor, clist->drag_pos);
-
+  
   if (clist->undo_selection)
     {
       list = clist->selection;
@@ -3989,7 +3989,7 @@ resync_selection (GtkCList *clist,
 	    }
 	}
     }    
-
+  
   if (clist->anchor < clist->drag_pos)
     {
       for (list = g_list_nth (clist->row_list, i); i <= e;
@@ -4051,10 +4051,10 @@ resync_selection (GtkCList *clist,
   for (list = clist->undo_unselection; list; list = list->next)
     gtk_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW],
 		     GPOINTER_TO_INT (list->data), -1, event);
-
+  
   clist->anchor = -1;
   clist->drag_pos = -1;
-
+  
   gtk_clist_thaw (clist);
 }
 
@@ -4074,15 +4074,15 @@ update_extended_selection (GtkCList *clist,
   gint h1 = 0;
   gint h2 = 0;
   gint top;
-
+  
   if (clist->selection_mode != GTK_SELECTION_EXTENDED || clist->anchor == -1)
     return;
-
+  
   if (row < 0)
     row = 0;
   if (row >= clist->rows)
     row = clist->rows - 1;
-
+  
   /* extending downwards */
   if (row > clist->drag_pos && clist->anchor <= clist->drag_pos)
     {
@@ -4127,12 +4127,12 @@ update_extended_selection (GtkCList *clist,
       else
 	e1 = row - 1;
     }
-
+  
   clist->drag_pos = row;
-
+  
   area.x = 0;
   area.width = clist->clist_window_width;
-
+  
   /* restore the elements between s1 and e1 */
   if (s1 >= 0)
     {
@@ -4140,14 +4140,14 @@ update_extended_selection (GtkCList *clist,
 	   i++, list = list->next)
 	if (GTK_CLIST_ROW (list)->selectable)
 	  {
-	    if (GTK_CLIST_CLASS_FW (clist)->selection_find (clist, i, list))
+	    if (GTK_CLIST_GET_CLASS (clist)->selection_find (clist, i, list))
 	      GTK_CLIST_ROW (list)->state = GTK_STATE_SELECTED;
 	    else
 	      GTK_CLIST_ROW (list)->state = GTK_STATE_NORMAL;
 	  }
-
+      
       top = ROW_TOP_YPIXEL (clist, clist->focus_row);
-
+      
       if (top + clist->row_height <= 0)
 	{
 	  area.y = 0;
@@ -4166,11 +4166,11 @@ update_extended_selection (GtkCList *clist,
 	gtk_clist_moveto (clist, clist->focus_row, -1, 0, 0);
       else if (top + clist->row_height > clist->clist_window_height)
 	gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
-
+      
       y1 = ROW_TOP_YPIXEL (clist, s1) - 1;
       h1 = (e1 - s1 + 1) * (clist->row_height + CELL_SPACING);
     }
-
+  
   /* extend the selection between s2 and e2 */
   if (s2 >= 0)
     {
@@ -4179,9 +4179,9 @@ update_extended_selection (GtkCList *clist,
 	if (GTK_CLIST_ROW (list)->selectable &&
 	    GTK_CLIST_ROW (list)->state != clist->anchor_state)
 	  GTK_CLIST_ROW (list)->state = clist->anchor_state;
-
+      
       top = ROW_TOP_YPIXEL (clist, clist->focus_row);
-
+      
       if (top + clist->row_height <= 0)
 	{
 	  area.y = 0;
@@ -4200,11 +4200,11 @@ update_extended_selection (GtkCList *clist,
 	gtk_clist_moveto (clist, clist->focus_row, -1, 0, 0);
       else if (top + clist->row_height > clist->clist_window_height)
 	gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
-
+      
       y2 = ROW_TOP_YPIXEL (clist, s2) - 1;
       h2 = (e2 - s2 + 1) * (clist->row_height + CELL_SPACING);
     }
-
+  
   area.y = MAX (0, MIN (y1, y2));
   if (area.y > clist->clist_window_height)
     area.y = 0;
@@ -4219,10 +4219,10 @@ start_selection (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
     return;
-
+  
   set_anchor (clist, GTK_CLIST_ADD_MODE(clist), clist->focus_row,
 	      clist->focus_row);
 }
@@ -4232,11 +4232,11 @@ end_selection (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_FOCUS(clist))
     return;
-
-  GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+  
+  GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
 }
 
 static void
@@ -4247,25 +4247,25 @@ extend_selection (GtkCList      *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if ((gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)) ||
       clist->selection_mode != GTK_SELECTION_EXTENDED)
     return;
-
+  
   if (auto_start_selection)
     set_anchor (clist, GTK_CLIST_ADD_MODE(clist), clist->focus_row,
 		clist->focus_row);
   else if (clist->anchor == -1)
     return;
-
+  
   move_focus_row (clist, scroll_type, position);
-
+  
   if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
       clist->clist_window_height)
     gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
   else if (ROW_TOP_YPIXEL (clist, clist->focus_row) < 0)
     gtk_clist_moveto (clist, clist->focus_row, -1, 0, 0);
-
+  
   update_extended_selection (clist, clist->focus_row);
 }
 
@@ -4276,12 +4276,12 @@ sync_selection (GtkCList *clist,
 {
   GList *list;
   gint d;
-
+  
   if (mode == SYNC_INSERT)
     d = 1;
   else
     d = -1;
-      
+  
   if (clist->focus_row >= row)
     {
       if (d > 0 || clist->focus_row > row)
@@ -4291,20 +4291,20 @@ sync_selection (GtkCList *clist,
       else if (clist->focus_row >= clist->rows)
 	clist->focus_row = clist->rows - 1;
     }
-
-  GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
-
+  
+  GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
+  
   g_list_free (clist->undo_selection);
   g_list_free (clist->undo_unselection);
   clist->undo_selection = NULL;
   clist->undo_unselection = NULL;
-
+  
   clist->anchor = -1;
   clist->drag_pos = -1;
   clist->undo_anchor = clist->focus_row;
-
+  
   list = clist->selection;
-
+  
   while (list)
     {
       if (GPOINTER_TO_INT (list->data) >= row)
@@ -4322,25 +4322,25 @@ gtk_clist_destroy (GtkObject *object)
 {
   gint i;
   GtkCList *clist;
-
+  
   g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_CLIST (object));
-
+  
   clist = GTK_CLIST (object);
-
+  
   /* freeze the list */
   clist->freeze_count++;
-
+  
   /* get rid of all the rows */
   gtk_clist_clear (clist);
-
+  
   /* Since we don't have a _remove method, unparent the children
    * instead of destroying them so the focus will be unset properly.
    * (For other containers, the _remove method takes care of the
    * unparent) The destroy will happen when the refcount drops
    * to zero.
    */
-
+  
   /* unref adjustments */
   if (clist->hadjustment)
     {
@@ -4354,9 +4354,9 @@ gtk_clist_destroy (GtkObject *object)
       gtk_object_unref (GTK_OBJECT (clist->vadjustment));
       clist->vadjustment = NULL;
     }
-
+  
   remove_grab (clist);
-
+  
   /* destroy the column buttons */
   for (i = 0; i < clist->columns; i++)
     if (clist->column[i].button)
@@ -4364,28 +4364,26 @@ gtk_clist_destroy (GtkObject *object)
 	gtk_widget_unparent (clist->column[i].button);
 	clist->column[i].button = NULL;
       }
-
+  
   if (GTK_OBJECT_CLASS (parent_class)->destroy)
     (*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 }
 
 static void
-gtk_clist_finalize (GtkObject *object)
+gtk_clist_finalize (GObject *object)
 {
   GtkCList *clist;
-
-  g_return_if_fail (object != NULL);
+  
   g_return_if_fail (GTK_IS_CLIST (object));
-
+  
   clist = GTK_CLIST (object);
-
+  
   columns_delete (clist);
-
+  
   g_mem_chunk_destroy (clist->cell_mem_chunk);
   g_mem_chunk_destroy (clist->row_mem_chunk);
-
-  if (GTK_OBJECT_CLASS (parent_class)->finalize)
-    (*GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 /* GTKWIDGET
@@ -4415,14 +4413,14 @@ gtk_clist_realize (GtkWidget *widget)
   gint border_width;
   gint i;
   gint j;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
-
+  
   clist = GTK_CLIST (widget);
-
+  
   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
-
+  
   border_width = GTK_CONTAINER (widget)->border_width;
   
   attributes.window_type = GDK_WINDOW_CHILD;
@@ -4440,18 +4438,18 @@ gtk_clist_realize (GtkWidget *widget)
 			    GDK_KEY_PRESS_MASK |
 			    GDK_KEY_RELEASE_MASK);
   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
-
+  
   /* main window */
   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
 				   &attributes, attributes_mask);
   gdk_window_set_user_data (widget->window, clist);
-
+  
   widget->style = gtk_style_attach (widget->style, widget->window);
-
+  
   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
-
+  
   /* column-title window */
-
+  
   attributes.x = clist->column_title_area.x;
   attributes.y = clist->column_title_area.y;
   attributes.width = clist->column_title_area.width;
@@ -4460,17 +4458,17 @@ gtk_clist_realize (GtkWidget *widget)
   clist->title_window = gdk_window_new (widget->window, &attributes,
 					attributes_mask);
   gdk_window_set_user_data (clist->title_window, clist);
-
+  
   gtk_style_set_background (widget->style, clist->title_window,
 			    GTK_STATE_NORMAL);
   gdk_window_show (clist->title_window);
-
+  
   /* set things up so column buttons are drawn in title window */
   for (i = 0; i < clist->columns; i++)
     if (clist->column[i].button)
       gtk_widget_set_parent_window (clist->column[i].button,
 				    clist->title_window);
-
+  
   /* clist-window */
   attributes.x = (clist->internal_allocation.x +
 		  widget->style->klass->xthickness);
@@ -4483,13 +4481,13 @@ gtk_clist_realize (GtkWidget *widget)
   clist->clist_window = gdk_window_new (widget->window, &attributes,
 					attributes_mask);
   gdk_window_set_user_data (clist->clist_window, clist);
-
+  
   gdk_window_set_background (clist->clist_window,
 			     &widget->style->base[GTK_STATE_NORMAL]);
   gdk_window_show (clist->clist_window);
   gdk_window_get_size (clist->clist_window, &clist->clist_window_width,
 		       &clist->clist_window_height);
-
+  
   /* create resize windows */
   attributes.wclass = GDK_INPUT_ONLY;
   attributes.event_mask = (GDK_BUTTON_PRESS_MASK |
@@ -4500,31 +4498,31 @@ gtk_clist_realize (GtkWidget *widget)
   attributes_mask = GDK_WA_CURSOR;
   attributes.cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
   clist->cursor_drag = attributes.cursor;
-
+  
   attributes.x =  LIST_WIDTH (clist) + 1;
   attributes.y = 0;
   attributes.width = 0;
   attributes.height = 0;
-
+  
   for (i = 0; i < clist->columns; i++)
     {
       clist->column[i].window = gdk_window_new (clist->title_window,
 						&attributes, attributes_mask);
       gdk_window_set_user_data (clist->column[i].window, clist);
     }
-
+  
   /* This is slightly less efficient than creating them with the
    * right size to begin with, but easier
    */
   size_allocate_title_buttons (clist);
-
+  
   /* GCs */
   clist->fg_gc = gdk_gc_new (widget->window);
   clist->bg_gc = gdk_gc_new (widget->window);
   
   /* We'll use this gc to do scrolling as well */
   gdk_gc_set_exposures (clist->fg_gc, TRUE);
-
+  
   values.foreground = (widget->style->white.pixel==0 ?
 		       widget->style->black:widget->style->white);
   values.function = GDK_XOR;
@@ -4534,22 +4532,22 @@ gtk_clist_realize (GtkWidget *widget)
 					  GDK_GC_FOREGROUND |
 					  GDK_GC_FUNCTION |
 					  GDK_GC_SUBWINDOW);
-
+  
   /* attach optional row/cell styles, allocate foreground/background colors */
   list = clist->row_list;
   for (i = 0; i < clist->rows; i++)
     {
       clist_row = list->data;
       list = list->next;
-
+      
       if (clist_row->style)
 	clist_row->style = gtk_style_attach (clist_row->style,
 					     clist->clist_window);
-
+      
       if (clist_row->fg_set || clist_row->bg_set)
 	{
 	  GdkColormap *colormap;
-
+	  
 	  colormap = gtk_widget_get_colormap (widget);
 	  if (clist_row->fg_set)
 	    gdk_color_alloc (colormap, &clist_row->foreground);
@@ -4569,33 +4567,33 @@ gtk_clist_unrealize (GtkWidget *widget)
 {
   gint i;
   GtkCList *clist;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
-
+  
   clist = GTK_CLIST (widget);
-
+  
   /* freeze the list */
   clist->freeze_count++;
-
+  
   if (GTK_WIDGET_MAPPED (widget))
     gtk_clist_unmap (widget);
-
+  
   GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
-
+  
   /* detach optional row/cell styles */
   if (GTK_WIDGET_REALIZED (widget))
     {
       GtkCListRow *clist_row;
       GList *list;
       gint j;
-
+      
       list = clist->row_list;
       for (i = 0; i < clist->rows; i++)
 	{
 	  clist_row = list->data;
 	  list = list->next;
-
+	  
 	  if (clist_row->style)
 	    gtk_style_detach (clist_row->style);
 	  for (j = 0; j < clist->columns; j++)
@@ -4603,12 +4601,12 @@ gtk_clist_unrealize (GtkWidget *widget)
 	      gtk_style_detach (clist_row->cell[j].style);
 	}
     }
-
+  
   gdk_cursor_destroy (clist->cursor_drag);
   gdk_gc_destroy (clist->xor_gc);
   gdk_gc_destroy (clist->fg_gc);
   gdk_gc_destroy (clist->bg_gc);
-
+  
   for (i = 0; i < clist->columns; i++)
     {
       if (clist->column[i].button)
@@ -4620,20 +4618,20 @@ gtk_clist_unrealize (GtkWidget *widget)
 	  clist->column[i].window = NULL;
 	}
     }
-
+  
   gdk_window_set_user_data (clist->clist_window, NULL);
   gdk_window_destroy (clist->clist_window);
   clist->clist_window = NULL;
-
+  
   gdk_window_set_user_data (clist->title_window, NULL);
   gdk_window_destroy (clist->title_window);
   clist->title_window = NULL;
-
+  
   clist->cursor_drag = NULL;
   clist->xor_gc = NULL;
   clist->fg_gc = NULL;
   clist->bg_gc = NULL;
-
+  
   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 }
@@ -4643,16 +4641,16 @@ gtk_clist_map (GtkWidget *widget)
 {
   gint i;
   GtkCList *clist;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
-
+  
   clist = GTK_CLIST (widget);
-
+  
   if (!GTK_WIDGET_MAPPED (widget))
     {
       GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
-
+      
       /* map column buttons */
       for (i = 0; i < clist->columns; i++)
 	{
@@ -4668,11 +4666,11 @@ gtk_clist_map (GtkWidget *widget)
 	    gdk_window_raise (clist->column[i].window);
 	    gdk_window_show (clist->column[i].window);
 	  }
-
+      
       gdk_window_show (clist->title_window);
       gdk_window_show (clist->clist_window);
       gdk_window_show (widget->window);
-
+      
       /* unfreeze the list */
       clist->freeze_count = 0;
     }
@@ -4683,30 +4681,30 @@ gtk_clist_unmap (GtkWidget *widget)
 {
   gint i;
   GtkCList *clist;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
-
+  
   clist = GTK_CLIST (widget);
-
+  
   if (GTK_WIDGET_MAPPED (widget))
     {
       GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
-
+      
       if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
 	{
 	  remove_grab (clist);
-
-	  GTK_CLIST_CLASS_FW (widget)->resync_selection (clist, NULL);
-
+	  
+	  GTK_CLIST_GET_CLASS (widget)->resync_selection (clist, NULL);
+	  
 	  clist->click_cell.row = -1;
 	  clist->click_cell.column = -1;
 	  clist->drag_button = 0;
-
+	  
 	  if (GTK_CLIST_IN_DRAG(clist))
 	    {
 	      gpointer drag_data;
-
+	      
 	      GTK_CLIST_UNSET_FLAG (clist, CLIST_IN_DRAG);
 	      drag_data = gtk_object_get_data (GTK_OBJECT (clist),
 					       "gtk-site-data");
@@ -4715,21 +4713,21 @@ gtk_clist_unmap (GtkWidget *widget)
 						    drag_data);
 	    }
 	}
-
+      
       for (i = 0; i < clist->columns; i++)
 	if (clist->column[i].window)
 	  gdk_window_hide (clist->column[i].window);
-
+      
       gdk_window_hide (clist->clist_window);
       gdk_window_hide (clist->title_window);
       gdk_window_hide (widget->window);
-
+      
       /* unmap column buttons */
       for (i = 0; i < clist->columns; i++)
 	if (clist->column[i].button &&
 	    GTK_WIDGET_MAPPED (clist->column[i].button))
 	  gtk_widget_unmap (clist->column[i].button);
-
+      
       /* freeze the list */
       clist->freeze_count++;
     }
@@ -4743,21 +4741,21 @@ gtk_clist_draw (GtkWidget    *widget,
   gint border_width;
   GdkRectangle child_area;
   int i;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
   g_return_if_fail (area != NULL);
-
+  
   if (GTK_WIDGET_DRAWABLE (widget))
     {
       clist = GTK_CLIST (widget);
       border_width = GTK_CONTAINER (widget)->border_width;
-
+      
       gdk_window_clear_area (widget->window,
 			     area->x - border_width, 
 			     area->y - border_width,
 			     area->width, area->height);
-
+      
       /* draw list shadow/border */
       gtk_draw_shadow (widget->style, widget->window,
 		       GTK_STATE_NORMAL, clist->shadow_type,
@@ -4767,10 +4765,10 @@ gtk_clist_draw (GtkWidget    *widget,
 		       clist->clist_window_height +
 		       (2 * widget->style->klass->ythickness) +
 		       clist->column_title_area.height);
-
+      
       gdk_window_clear_area (clist->clist_window, 0, 0, 0, 0);
       draw_rows (clist, NULL);
-
+      
       for (i = 0; i < clist->columns; i++)
 	{
 	  if (!clist->column[i].visible)
@@ -4787,15 +4785,15 @@ gtk_clist_expose (GtkWidget      *widget,
 		  GdkEventExpose *event)
 {
   GtkCList *clist;
-
+  
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
-
+  
   if (GTK_WIDGET_DRAWABLE (widget))
     {
       clist = GTK_CLIST (widget);
-
+      
       /* draw border */
       if (event->window == widget->window)
 	gtk_draw_shadow (widget->style, widget->window,
@@ -4806,12 +4804,12 @@ gtk_clist_expose (GtkWidget      *widget,
 			 clist->clist_window_height +
 			 (2 * widget->style->klass->ythickness) +
 			 clist->column_title_area.height);
-
+      
       /* exposure events on the list */
       if (event->window == clist->clist_window)
 	draw_rows (clist, &event->area);
     }
-
+  
   return FALSE;
 }
 
@@ -4820,24 +4818,24 @@ gtk_clist_style_set (GtkWidget *widget,
 		     GtkStyle  *previous_style)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
-
+  
   if (GTK_WIDGET_CLASS (parent_class)->style_set)
     (*GTK_WIDGET_CLASS (parent_class)->style_set) (widget, previous_style);
-
+  
   clist = GTK_CLIST (widget);
-
+  
   if (GTK_WIDGET_REALIZED (widget))
     {
       gtk_style_set_background (widget->style, widget->window, widget->state);
       gtk_style_set_background (widget->style, clist->title_window, GTK_STATE_SELECTED);
       gdk_window_set_background (clist->clist_window, &widget->style->base[GTK_STATE_NORMAL]);
     }
-
+  
   /* Fill in data after widget has correct style */
-
+  
   /* text properties */
   if (!GTK_CLIST_ROW_HEIGHT_SET(clist))
     {
@@ -4849,13 +4847,13 @@ gtk_clist_style_set (GtkWidget *widget,
     clist->row_center_offset = 1.5 + (clist->row_height +
 				      widget->style->font->ascent -
 				      widget->style->font->descent - 1) / 2;
-
+  
   /* Column widths */
   if (!GTK_CLIST_AUTO_RESIZE_BLOCKED(clist))
     {
       gint width;
       gint i;
-
+      
       for (i = 0; i < clist->columns; i++)
 	if (clist->column[i].auto_resize)
 	  {
@@ -4873,11 +4871,11 @@ gtk_clist_key_press (GtkWidget   *widget,
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
-
+  
   if (GTK_WIDGET_CLASS (parent_class)->key_press_event &&
       GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event))
     return TRUE;
-
+  
   switch (event->keyval)
     {
     case GDK_Tab:
@@ -4905,42 +4903,42 @@ gtk_clist_button_press (GtkWidget      *widget,
   gint row;
   gint column;
   gint button_actions;
-
+  
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
-
+  
   clist = GTK_CLIST (widget);
-
+  
   button_actions = clist->button_actions[event->button - 1];
-
+  
   if (button_actions == GTK_BUTTON_IGNORED)
     return FALSE;
-
+  
   /* selections on the list */
   if (event->window == clist->clist_window)
     {
       x = event->x;
       y = event->y;
-
+      
       if (get_selection_info (clist, x, y, &row, &column))
 	{
 	  gint old_row = clist->focus_row;
-
+	  
 	  if (clist->focus_row == -1)
 	    old_row = row;
-
+	  
 	  if (event->type == GDK_BUTTON_PRESS)
 	    {
 	      GdkEventMask mask = ((1 << (4 + event->button)) |
 				   GDK_POINTER_MOTION_HINT_MASK |
 				   GDK_BUTTON_RELEASE_MASK);
-
+	      
 	      if (gdk_pointer_grab (clist->clist_window, FALSE, mask,
 				    NULL, NULL, event->time))
 		return FALSE;
 	      gtk_grab_add (widget);
-
+	      
 	      clist->click_cell.row = row;
 	      clist->click_cell.column = column;
 	      clist->drag_button = event->button;
@@ -4949,11 +4947,11 @@ gtk_clist_button_press (GtkWidget      *widget,
 	    {
 	      clist->click_cell.row = -1;
 	      clist->click_cell.column = -1;
-
+	      
 	      clist->drag_button = 0;
 	      remove_grab (clist);
 	    }
-
+	  
 	  if (button_actions & GTK_BUTTON_SELECTS)
 	    {
 	      if (GTK_CLIST_ADD_MODE(clist))
@@ -4986,10 +4984,10 @@ gtk_clist_button_press (GtkWidget      *widget,
 		    clist->focus_row = row;
 		}
 	    }
-
+	  
 	  if (!GTK_WIDGET_HAS_FOCUS(widget))
 	    gtk_widget_grab_focus (widget);
-
+	  
 	  if (button_actions & GTK_BUTTON_SELECTS)
 	    {
 	      switch (clist->selection_mode)
@@ -5017,7 +5015,7 @@ gtk_clist_button_press (GtkWidget      *widget,
 		      if (clist->anchor != -1)
 			{
 			  update_extended_selection (clist, clist->focus_row);
-			  GTK_CLIST_CLASS_FW (clist)->resync_selection
+			  GTK_CLIST_GET_CLASS (clist)->resync_selection
 			    (clist, (GdkEvent *) event);
 			}
 		      gtk_signal_emit (GTK_OBJECT (clist),
@@ -5025,7 +5023,7 @@ gtk_clist_button_press (GtkWidget      *widget,
 				       row, column, event);
 		      break;
 		    }
-	      
+		  
 		  if (event->state & GDK_CONTROL_MASK)
 		    {
 		      if (event->state & GDK_SHIFT_MASK)
@@ -5052,14 +5050,14 @@ gtk_clist_button_press (GtkWidget      *widget,
 			}
 		      break;
 		    }
-
+		  
 		  if (event->state & GDK_SHIFT_MASK)
 		    {
 		      set_anchor (clist, FALSE, old_row, old_row);
 		      update_extended_selection (clist, clist->focus_row);
 		      break;
 		    }
-
+		  
 		  if (clist->anchor == -1)
 		    set_anchor (clist, FALSE, row, old_row);
 		  else
@@ -5072,36 +5070,36 @@ gtk_clist_button_press (GtkWidget      *widget,
 	}
       return FALSE;
     }
-
+  
   /* press on resize windows */
   for (i = 0; i < clist->columns; i++)
     if (clist->column[i].resizeable && clist->column[i].window &&
 	event->window == clist->column[i].window)
       {
 	gpointer drag_data;
-
+	
 	if (gdk_pointer_grab (clist->column[i].window, FALSE,
 			      GDK_POINTER_MOTION_HINT_MASK |
 			      GDK_BUTTON1_MOTION_MASK |
 			      GDK_BUTTON_RELEASE_MASK,
 			      NULL, NULL, event->time))
 	  return FALSE;
-
+	
 	gtk_grab_add (widget);
 	GTK_CLIST_SET_FLAG (clist, CLIST_IN_DRAG);
-
+	
 	/* block attached dnd signal handler */
 	drag_data = gtk_object_get_data (GTK_OBJECT (clist), "gtk-site-data");
 	if (drag_data)
 	  gtk_signal_handler_block_by_data (GTK_OBJECT (clist), drag_data);
-
+	
 	if (!GTK_WIDGET_HAS_FOCUS(widget))
 	  gtk_widget_grab_focus (widget);
-
+	
 	clist->drag_pos = i;
 	clist->x_drag = (COLUMN_LEFT_XPIXEL(clist, i) + COLUMN_INSET +
 			 clist->column[i].area.width + CELL_SPACING);
-
+	
 	if (GTK_CLIST_ADD_MODE(clist))
 	  gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_SOLID, 0, 0);
 	draw_xor_line (clist);
@@ -5115,17 +5113,17 @@ gtk_clist_button_release (GtkWidget      *widget,
 {
   GtkCList *clist;
   gint button_actions;
-
+  
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
-
+  
   clist = GTK_CLIST (widget);
-
+  
   button_actions = clist->button_actions[event->button - 1];
   if (button_actions == GTK_BUTTON_IGNORED)
     return FALSE;
-
+  
   /* release on resize windows */
   if (GTK_CLIST_IN_DRAG(clist))
     {
@@ -5133,46 +5131,46 @@ gtk_clist_button_release (GtkWidget      *widget,
       gint width;
       gint x;
       gint i;
-
+      
       i = clist->drag_pos;
       clist->drag_pos = -1;
-
+      
       /* unblock attached dnd signal handler */
       drag_data = gtk_object_get_data (GTK_OBJECT (clist), "gtk-site-data");
       if (drag_data)
 	gtk_signal_handler_unblock_by_data (GTK_OBJECT (clist), drag_data);
-
+      
       GTK_CLIST_UNSET_FLAG (clist, CLIST_IN_DRAG);
       gtk_widget_get_pointer (widget, &x, NULL);
       gtk_grab_remove (widget);
       gdk_pointer_ungrab (event->time);
-
+      
       if (clist->x_drag >= 0)
 	draw_xor_line (clist);
-
+      
       if (GTK_CLIST_ADD_MODE(clist))
 	{
 	  gdk_gc_set_line_attributes (clist->xor_gc, 1,
 				      GDK_LINE_ON_OFF_DASH, 0, 0);
 	  gdk_gc_set_dashes (clist->xor_gc, 0, "\4\4", 2);
 	}
-
+      
       width = new_column_width (clist, i, &x);
       gtk_clist_set_column_width (clist, i, width);
       return FALSE;
     }
-
+  
   if (clist->drag_button == event->button)
     {
       gint row;
       gint column;
-
+      
       clist->drag_button = 0;
       clist->click_cell.row = -1;
       clist->click_cell.column = -1;
-
+      
       remove_grab (clist);
-
+      
       if (button_actions & GTK_BUTTON_SELECTS)
 	{
 	  switch (clist->selection_mode)
@@ -5182,7 +5180,7 @@ gtk_clist_button_release (GtkWidget      *widget,
 		  !GTK_WIDGET_CAN_FOCUS (widget) ||
 		  event->x < 0 || event->x >= clist->clist_window_width ||
 		  event->y < 0 || event->y >= clist->clist_window_height)
-		GTK_CLIST_CLASS_FW (clist)->resync_selection
+		GTK_CLIST_GET_CLASS (clist)->resync_selection
 		  (clist, (GdkEvent *) event);
 	      break;
 	    case GTK_SELECTION_SINGLE:
@@ -5213,17 +5211,17 @@ gtk_clist_motion (GtkWidget      *widget,
   gint row;
   gint new_width;
   gint button_actions = 0;
-
+  
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
-
+  
   clist = GTK_CLIST (widget);
   if (!(gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist)))
     return FALSE;
-
+  
   if (clist->drag_button > 0)
     button_actions = clist->button_actions[clist->drag_button - 1];
-
+  
   if (GTK_CLIST_IN_DRAG(clist))
     {
       if (event->is_hint || event->window != widget->window)
@@ -5237,13 +5235,13 @@ gtk_clist_motion (GtkWidget      *widget,
 	  /* x_drag < 0 indicates that the xor line is already invisible */
 	  if (clist->x_drag >= 0)
 	    draw_xor_line (clist);
-
+	  
 	  clist->x_drag = x;
-
+	  
 	  if (clist->x_drag >= 0)
 	    draw_xor_line (clist);
 	}
-
+      
       if (new_width <= MAX (COLUMN_MIN_WIDTH + 1,
 			    clist->column[clist->drag_pos].min_width + 1))
 	{
@@ -5263,7 +5261,7 @@ gtk_clist_motion (GtkWidget      *widget,
 	  return FALSE;
 	}
     }
-
+  
   if (event->is_hint || event->window != clist->clist_window)
     gdk_window_get_pointer (clist->clist_window, &x, &y, NULL);
   else
@@ -5271,7 +5269,7 @@ gtk_clist_motion (GtkWidget      *widget,
       x = event->x;
       y = event->y;
     }
-
+  
   if (GTK_CLIST_REORDERABLE(clist) && button_actions & GTK_BUTTON_DRAGS)
     {
       /* delayed drag start */
@@ -5287,25 +5285,25 @@ gtk_clist_motion (GtkWidget      *widget,
 		 clist->column[clist->click_cell.column].area.width)))
 	{
 	  GtkTargetList  *target_list;
-
+	  
 	  target_list = gtk_target_list_new (&clist_target_table, 1);
 	  gtk_drag_begin (widget, target_list, GDK_ACTION_MOVE,
 			  clist->drag_button, (GdkEvent *)event);
-
+	  
 	}
       return TRUE;
     }
-
+  
   /* horizontal autoscrolling */
   if (clist->hadjustment && LIST_WIDTH (clist) > clist->clist_window_width &&
       (x < 0 || x >= clist->clist_window_width))
     {
       if (clist->htimer)
 	return FALSE;
-
+      
       clist->htimer = gtk_timeout_add
 	(SCROLL_TIME, (GtkFunction) horizontal_timeout, clist);
-
+      
       if (!((x < 0 && clist->hadjustment->value == 0) ||
 	    (x >= clist->clist_window_width &&
 	     clist->hadjustment->value ==
@@ -5317,46 +5315,46 @@ gtk_clist_motion (GtkWidget      *widget,
 	    move_horizontal (clist, 1 + (x - clist->clist_window_width) / 2);
 	}
     }
-
+  
   if (GTK_CLIST_IN_DRAG(clist))
     return FALSE;
-
+  
   /* vertical autoscrolling */
   row = ROW_FROM_YPIXEL (clist, y);
-
+  
   /* don't scroll on last pixel row if it's a cell spacing */
   if (y == clist->clist_window_height - 1 &&
       y == ROW_TOP_YPIXEL (clist, row-1) + clist->row_height)
     return FALSE;
-
+  
   if (LIST_HEIGHT (clist) > clist->clist_window_height &&
       (y < 0 || y >= clist->clist_window_height))
     {
       if (clist->vtimer)
 	return FALSE;
-
+      
       clist->vtimer = gtk_timeout_add (SCROLL_TIME,
 				       (GtkFunction) vertical_timeout, clist);
-
+      
       if (clist->drag_button &&
 	  ((y < 0 && clist->focus_row == 0) ||
 	   (y >= clist->clist_window_height &&
 	    clist->focus_row == clist->rows - 1)))
 	return FALSE;
     }
-
+  
   row = CLAMP (row, 0, clist->rows - 1);
-
+  
   if (button_actions & GTK_BUTTON_SELECTS &
       !gtk_object_get_data (GTK_OBJECT (widget), "gtk-site-data"))
     {
       if (row == clist->focus_row)
 	return FALSE;
-
+      
       gtk_clist_draw_focus (widget);
       clist->focus_row = row;
       gtk_clist_draw_focus (widget);
-
+      
       switch (clist->selection_mode)
 	{
 	case GTK_SELECTION_BROWSE:
@@ -5376,7 +5374,7 @@ gtk_clist_motion (GtkWidget      *widget,
   else if (ROW_TOP_YPIXEL(clist, row) + clist->row_height >
 	   clist->clist_window_height)
     move_vertical (clist, row, 1);
-
+  
   return FALSE;
 }
 
@@ -5386,16 +5384,16 @@ gtk_clist_size_request (GtkWidget      *widget,
 {
   GtkCList *clist;
   gint i;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
   g_return_if_fail (requisition != NULL);
-
+  
   clist = GTK_CLIST (widget);
-
+  
   requisition->width = 0;
   requisition->height = 0;
-
+  
   /* compute the size of the column title (title) area */
   clist->column_title_area.height = 0;
   if (GTK_CLIST_SHOW_TITLES(clist))
@@ -5410,13 +5408,13 @@ gtk_clist_size_request (GtkWidget      *widget,
 	    MAX (clist->column_title_area.height,
 		 child_requisition.height);
 	}
-
+  
   requisition->width += (widget->style->klass->xthickness +
 			 GTK_CONTAINER (widget)->border_width) * 2;
   requisition->height += (clist->column_title_area.height +
 			  (widget->style->klass->ythickness +
 			   GTK_CONTAINER (widget)->border_width) * 2);
-
+  
   /* if (!clist->hadjustment) */
   requisition->width += list_requisition_width (clist);
   /* if (!clist->vadjustment) */
@@ -5430,15 +5428,15 @@ gtk_clist_size_allocate (GtkWidget     *widget,
   GtkCList *clist;
   GtkAllocation clist_allocation;
   gint border_width;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
   g_return_if_fail (allocation != NULL);
-
+  
   clist = GTK_CLIST (widget);
   widget->allocation = *allocation;
   border_width = GTK_CONTAINER (widget)->border_width;
-
+  
   if (GTK_WIDGET_REALIZED (widget))
     {
       gdk_window_move_resize (widget->window,
@@ -5447,7 +5445,7 @@ gtk_clist_size_allocate (GtkWidget     *widget,
 			      allocation->width - border_width * 2,
 			      allocation->height - border_width * 2);
     }
-
+  
   /* use internal allocation structure for all the math
    * because it's easier than always subtracting the container
    * border width */
@@ -5457,7 +5455,7 @@ gtk_clist_size_allocate (GtkWidget     *widget,
 					  border_width * 2);
   clist->internal_allocation.height = MAX (1, (gint)allocation->height -
 					   border_width * 2);
-	
+  
   /* allocate clist window assuming no scrollbars */
   clist_allocation.x = (clist->internal_allocation.x +
 			widget->style->klass->xthickness);
@@ -5499,7 +5497,7 @@ gtk_clist_size_allocate (GtkWidget     *widget,
   /* column button allocation */
   size_allocate_columns (clist, FALSE);
   size_allocate_title_buttons (clist);
-
+  
   adjust_adjustments (clist, TRUE);
 }
 
@@ -5514,16 +5512,16 @@ gtk_clist_forall (GtkContainer *container,
 {
   GtkCList *clist;
   guint i;
-
+  
   g_return_if_fail (container != NULL);
   g_return_if_fail (GTK_IS_CLIST (container));
   g_return_if_fail (callback != NULL);
-
+  
   if (!include_internals)
     return;
-
+  
   clist = GTK_CLIST (container);
-      
+  
   /* callback for the column buttons */
   for (i = 0; i < clist->columns; i++)
     if (clist->column[i].button)
@@ -5548,13 +5546,13 @@ get_cell_style (GtkCList     *clist,
 		GdkGC       **bg_gc)
 {
   gint fg_state;
-
+  
   if ((state == GTK_STATE_NORMAL) &&
       (GTK_WIDGET (clist)->state == GTK_STATE_INSENSITIVE))
     fg_state = GTK_STATE_INSENSITIVE;
   else
     fg_state = state;
-
+  
   if (clist_row->cell[column].style)
     {
       if (style)
@@ -5593,7 +5591,7 @@ get_cell_style (GtkCList     *clist,
 	else
 	  *bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
       }
-
+      
       if (state != GTK_STATE_SELECTED)
 	{
 	  if (fg_gc && clist_row->fg_set)
@@ -5617,13 +5615,13 @@ draw_cell_pixmap (GdkWindow    *window,
 {
   gint xsrc = 0;
   gint ysrc = 0;
-
+  
   if (mask)
     {
       gdk_gc_set_clip_mask (fg_gc, mask);
       gdk_gc_set_clip_origin (fg_gc, x, y);
     }
-
+  
   if (x < clip_rectangle->x)
     {
       xsrc = clip_rectangle->x - x;
@@ -5632,7 +5630,7 @@ draw_cell_pixmap (GdkWindow    *window,
     }
   if (x + width > clip_rectangle->x + clip_rectangle->width)
     width = clip_rectangle->x + clip_rectangle->width - x;
-
+  
   if (y < clip_rectangle->y)
     {
       ysrc = clip_rectangle->y - y;
@@ -5641,12 +5639,12 @@ draw_cell_pixmap (GdkWindow    *window,
     }
   if (y + height > clip_rectangle->y + clip_rectangle->height)
     height = clip_rectangle->y + clip_rectangle->height - y;
-
+  
   gdk_draw_pixmap (window, fg_gc, pixmap, xsrc, ysrc, x, y, width, height);
   gdk_gc_set_clip_origin (fg_gc, 0, 0);
   if (mask)
     gdk_gc_set_clip_mask (fg_gc, NULL);
-
+  
   return x + MAX (width, 0);
 }
 
@@ -5665,39 +5663,39 @@ draw_row (GtkCList     *clist,
   gint last_column;
   gint state;
   gint i;
-
+  
   g_return_if_fail (clist != NULL);
-
+  
   /* bail now if we arn't drawable yet */
   if (!GTK_WIDGET_DRAWABLE (clist) || row < 0 || row >= clist->rows)
     return;
-
+  
   widget = GTK_WIDGET (clist);
-
+  
   /* if the function is passed the pointer to the row instead of null,
    * it avoids this expensive lookup */
   if (!clist_row)
     clist_row = ROW_ELEMENT (clist, row)->data;
-
+  
   /* rectangle of the entire row */
   row_rectangle.x = 0;
   row_rectangle.y = ROW_TOP_YPIXEL (clist, row);
   row_rectangle.width = clist->clist_window_width;
   row_rectangle.height = clist->row_height;
-
+  
   /* rectangle of the cell spacing above the row */
   cell_rectangle.x = 0;
   cell_rectangle.y = row_rectangle.y - CELL_SPACING;
   cell_rectangle.width = row_rectangle.width;
   cell_rectangle.height = CELL_SPACING;
-
+  
   /* rectangle used to clip drawing operations, its y and height
    * positions only need to be set once, so we set them once here. 
    * the x and width are set withing the drawing loop below once per
    * column */
   clip_rectangle.y = row_rectangle.y;
   clip_rectangle.height = row_rectangle.height;
-
+  
   if (clist_row->state == GTK_STATE_NORMAL)
     {
       if (clist_row->fg_set)
@@ -5705,9 +5703,9 @@ draw_row (GtkCList     *clist,
       if (clist_row->bg_set)
 	gdk_gc_set_foreground (clist->bg_gc, &clist_row->background);
     }
-
+  
   state = clist_row->state;
-
+  
   /* draw the cell borders and background */
   if (area)
     {
@@ -5721,12 +5719,12 @@ draw_row (GtkCList     *clist,
 			    intersect_rectangle.y,
 			    intersect_rectangle.width,
 			    intersect_rectangle.height);
-
+      
       /* the last row has to clear its bottom cell spacing too */
       if (clist_row == clist->row_list_end->data)
 	{
 	  cell_rectangle.y += clist->row_height + CELL_SPACING;
-
+	  
 	  if (gdk_rectangle_intersect (area, &cell_rectangle,
 				       &intersect_rectangle))
 	    gdk_draw_rectangle (clist->clist_window,
@@ -5737,10 +5735,10 @@ draw_row (GtkCList     *clist,
 				intersect_rectangle.width,
 				intersect_rectangle.height);
 	}
-
+      
       if (!gdk_rectangle_intersect (area, &row_rectangle,&intersect_rectangle))
 	return;
-
+      
     }
   else
     {
@@ -5752,12 +5750,12 @@ draw_row (GtkCList     *clist,
 			  cell_rectangle.y,
 			  cell_rectangle.width,
 			  cell_rectangle.height);
-
+      
       /* the last row has to clear its bottom cell spacing too */
       if (clist_row == clist->row_list_end->data)
 	{
 	  cell_rectangle.y += clist->row_height + CELL_SPACING;
-
+	  
 	  gdk_draw_rectangle (clist->clist_window,
 			      widget->style->base_gc[GTK_STATE_ACTIVE],
 			      TRUE,
@@ -5771,28 +5769,28 @@ draw_row (GtkCList     *clist,
   for (last_column = clist->columns - 1;
        last_column >= 0 && !clist->column[last_column].visible; last_column--)
     ;
-
+  
   /* iterate and draw all the columns (row cells) and draw their contents */
   for (i = 0; i < clist->columns; i++)
     {
       GtkStyle *style;
       GdkGC *fg_gc;
       GdkGC *bg_gc;
-
+      
       gint width;
       gint height;
       gint pixmap_width;
       gint offset = 0;
       gint row_center_offset;
-
+      
       if (!clist->column[i].visible)
 	continue;
-
+      
       get_cell_style (clist, clist_row, state, i, &style, &fg_gc, &bg_gc);
-
+      
       clip_rectangle.x = clist->column[i].area.x + clist->hoffset;
       clip_rectangle.width = clist->column[i].area.width;
-
+      
       /* calculate clipping region clipping region */
       clip_rectangle.x -= COLUMN_INSET + CELL_SPACING;
       clip_rectangle.width += (2 * COLUMN_INSET + CELL_SPACING +
@@ -5801,14 +5799,14 @@ draw_row (GtkCList     *clist,
       if (area && !gdk_rectangle_intersect (area, &clip_rectangle,
 					    &intersect_rectangle))
 	continue;
-
+      
       gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
 			  rect->x, rect->y, rect->width, rect->height);
-
+      
       clip_rectangle.x += COLUMN_INSET + CELL_SPACING;
       clip_rectangle.width -= (2 * COLUMN_INSET + CELL_SPACING +
 			       (i == last_column) * CELL_SPACING);
-
+      
       /* calculate real width for column justification */
       pixmap_width = 0;
       offset = 0;
@@ -5836,7 +5834,7 @@ draw_row (GtkCList     *clist,
 	  continue;
 	  break;
 	}
-
+      
       switch (clist->column[i].justification)
 	{
 	case GTK_JUSTIFY_LEFT:
@@ -5852,7 +5850,7 @@ draw_row (GtkCList     *clist,
 		    (clip_rectangle.width / 2) - (width / 2));
 	  break;
 	};
-
+      
       /* Draw Text and/or Pixmap */
       switch (clist_row->cell[i].type)
 	{
@@ -5878,11 +5876,11 @@ draw_row (GtkCList     *clist,
 	case GTK_CELL_TEXT:
 	  if (style != GTK_WIDGET (clist)->style)
 	    row_center_offset = (((clist->row_height - style->font->ascent -
-				  style->font->descent - 1) / 2) + 1.5 +
+				   style->font->descent - 1) / 2) + 1.5 +
 				 style->font->ascent);
 	  else
 	    row_center_offset = clist->row_center_offset;
-
+	  
 	  gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
 	  gdk_draw_string (clist->clist_window, style->font, fg_gc,
 			   offset,
@@ -5897,7 +5895,7 @@ draw_row (GtkCList     *clist,
 	  break;
 	}
     }
-
+  
   /* draw focus rectangle */
   if (clist->focus_row == row &&
       GTK_WIDGET_CAN_FOCUS (widget) && GTK_WIDGET_HAS_FOCUS(widget))
@@ -5928,14 +5926,14 @@ draw_rows (GtkCList     *clist,
   gint i;
   gint first_row;
   gint last_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (clist->row_height == 0 ||
       !GTK_WIDGET_DRAWABLE (clist))
     return;
-
+  
   if (area)
     {
       first_row = ROW_FROM_YPIXEL (clist, area->y);
@@ -5946,28 +5944,28 @@ draw_rows (GtkCList     *clist,
       first_row = ROW_FROM_YPIXEL (clist, 0);
       last_row = ROW_FROM_YPIXEL (clist, clist->clist_window_height);
     }
-
+  
   /* this is a small special case which exposes the bottom cell line
    * on the last row -- it might go away if I change the wall the cell
    * spacings are drawn
    */
   if (clist->rows == first_row)
     first_row--;
-
+  
   list = ROW_ELEMENT (clist, first_row);
   i = first_row;
   while (list)
     {
       clist_row = list->data;
       list = list->next;
-
+      
       if (i > last_row)
 	return;
-
-      GTK_CLIST_CLASS_FW (clist)->draw_row (clist, area, i, clist_row);
+      
+      GTK_CLIST_GET_CLASS (clist)->draw_row (clist, area, i, clist_row);
       i++;
     }
-
+  
   if (!area)
     gdk_window_clear_area (clist->clist_window, 0,
 			   ROW_TOP_YPIXEL (clist, i), 0, 0);
@@ -5977,11 +5975,11 @@ static void
 draw_xor_line (GtkCList *clist)
 {
   GtkWidget *widget;
-
+  
   g_return_if_fail (clist != NULL);
-
+  
   widget = GTK_WIDGET (clist);
-
+  
   gdk_draw_line (widget->window, clist->xor_gc,
                  clist->x_drag,
 		 widget->style->klass->ythickness,
@@ -6015,26 +6013,26 @@ get_selection_info (GtkCList *clist,
 		    gint     *column)
 {
   gint trow, tcol;
-
+  
   g_return_val_if_fail (clist != NULL, 0);
   g_return_val_if_fail (GTK_IS_CLIST (clist), 0);
-
+  
   /* bounds checking, return false if the user clicked 
    * on a blank area */
   trow = ROW_FROM_YPIXEL (clist, y);
   if (trow >= clist->rows)
     return 0;
-
+  
   if (row)
     *row = trow;
-
+  
   tcol = COLUMN_FROM_XPIXEL (clist, x);
   if (tcol >= clist->columns)
     return 0;
-
+  
   if (column)
     *column = tcol;
-
+  
   return 1;
 }
 
@@ -6069,7 +6067,7 @@ adjust_adjustments (GtkCList *clist,
       clist->vadjustment->step_increment = clist->row_height;
       clist->vadjustment->lower = 0;
       clist->vadjustment->upper = LIST_HEIGHT (clist);
-
+      
       if (clist->clist_window_height - clist->voffset > LIST_HEIGHT (clist) ||
 	  (clist->voffset + (gint)clist->vadjustment->value) != 0)
 	{
@@ -6080,7 +6078,7 @@ adjust_adjustments (GtkCList *clist,
 	}
       gtk_signal_emit_by_name (GTK_OBJECT (clist->vadjustment), "changed");
     }
-
+  
   if (clist->hadjustment)
     {
       clist->hadjustment->page_size = clist->clist_window_width;
@@ -6088,7 +6086,7 @@ adjust_adjustments (GtkCList *clist,
       clist->hadjustment->step_increment = 10;
       clist->hadjustment->lower = 0;
       clist->hadjustment->upper = LIST_WIDTH (clist);
-
+      
       if (clist->clist_window_width - clist->hoffset > LIST_WIDTH (clist) ||
 	  (clist->hoffset + (gint)clist->hadjustment->value) != 0)
 	{
@@ -6099,15 +6097,15 @@ adjust_adjustments (GtkCList *clist,
 	}
       gtk_signal_emit_by_name (GTK_OBJECT (clist->hadjustment), "changed");
     }
-
+  
   if (!block_resize && (!clist->vadjustment || !clist->hadjustment))
     {
       GtkWidget *widget;
       GtkRequisition requisition;
-
+      
       widget = GTK_WIDGET (clist);
       gtk_widget_size_request (widget, &requisition);
-
+      
       if ((!clist->hadjustment &&
 	   requisition.width != widget->allocation.width) ||
 	  (!clist->vadjustment &&
@@ -6121,10 +6119,10 @@ vadjustment_changed (GtkAdjustment *adjustment,
 		     gpointer       data)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (adjustment != NULL);
   g_return_if_fail (data != NULL);
-
+  
   clist = GTK_CLIST (data);
 }
 
@@ -6133,10 +6131,10 @@ hadjustment_changed (GtkAdjustment *adjustment,
 		     gpointer       data)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (adjustment != NULL);
   g_return_if_fail (data != NULL);
-
+  
   clist = GTK_CLIST (data);
 }
 
@@ -6147,23 +6145,23 @@ vadjustment_value_changed (GtkAdjustment *adjustment,
   GtkCList *clist;
   GdkRectangle area;
   gint diff, value;
-
+  
   g_return_if_fail (adjustment != NULL);
   g_return_if_fail (data != NULL);
   g_return_if_fail (GTK_IS_CLIST (data));
-
+  
   clist = GTK_CLIST (data);
-
+  
   if (!GTK_WIDGET_DRAWABLE (clist) || adjustment != clist->vadjustment)
     return;
-
+  
   value = adjustment->value;
-
+  
   if (value > -clist->voffset)
     {
       /* scroll down */
       diff = value + clist->voffset;
-
+      
       /* we have to re-draw the whole screen here... */
       if (diff >= clist->clist_window_height)
 	{
@@ -6171,13 +6169,13 @@ vadjustment_value_changed (GtkAdjustment *adjustment,
 	  draw_rows (clist, NULL);
 	  return;
 	}
-
+      
       if ((diff != 0) && (diff != clist->clist_window_height))
 	gdk_window_copy_area (clist->clist_window, clist->fg_gc,
 			      0, 0, clist->clist_window, 0, diff,
 			      clist->clist_window_width,
 			      clist->clist_window_height - diff);
-
+      
       area.x = 0;
       area.y = clist->clist_window_height - diff;
       area.width = clist->clist_window_width;
@@ -6187,7 +6185,7 @@ vadjustment_value_changed (GtkAdjustment *adjustment,
     {
       /* scroll up */
       diff = -clist->voffset - value;
-
+      
       /* we have to re-draw the whole screen here... */
       if (diff >= clist->clist_window_height)
 	{
@@ -6195,23 +6193,23 @@ vadjustment_value_changed (GtkAdjustment *adjustment,
 	  draw_rows (clist, NULL);
 	  return;
 	}
-
+      
       if ((diff != 0) && (diff != clist->clist_window_height))
 	gdk_window_copy_area (clist->clist_window, clist->fg_gc,
 			      0, diff, clist->clist_window, 0, 0,
 			      clist->clist_window_width,
 			      clist->clist_window_height - diff);
-
+      
       area.x = 0;
       area.y = 0;
       area.width = clist->clist_window_width;
       area.height = diff;
     }
-
+  
   clist->voffset = -value;
   if ((diff != 0) && (diff != clist->clist_window_height))
     check_exposures (clist);
-
+  
   draw_rows (clist, &area);
 }
 
@@ -6225,18 +6223,18 @@ hadjustment_value_changed (GtkAdjustment *adjustment,
   gint y = 0;
   gint diff = 0;
   gint value;
-
+  
   g_return_if_fail (adjustment != NULL);
   g_return_if_fail (data != NULL);
   g_return_if_fail (GTK_IS_CLIST (data));
-
+  
   clist = GTK_CLIST (data);
-
+  
   if (!GTK_WIDGET_DRAWABLE (clist) || adjustment != clist->hadjustment)
     return;
-
+  
   value = adjustment->value;
-
+  
   /* move the column buttons and resize windows */
   for (i = 0; i < clist->columns; i++)
     {
@@ -6258,7 +6256,7 @@ hadjustment_value_changed (GtkAdjustment *adjustment,
 	    }
 	}
     }
-
+  
   if (value > -clist->hoffset)
     {
       /* scroll right */
@@ -6272,12 +6270,12 @@ hadjustment_value_changed (GtkAdjustment *adjustment,
 	  draw_rows (clist, NULL);
 	  return;
 	}
-
+      
       if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
 	  !GTK_CLIST_CHILD_HAS_FOCUS(clist) && GTK_CLIST_ADD_MODE(clist))
 	{
 	  y = ROW_TOP_YPIXEL (clist, clist->focus_row);
-	      
+	  
 	  gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE, 0, y,
 			      clist->clist_window_width - 1,
 			      clist->row_height - 1);
@@ -6290,7 +6288,7 @@ hadjustment_value_changed (GtkAdjustment *adjustment,
 			    0,
 			    clist->clist_window_width - diff,
 			    clist->clist_window_height);
-
+      
       area.x = clist->clist_window_width - diff;
     }
   else
@@ -6298,7 +6296,7 @@ hadjustment_value_changed (GtkAdjustment *adjustment,
       /* scroll left */
       if (!(diff = -clist->hoffset - value))
 	return;
-
+      
       clist->hoffset = -value;
       
       /* we have to re-draw the whole screen here... */
@@ -6317,7 +6315,7 @@ hadjustment_value_changed (GtkAdjustment *adjustment,
 			      clist->clist_window_width - 1,
 			      clist->row_height - 1);
 	}
-
+      
       gdk_window_copy_area (clist->clist_window,
 			    clist->fg_gc,
 			    diff, 0,
@@ -6326,16 +6324,16 @@ hadjustment_value_changed (GtkAdjustment *adjustment,
 			    0,
 			    clist->clist_window_width - diff,
 			    clist->clist_window_height);
-	  
+      
       area.x = 0;
     }
-
+  
   area.y = 0;
   area.width = diff;
   area.height = clist->clist_window_height;
-
+  
   check_exposures (clist);
-
+  
   if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
       !GTK_CLIST_CHILD_HAS_FOCUS(clist))
     {
@@ -6384,10 +6382,10 @@ static void
 check_exposures (GtkCList *clist)
 {
   GdkEvent *event;
-
+  
   if (!GTK_WIDGET_REALIZED (clist))
     return;
-
+  
   /* Make sure graphics expose events are processed before scrolling
    * again */
   while ((event = gdk_event_get_graphics_expose (clist->clist_window)) != NULL)
@@ -6417,9 +6415,9 @@ columns_new (GtkCList *clist)
 {
   GtkCListColumn *column;
   gint i;
-
+  
   column = g_new (GtkCListColumn, clist->columns);
-
+  
   for (i = 0; i < clist->columns; i++)
     {
       column[i].area.x = 0;
@@ -6439,7 +6437,7 @@ columns_new (GtkCList *clist)
       column[i].button_passive = FALSE;
       column[i].justification = GTK_JUSTIFY_LEFT;
     }
-
+  
   return column;
 }
 
@@ -6450,7 +6448,7 @@ column_title_new (GtkCList    *clist,
 {
   if (clist->column[column].title)
     g_free (clist->column[column].title);
-
+  
   clist->column[column].title = g_strdup (title);
 }
 
@@ -6458,11 +6456,11 @@ static void
 columns_delete (GtkCList *clist)
 {
   gint i;
-
+  
   for (i = 0; i < clist->columns; i++)
     if (clist->column[i].title)
       g_free (clist->column[i].title);
-      
+  
   g_free (clist->column);
 }
 
@@ -6471,10 +6469,10 @@ row_new (GtkCList *clist)
 {
   int i;
   GtkCListRow *clist_row;
-
+  
   clist_row = g_chunk_new (GtkCListRow, clist->row_mem_chunk);
   clist_row->cell = g_chunk_new (GtkCell, clist->cell_mem_chunk);
-
+  
   for (i = 0; i < clist->columns; i++)
     {
       clist_row->cell[i].type = GTK_CELL_EMPTY;
@@ -6482,7 +6480,7 @@ row_new (GtkCList *clist)
       clist_row->cell[i].horizontal = 0;
       clist_row->cell[i].style = NULL;
     }
-
+  
   clist_row->fg_set = FALSE;
   clist_row->bg_set = FALSE;
   clist_row->style = NULL;
@@ -6490,7 +6488,7 @@ row_new (GtkCList *clist)
   clist_row->state = GTK_STATE_NORMAL;
   clist_row->data = NULL;
   clist_row->destroy = NULL;
-
+  
   return clist_row;
 }
 
@@ -6499,10 +6497,10 @@ row_delete (GtkCList    *clist,
 	    GtkCListRow *clist_row)
 {
   gint i;
-
+  
   for (i = 0; i < clist->columns; i++)
     {
-      GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+      GTK_CLIST_GET_CLASS (clist)->set_cell_contents
 	(clist, clist_row, i, GTK_CELL_EMPTY, NULL, 0, NULL, NULL);
       if (clist_row->cell[i].style)
 	{
@@ -6511,17 +6509,17 @@ row_delete (GtkCList    *clist,
 	  gtk_style_unref (clist_row->cell[i].style);
 	}
     }
-
+  
   if (clist_row->style)
     {
       if (GTK_WIDGET_REALIZED (clist))
         gtk_style_detach (clist_row->style);
       gtk_style_unref (clist_row->style);
     }
-
+  
   if (clist_row->destroy)
     clist_row->destroy (clist_row->data);
-
+  
   g_mem_chunk_free (clist->cell_mem_chunk, clist_row->cell);
   g_mem_chunk_free (clist->row_mem_chunk, clist_row);
 }
@@ -6541,17 +6539,17 @@ gtk_clist_focus (GtkContainer     *container,
   GtkCList *clist;
   GtkWidget *focus_child;
   gint old_row;
-
+  
   g_return_val_if_fail (container != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (container), FALSE);
-
+  
   if (!GTK_WIDGET_IS_SENSITIVE (container))
     return FALSE;
   
   clist = GTK_CLIST (container);
   focus_child = container->focus_child;
   old_row = clist->focus_row;
-
+  
   switch (direction)
     {
     case GTK_DIR_LEFT:
@@ -6562,7 +6560,7 @@ gtk_clist_focus (GtkContainer     *container,
 	    return TRUE;
 	  gtk_container_set_focus_child (container, NULL);
 	  return FALSE;
-	 }
+	}
       gtk_widget_grab_focus (GTK_WIDGET (container));
       return TRUE;
     case GTK_DIR_DOWN:
@@ -6570,7 +6568,7 @@ gtk_clist_focus (GtkContainer     *container,
       if (GTK_CLIST_CHILD_HAS_FOCUS(clist))
 	{
 	  gboolean tf = FALSE;
-
+	  
 	  if (((focus_child && direction == GTK_DIR_DOWN) ||
 	       !(tf = title_focus (clist, GTK_DIR_TAB_FORWARD)))
 	      && clist->rows)
@@ -6578,7 +6576,7 @@ gtk_clist_focus (GtkContainer     *container,
 	      if (clist->focus_row < 0)
 		{
 		  clist->focus_row = 0;
-
+		  
 		  if ((clist->selection_mode == GTK_SELECTION_BROWSE ||
 		       clist->selection_mode == GTK_SELECTION_EXTENDED) &&
 		      !clist->selection)
@@ -6589,7 +6587,7 @@ gtk_clist_focus (GtkContainer     *container,
 	      gtk_widget_grab_focus (GTK_WIDGET (container));
 	      return TRUE;
 	    }
-
+	  
 	  if (tf)
 	    return TRUE;
 	}
@@ -6614,17 +6612,17 @@ gtk_clist_focus (GtkContainer     *container,
 	  gtk_widget_grab_focus (GTK_WIDGET (container));
 	  return TRUE;
 	}
-
+      
       GTK_CLIST_SET_FLAG (clist, CLIST_CHILD_HAS_FOCUS);
-
+      
       if (title_focus (clist, direction))
 	return TRUE;
-
+      
       break;
     default:
       break;
     }
-
+  
   gtk_container_set_focus_child (container, NULL);
   return FALSE;
 }
@@ -6633,13 +6631,13 @@ static void
 gtk_clist_draw_focus (GtkWidget *widget)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
-
+  
   if (!GTK_WIDGET_DRAWABLE (widget) || !GTK_WIDGET_CAN_FOCUS (widget))
     return;
-
+  
   clist = GTK_CLIST (widget);
   if (clist->focus_row >= 0)
     gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
@@ -6653,21 +6651,21 @@ gtk_clist_focus_in (GtkWidget     *widget,
 		    GdkEventFocus *event)
 {
   GtkCList *clist;
-
+  
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
-
+  
   GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
   GTK_CLIST_UNSET_FLAG (widget, CLIST_CHILD_HAS_FOCUS);
-
+  
   clist = GTK_CLIST (widget);
-
+  
   if (clist->selection_mode == GTK_SELECTION_BROWSE &&
       clist->selection == NULL && clist->focus_row > -1)
     {
       GList *list;
-
+      
       list = g_list_nth (clist->row_list, clist->focus_row);
       if (list && GTK_CLIST_ROW (list)->selectable)
 	gtk_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW],
@@ -6677,7 +6675,7 @@ gtk_clist_focus_in (GtkWidget     *widget,
     }
   else
     gtk_widget_draw_focus (widget);
-
+  
   return FALSE;
 }
 
@@ -6686,20 +6684,20 @@ gtk_clist_focus_out (GtkWidget     *widget,
 		     GdkEventFocus *event)
 {
   GtkCList *clist;
-
+  
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
-
+  
   GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
   GTK_CLIST_SET_FLAG (widget, CLIST_CHILD_HAS_FOCUS);
-
+  
   gtk_widget_draw_focus (widget);
   
   clist = GTK_CLIST (widget);
-
-  GTK_CLIST_CLASS_FW (widget)->resync_selection (clist, (GdkEvent *) event);
-
+  
+  GTK_CLIST_GET_CLASS (widget)->resync_selection (clist, (GdkEvent *) event);
+  
   return FALSE;
 }
 
@@ -6709,13 +6707,13 @@ gtk_clist_set_focus_child (GtkContainer *container,
 {
   g_return_if_fail (container != NULL);
   g_return_if_fail (GTK_IS_CLIST (container));
-
+  
   if (child)
     {
       g_return_if_fail (GTK_IS_WIDGET (child));
       GTK_CLIST_SET_FLAG (container, CLIST_CHILD_HAS_FOCUS);
     }
-
+  
   parent_class->set_focus_child (container, child);
 }
 
@@ -6729,12 +6727,12 @@ title_focus (GtkCList *clist,
   gint d = 1;
   gint i = 0;
   gint j;
-
+  
   if (!GTK_CLIST_SHOW_TITLES(clist))
     return FALSE;
-
+  
   focus_child = GTK_CONTAINER (clist)->focus_child;
-
+  
   for (last_column = clist->columns - 1;
        last_column >= 0 && !clist->column[last_column].visible; last_column--)
     ;
@@ -6771,7 +6769,7 @@ title_focus (GtkCList *clist,
 	}
       break;
     }
-
+  
   if (focus_child)
     while (i < clist->columns)
       {
@@ -6794,9 +6792,9 @@ title_focus (GtkCList *clist,
 	  }
 	i++;
       }
-
+  
   j = i;
-
+  
   if (!return_val)
     while (j >= 0 && j < clist->columns)
       {
@@ -6852,12 +6850,12 @@ move_focus_row (GtkCList      *clist,
 		gfloat         position)
 {
   GtkWidget *widget;
-
+  
   g_return_if_fail (clist != 0);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   widget = GTK_WIDGET (clist);
-
+  
   switch (scroll_type)
     {
     case GTK_SCROLL_STEP_BACKWARD:
@@ -6914,17 +6912,17 @@ scroll_horizontal (GtkCList      *clist,
 {
   gint column = 0;
   gint last_column;
-
+  
   g_return_if_fail (clist != 0);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
     return;
-
+  
   for (last_column = clist->columns - 1;
        last_column >= 0 && !clist->column[last_column].visible; last_column--)
     ;
-
+  
   switch (scroll_type)
     {
     case GTK_SCROLL_STEP_BACKWARD:
@@ -6951,17 +6949,17 @@ scroll_horizontal (GtkCList      *clist,
 	{
 	  gint vis_columns = 0;
 	  gint i;
-
+	  
 	  for (i = 0; i <= last_column; i++)
  	    if (clist->column[i].visible)
 	      vis_columns++;
-
+	  
 	  column = position * vis_columns;
-
+	  
 	  for (i = 0; i <= last_column && column > 0; i++)
 	    if (clist->column[i].visible)
 	      column--;
-
+	  
 	  column = i;
 	}
       else
@@ -6970,7 +6968,7 @@ scroll_horizontal (GtkCList      *clist,
     default:
       break;
     }
-
+  
   if (COLUMN_LEFT_XPIXEL (clist, column) < CELL_SPACING + COLUMN_INSET)
     gtk_clist_moveto (clist, -1, column, 0, 0);
   else if (COLUMN_LEFT_XPIXEL (clist, column) + CELL_SPACING + COLUMN_INSET - 1
@@ -6989,23 +6987,23 @@ scroll_vertical (GtkCList      *clist,
 		 gfloat         position)
 {
   gint old_focus_row;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
     return;
-
+  
   switch (clist->selection_mode)
     {
     case GTK_SELECTION_EXTENDED:
       if (clist->anchor >= 0)
 	return;
     case GTK_SELECTION_BROWSE:
-
+      
       old_focus_row = clist->focus_row;
       move_focus_row (clist, scroll_type, position);
-
+      
       if (old_focus_row != clist->focus_row)
 	{
 	  if (clist->selection_mode == GTK_SELECTION_BROWSE)
@@ -7017,7 +7015,7 @@ scroll_vertical (GtkCList      *clist,
 	      clist->undo_anchor = old_focus_row;
 	    }
 	}
-
+      
       switch (gtk_clist_row_is_visible (clist, clist->focus_row))
 	{
 	case GTK_VISIBILITY_NONE:
@@ -7071,7 +7069,7 @@ scroll_vertical (GtkCList      *clist,
       break;
     default:
       move_focus_row (clist, scroll_type, position);
-
+      
       if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
 	  clist->clist_window_height)
 	gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
@@ -7086,10 +7084,10 @@ move_horizontal (GtkCList *clist,
 		 gint      diff)
 {
   gfloat value;
-
+  
   if (!clist->hadjustment)
     return;
-
+  
   value = CLAMP (clist->hadjustment->value + diff, 0.0,
 		 clist->hadjustment->upper - clist->hadjustment->page_size);
   gtk_adjustment_set_value(clist->hadjustment, value);
@@ -7101,17 +7099,17 @@ move_vertical (GtkCList *clist,
 	       gfloat    align)
 {
   gfloat value;
-
+  
   if (!clist->vadjustment)
     return;
-
+  
   value = (ROW_TOP_YPIXEL (clist, row) - clist->voffset -
 	   align * (clist->clist_window_height - clist->row_height) +
 	   (2 * align - 1) * CELL_SPACING);
-
+  
   if (value + clist->vadjustment->page_size > clist->vadjustment->upper)
     value = clist->vadjustment->upper - clist->vadjustment->page_size;
-
+  
   gtk_adjustment_set_value(clist->vadjustment, value);
 }
 
@@ -7119,16 +7117,16 @@ static gint
 horizontal_timeout (GtkCList *clist)
 {
   GdkEventMotion event = { 0 };
-
+  
   GDK_THREADS_ENTER ();
-
+  
   clist->htimer = 0;
-
+  
   event.type = GDK_MOTION_NOTIFY;
   event.send_event = TRUE;
-
+  
   gtk_clist_motion (GTK_WIDGET (clist), &event);
-
+  
   GDK_THREADS_LEAVE ();
   
   return FALSE;
@@ -7138,18 +7136,18 @@ static gint
 vertical_timeout (GtkCList *clist)
 {
   GdkEventMotion event = { 0 };
-
+  
   GDK_THREADS_ENTER ();
-
+  
   clist->vtimer = 0;
-
+  
   event.type = GDK_MOTION_NOTIFY;
   event.send_event = TRUE;
-
+  
   gtk_clist_motion (GTK_WIDGET (clist), &event);
-
+  
   GDK_THREADS_LEAVE ();
-
+  
   return FALSE;
 }
 
@@ -7162,13 +7160,13 @@ remove_grab (GtkCList *clist)
       if (gdk_pointer_is_grabbed ())
 	gdk_pointer_ungrab (GDK_CURRENT_TIME);
     }
-
+  
   if (clist->htimer)
     {
       gtk_timeout_remove (clist->htimer);
       clist->htimer = 0;
     }
-
+  
   if (clist->vtimer)
     {
       gtk_timeout_remove (clist->vtimer);
@@ -7188,8 +7186,8 @@ gtk_clist_sort (GtkCList *clist)
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
-  GTK_CLIST_CLASS_FW (clist)->sort_list (clist);
+  
+  GTK_CLIST_GET_CLASS (clist)->sort_list (clist);
 }
 
 void
@@ -7198,7 +7196,7 @@ gtk_clist_set_compare_func (GtkCList            *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   clist->compare = (cmp_func) ? cmp_func : default_compare;
 }
 
@@ -7234,10 +7232,10 @@ gtk_clist_set_sort_column (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (column < 0 || column >= clist->columns)
     return;
-
+  
   clist->sort_column = column;
 }
 
@@ -7254,10 +7252,10 @@ default_compare (GtkCList      *clist,
 {
   char *text1 = NULL;
   char *text2 = NULL;
-
+  
   GtkCListRow *row1 = (GtkCListRow *) ptr1;
   GtkCListRow *row2 = (GtkCListRow *) ptr2;
-
+  
   switch (row1->cell[clist->sort_column].type)
     {
     case GTK_CELL_TEXT:
@@ -7269,7 +7267,7 @@ default_compare (GtkCList      *clist,
     default:
       break;
     }
- 
+  
   switch (row2->cell[clist->sort_column].type)
     {
     case GTK_CELL_TEXT:
@@ -7281,13 +7279,13 @@ default_compare (GtkCList      *clist,
     default:
       break;
     }
-
+  
   if (!text2)
     return (text1 != NULL);
-
+  
   if (!text1)
     return -1;
-
+  
   return strcmp (text1, text2);
 }
 
@@ -7297,31 +7295,31 @@ real_sort_list (GtkCList *clist)
   GList *list;
   GList *work;
   gint i;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (clist->rows <= 1)
     return;
-
+  
   if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
     return;
-
+  
   gtk_clist_freeze (clist);
-
+  
   if (clist->anchor != -1 && clist->selection_mode == GTK_SELECTION_EXTENDED)
     {
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
       g_list_free (clist->undo_selection);
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
     }
-   
+  
   clist->row_list = gtk_clist_mergesort (clist, clist->row_list, clist->rows);
-
+  
   work = clist->selection;
-
+  
   for (i = 0, list = clist->row_list; i < clist->rows; i++, list = list->next)
     {
       if (GTK_CLIST_ROW (list)->state == GTK_STATE_SELECTED)
@@ -7333,7 +7331,7 @@ real_sort_list (GtkCList *clist)
       if (i == clist->rows - 1)
 	clist->row_list_end = list;
     }
-
+  
   gtk_clist_thaw (clist);
 }
 
@@ -7345,9 +7343,9 @@ gtk_clist_merge (GtkCList *clist,
   GList z = { 0 };                    /* auxiliary node */
   GList *c;
   gint cmp;
-
+  
   c = &z;
-
+  
   while (a || b)
     {
       if (a && !b)
@@ -7387,7 +7385,7 @@ gtk_clist_merge (GtkCList *clist,
 	    }
 	}
     }
-
+  
   return z.next;
 }
 
@@ -7398,7 +7396,7 @@ gtk_clist_mergesort (GtkCList *clist,
 {
   GList *half;
   gint i;
-
+  
   if (num == 1)
     {
       return list;
@@ -7409,15 +7407,15 @@ gtk_clist_mergesort (GtkCList *clist,
       half = list;
       for (i = 0; i < num / 2; i++)
 	half = half->next;
-
+      
       /* cut the list in two */
       half->prev->next = NULL;
       half->prev = NULL;
-
+      
       /* recursively sort both lists */
       return gtk_clist_merge (clist,
-		       gtk_clist_mergesort (clist, list, num / 2),
-		       gtk_clist_mergesort (clist, half, num - num / 2));
+			      gtk_clist_mergesort (clist, list, num / 2),
+			      gtk_clist_mergesort (clist, half, num - num / 2));
     }
 }
 
@@ -7427,7 +7425,7 @@ static void
 drag_source_info_destroy (gpointer data)
 {
   GtkCListCellInfo *info = data;
-
+  
   g_free (info);
 }
 
@@ -7435,7 +7433,7 @@ static void
 drag_dest_info_destroy (gpointer data)
 {
   GtkCListDestInfo *info = data;
-
+  
   g_free (info);
 }
 
@@ -7446,15 +7444,15 @@ drag_dest_cell (GtkCList         *clist,
 		GtkCListDestInfo *dest_info)
 {
   GtkWidget *widget;
-
+  
   widget = GTK_WIDGET (clist);
-
+  
   dest_info->insert_pos = GTK_CLIST_DRAG_NONE;
-
+  
   y -= (GTK_CONTAINER (clist)->border_width +
 	widget->style->klass->ythickness +
 	clist->column_title_area.height);
-
+  
   dest_info->cell.row = ROW_FROM_YPIXEL (clist, y);
   if (dest_info->cell.row >= clist->rows)
     {
@@ -7463,15 +7461,15 @@ drag_dest_cell (GtkCList         *clist,
     }
   if (dest_info->cell.row < -1)
     dest_info->cell.row = -1;
-
+  
   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)
     {
       gint y_delta;
       gint h = 0;
-
+      
       y_delta = y - ROW_TOP_YPIXEL (clist, dest_info->cell.row);
       
       if (GTK_CLIST_DRAW_DRAG_RECT(clist))
@@ -7484,7 +7482,7 @@ drag_dest_cell (GtkCList         *clist,
 	  dest_info->insert_pos = GTK_CLIST_DRAG_BEFORE;
 	  h = clist->row_height / 2;
 	}
-
+      
       if (GTK_CLIST_DRAW_DRAG_LINE(clist))
 	{
 	  if (y_delta < h)
@@ -7501,21 +7499,21 @@ gtk_clist_drag_begin (GtkWidget	     *widget,
 {
   GtkCList *clist;
   GtkCListCellInfo *info;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
   g_return_if_fail (context != NULL);
-
+  
   clist = GTK_CLIST (widget);
-
+  
   clist->drag_button = 0;
   remove_grab (clist);
-
+  
   switch (clist->selection_mode)
     {
     case GTK_SELECTION_EXTENDED:
       update_extended_selection (clist, clist->focus_row);
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
       break;
     case GTK_SELECTION_SINGLE:
     case GTK_SELECTION_MULTIPLE:
@@ -7523,24 +7521,24 @@ gtk_clist_drag_begin (GtkWidget	     *widget,
     case GTK_SELECTION_BROWSE:
       break;
     }
-
+  
   info = g_dataset_get_data (context, "gtk-clist-drag-source");
-
+  
   if (!info)
     {
       info = g_new (GtkCListCellInfo, 1);
-
+      
       if (clist->click_cell.row < 0)
 	clist->click_cell.row = 0;
       else if (clist->click_cell.row >= clist->rows)
 	clist->click_cell.row = clist->rows - 1;
       info->row = clist->click_cell.row;
       info->column = clist->click_cell.column;
-
+      
       g_dataset_set_data_full (context, "gtk-clist-drag-source", info,
 			       drag_source_info_destroy);
     }
-
+  
   if (GTK_CLIST_USE_DRAG_ICONS (clist))
     gtk_drag_set_icon_default (context);
 }
@@ -7550,13 +7548,13 @@ gtk_clist_drag_end (GtkWidget	   *widget,
 		    GdkDragContext *context)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
   g_return_if_fail (context != NULL);
-
+  
   clist = GTK_CLIST (widget);
-
+  
   clist->click_cell.row = -1;
   clist->click_cell.column = -1;
 }
@@ -7568,13 +7566,13 @@ gtk_clist_drag_leave (GtkWidget      *widget,
 {
   GtkCList *clist;
   GtkCListDestInfo *dest_info;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
   g_return_if_fail (context != NULL);
-
+  
   clist = GTK_CLIST (widget);
-
+  
   dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
   
   if (dest_info)
@@ -7585,13 +7583,13 @@ gtk_clist_drag_leave (GtkWidget      *widget,
 	{
 	  GList *list;
 	  GdkAtom atom = gdk_atom_intern ("gtk-clist-drag-reorder", FALSE);
-
+	  
 	  list = context->targets;
 	  while (list)
 	    {
 	      if (atom == GPOINTER_TO_INT (list->data))
 		{
-		  GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+		  GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
 		    (clist,
 		     g_list_nth (clist->row_list, dest_info->cell.row)->data,
 		     dest_info->cell.row, dest_info->insert_pos);
@@ -7614,33 +7612,33 @@ gtk_clist_drag_motion (GtkWidget      *widget,
   GtkCList *clist;
   GtkCListDestInfo new_info;
   GtkCListDestInfo *dest_info;
-
+  
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
-
+  
   clist = GTK_CLIST (widget);
-
+  
   dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
-
+  
   if (!dest_info)
     {
       dest_info = g_new (GtkCListDestInfo, 1);
-
+      
       dest_info->insert_pos  = GTK_CLIST_DRAG_NONE;
       dest_info->cell.row    = -1;
       dest_info->cell.column = -1;
-
+      
       g_dataset_set_data_full (context, "gtk-clist-drag-dest", dest_info,
 			       drag_dest_info_destroy);
     }
-
+  
   drag_dest_cell (clist, x, y, &new_info);
-
+  
   if (GTK_CLIST_REORDERABLE (clist))
     {
       GList *list;
       GdkAtom atom = gdk_atom_intern ("gtk-clist-drag-reorder", FALSE);
-
+      
       list = context->targets;
       while (list)
 	{
@@ -7648,7 +7646,7 @@ gtk_clist_drag_motion (GtkWidget      *widget,
 	    break;
 	  list = list->next;
 	}
-
+      
       if (list)
 	{
 	  if (gtk_drag_get_source_widget (context) != widget ||
@@ -7666,32 +7664,32 @@ gtk_clist_drag_motion (GtkWidget      *widget,
 		}
 	      return TRUE;
 	    }
-		
+	  
 	  if (new_info.cell.row != dest_info->cell.row ||
 	      (new_info.cell.row == dest_info->cell.row &&
 	       dest_info->insert_pos != new_info.insert_pos))
 	    {
 	      if (dest_info->cell.row >= 0)
-		GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+		GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
 		  (clist, g_list_nth (clist->row_list,
 				      dest_info->cell.row)->data,
 		   dest_info->cell.row, dest_info->insert_pos);
-
+	      
 	      dest_info->insert_pos  = new_info.insert_pos;
 	      dest_info->cell.row    = new_info.cell.row;
 	      dest_info->cell.column = new_info.cell.column;
 	      
-	      GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+	      GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
 		(clist, g_list_nth (clist->row_list,
 				    dest_info->cell.row)->data,
 		 dest_info->cell.row, dest_info->insert_pos);
-
+	      
 	      gdk_drag_status (context, context->suggested_action, time);
 	    }
 	  return TRUE;
 	}
     }
-
+  
   dest_info->insert_pos  = new_info.insert_pos;
   dest_info->cell.row    = new_info.cell.row;
   dest_info->cell.column = new_info.cell.column;
@@ -7708,13 +7706,13 @@ gtk_clist_drag_drop (GtkWidget      *widget,
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CLIST (widget), FALSE);
   g_return_val_if_fail (context != NULL, FALSE);
-
+  
   if (GTK_CLIST_REORDERABLE (widget) &&
       gtk_drag_get_source_widget (context) == widget)
     {
       GList *list;
       GdkAtom atom = gdk_atom_intern ("gtk-clist-drag-reorder", FALSE);
-
+      
       list = context->targets;
       while (list)
 	{
@@ -7736,14 +7734,14 @@ gtk_clist_drag_data_received (GtkWidget        *widget,
 			      guint             time)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CLIST (widget));
   g_return_if_fail (context != NULL);
   g_return_if_fail (selection_data != NULL);
-
+  
   clist = GTK_CLIST (widget);
-
+  
   if (GTK_CLIST_REORDERABLE (clist) &&
       gtk_drag_get_source_widget (context) == widget &&
       selection_data->target ==
@@ -7752,21 +7750,21 @@ gtk_clist_drag_data_received (GtkWidget        *widget,
       selection_data->length == sizeof (GtkCListCellInfo))
     {
       GtkCListCellInfo *source_info;
-
+      
       source_info = (GtkCListCellInfo *)(selection_data->data);
       if (source_info)
 	{
 	  GtkCListDestInfo dest_info;
-
+	  
 	  drag_dest_cell (clist, x, y, &dest_info);
-
+	  
 	  if (dest_info.insert_pos == GTK_CLIST_DRAG_AFTER)
 	    dest_info.cell.row++;
 	  if (source_info->row < dest_info.cell.row)
 	    dest_info.cell.row--;
 	  if (dest_info.cell.row != source_info->row)
 	    gtk_clist_row_move (clist, source_info->row, dest_info.cell.row);
-
+	  
 	  g_dataset_remove_data (context, "gtk-clist-drag-dest");
 	}
     }
@@ -7783,21 +7781,21 @@ gtk_clist_drag_data_get (GtkWidget        *widget,
   g_return_if_fail (GTK_IS_CLIST (widget));
   g_return_if_fail (context != NULL);
   g_return_if_fail (selection_data != NULL);
-
+  
   if (selection_data->target ==
       gdk_atom_intern ("gtk-clist-drag-reorder", FALSE))
     {
       GtkCListCellInfo *info;
-
+      
       info = g_dataset_get_data (context, "gtk-clist-drag-source");
-
+      
       if (info)
 	{
 	  GtkCListCellInfo ret_info;
-
+	  
 	  ret_info.row = info->row;
 	  ret_info.column = info->column;
-
+	  
 	  gtk_selection_data_set (selection_data, selection_data->target,
 				  GTK_TYPE_POINTER, (guchar *) &ret_info,
 				  sizeof (GtkCListCellInfo));
@@ -7815,9 +7813,9 @@ draw_drag_highlight (GtkCList        *clist,
 		     GtkCListDragPos  drag_pos)
 {
   gint y;
-
+  
   y = ROW_TOP_YPIXEL (clist, dest_row_number) - 1;
-
+  
   switch (drag_pos)
     {
     case GTK_CLIST_DRAG_NONE:
@@ -7840,15 +7838,15 @@ gtk_clist_set_reorderable (GtkCList *clist,
 			   gboolean  reorderable)
 {
   GtkWidget *widget;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if ((GTK_CLIST_REORDERABLE(clist) != 0) == reorderable)
     return;
-
+  
   widget = GTK_WIDGET (clist);
-
+  
   if (reorderable)
     {
       GTK_CLIST_SET_FLAG (clist, CLIST_REORDERABLE);
@@ -7869,7 +7867,7 @@ gtk_clist_set_use_drag_icons (GtkCList *clist,
 {
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CLIST (clist));
-
+  
   if (use_icons != 0)
     GTK_CLIST_SET_FLAG (clist, CLIST_USE_DRAG_ICONS);
   else
@@ -7891,9 +7889,9 @@ gtk_clist_set_button_actions (GtkCList *clist,
 	  remove_grab (clist);
 	  clist->drag_button = 0;
 	}
-
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
-
+      
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
+      
       clist->button_actions[button] = button_actions;
     }
 }
diff --git a/gtk/gtkcolorsel.c b/gtk/gtkcolorsel.c
index 6af300bd9..9071f8924 100644
--- a/gtk/gtkcolorsel.c
+++ b/gtk/gtkcolorsel.c
@@ -1,4 +1,4 @@
- /* GTK - The GIMP Toolkit
+/* GTK - The GIMP Toolkit
  * Copyright (C) 2000 Red Hat, Inc.
  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
  *
@@ -25,8 +25,7 @@
  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  */
 
-#include <glib.h>
-#include "gdk/gdkx.h"
+#include "x11/gdkx.h"
 #include "gdk/gdkkeysyms.h"
 #include "gtkcolorsel.h"
 #include "gtkhsv.h"
@@ -72,15 +71,17 @@ typedef struct _ColorSelectionPrivate ColorSelectionPrivate;
 
 struct _ColorSelectionPrivate
 {
-  /* < Private > */
-  gboolean use_opacity;
-  gboolean use_palette;
-  gboolean changing;
-  gboolean default_set;
-
+  guint use_opacity : 1;
+  guint use_palette : 1;
+  guint changing : 1;
+  guint default_set : 1;
+  
+  /* The color dropper */
+  guint moving_dropper : 1;
+  
   gdouble color[COLORSEL_NUM_CHANNELS];
   gdouble old_color[COLORSEL_NUM_CHANNELS];
-
+  
   GtkWidget *triangle_colorsel;
   GtkWidget *hue_spinbutton;
   GtkWidget *sat_spinbutton;
@@ -93,28 +94,25 @@ struct _ColorSelectionPrivate
   GtkWidget *opacity_entry;
   GtkWidget *palette_frame;
   GtkWidget *hex_entry;
-
+  
   /* The Palette code */
-  GtkWidget *custom_palette [CUSTOM_PALETTE_WIDTH][CUSTOM_PALETTE_HEIGHT];
+  GtkWidget *custom_palette [GTK_CUSTOM_PALETTE_WIDTH][GTK_CUSTOM_PALETTE_HEIGHT];
   GtkWidget *last_palette;
-
+  
   /* The color_sample stuff */
   GtkWidget *sample_area;
   GtkWidget *old_sample;
   GtkWidget *cur_sample;
   GtkWidget *colorsel;
-
-  /* The color dropper */
-  gboolean moving_dropper;
 };
 
 
-static void gtk_color_selection_init		(GtkColorSelection		 *colorsel);
+static void gtk_color_selection_init		(GtkColorSelection	 *colorsel);
 static void gtk_color_selection_class_init	(GtkColorSelectionClass	 *klass);
-static void gtk_color_selection_destroy        (GtkObject *object);
-static void update_color (GtkColorSelection *colorsel);
+static void gtk_color_selection_destroy		(GtkObject		 *object);
+static void update_color			(GtkColorSelection	 *colorsel);
 
-static GtkVBoxClass *parent_class = NULL;
+static gpointer parent_class = NULL;
 static guint color_selection_signals[LAST_SIGNAL] = { 0 };
 
 
@@ -206,7 +204,7 @@ color_sample_drag_begin (GtkWidget      *widget,
   gdouble *colsrc;
   GdkColor bg;
   gint n, i;
-
+  
   priv = colorsel->private;
   window = gtk_window_new (GTK_WINDOW_POPUP);
   gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
@@ -216,29 +214,29 @@ color_sample_drag_begin (GtkWidget      *widget,
 			    "gtk-color-selection-drag-window",
 			    window,
 			    (GtkDestroyNotify) gtk_widget_destroy);
-
+  
   if (widget == priv->old_sample)
     colsrc = priv->old_color;
   else
     colsrc = priv->color;
-
+  
   for (i=0, n = COLORSEL_RED; n <= COLORSEL_BLUE; n++)
     {
       colors[i++] = colsrc[n];
     }
-
+  
   if (priv->use_opacity)
     {
       colors[i] = colsrc[COLORSEL_OPACITY];
     }
-
+  
   bg.red = 0xffff * colors[0];
   bg.green = 0xffff * colors[1];
   bg.blue = 0xffff * colors[2];
-
+  
   gdk_color_alloc (gtk_widget_get_colormap (window), &bg);
   gdk_window_set_background (window->window, &bg);
-
+  
   gtk_drag_set_icon_widget (context, window, -2, -2);
 }
 
@@ -265,33 +263,33 @@ color_sample_drop_handle (GtkWidget        *widget,
   guint16 *vals;
   gdouble color[4];
   priv = colorsel->private;
-
+  
   /* This is currently a guint16 array of the format:
    * R
    * G
    * B
    * opacity
    */
-
+  
   if (selection_data->length < 0)
     return;
-
+  
   if ((selection_data->format != 16) ||
       (selection_data->length != 8))
     {
       g_warning ("Received invalid color data\n");
       return;
     }
-
+  
   vals = (guint16 *)selection_data->data;
-
+  
   if (widget == priv->cur_sample)
     {
       color[0] = (gdouble)vals[0] / 0xffff;
       color[1] = (gdouble)vals[1] / 0xffff;
       color[2] = (gdouble)vals[2] / 0xffff;
       color[3] = (gdouble)vals[3] / 0xffff;
-
+      
       gtk_color_selection_set_color (colorsel, color);
     }
 }
@@ -308,19 +306,19 @@ color_sample_drag_handle (GtkWidget        *widget,
   ColorSelectionPrivate *priv;
   guint16 vals[4];
   gdouble *colsrc;
-
+  
   priv = colorsel->private;
-
+  
   if (widget == priv->old_sample)
     colsrc = priv->old_color;
   else
     colsrc = priv->color;
-
+  
   vals[0] = colsrc[COLORSEL_RED] * 0xffff;
   vals[1] = colsrc[COLORSEL_GREEN] * 0xffff;
   vals[2] = colsrc[COLORSEL_BLUE] * 0xffff;
   vals[3] = priv->use_opacity ? colsrc[COLORSEL_OPACITY] * 0xffff : 0xffff;
-
+  
   gtk_selection_data_set (selection_data,
 			  gdk_atom_intern ("application/x-color", FALSE),
 			  16, (guchar *)vals, 8);
@@ -336,14 +334,14 @@ color_sample_draw_sample (GtkColorSelection *colorsel, int which)
   gdouble o;
   guchar *buf;
   ColorSelectionPrivate *priv;
-
+  
   g_return_if_fail (colorsel != NULL);
   priv = colorsel->private;
-
+  
   g_return_if_fail (priv->sample_area != NULL);
   if (!GTK_WIDGET_DRAWABLE (priv->sample_area))
     return;
-
+  
   if (which == 0)
     {
       da = priv->old_sample;
@@ -358,12 +356,12 @@ color_sample_draw_sample (GtkColorSelection *colorsel, int which)
 	c[n] = (guchar) (255.0 * priv->color[i]);
       goff =  priv->old_sample->allocation.width % 32;
     }
-
+  
   wid = da->allocation.width;
   heig = da->allocation.height;
-
+  
   buf = g_new(guchar, 3 * wid * heig);
-
+  
 #if 0
   i = COLORSEL_RED;
   for (n = 0; n < 3; n++)
@@ -372,11 +370,11 @@ color_sample_draw_sample (GtkColorSelection *colorsel, int which)
       c[n + 3] = (guchar) (255.0 * priv->color[i++]);
     }
 #endif
-
+  
   if (priv->use_opacity)
     {
       o = (which) ? priv->color[COLORSEL_OPACITY] : priv->old_color[COLORSEL_OPACITY];
-
+      
       for (n = 0; n < 3; n++)
 	{
 	  cc[n] = (guchar) ((1.0 - o) * 192 + (o * (gdouble) c[n]));
@@ -384,7 +382,7 @@ color_sample_draw_sample (GtkColorSelection *colorsel, int which)
 	}
       cp = cc;
     }
-
+  
   i = 0;
   for (y = 0; y < heig; y++)
     {
@@ -394,12 +392,12 @@ color_sample_draw_sample (GtkColorSelection *colorsel, int which)
 	    f = 3 * ((((goff + x) % 32) < 16) ^ ((y % 32) < 16));
 	  else
 	    f = 0;
-
+	  
 	  for (n = 0; n < 3; n++)
 	    buf[i++] = cp[n + f];
 	}
     }
-
+  
   gdk_draw_rgb_image(da->window,
 		     da->style->black_gc,
 		     0, 0,
@@ -407,10 +405,9 @@ color_sample_draw_sample (GtkColorSelection *colorsel, int which)
 		     GDK_RGB_DITHER_NORMAL,
 		     buf,
 		     3*wid);
-
-
+  
+  
   g_free (buf);
-
 }
 
 
@@ -442,32 +439,32 @@ color_sample_setup_dnd (GtkColorSelection *colorsel, GtkWidget *sample)
   };
   ColorSelectionPrivate *priv;
   priv = colorsel->private;
-
+  
   gtk_drag_source_set (sample,
 		       GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
 		       targets, 1,
 		       GDK_ACTION_COPY | GDK_ACTION_MOVE);
-
+  
   gtk_signal_connect (GTK_OBJECT (sample),
 		      "drag_begin",
 		      GTK_SIGNAL_FUNC (color_sample_drag_begin),
 		      colorsel);
   if (sample == priv->cur_sample)
     {
-
+      
       gtk_drag_dest_set (sample,
 			 GTK_DEST_DEFAULT_HIGHLIGHT |
 			 GTK_DEST_DEFAULT_MOTION |
 			 GTK_DEST_DEFAULT_DROP,
 			 targets, 1,
 			 GDK_ACTION_COPY);
-
+      
       gtk_signal_connect (GTK_OBJECT (sample),
 			  "drag_end",
 			  GTK_SIGNAL_FUNC (color_sample_drag_end),
 			  colorsel);
     }
-
+  
   gtk_signal_connect (GTK_OBJECT (sample),
 		      "drag_data_get",
 		      GTK_SIGNAL_FUNC (color_sample_drag_handle),
@@ -476,7 +473,7 @@ color_sample_setup_dnd (GtkColorSelection *colorsel, GtkWidget *sample)
 		      "drag_data_received",
 		      GTK_SIGNAL_FUNC (color_sample_drop_handle),
 		      colorsel);
-
+  
 }
 
 
@@ -484,48 +481,36 @@ static void
 color_sample_new (GtkColorSelection *colorsel)
 {
   ColorSelectionPrivate *priv;
-
+  
   priv = colorsel->private;
-
+  
   gtk_widget_push_visual(gdk_rgb_get_visual());
   gtk_widget_push_colormap(gdk_rgb_get_cmap());
-
+  
   priv->sample_area = gtk_hbox_new (FALSE, 0);
   priv->old_sample = gtk_drawing_area_new ();
   priv->cur_sample = gtk_drawing_area_new ();
-
+  
   gtk_box_pack_start (GTK_BOX (priv->sample_area), priv->old_sample,
 		      TRUE, TRUE, 0);
   gtk_box_pack_start (GTK_BOX (priv->sample_area), priv->cur_sample,
 		      TRUE, TRUE, 0);
   gtk_widget_pop_visual();
   gtk_widget_pop_colormap();
-
+  
   gtk_signal_connect(GTK_OBJECT (priv->old_sample), "expose_event",
 		     GTK_SIGNAL_FUNC (color_old_sample_expose),
 		     colorsel);
   gtk_signal_connect(GTK_OBJECT (priv->cur_sample), "expose_event",
 		     GTK_SIGNAL_FUNC (color_cur_sample_expose),
 		     colorsel);
-
+  
   color_sample_setup_dnd (colorsel, priv->old_sample);
   color_sample_setup_dnd (colorsel, priv->cur_sample);
-
+  
   gtk_widget_show_all (priv->sample_area);
 }
 
-static void
-color_sample_set_use_opacity (GtkColorSelection *colorsel)
-{
-  ColorSelectionPrivate *priv;
-
-  g_return_if_fail (colorsel != NULL);
-
-  priv = colorsel->private;
-
-  color_sample_draw_samples (colorsel);
-}
-
 
 /*
  *
@@ -539,9 +524,9 @@ static void
 palette_get_color (GtkWidget *drawing_area, gdouble *color)
 {
   gdouble *color_val;
-
+  
   g_return_if_fail (color != NULL);
-
+  
   color_val = gtk_object_get_data (GTK_OBJECT (drawing_area), "color_val");
   if (color_val == NULL)
     {
@@ -552,7 +537,7 @@ palette_get_color (GtkWidget *drawing_area, gdouble *color)
       color[3] = 1.0;
       return;
     }
-
+  
   color[0] = color_val[0];
   color[1] = color_val[1];
   color[2] = color_val[2];
@@ -561,29 +546,31 @@ palette_get_color (GtkWidget *drawing_area, gdouble *color)
 
 #define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
 static void
-palette_paint (GtkWidget *drawing_area, GdkRectangle *area, gpointer data)
+palette_paint (GtkWidget    *drawing_area,
+	       GdkRectangle *area,
+	       gpointer      data)
 {
   if (drawing_area->window == NULL)
     return;
-
+  
   gdk_window_clear_area (drawing_area->window,
 			 area->x,
 			 area->y,
 			 area->width, 
 			 area->height);
-
+  
   if (GTK_WIDGET_HAS_FOCUS (drawing_area))
     {
       GdkGC *gc;
       gdouble color[4];
-
+      
       palette_get_color (drawing_area, color);
-
+      
       if (INTENSITY (color[0], color[1], color[2]) > 0.5)
 	gc = drawing_area->style->black_gc;
       else
 	gc = drawing_area->style->white_gc;
-
+      
       gdk_draw_rectangle (drawing_area->window,
 			  gc, FALSE, 0, 0,
 			  drawing_area->allocation.width - 1,
@@ -592,22 +579,26 @@ palette_paint (GtkWidget *drawing_area, GdkRectangle *area, gpointer data)
 }
 
 static void
-palette_expose (GtkWidget *drawing_area, GdkEventExpose *event, gpointer data)
+palette_expose (GtkWidget      *drawing_area,
+		GdkEventExpose *event,
+		gpointer        data)
 {
   if (drawing_area->window == NULL)
     return;
-
+  
   palette_paint (drawing_area, &(event->area), data);
 }
 
 static void
-palette_focus_in (GtkWidget *drawing_area, GdkEventFocus *event, gpointer data)
+palette_focus_in (GtkWidget     *drawing_area,
+		  GdkEventFocus *event,
+		  gpointer       data)
 {
   ColorSelectionPrivate *priv;
-
+  
   if (drawing_area->window == NULL)
     return;
-
+  
   priv = GTK_COLOR_SELECTION (data)->private;
   priv->last_palette = drawing_area;
   GTK_WIDGET_SET_FLAGS (drawing_area, GTK_HAS_FOCUS);
@@ -616,14 +607,18 @@ palette_focus_in (GtkWidget *drawing_area, GdkEventFocus *event, gpointer data)
 }
 
 static void
-palette_focus_out (GtkWidget *drawing_area, GdkEventFocus *event, gpointer data)
+palette_focus_out (GtkWidget     *drawing_area,
+		   GdkEventFocus *event,
+		   gpointer       data)
 {
   GTK_WIDGET_UNSET_FLAGS (drawing_area, GTK_HAS_FOCUS);
   gtk_widget_queue_clear_area (drawing_area, 0, 0, drawing_area->allocation.x, drawing_area->allocation.y);
 }
 
 static void
-palette_press (GtkWidget *drawing_area, GdkEventButton *event, gpointer data)
+palette_press (GtkWidget      *drawing_area,
+	       GdkEventButton *event,
+	       gpointer        data)
 {
   gtk_widget_grab_focus (drawing_area);
   if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (drawing_area), "color_set")) != 0)
@@ -635,7 +630,9 @@ palette_press (GtkWidget *drawing_area, GdkEventButton *event, gpointer data)
 }
 
 static void
-palette_draw (GtkWidget *drawing_area, GdkRectangle *area, gpointer data)
+palette_draw (GtkWidget    *drawing_area,
+	      GdkRectangle *area,
+	      gpointer      data)
 {
   palette_paint (drawing_area, area, data);
 }
@@ -645,7 +642,7 @@ palette_unset_color (GtkWidget *drawing_area)
 {
   if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (drawing_area), "color_set")) == 0)
     return;
-
+  
   gtk_widget_reset_rc_styles (drawing_area);
   gtk_object_set_data (GTK_OBJECT (drawing_area), "color_set", GINT_TO_POINTER (0));
 }
@@ -660,7 +657,7 @@ palette_drag_begin (GtkWidget      *widget,
   GtkWidget *window;
   gdouble colors[4];
   GdkColor bg;
-
+  
   priv = colorsel->private;
   window = gtk_window_new (GTK_WINDOW_POPUP);
   gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
@@ -670,15 +667,15 @@ palette_drag_begin (GtkWidget      *widget,
 			    "gtk-color-selection-drag-window",
 			    window,
 			    (GtkDestroyNotify) gtk_widget_destroy);
-
+  
   palette_get_color (widget, colors);
   bg.red = 0xffff * colors[0];
   bg.green = 0xffff * colors[1];
   bg.blue = 0xffff * colors[2];
-
+  
   gdk_color_alloc (gtk_widget_get_colormap (window), &bg);
   gdk_window_set_background (window->window, &bg);
-
+  
   gtk_drag_set_icon_widget (context, window, -2, -2);
 }
 
@@ -692,26 +689,28 @@ palette_drag_handle (GtkWidget        *widget,
 {
   guint16 vals[4];
   gdouble colsrc[4];
-
+  
   palette_get_color (widget, colsrc);
-
+  
   vals[0] = colsrc[COLORSEL_RED] * 0xffff;
   vals[1] = colsrc[COLORSEL_GREEN] * 0xffff;
   vals[2] = colsrc[COLORSEL_BLUE] * 0xffff;
   vals[3] = 0xffff;
-
+  
   gtk_selection_data_set (selection_data,
 			  gdk_atom_intern ("application/x-color", FALSE),
 			  16, (guchar *)vals, 8);
 }
 
 static void
-palette_set_color (GtkWidget *drawing_area, GtkColorSelection *colorsel, gdouble *color)
+palette_set_color (GtkWidget         *drawing_area,
+		   GtkColorSelection *colorsel,
+		   gdouble           *color)
 {
   GtkRcStyle *rc_style;
   gdouble *new_color = g_new (double, 4);
   gdouble *old_color;
-
+  
   rc_style = gtk_rc_style_new ();
   rc_style->bg[GTK_STATE_NORMAL].red = color[0]*65535;
   rc_style->bg[GTK_STATE_NORMAL].green = color[1]*65535;
@@ -719,7 +718,7 @@ palette_set_color (GtkWidget *drawing_area, GtkColorSelection *colorsel, gdouble
   rc_style->color_flags[GTK_STATE_NORMAL] = GTK_RC_BG;
   gtk_rc_style_ref (rc_style);
   gtk_widget_modify_style (drawing_area, rc_style);
-
+  
   if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (drawing_area), "color_set")) == 0)
     {
       static const GtkTargetEntry targets[] = {
@@ -729,7 +728,7 @@ palette_set_color (GtkWidget *drawing_area, GtkColorSelection *colorsel, gdouble
 			   GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
 			   targets, 1,
 			   GDK_ACTION_COPY | GDK_ACTION_MOVE);
-
+      
       gtk_signal_connect (GTK_OBJECT (drawing_area),
 			  "drag_begin",
 			  GTK_SIGNAL_FUNC (palette_drag_begin),
@@ -738,7 +737,7 @@ palette_set_color (GtkWidget *drawing_area, GtkColorSelection *colorsel, gdouble
 			  "drag_data_get",
 			  GTK_SIGNAL_FUNC (palette_drag_handle),
 			  colorsel);
-
+      
       gtk_object_set_data (GTK_OBJECT (drawing_area), "color_set", GINT_TO_POINTER (1));
     }
   else
@@ -753,7 +752,7 @@ palette_set_color (GtkWidget *drawing_area, GtkColorSelection *colorsel, gdouble
   new_color[1] = color[1];
   new_color[2] = color[2];
   new_color[3] = 1.0;
-
+  
   gtk_object_set_data (GTK_OBJECT (drawing_area), "color_val", new_color);
 }
 
@@ -777,19 +776,19 @@ palette_drop_handle (GtkWidget        *widget,
 {
   guint16 *vals;
   gdouble color[4];
-
+  
   if (selection_data->length < 0)
     return;
-
+  
   if ((selection_data->format != 16) ||
       (selection_data->length != 8))
     {
       g_warning ("Received invalid color data\n");
       return;
     }
-
+  
   vals = (guint16 *)selection_data->data;
-
+  
   color[0] = (gdouble)vals[0] / 0xffff;
   color[1] = (gdouble)vals[1] / 0xffff;
   color[2] = (gdouble)vals[2] / 0xffff;
@@ -798,24 +797,24 @@ palette_drop_handle (GtkWidget        *widget,
   gtk_color_selection_set_color (GTK_COLOR_SELECTION (data), color);
 }
 
-static int
-palette_activate (GtkWidget        *widget,
-		  GdkEventKey      *event,
-		  gpointer          data)
+static gint
+palette_activate (GtkWidget   *widget,
+		  GdkEventKey *event,
+		  gpointer     data)
 {
   GtkColorSelection *colorsel = data;
   ColorSelectionPrivate *priv;
-
+  
   if ((event->keyval == ' ') || (event->keyval == GDK_Return))
     {
       priv = colorsel->private;
       palette_set_color (widget, GTK_COLOR_SELECTION (data), priv->color);
     }
-
+  
   return TRUE;
 }
 
-static GtkWidget *
+static GtkWidget*
 palette_new (GtkColorSelection *colorsel)
 {
   GtkWidget *retval;
@@ -823,29 +822,29 @@ palette_new (GtkColorSelection *colorsel)
   static const GtkTargetEntry targets[] = {
     { "application/x-color", 0 }
   };
-
+  
   retval = gtk_drawing_area_new ();
   gtk_object_set_data (GTK_OBJECT (retval), "color_set", GINT_TO_POINTER (0)); 
   gtk_widget_set_events (retval, GDK_BUTTON_PRESS_MASK | GDK_EXPOSURE_MASK);
-
+  
   GTK_WIDGET_SET_FLAGS (retval, GTK_CAN_FOCUS);
   gtk_signal_connect (GTK_OBJECT (retval), "focus_in_event", palette_focus_in, colorsel);
   gtk_signal_connect (GTK_OBJECT (retval), "focus_out_event", palette_focus_out, colorsel);
   gtk_signal_connect (GTK_OBJECT (retval), "draw", palette_draw, colorsel);
   gtk_signal_connect (GTK_OBJECT (retval), "expose_event", palette_expose, colorsel);
   gtk_signal_connect (GTK_OBJECT (retval), "button_press_event", palette_press, colorsel);
-
+  
   gtk_drag_dest_set (retval,
 		     GTK_DEST_DEFAULT_HIGHLIGHT |
 		     GTK_DEST_DEFAULT_MOTION |
 		     GTK_DEST_DEFAULT_DROP,
 		     targets, 1,
 		     GDK_ACTION_COPY);
-
+  
   gtk_signal_connect (GTK_OBJECT (retval), "drag_end", palette_drag_end, NULL);
   gtk_signal_connect (GTK_OBJECT (retval), "drag_data_received", palette_drop_handle, colorsel);
   gtk_signal_connect (GTK_OBJECT (retval), "key_press_event", GTK_SIGNAL_FUNC (palette_activate), colorsel);
-
+  
   return retval;
 }
 
@@ -857,10 +856,10 @@ palette_new (GtkColorSelection *colorsel)
  */
 
 static void
-initialize_cursor ()
+initialize_cursor (void)
 {
   GdkColor fg, bg;
-
+  
   GdkPixmap *pixmap =
     gdk_bitmap_create_from_data (NULL,
 				 dropper_bits,
@@ -869,19 +868,22 @@ initialize_cursor ()
     gdk_bitmap_create_from_data (NULL,
 				 dropper_mask,
 				 DROPPER_WIDTH, DROPPER_HEIGHT);
-
+  
   gdk_color_white (gdk_colormap_get_system (), &bg);
   gdk_color_black (gdk_colormap_get_system (), &fg);
-
+  
   picker_cursor = gdk_cursor_new_from_pixmap (pixmap, mask, &fg, &bg, DROPPER_X_HOT ,DROPPER_Y_HOT);
-
+  
   gdk_pixmap_unref (pixmap);
   gdk_pixmap_unref (mask);
-
+  
 }
 
 static void
-grab_color_at_mouse (GtkWidget *button, int x_root, int y_root, gpointer data)
+grab_color_at_mouse (GtkWidget *button,
+		     gint       x_root,
+		     gint       y_root,
+		     gpointer   data)
 {
   GdkImage *image;
   guint32 pixel;
@@ -890,13 +892,13 @@ grab_color_at_mouse (GtkWidget *button, int x_root, int y_root, gpointer data)
   ColorSelectionPrivate *priv;
   GdkColormap *colormap = gdk_colormap_get_system ();
   XColor xcolor;
-
+  
   priv = colorsel->private;
-
+  
   image = gdk_image_get (GDK_ROOT_PARENT (), x_root, y_root, 1, 1);
   pixel = gdk_image_get_pixel (image, 0, 0);
   visual = gdk_colormap_get_visual (colormap);
-
+  
   switch (visual->type) {
   case GDK_VISUAL_DIRECT_COLOR:
   case GDK_VISUAL_TRUE_COLOR:
@@ -926,7 +928,7 @@ grab_color_at_mouse (GtkWidget *button, int x_root, int y_root, gpointer data)
     g_assert_not_reached ();
     break;
   }
-
+  
   gtk_rgb_to_hsv (priv->color[COLORSEL_RED],
 		  priv->color[COLORSEL_GREEN],
 		  priv->color[COLORSEL_BLUE],
@@ -937,33 +939,39 @@ grab_color_at_mouse (GtkWidget *button, int x_root, int y_root, gpointer data)
 }
 
 static void
-mouse_motion (GtkWidget *button, GdkEventMotion *event, gpointer data)
+mouse_motion (GtkWidget      *button,
+	      GdkEventMotion *event,
+	      gpointer        data)
 {
   grab_color_at_mouse (button, event->x_root, event->y_root, data); 
 }
 
 static void
-mouse_release (GtkWidget *button, GdkEventButton *event, gpointer data)
+mouse_release (GtkWidget      *button,
+	       GdkEventButton *event,
+	       gpointer        data)
 {
   GtkColorSelection *colorsel = data;
   ColorSelectionPrivate *priv;
   priv = colorsel->private;
-
+  
   gtk_signal_disconnect_by_func (GTK_OBJECT (button), mouse_motion, data);
   gtk_signal_disconnect_by_func (GTK_OBJECT (button), mouse_release, data);
-
+  
   grab_color_at_mouse (button, event->x_root, event->y_root, data);
   gdk_pointer_ungrab (0);
 }
 
 /* Helper Functions */
 static void
-mouse_press (GtkWidget *button, GdkEventButton *event, gpointer data)
+mouse_press (GtkWidget      *button,
+	     GdkEventButton *event,
+	     gpointer        data)
 {
   GtkColorSelection *colorsel = data;
   ColorSelectionPrivate *priv;
   priv = colorsel->private;
-
+  
   gtk_signal_connect (GTK_OBJECT (button), "motion_notify_event", mouse_motion, data);
   gtk_signal_connect (GTK_OBJECT (button), "button_release_event", mouse_release, data);
   gtk_signal_disconnect_by_func (GTK_OBJECT (button), mouse_press, data); 
@@ -975,12 +983,12 @@ get_screen_color (GtkWidget *button)
 {
   GtkColorSelection *colorsel = gtk_object_get_data (GTK_OBJECT (button), "COLORSEL");
   ColorSelectionPrivate *priv = colorsel->private; 
-
+  
   if (picker_cursor == NULL)
     {
       initialize_cursor ();
     }
-
+  
   /* Why do we do this? Because the "clicked" signal will be emitted after the "button_released"
      signal. We don't want to do this stuff again, though, or else it will get trapped here. So, 
      priv->moving_dropper is initialized to FALSE at the initialization of the colorselector, 
@@ -990,7 +998,7 @@ get_screen_color (GtkWidget *button)
     {
       priv->moving_dropper = TRUE;
       gtk_signal_connect (GTK_OBJECT (button), "button_press_event", mouse_press, colorsel); 
-
+      
       gdk_pointer_grab (button->window,
 			FALSE,
 			GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
@@ -1005,19 +1013,20 @@ get_screen_color (GtkWidget *button)
 }
 
 void
-hex_changed (GtkWidget *hex_entry, gpointer data)
+hex_changed (GtkWidget *hex_entry,
+	     gpointer   data)
 {
   GtkColorSelection *colorsel;
   ColorSelectionPrivate *priv;
   GdkColor color;
   gchar *text;
-
+  
   colorsel = GTK_COLOR_SELECTION (data);
   priv = colorsel->private;
-
+  
   if (priv->changing)
     return;
-
+  
   text = gtk_editable_get_chars (GTK_EDITABLE (priv->hex_entry), 0, -1);
   if (gdk_color_parse (text, &color))
     {
@@ -1036,17 +1045,18 @@ hex_changed (GtkWidget *hex_entry, gpointer data)
 }
 
 void
-hsv_changed (GtkWidget *hsv, gpointer data)
+hsv_changed (GtkWidget *hsv,
+	     gpointer   data)
 {
   GtkColorSelection *colorsel;
   ColorSelectionPrivate *priv;
-
+  
   colorsel = GTK_COLOR_SELECTION (data);
   priv = colorsel->private;
-
+  
   if (priv->changing)
     return;
-
+  
   gtk_hsv_get_color (GTK_HSV (hsv),
 		     &priv->color[COLORSEL_HUE],
 		     &priv->color[COLORSEL_SATURATION],
@@ -1061,17 +1071,18 @@ hsv_changed (GtkWidget *hsv, gpointer data)
 }
 
 void
-adjustment_changed (GtkAdjustment *adjustment, gpointer data)
+adjustment_changed (GtkAdjustment *adjustment,
+		    gpointer       data)
 {
   GtkColorSelection *colorsel;
   ColorSelectionPrivate *priv;
-
+  
   colorsel = GTK_COLOR_SELECTION (gtk_object_get_data (GTK_OBJECT (adjustment), "COLORSEL"));
   priv = colorsel->private;
-
+  
   if (priv->changing)
     return;
-
+  
   switch (GPOINTER_TO_INT (data))
     {
     case COLORSEL_SATURATION:
@@ -1097,7 +1108,7 @@ adjustment_changed (GtkAdjustment *adjustment, gpointer data)
     case COLORSEL_GREEN:
     case COLORSEL_BLUE:
       priv->color[GPOINTER_TO_INT (data)] = adjustment->value / 255;
-
+      
       gtk_rgb_to_hsv (priv->color[COLORSEL_RED],
 		      priv->color[COLORSEL_GREEN],
 		      priv->color[COLORSEL_BLUE],
@@ -1113,53 +1124,57 @@ adjustment_changed (GtkAdjustment *adjustment, gpointer data)
 }
 
 void 
-opacity_entry_changed (GtkWidget *opacity_entry, gpointer data)
+opacity_entry_changed (GtkWidget *opacity_entry,
+		       gpointer   data)
 {
   GtkColorSelection *colorsel;
   ColorSelectionPrivate *priv;
   GtkAdjustment *adj;
   gchar *text;
-
+  
   colorsel = GTK_COLOR_SELECTION (data);
   priv = colorsel->private;
   
   if (priv->changing)
     return;
-
+  
   text = gtk_editable_get_chars (GTK_EDITABLE (priv->opacity_entry), 0, -1);
   adj = gtk_range_get_adjustment (GTK_RANGE (priv->opacity_slider));
   gtk_adjustment_set_value (adj, g_strtod (text, NULL)); 
-
+  
   update_color (colorsel);
-
+  
   g_free (text);
 }
 
 static void
-widget_focus_in (GtkWidget *drawing_area, GdkEventFocus *event, gpointer data)
-     /* This signal is connected to by all of the widgets except the "Set Color" button */
-     /* This will let you add a color to the currently selected palette */
+widget_focus_in (GtkWidget     *drawing_area,
+		 GdkEventFocus *event,
+		 gpointer       data)
 {
   GtkColorSelection *colorsel = GTK_COLOR_SELECTION (data);
-  ColorSelectionPrivate *priv;
-
-  priv = colorsel->private;
-
+  ColorSelectionPrivate *priv = colorsel->private;
+  
+  /* This signal is connected to by all of the widgets except the "Set Color" button
+   * This will let you add a color to the currently selected palette
+   */
+  
   priv->last_palette = NULL;
 }
 
 
 static void
 make_label_spinbutton (GtkColorSelection *colorsel,
-		       GtkWidget **spinbutton,
-		       gchar *text,
-		       GtkWidget *table,
-		       gint i, gint j,
-		       gint channel_type)
+		       GtkWidget        **spinbutton,
+		       gchar             *text,
+		       GtkWidget         *table,
+		       gint               i,
+		       gint               j,
+		       gint               channel_type)
 {
   GtkWidget *label;
   GtkAdjustment *adjust;
-
+  
   if (channel_type == COLORSEL_HUE)
     {
       adjust = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 360.0, 1.0, 1.0, 1.0));
@@ -1176,15 +1191,18 @@ make_label_spinbutton (GtkColorSelection *colorsel,
   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
   gtk_table_attach_defaults (GTK_TABLE (table), label, i, i+1, j, j+1);
   gtk_table_attach_defaults (GTK_TABLE (table), *spinbutton, i+1, i+2, j, j+1);
-
+  
 }
 
 static void
-make_palette_frame (GtkColorSelection *colorsel, GtkWidget *table, gint i, gint j)
+make_palette_frame (GtkColorSelection *colorsel,
+		    GtkWidget         *table,
+		    gint               i,
+		    gint               j)
 {
   GtkWidget *frame;
   ColorSelectionPrivate *priv;
-
+  
   priv = colorsel->private;
   frame = gtk_frame_new (NULL);
   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
@@ -1201,9 +1219,10 @@ update_color (GtkColorSelection *colorsel)
   gchar entryval[12];
   gchar opacity_text[32];
   gchar *ptr;
+  
   priv->changing = TRUE;
   color_sample_draw_samples (colorsel);
-
+  
   gtk_hsv_set_color (GTK_HSV (priv->triangle_colorsel),
 		     priv->color[COLORSEL_HUE],
 		     priv->color[COLORSEL_SATURATION],
@@ -1229,15 +1248,15 @@ update_color (GtkColorSelection *colorsel)
   gtk_adjustment_set_value (gtk_range_get_adjustment
 			    (GTK_RANGE (priv->opacity_slider)),
 			    priv->color[COLORSEL_OPACITY] * 255);
-
+  
   g_snprintf (opacity_text, 32, "%.0f", priv->color[COLORSEL_OPACITY] * 255);
   gtk_entry_set_text (GTK_ENTRY (priv->opacity_entry), opacity_text);
-
+  
   g_snprintf (entryval, 11, "#%2X%2X%2X",
 	      (guint) (255 * priv->color[COLORSEL_RED]),
 	      (guint) (255 * priv->color[COLORSEL_GREEN]),
 	      (guint) (255 * priv->color[COLORSEL_BLUE]));
-
+  
   for (ptr = entryval; *ptr; ptr++)
     if (*ptr == ' ')
       *ptr = '0';
@@ -1246,36 +1265,42 @@ update_color (GtkColorSelection *colorsel)
 }
 
 static void
-add_button_pressed (GtkWidget *button, GtkColorSelection *colorsel)
+add_button_pressed (GtkWidget         *button,
+		    GtkColorSelection *colorsel)
 {
-  gint i, j;
   ColorSelectionPrivate *priv;
-
+  gint i, j;
+  
   priv = colorsel->private;
-
-  for (j = 0; j < CUSTOM_PALETTE_HEIGHT; j++)
+  
+  for (j = 0; j < GTK_CUSTOM_PALETTE_HEIGHT; j++)
     {
-      for (i = 0; i < CUSTOM_PALETTE_WIDTH; i++)
+      for (i = 0; i < GTK_CUSTOM_PALETTE_WIDTH; i++)
 	{
 	  /* Either last_palette is set and we're on it, or it's an empty palette */
 	  if ((priv->last_palette && priv->last_palette == priv->custom_palette[i][j]) ||
-	      ((priv->last_palette == NULL) && (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (priv->custom_palette[i][j]),
-										      "color_set")) == 0)))
+	      ((priv->last_palette == NULL) &&
+	       (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (priv->custom_palette[i][j]),
+						      "color_set")) == 0)))
 	    {
 	      palette_set_color (priv->custom_palette[i][j], colorsel, priv->color);
+
 	      /* forward the selection */
-	      if ((i == CUSTOM_PALETTE_WIDTH - 1) && (j == CUSTOM_PALETTE_HEIGHT - 1))
+	      if ((i == GTK_CUSTOM_PALETTE_WIDTH - 1) && (j == GTK_CUSTOM_PALETTE_HEIGHT - 1))
 		gtk_widget_grab_focus (priv->custom_palette[0][0]);
-	      else if (i == CUSTOM_PALETTE_WIDTH - 1)
+	      else if (i == GTK_CUSTOM_PALETTE_WIDTH - 1)
 		gtk_widget_grab_focus (priv->custom_palette[0][j + 1]);
 	      else
 		gtk_widget_grab_focus (priv->custom_palette[i + 1][j]);
+
 	      return;
 	    }
 	}
     }
+
   /* the palette is totally full.  Add to the first one totally arbitrarily */
   palette_set_color (priv->custom_palette[0][0], colorsel, priv->color);
+
   /* forward the selection */
   gtk_widget_grab_focus (priv->custom_palette[1][0]);
 }
@@ -1284,7 +1309,7 @@ GtkType
 gtk_color_selection_get_type (void)
 {
   static GtkType color_selection_type = 0;
-
+  
   if (!color_selection_type)
     {
       static const GtkTypeInfo color_selection_info =
@@ -1298,10 +1323,10 @@ gtk_color_selection_get_type (void)
         /* reserved_2 */ NULL,
         (GtkClassInitFunc) NULL,
       };
-
-      color_selection_type = gtk_type_unique (gtk_vbox_get_type (), &color_selection_info);
+      
+      color_selection_type = gtk_type_unique (GTK_TYPE_VBOX, &color_selection_info);
     }
-
+  
   return color_selection_type;
 }
 
@@ -1309,22 +1334,22 @@ static void
 gtk_color_selection_class_init (GtkColorSelectionClass *klass)
 {
   GtkObjectClass *object_class;
-
+  
   object_class = (GtkObjectClass*) klass;
-
-  parent_class = gtk_type_class (gtk_vbox_get_type ());
-
+  
+  parent_class = gtk_type_class (GTK_TYPE_VBOX);
+  
   color_selection_signals[COLOR_CHANGED] =
     gtk_signal_new ("color_changed",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkColorSelectionClass, color_changed),
                     gtk_marshal_NONE__NONE,
                     GTK_TYPE_NONE, 0);
-
-
+  
+  
   gtk_object_class_add_signals (object_class, color_selection_signals, LAST_SIGNAL);
-
+  
   object_class->destroy = gtk_color_selection_destroy;
 }
 
@@ -1342,53 +1367,51 @@ gtk_color_selection_init (GtkColorSelection *colorsel)
   GdkBitmap *mask = NULL;
   gint i, j;
   ColorSelectionPrivate *priv;
-
-  priv = colorsel->private = g_new (ColorSelectionPrivate, 1);
+  
+  priv = colorsel->private = g_new0 (ColorSelectionPrivate, 1);
   priv->changing = FALSE;
   priv->default_set = FALSE;
   priv->last_palette = NULL;
   priv->moving_dropper = FALSE;
-
+  
   gtk_box_set_spacing (GTK_BOX (colorsel), 4);
   top_hbox = gtk_hbox_new (FALSE, 8);
   gtk_box_pack_start (GTK_BOX (colorsel), top_hbox, FALSE, FALSE, 0);
-
+  
   vbox = gtk_vbox_new (FALSE, 4);
   priv->triangle_colorsel = gtk_hsv_new ();
   gtk_signal_connect (GTK_OBJECT (priv->triangle_colorsel), "changed", hsv_changed, colorsel);
   gtk_hsv_set_metrics (GTK_HSV (priv->triangle_colorsel), 174, 15);
   gtk_box_pack_start (GTK_BOX (top_hbox), vbox, FALSE, FALSE, 0);
   gtk_box_pack_start (GTK_BOX (vbox), priv->triangle_colorsel, FALSE, FALSE, 0);
-
+  
   hbox = gtk_hbox_new (FALSE, 4);
   gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
-
+  
   frame = gtk_frame_new (NULL);
   gtk_widget_set_usize (frame, -1, 30);
   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
   color_sample_new (colorsel);
   gtk_container_add (GTK_CONTAINER (frame), priv->sample_area);
   gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
-
+  
   button = gtk_button_new ();
   gtk_signal_connect (GTK_OBJECT (button), "focus_in_event", widget_focus_in, colorsel);
-  gtk_widget_set_events (button, GDK_POINTER_MOTION_MASK
-                                | GDK_POINTER_MOTION_HINT_MASK);
+  gtk_widget_set_events (button, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
   gtk_object_set_data (GTK_OBJECT (button), "COLORSEL", colorsel); 
   gtk_signal_connect (GTK_OBJECT (button), "clicked", get_screen_color, NULL);
   dropper_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL, gtk_widget_get_colormap (button), &mask, NULL, picker);
   dropper_image = gtk_pixmap_new (dropper_pixmap, mask);
   gtk_container_add (GTK_CONTAINER (button), dropper_image);
-  label = gtk_label_new (_("Color Picker"));
   gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
-
+  
   top_right_vbox = gtk_vbox_new (FALSE, 4);
   gtk_box_pack_start (GTK_BOX (top_hbox), top_right_vbox, FALSE, FALSE, 0);
   table = gtk_table_new (8, 6, FALSE);
   gtk_box_pack_start (GTK_BOX (top_right_vbox), table, FALSE, FALSE, 0);
   gtk_table_set_row_spacings (GTK_TABLE (table), 4);
   gtk_table_set_col_spacings (GTK_TABLE (table), 4);
-
+  
   make_label_spinbutton (colorsel, &priv->hue_spinbutton, _("Hue:"), table, 0, 0, COLORSEL_HUE);
   make_label_spinbutton (colorsel, &priv->sat_spinbutton, _("Saturation:"), table, 0, 1, COLORSEL_SATURATION);
   make_label_spinbutton (colorsel, &priv->val_spinbutton, _("Value:"), table, 0, 2, COLORSEL_VALUE);
@@ -1396,7 +1419,7 @@ gtk_color_selection_init (GtkColorSelection *colorsel)
   make_label_spinbutton (colorsel, &priv->green_spinbutton, _("Green:"), table, 6, 1, COLORSEL_GREEN);
   make_label_spinbutton (colorsel, &priv->blue_spinbutton, _("Blue:"), table, 6, 2, COLORSEL_BLUE);
   gtk_table_attach_defaults (GTK_TABLE (table), gtk_hseparator_new (), 0, 8, 3, 4); 
-
+  
   priv->opacity_label = gtk_label_new (_("Opacity:")); 
   gtk_misc_set_alignment (GTK_MISC (priv->opacity_label), 1.0, 0.5); 
   gtk_table_attach_defaults (GTK_TABLE (table), priv->opacity_label, 0, 1, 4, 5); 
@@ -1411,7 +1434,7 @@ gtk_color_selection_init (GtkColorSelection *colorsel)
   gtk_signal_connect (GTK_OBJECT (priv->opacity_entry), "focus_in_event", widget_focus_in, colorsel);
   gtk_signal_connect (GTK_OBJECT (priv->opacity_entry), "activate", opacity_entry_changed, colorsel);
   gtk_table_attach_defaults (GTK_TABLE (table), priv->opacity_entry, 7, 8, 4, 5);
-
+  
   label = gtk_label_new (_("Hex Value:"));
   gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 5, 6);
   gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
@@ -1420,14 +1443,14 @@ gtk_color_selection_init (GtkColorSelection *colorsel)
   gtk_widget_set_usize (priv->hex_entry, 75, -1);  
   gtk_table_set_col_spacing (GTK_TABLE (table), 3, 25);
   gtk_table_attach_defaults (GTK_TABLE (table), priv->hex_entry, 1, 5, 5, 6);
-
+  
   /* Set up the palette */
-  table = gtk_table_new (CUSTOM_PALETTE_HEIGHT, CUSTOM_PALETTE_WIDTH, TRUE);
+  table = gtk_table_new (GTK_CUSTOM_PALETTE_HEIGHT, GTK_CUSTOM_PALETTE_WIDTH, TRUE);
   gtk_table_set_row_spacings (GTK_TABLE (table), 1);
   gtk_table_set_col_spacings (GTK_TABLE (table), 1);
-  for (i = 0; i < CUSTOM_PALETTE_WIDTH; i++)
+  for (i = 0; i < GTK_CUSTOM_PALETTE_WIDTH; i++)
     {
-      for (j = 0; j < CUSTOM_PALETTE_HEIGHT; j++)
+      for (j = 0; j < GTK_CUSTOM_PALETTE_HEIGHT; j++)
 	{
 	  make_palette_frame (colorsel, table, i, j);
 	}
@@ -1441,16 +1464,16 @@ gtk_color_selection_init (GtkColorSelection *colorsel)
   gtk_signal_connect (GTK_OBJECT (button), "clicked", add_button_pressed, colorsel);
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
-
+  
   gtk_widget_show_all (top_hbox);
-
+  
   if (priv->use_opacity == FALSE)
     {
       gtk_widget_hide (priv->opacity_label);
       gtk_widget_hide (priv->opacity_slider);
       gtk_widget_hide (priv->opacity_entry);
     }
-
+  
   if (priv->use_palette == FALSE)
     {
       gtk_widget_hide (priv->palette_frame);
@@ -1460,7 +1483,15 @@ gtk_color_selection_init (GtkColorSelection *colorsel)
 static void
 gtk_color_selection_destroy (GtkObject *object)
 {
-  g_free (GTK_COLOR_SELECTION (object)->private);
+  GtkColorSelection *cselection = GTK_COLOR_SELECTION (object);
+  
+  if (cselection->private)
+    {
+      g_free (cselection->private);
+      cselection->private = NULL;
+    }
+  
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 
@@ -1483,28 +1514,28 @@ gtk_color_selection_new (void)
   color[1] = 1.0;
   color[2] = 1.0;
   color[3] = 1.0;
-
+  
   colorsel = gtk_type_new (GTK_TYPE_COLOR_SELECTION);
   priv = colorsel->private;
   gtk_color_selection_set_color (colorsel, color);
   gtk_color_selection_set_use_opacity (colorsel, FALSE);
-
+  
   /* We want to make sure that default_set is FALSE */
   /* This way the user can still set it */
   priv->default_set = FALSE;
-
+  
   return GTK_WIDGET (colorsel);
 }
 
 
 void
-gtk_color_selection_set_update_policy (GtkColorSelection    *colorsel,
-					GtkUpdateType          policy)
+gtk_color_selection_set_update_policy (GtkColorSelection *colorsel,
+				       GtkUpdateType      policy)
 {
   g_return_if_fail (colorsel != NULL);
   g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
   /* */
-  g_warning ("This function is deprecated.");
+  g_warning (G_STRLOC ": This function is deprecated.");
 }
 
 /**
@@ -1516,13 +1547,15 @@ gtk_color_selection_set_update_policy (GtkColorSelection    *colorsel,
  * Return value: TRUE if the @colorsel uses opacity.  FALSE if it does't.
  **/
 gboolean
-gtk_color_selection_get_use_opacity   (GtkColorSelection    *colorsel)
+gtk_color_selection_get_use_opacity (GtkColorSelection *colorsel)
 {
   ColorSelectionPrivate *priv;
+  
   g_return_val_if_fail (colorsel != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
-
+  
   priv = colorsel->private;
+  
   return priv->use_opacity;
 }
 
@@ -1535,31 +1568,34 @@ gtk_color_selection_get_use_opacity   (GtkColorSelection    *colorsel)
  * 
  **/
 void
-gtk_color_selection_set_use_opacity   (GtkColorSelection    *colorsel,
-					gboolean               use_opacity)
+gtk_color_selection_set_use_opacity (GtkColorSelection *colorsel,
+				     gboolean           use_opacity)
 {
   ColorSelectionPrivate *priv;
+  
   g_return_if_fail (colorsel != NULL);
   g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+  
   priv = colorsel->private;
-  if (priv->use_opacity == use_opacity)
-    return;
-
-  priv->use_opacity = use_opacity;
-  if (use_opacity)
-    {
-      gtk_widget_show (priv->opacity_slider);
-      gtk_widget_show (priv->opacity_label);
-      gtk_widget_show (priv->opacity_entry);
-    }
-  else
+  use_opacity = use_opacity != FALSE;
+  
+  if (priv->use_opacity != use_opacity)
     {
-      gtk_widget_hide (priv->opacity_slider);
-      gtk_widget_hide (priv->opacity_label);
-      gtk_widget_hide (priv->opacity_entry);
+      priv->use_opacity = use_opacity;
+      if (use_opacity)
+	{
+	  gtk_widget_show (priv->opacity_slider);
+	  gtk_widget_show (priv->opacity_label);
+	  gtk_widget_show (priv->opacity_entry);
+	}
+      else
+	{
+	  gtk_widget_hide (priv->opacity_slider);
+	  gtk_widget_hide (priv->opacity_label);
+	  gtk_widget_hide (priv->opacity_entry);
+	}
+      color_sample_draw_samples (colorsel);
     }
-  color_sample_set_use_opacity (colorsel);
 }
 
 /**
@@ -1571,13 +1607,14 @@ gtk_color_selection_set_use_opacity   (GtkColorSelection    *colorsel,
  * Return value: TRUE if the palette is used.  FALSE if it isn't.
  **/
 gboolean
-gtk_color_selection_get_use_palette   (GtkColorSelection    *colorsel)
+gtk_color_selection_get_use_palette (GtkColorSelection *colorsel)
 {
   ColorSelectionPrivate *priv;
-  g_return_val_if_fail (colorsel != NULL, FALSE);
+  
   g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
-
+  
   priv = colorsel->private;
+  
   return priv->use_palette;
 }
 
@@ -1590,22 +1627,24 @@ gtk_color_selection_get_use_palette   (GtkColorSelection    *colorsel)
  * 
  **/
 void
-gtk_color_selection_set_use_palette   (GtkColorSelection    *colorsel,
-					gboolean               use_palette)
+gtk_color_selection_set_use_palette (GtkColorSelection *colorsel,
+				     gboolean           use_palette)
 {
   ColorSelectionPrivate *priv;
   g_return_if_fail (colorsel != NULL);
   g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+  
   priv = colorsel->private;
-  if (priv->use_palette == use_palette)
-    return;
-
-  priv->use_palette = use_palette;
-  if (use_palette)
-    gtk_widget_show (priv->palette_frame);
-  else
-    gtk_widget_hide (priv->palette_frame);
+  use_palette = use_palette != FALSE;
+  
+  if (priv->use_palette != use_palette)
+    {
+      priv->use_palette = use_palette;
+      if (use_palette)
+	gtk_widget_show (priv->palette_frame);
+      else
+	gtk_widget_hide (priv->palette_frame);
+    }
 }
 
 /**
@@ -1618,15 +1657,15 @@ gtk_color_selection_set_use_palette   (GtkColorSelection    *colorsel,
  * 
  **/
 void
-gtk_color_selection_set_color         (GtkColorSelection    *colorsel,
-					gdouble               *color)
+gtk_color_selection_set_color (GtkColorSelection    *colorsel,
+			       gdouble              *color)
 {
   ColorSelectionPrivate *priv;
   gint i;
-
+  
   g_return_if_fail (colorsel != NULL);
   g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+  
   priv = colorsel->private;
   priv->changing = TRUE;
   priv->color[COLORSEL_RED] = color[0];
@@ -1657,14 +1696,14 @@ gtk_color_selection_set_color         (GtkColorSelection    *colorsel,
  * 
  **/
 void
-gtk_color_selection_get_color         (GtkColorSelection    *colorsel,
-					gdouble               *color)
+gtk_color_selection_get_color (GtkColorSelection *colorsel,
+			       gdouble           *color)
 {
   ColorSelectionPrivate *priv;
-
+  
   g_return_if_fail (colorsel != NULL);
   g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+  
   priv = colorsel->private;
   color[0] = priv->color[COLORSEL_RED];
   color[1] = priv->color[COLORSEL_GREEN];
@@ -1684,14 +1723,14 @@ gtk_color_selection_get_color         (GtkColorSelection    *colorsel,
  * 
  **/
 void
-gtk_color_selection_set_old_color (GtkColorSelection    *colorsel,
-				    gdouble               *color)
+gtk_color_selection_set_old_color (GtkColorSelection *colorsel,
+				   gdouble          *color)
 {
   ColorSelectionPrivate *priv;
-
+  
   g_return_if_fail (colorsel != NULL);
   g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+  
   priv = colorsel->private;
   priv->changing = TRUE;
   priv->old_color[COLORSEL_RED] = color[0];
@@ -1717,14 +1756,14 @@ gtk_color_selection_set_old_color (GtkColorSelection    *colorsel,
  * 
  **/
 void
-gtk_color_selection_get_old_color (GtkColorSelection    *colorsel,
-				    gdouble               *color)
+gtk_color_selection_get_old_color (GtkColorSelection *colorsel,
+				   gdouble           *color)
 {
   ColorSelectionPrivate *priv;
-
+  
   g_return_if_fail (colorsel != NULL);
   g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-
+  
   priv = colorsel->private;
   color[0] = priv->old_color[COLORSEL_RED];
   color[1] = priv->old_color[COLORSEL_GREEN];
@@ -1744,16 +1783,16 @@ gtk_color_selection_get_old_color (GtkColorSelection    *colorsel,
  **/
 void
 gtk_color_selection_set_palette_color (GtkColorSelection   *colorsel,
-					gint                  x,
-					gint                  y,
-					gdouble              *color)
+				       gint                 x,
+				       gint                 y,
+				       gdouble             *color)
 {
   ColorSelectionPrivate *priv;
-
+  
   g_return_if_fail (colorsel != NULL);
   g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-  g_return_if_fail (x >= 0 && y >= 0 && x < CUSTOM_PALETTE_WIDTH && y < CUSTOM_PALETTE_HEIGHT);
-
+  g_return_if_fail (x >= 0 && y >= 0 && x < GTK_CUSTOM_PALETTE_WIDTH && y < GTK_CUSTOM_PALETTE_HEIGHT);
+  
   priv = colorsel->private;
   palette_set_color (priv->custom_palette[x][y], colorsel, color);
 }
@@ -1773,21 +1812,21 @@ gtk_color_selection_set_palette_color (GtkColorSelection   *colorsel,
  **/
 gboolean
 gtk_color_selection_get_palette_color (GtkColorSelection   *colorsel,
-					gint                  x,
-					gint                  y,
-					gdouble              *color)
+				       gint                 x,
+				       gint                 y,
+				       gdouble             *color)
 {
   ColorSelectionPrivate *priv;
-
+  
   g_return_val_if_fail (colorsel != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
-  g_return_val_if_fail (x >= 0 && y >= 0 && x < CUSTOM_PALETTE_WIDTH && y < CUSTOM_PALETTE_HEIGHT, FALSE);
-
+  g_return_val_if_fail (x >= 0 && y >= 0 && x < GTK_CUSTOM_PALETTE_WIDTH && y < GTK_CUSTOM_PALETTE_HEIGHT, FALSE);
+  
   priv = colorsel->private;
-
+  
   if (GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (priv->custom_palette[x][y]), "color_set")) == 0)
     return FALSE;
-
+  
   palette_get_color (priv->custom_palette[x][y], color);
   return TRUE;
 }
@@ -1803,15 +1842,15 @@ gtk_color_selection_get_palette_color (GtkColorSelection   *colorsel,
  **/
 void
 gtk_color_selection_unset_palette_color (GtkColorSelection   *colorsel,
-					  gint                  x,
-					  gint                  y)
+					 gint                 x,
+					 gint                 y)
 {
   ColorSelectionPrivate *priv;
-
+  
   g_return_if_fail (colorsel != NULL);
   g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
-  g_return_if_fail (x >= 0 && y >= 0 && x < CUSTOM_PALETTE_WIDTH && y < CUSTOM_PALETTE_HEIGHT);
-
+  g_return_if_fail (x >= 0 && y >= 0 && x < GTK_CUSTOM_PALETTE_WIDTH && y < GTK_CUSTOM_PALETTE_HEIGHT);
+  
   priv = colorsel->private;
   palette_unset_color (priv->custom_palette[x][y]);
 }
@@ -1826,14 +1865,14 @@ gtk_color_selection_unset_palette_color (GtkColorSelection   *colorsel,
  * if the selection has stopped.
  **/
 gboolean
-gtk_color_selection_is_adjusting (GtkColorSelection    *colorsel)
+gtk_color_selection_is_adjusting (GtkColorSelection *colorsel)
 {
   ColorSelectionPrivate *priv;
-
+  
   g_return_val_if_fail (colorsel != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_COLOR_SELECTION (colorsel), FALSE);
   
   priv = colorsel->private;
-
+  
   return (gtk_hsv_is_adjusting (GTK_HSV (priv->triangle_colorsel)));
 }
diff --git a/gtk/gtkcolorsel.h b/gtk/gtkcolorsel.h
index 56f11bd80..00104463f 100644
--- a/gtk/gtkcolorsel.h
+++ b/gtk/gtkcolorsel.h
@@ -34,6 +34,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+
 #define GTK_TYPE_COLOR_SELECTION			(gtk_color_selection_get_type ())
 #define GTK_COLOR_SELECTION(obj)			(GTK_CHECK_CAST ((obj), GTK_TYPE_COLOR_SELECTION, GtkColorSelection))
 #define GTK_COLOR_SELECTION_CLASS(klass)		(GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_SELECTION, GtkColorSelectionClass))
@@ -43,8 +44,8 @@ extern "C" {
 
 
 /* Number of elements in the custom palatte */
-#define CUSTOM_PALETTE_WIDTH 10
-#define CUSTOM_PALETTE_HEIGHT 2
+#define GTK_CUSTOM_PALETTE_WIDTH 10
+#define GTK_CUSTOM_PALETTE_HEIGHT 2
 
 typedef struct _GtkColorSelection       GtkColorSelection;
 typedef struct _GtkColorSelectionClass  GtkColorSelectionClass;
@@ -52,7 +53,7 @@ typedef struct _GtkColorSelectionClass  GtkColorSelectionClass;
 
 struct _GtkColorSelection
 {
-  GtkVBox parent;
+  GtkVBox parent_instance;
 
   /* < private > */
   gpointer private;
@@ -68,16 +69,16 @@ struct _GtkColorSelectionClass
 
 /* ColorSelection */ 
 
-GtkType    gtk_color_selection_get_type          (void);
-GtkWidget *gtk_color_selection_new               (void);
-void       gtk_color_selection_set_update_policy (GtkColorSelection *colorsel,
-						  GtkUpdateType      policy);
-gboolean   gtk_color_selection_get_use_opacity   (GtkColorSelection *colorsel);
-void       gtk_color_selection_set_use_opacity   (GtkColorSelection *colorsel,
-						  gboolean           use_opacity);
-gboolean   gtk_color_selection_get_use_palette   (GtkColorSelection *colorsel);
-void       gtk_color_selection_set_use_palette   (GtkColorSelection *colorsel,
-						  gboolean           use_palette);
+GtkType     gtk_color_selection_get_type          (void);
+GtkWidget * gtk_color_selection_new               (void);
+void        gtk_color_selection_set_update_policy (GtkColorSelection *colorsel,
+						   GtkUpdateType      policy);
+gboolean    gtk_color_selection_get_use_opacity   (GtkColorSelection *colorsel);
+void        gtk_color_selection_set_use_opacity   (GtkColorSelection *colorsel,
+						   gboolean           use_opacity);
+gboolean    gtk_color_selection_get_use_palette   (GtkColorSelection *colorsel);
+void        gtk_color_selection_set_use_palette   (GtkColorSelection *colorsel,
+						   gboolean           use_palette);
 
 /* The Color set is an array of doubles, of the following format:
  * color[0] = red_channel;
@@ -85,26 +86,26 @@ void       gtk_color_selection_set_use_palette   (GtkColorSelection *colorsel,
  * color[2] = blue_channel;
  * color[3] = alpha_channel;
  */
-void       gtk_color_selection_set_color          (GtkColorSelection    *colorsel,
+void       gtk_color_selection_set_color           (GtkColorSelection    *colorsel,
 						    gdouble               *color);
-void       gtk_color_selection_get_color          (GtkColorSelection    *colorsel,
+void       gtk_color_selection_get_color           (GtkColorSelection    *colorsel,
 						    gdouble               *color);
-void       gtk_color_selection_set_old_color      (GtkColorSelection    *colorsel,
+void       gtk_color_selection_set_old_color       (GtkColorSelection    *colorsel,
 						    gdouble               *color);
-void       gtk_color_selection_get_old_color      (GtkColorSelection    *colorsel,
+void       gtk_color_selection_get_old_color       (GtkColorSelection    *colorsel,
 						    gdouble               *color);
-void       gtk_color_selection_set_palette_color  (GtkColorSelection   *colorsel,
-					 	    gint                  x,
+void       gtk_color_selection_set_palette_color   (GtkColorSelection   *colorsel,
+						    gint                  x,
 						    gint                  y,
 						    gdouble              *color);
-gboolean   gtk_color_selection_get_palette_color  (GtkColorSelection   *colorsel,
+gboolean   gtk_color_selection_get_palette_color   (GtkColorSelection   *colorsel,
 						    gint                  x,
 						    gint                  y,
 						    gdouble              *color);
-void       gtk_color_selection_unset_palette_color(GtkColorSelection   *colorsel,
+void       gtk_color_selection_unset_palette_color (GtkColorSelection   *colorsel,
 						    gint                  x,
 						    gint                  y);
-gboolean   gtk_color_selection_is_adjusting       (GtkColorSelection    *colorsel);
+gboolean   gtk_color_selection_is_adjusting        (GtkColorSelection    *colorsel);
 
 
 #ifdef __cplusplus
diff --git a/gtk/gtkcolorseldialog.c b/gtk/gtkcolorseldialog.c
index c884ca96d..4c32b7b21 100644
--- a/gtk/gtkcolorseldialog.c
+++ b/gtk/gtkcolorseldialog.c
@@ -44,7 +44,7 @@ GtkType
 gtk_color_selection_dialog_get_type (void)
 {
   static GtkType color_selection_dialog_type = 0;
-
+  
   if (!color_selection_dialog_type)
     {
       GtkTypeInfo colorsel_diag_info =
@@ -58,10 +58,10 @@ gtk_color_selection_dialog_get_type (void)
 	/* reserved_2 */ NULL,
         (GtkClassInitFunc) NULL,
       };
-
+      
       color_selection_dialog_type = gtk_type_unique (GTK_TYPE_DIALOG, &colorsel_diag_info);
     }
-
+  
   return color_selection_dialog_type;
 }
 
@@ -69,9 +69,9 @@ static void
 gtk_color_selection_dialog_class_init (GtkColorSelectionDialogClass *klass)
 {
   GtkObjectClass *object_class;
-
+  
   object_class = (GtkObjectClass*) klass;
-
+  
   color_selection_dialog_parent_class = gtk_type_class (GTK_TYPE_DIALOG);
 }
 
@@ -79,47 +79,47 @@ static void
 gtk_color_selection_dialog_init (GtkColorSelectionDialog *colorseldiag)
 {
   GtkWidget *action_area_button_box, *frame;
-
+  
   gtk_widget_set_visual (GTK_WIDGET (colorseldiag), gdk_rgb_get_visual ());
   gtk_widget_set_colormap (GTK_WIDGET (colorseldiag), gdk_rgb_get_cmap ());
-
+  
   gtk_widget_push_visual (gdk_rgb_get_visual ());
   gtk_widget_push_colormap (gdk_rgb_get_cmap ());
-
+  
   frame = gtk_frame_new (NULL);
   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (colorseldiag)->vbox), frame);
   gtk_container_set_border_width (GTK_CONTAINER (frame), 10); 
   gtk_widget_show (frame); 
-
+  
   colorseldiag->colorsel = gtk_color_selection_new ();
   gtk_color_selection_set_use_palette (GTK_COLOR_SELECTION(colorseldiag->colorsel), FALSE); 
   gtk_color_selection_set_use_opacity (GTK_COLOR_SELECTION(colorseldiag->colorsel), FALSE);
   gtk_container_add (GTK_CONTAINER (frame), colorseldiag->colorsel);
   gtk_widget_show (colorseldiag->colorsel);
-
+  
   action_area_button_box = gtk_hbutton_box_new ();
   gtk_button_box_set_layout (GTK_BUTTON_BOX(action_area_button_box), GTK_BUTTONBOX_END);
   gtk_button_box_set_spacing (GTK_BUTTON_BOX(action_area_button_box), 5);
   gtk_box_pack_end (GTK_BOX (GTK_DIALOG (colorseldiag)->action_area), action_area_button_box, TRUE, TRUE, 0);
   gtk_widget_show (action_area_button_box);
-
+  
   colorseldiag->ok_button = gtk_button_new_with_label (_("OK"));
   GTK_WIDGET_SET_FLAGS (colorseldiag->ok_button, GTK_CAN_DEFAULT);
   gtk_box_pack_start (GTK_BOX (action_area_button_box), colorseldiag->ok_button, TRUE, TRUE, 0);
   gtk_widget_grab_default (colorseldiag->ok_button);
   gtk_widget_show (colorseldiag->ok_button);
-
+  
   colorseldiag->cancel_button = gtk_button_new_with_label (_("Cancel"));
   GTK_WIDGET_SET_FLAGS (colorseldiag->cancel_button, GTK_CAN_DEFAULT);
   gtk_box_pack_start (GTK_BOX (action_area_button_box), colorseldiag->cancel_button, TRUE, TRUE, 0);
   gtk_widget_show (colorseldiag->cancel_button);
-
+  
   colorseldiag->help_button = gtk_button_new_with_label (_("Help"));
   GTK_WIDGET_SET_FLAGS (colorseldiag->help_button, GTK_CAN_DEFAULT);
   gtk_box_pack_start (GTK_BOX (action_area_button_box), colorseldiag->help_button, TRUE, TRUE, 0);
   gtk_widget_show (colorseldiag->help_button);
-
+  
   gtk_widget_pop_colormap ();
   gtk_widget_pop_visual ();
 }
@@ -128,11 +128,10 @@ GtkWidget*
 gtk_color_selection_dialog_new (const gchar *title)
 {
   GtkColorSelectionDialog *colorseldiag;
-
+  
   colorseldiag = gtk_type_new (GTK_TYPE_COLOR_SELECTION_DIALOG);
   gtk_window_set_title (GTK_WINDOW (colorseldiag), title);
   gtk_window_set_policy(GTK_WINDOW (colorseldiag), FALSE, FALSE, TRUE);
-
+  
   return GTK_WIDGET (colorseldiag);
 }
-
diff --git a/gtk/gtkcolorseldialog.h b/gtk/gtkcolorseldialog.h
index ba6530cc2..ac065c906 100644
--- a/gtk/gtkcolorseldialog.h
+++ b/gtk/gtkcolorseldialog.h
@@ -29,7 +29,7 @@
 #include <gtk/gtkdialog.h>
 #include <gtk/gtkcolorsel.h>
 #include <gtk/gtkvbox.h>
-#include "gtkintl.h"
+#include <gtk/gtkintl.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -49,7 +49,7 @@ typedef struct _GtkColorSelectionDialogClass  GtkColorSelectionDialogClass;
 
 struct _GtkColorSelectionDialog
 {
-  GtkDialog dialog;
+  GtkDialog parent_instance;
 
   GtkWidget *colorsel;
   GtkWidget *ok_button;
@@ -64,8 +64,8 @@ struct _GtkColorSelectionDialogClass
 
 
 /* ColorSelectionDialog */ 
-GtkType    gtk_color_selection_dialog_get_type    (void); 
-GtkWidget* gtk_color_selection_dialog_new         (const gchar *title); 
+GtkType    gtk_color_selection_dialog_get_type (void); 
+GtkWidget* gtk_color_selection_dialog_new      (const gchar *title); 
 
 
 #ifdef __cplusplus
diff --git a/gtk/gtkcombo.c b/gtk/gtkcombo.c
index 33cb37669..fc0f267b0 100644
--- a/gtk/gtkcombo.c
+++ b/gtk/gtkcombo.c
@@ -110,13 +110,18 @@ gtk_combo_class_init (GtkComboClass * klass)
 }
 
 static void
-gtk_combo_destroy (GtkObject * combo)
+gtk_combo_destroy (GtkObject *object)
 {
-  gtk_widget_destroy (GTK_COMBO (combo)->popwin);
-  gtk_widget_unref (GTK_COMBO (combo)->popwin);
+  GtkCombo *combo = GTK_COMBO (object);
 
-  if (GTK_OBJECT_CLASS (parent_class)->destroy)
-    (*GTK_OBJECT_CLASS (parent_class)->destroy) (combo);
+  if (combo->popwin)
+    {
+      gtk_widget_destroy (combo->popwin);
+      gtk_widget_unref (combo->popwin);
+      combo->popwin = NULL;
+    }
+
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 static int
@@ -340,9 +345,8 @@ gtk_combo_get_pos (GtkCombo * combo, gint * x, gint * y, gint * height, gint * w
       if (!show_hscroll &&
 	  alloc_width < list_requisition.width)
 	{
-	  work_height += popup->hscrollbar->requisition.height +
-	    GTK_SCROLLED_WINDOW_CLASS 
-	    (GTK_OBJECT (combo->popup)->klass)->scrollbar_spacing;
+	  work_height += (popup->hscrollbar->requisition.height +
+			  GTK_SCROLLED_WINDOW_GET_CLASS (combo->popup)->scrollbar_spacing);
 	  show_hscroll = TRUE;
 	}
       if (!show_vscroll && 
@@ -354,10 +358,8 @@ gtk_combo_get_pos (GtkCombo * combo, gint * x, gint * y, gint * height, gint * w
 	      *y -= (work_height + list_requisition.height + real_height);
 	      break;
 	    }
-	  alloc_width -= 
-	    popup->vscrollbar->requisition.width +
-	    GTK_SCROLLED_WINDOW_CLASS 
-	    (GTK_OBJECT (combo->popup)->klass)->scrollbar_spacing;
+	  alloc_width -= (popup->vscrollbar->requisition.width +
+			  GTK_SCROLLED_WINDOW_GET_CLASS (combo->popup)->scrollbar_spacing);
 	  show_vscroll = TRUE;
 	}
     } while (old_width != alloc_width || old_height != work_height);
@@ -834,7 +836,10 @@ gtk_combo_item_destroy (GtkObject * object)
 
   key = gtk_object_get_data (object, gtk_combo_string_key);
   if (key)
-    g_free (key);
+    {
+      gtk_object_remove_data (object, gtk_combo_string_key);
+      g_free (key);
+    }
 }
 
 void
diff --git a/gtk/gtkcontainer.c b/gtk/gtkcontainer.c
index 5e3fbd149..ec2eca973 100644
--- a/gtk/gtkcontainer.c
+++ b/gtk/gtkcontainer.c
@@ -173,7 +173,7 @@ gtk_container_class_init (GtkContainerClass *class)
   container_signals[ADD] =
     gtk_signal_new ("add",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkContainerClass, add),
                     gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -181,7 +181,7 @@ gtk_container_class_init (GtkContainerClass *class)
   container_signals[REMOVE] =
     gtk_signal_new ("remove",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkContainerClass, remove),
                     gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -189,14 +189,14 @@ gtk_container_class_init (GtkContainerClass *class)
   container_signals[CHECK_RESIZE] =
     gtk_signal_new ("check_resize",
                     GTK_RUN_LAST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkContainerClass, check_resize),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   container_signals[FOCUS] =
     gtk_signal_new ("focus",
                     GTK_RUN_LAST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkContainerClass, focus),
                     gtk_marshal_ENUM__ENUM,
 		    GTK_TYPE_DIRECTION_TYPE, 1,
@@ -204,7 +204,7 @@ gtk_container_class_init (GtkContainerClass *class)
   container_signals[SET_FOCUS_CHILD] =
     gtk_signal_new ("set-focus-child",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkContainerClass, set_focus_child),
                     gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -237,7 +237,7 @@ gtk_container_child_type (GtkContainer      *container)
   g_return_val_if_fail (container != NULL, 0);
   g_return_val_if_fail (GTK_IS_CONTAINER (container), 0);
 
-  class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
+  class = GTK_CONTAINER_GET_CLASS (container);
   if (class->child_type)
     slot = class->child_type (container);
   else
@@ -1104,7 +1104,7 @@ gtk_container_forall (GtkContainer *container,
   g_return_if_fail (GTK_IS_CONTAINER (container));
   g_return_if_fail (callback != NULL);
 
-  class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
+  class = GTK_CONTAINER_GET_CLASS (container);
 
   if (class->forall)
     class->forall (container, TRUE, callback, callback_data);
@@ -1121,7 +1121,7 @@ gtk_container_foreach (GtkContainer *container,
   g_return_if_fail (GTK_IS_CONTAINER (container));
   g_return_if_fail (callback != NULL);
 
-  class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
+  class = GTK_CONTAINER_GET_CLASS (container);
 
   if (class->forall)
     class->forall (container, FALSE, callback, callback_data);
@@ -1144,8 +1144,8 @@ gtk_container_foreach_unmarshal (GtkWidget *child,
   
   /* first argument */
   args[0].name = NULL;
-  args[0].type = GTK_OBJECT(child)->klass->type;
-  GTK_VALUE_OBJECT(args[0]) = GTK_OBJECT (child);
+  args[0].type = GTK_OBJECT_TYPE (child);
+  GTK_VALUE_OBJECT (args[0]) = GTK_OBJECT (child);
   
   /* location for return value */
   args[1].name = NULL;
@@ -1227,42 +1227,6 @@ gtk_container_children (GtkContainer *container)
   return g_list_reverse (children);
 }
 
-void
-gtk_container_register_toplevel (GtkContainer *container)
-{
-  g_return_if_fail (container != NULL);
-  
-  toplevel_list = g_list_prepend (toplevel_list, container);
-  
-  gtk_widget_ref (GTK_WIDGET (container));
-  gtk_object_sink (GTK_OBJECT (container));
-}
-
-void
-gtk_container_unregister_toplevel (GtkContainer *container)
-{
-  GList *node;
-
-  g_return_if_fail (container != NULL);
-
-  node = g_list_find (toplevel_list, container);
-  g_return_if_fail (node != NULL);
-
-  toplevel_list = g_list_remove_link (toplevel_list, node);
-  g_list_free_1 (node);
-
-  gtk_widget_unref (GTK_WIDGET (container));
-}
-
-GList*
-gtk_container_get_toplevels (void)
-{
-  /* XXX: fixme we should ref all these widgets and duplicate
-   * the list.
-   */
-  return toplevel_list;
-}
-
 static void
 gtk_container_child_position_callback (GtkWidget *widget,
 				       gpointer   client_data)
@@ -1327,7 +1291,7 @@ gtk_container_child_composite_name (GtkContainer *container,
 	{
 	  GtkContainerClass *class;
 
-	  class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
+	  class = GTK_CONTAINER_GET_CLASS (container);
 	  if (class->composite_name)
 	    name = class->composite_name (container, child);
 	}
diff --git a/gtk/gtkcontainer.h b/gtk/gtkcontainer.h
index f3e1de358..89e8c36e3 100644
--- a/gtk/gtkcontainer.h
+++ b/gtk/gtkcontainer.h
@@ -141,9 +141,6 @@ void   gtk_container_set_focus_vadjustment (GtkContainer     *container,
 					    GtkAdjustment    *adjustment);
 void   gtk_container_set_focus_hadjustment (GtkContainer     *container,
 					    GtkAdjustment    *adjustment);
-void    gtk_container_register_toplevel	   (GtkContainer     *container);
-void    gtk_container_unregister_toplevel  (GtkContainer     *container);
-GList*  gtk_container_get_toplevels        (void);
 
 void    gtk_container_resize_children      (GtkContainer     *container);
 
diff --git a/gtk/gtkctree.c b/gtk/gtkctree.c
index 8532317b0..79ebafed3 100644
--- a/gtk/gtkctree.c
+++ b/gtk/gtkctree.c
@@ -56,26 +56,25 @@ COLUMN_FROM_XPIXEL (GtkCList * clist,
 		    gint x)
 {
   gint i, cx;
-
+  
   for (i = 0; i < clist->columns; i++)
     if (clist->column[i].visible)
       {
 	cx = clist->column[i].area.x + clist->hoffset;
-
+	
 	if (x >= (cx - (COLUMN_INSET + CELL_SPACING)) &&
 	    x <= (cx + clist->column[i].area.width + COLUMN_INSET))
 	  return i;
       }
-
+  
   /* no match */
   return -1;
 }
 
-#define GTK_CLIST_CLASS_FW(_widget_) GTK_CLIST_CLASS (((GtkObject*) (_widget_))->klass)
 #define CLIST_UNFROZEN(clist)     (((GtkCList*) (clist))->freeze_count == 0)
 #define CLIST_REFRESH(clist)    G_STMT_START { \
   if (CLIST_UNFROZEN (clist)) \
-    GTK_CLIST_CLASS_FW (clist)->refresh ((GtkCList*) (clist)); \
+    GTK_CLIST_GET_CLASS (clist)->refresh ((GtkCList*) (clist)); \
 } G_STMT_END
 
 
@@ -319,7 +318,7 @@ GtkType
 gtk_ctree_get_type (void)
 {
   static GtkType ctree_type = 0;
-
+  
   if (!ctree_type)
     {
       static const GtkTypeInfo ctree_info =
@@ -333,10 +332,10 @@ gtk_ctree_get_type (void)
         /* reserved_2 */ NULL,
         (GtkClassInitFunc) NULL,
       };
-
+      
       ctree_type = gtk_type_unique (GTK_TYPE_CLIST, &ctree_info);
     }
-
+  
   return ctree_type;
 }
 
@@ -347,15 +346,15 @@ gtk_ctree_class_init (GtkCTreeClass *klass)
   GtkWidgetClass *widget_class;
   GtkCListClass *clist_class;
   GtkBindingSet *binding_set;
-
+  
   object_class = (GtkObjectClass *) klass;
   widget_class = (GtkWidgetClass *) klass;
   container_class = (GtkContainerClass *) klass;
   clist_class = (GtkCListClass *) klass;
-
+  
   parent_class = gtk_type_class (GTK_TYPE_CLIST);
   container_class = gtk_type_class (GTK_TYPE_CONTAINER);
-
+  
   gtk_object_add_arg_type ("GtkCTree::n_columns",
 			   GTK_TYPE_UINT,
 			   GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT_ONLY,
@@ -386,39 +385,39 @@ gtk_ctree_class_init (GtkCTreeClass *klass)
 			   ARG_EXPANDER_STYLE);
   object_class->set_arg = gtk_ctree_set_arg;
   object_class->get_arg = gtk_ctree_get_arg;
-
+  
   ctree_signals[TREE_SELECT_ROW] =
     gtk_signal_new ("tree_select_row",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_select_row),
 		    gtk_marshal_NONE__POINTER_INT,
 		    GTK_TYPE_NONE, 2, GTK_TYPE_CTREE_NODE, GTK_TYPE_INT);
   ctree_signals[TREE_UNSELECT_ROW] =
     gtk_signal_new ("tree_unselect_row",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_unselect_row),
 		    gtk_marshal_NONE__POINTER_INT,
 		    GTK_TYPE_NONE, 2, GTK_TYPE_CTREE_NODE, GTK_TYPE_INT);
   ctree_signals[TREE_EXPAND] =
     gtk_signal_new ("tree_expand",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_expand),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1, GTK_TYPE_CTREE_NODE);
   ctree_signals[TREE_COLLAPSE] =
     gtk_signal_new ("tree_collapse",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_collapse),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1, GTK_TYPE_CTREE_NODE);
   ctree_signals[TREE_MOVE] =
     gtk_signal_new ("tree_move",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCTreeClass, tree_move),
 		    gtk_marshal_NONE__POINTER_POINTER_POINTER,
 		    GTK_TYPE_NONE, 3, GTK_TYPE_CTREE_NODE,
@@ -426,21 +425,21 @@ gtk_ctree_class_init (GtkCTreeClass *klass)
   ctree_signals[CHANGE_FOCUS_ROW_EXPANSION] =
     gtk_signal_new ("change_focus_row_expansion",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCTreeClass,
 				       change_focus_row_expansion),
 		    gtk_marshal_NONE__ENUM,
 		    GTK_TYPE_NONE, 1, GTK_TYPE_CTREE_EXPANSION_TYPE);
   gtk_object_class_add_signals (object_class, ctree_signals, LAST_SIGNAL);
-
+  
   widget_class->realize = gtk_ctree_realize;
   widget_class->unrealize = gtk_ctree_unrealize;
   widget_class->button_press_event = gtk_ctree_button_press;
-
+  
   widget_class->drag_begin = gtk_ctree_drag_begin;
   widget_class->drag_motion = gtk_ctree_drag_motion;
   widget_class->drag_data_received = gtk_ctree_drag_data_received;
-
+  
   clist_class->select_row = real_select_row;
   clist_class->unselect_row = real_unselect_row;
   clist_class->row_move = real_row_move;
@@ -459,14 +458,14 @@ gtk_ctree_class_init (GtkCTreeClass *klass)
   clist_class->sort_list = real_sort_list;
   clist_class->set_cell_contents = set_cell_contents;
   clist_class->cell_size_request = cell_size_request;
-
+  
   klass->tree_select_row = real_tree_select;
   klass->tree_unselect_row = real_tree_unselect;
   klass->tree_expand = real_tree_expand;
   klass->tree_collapse = real_tree_collapse;
   klass->tree_move = real_tree_move;
   klass->change_focus_row_expansion = change_focus_row_expansion;
-
+  
   binding_set = gtk_binding_set_by_class (klass);
   gtk_binding_entry_add_signal (binding_set,
 				'+', GDK_SHIFT_MASK,
@@ -515,9 +514,9 @@ gtk_ctree_set_arg (GtkObject      *object,
 		   guint           arg_id)
 {
   GtkCTree *ctree;
-
+  
   ctree = GTK_CTREE (object);
-
+  
   switch (arg_id)
     {
     case ARG_N_COLUMNS: /* construct-only arg, only set when !GTK_CONSTRUCTED */
@@ -563,9 +562,9 @@ gtk_ctree_get_arg (GtkObject      *object,
 		   guint           arg_id)
 {
   GtkCTree *ctree;
-
+  
   ctree = GTK_CTREE (object);
-
+  
   switch (arg_id)
     {
     case ARG_N_COLUMNS:
@@ -599,12 +598,12 @@ static void
 gtk_ctree_init (GtkCTree *ctree)
 {
   GtkCList *clist;
-
+  
   GTK_CLIST_SET_FLAG (ctree, CLIST_DRAW_DRAG_RECT);
   GTK_CLIST_SET_FLAG (ctree, CLIST_DRAW_DRAG_LINE);
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   ctree->tree_indent    = 20;
   ctree->tree_spacing   = 5;
   ctree->tree_column    = 0;
@@ -612,7 +611,7 @@ gtk_ctree_init (GtkCTree *ctree)
   ctree->expander_style = GTK_CTREE_EXPANDER_SQUARE;
   ctree->drag_compare   = NULL;
   ctree->show_stub      = TRUE;
-
+  
   clist->button_actions[0] |= GTK_BUTTON_EXPANDS;
 }
 
@@ -623,24 +622,24 @@ ctree_attach_styles (GtkCTree     *ctree,
 {
   GtkCList *clist;
   gint i;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (GTK_CTREE_ROW (node)->row.style)
     GTK_CTREE_ROW (node)->row.style =
       gtk_style_attach (GTK_CTREE_ROW (node)->row.style, clist->clist_window);
-
+  
   if (GTK_CTREE_ROW (node)->row.fg_set || GTK_CTREE_ROW (node)->row.bg_set)
     {
       GdkColormap *colormap;
-
+      
       colormap = gtk_widget_get_colormap (GTK_WIDGET (ctree));
       if (GTK_CTREE_ROW (node)->row.fg_set)
 	gdk_color_alloc (colormap, &(GTK_CTREE_ROW (node)->row.foreground));
       if (GTK_CTREE_ROW (node)->row.bg_set)
 	gdk_color_alloc (colormap, &(GTK_CTREE_ROW (node)->row.background));
     }
-
+  
   for (i = 0; i < clist->columns; i++)
     if  (GTK_CTREE_ROW (node)->row.cell[i].style)
       GTK_CTREE_ROW (node)->row.cell[i].style =
@@ -655,9 +654,9 @@ ctree_detach_styles (GtkCTree     *ctree,
 {
   GtkCList *clist;
   gint i;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (GTK_CTREE_ROW (node)->row.style)
     gtk_style_detach (GTK_CTREE_ROW (node)->row.style);
   for (i = 0; i < clist->columns; i++)
@@ -674,15 +673,15 @@ gtk_ctree_realize (GtkWidget *widget)
   GtkCTreeNode *node;
   GtkCTreeNode *child;
   gint i;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CTREE (widget));
-
+  
   GTK_WIDGET_CLASS (parent_class)->realize (widget);
-
+  
   ctree = GTK_CTREE (widget);
   clist = GTK_CLIST (widget);
-
+  
   node = GTK_CTREE_NODE (clist->row_list);
   for (i = 0; i < clist->rows; i++)
     {
@@ -692,7 +691,7 @@ gtk_ctree_realize (GtkWidget *widget)
 	  gtk_ctree_pre_recursive (ctree, child, ctree_attach_styles, NULL);
       node = GTK_CTREE_NODE_NEXT (node);
     }
-
+  
   values.foreground = widget->style->fg[GTK_STATE_NORMAL];
   values.background = widget->style->base[GTK_STATE_NORMAL];
   values.subwindow_mode = GDK_INCLUDE_INFERIORS;
@@ -703,7 +702,7 @@ gtk_ctree_realize (GtkWidget *widget)
 					    GDK_GC_BACKGROUND |
 					    GDK_GC_SUBWINDOW |
 					    GDK_GC_LINE_STYLE);
-
+  
   if (ctree->line_style == GTK_CTREE_LINES_DOTTED)
     {
       gdk_gc_set_line_attributes (ctree->lines_gc, 1, 
@@ -717,21 +716,21 @@ gtk_ctree_unrealize (GtkWidget *widget)
 {
   GtkCTree *ctree;
   GtkCList *clist;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CTREE (widget));
-
+  
   GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
-
+  
   ctree = GTK_CTREE (widget);
   clist = GTK_CLIST (widget);
-
+  
   if (GTK_WIDGET_REALIZED (widget))
     {
       GtkCTreeNode *node;
       GtkCTreeNode *child;
       gint i;
-
+      
       node = GTK_CTREE_NODE (clist->row_list);
       for (i = 0; i < clist->rows; i++)
 	{
@@ -743,7 +742,7 @@ gtk_ctree_unrealize (GtkWidget *widget)
 	  node = GTK_CTREE_NODE_NEXT (node);
 	}
     }
-
+  
   gdk_gc_destroy (ctree->lines_gc);
 }
 
@@ -754,19 +753,19 @@ gtk_ctree_button_press (GtkWidget      *widget,
   GtkCTree *ctree;
   GtkCList *clist;
   gint button_actions;
-
+  
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CTREE (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
-
+  
   ctree = GTK_CTREE (widget);
   clist = GTK_CLIST (widget);
-
+  
   button_actions = clist->button_actions[event->button - 1];
-
+  
   if (button_actions == GTK_BUTTON_IGNORED)
     return FALSE;
-
+  
   if (event->window == clist->clist_window)
     {
       GtkCTreeNode *work;
@@ -774,15 +773,15 @@ gtk_ctree_button_press (GtkWidget      *widget,
       gint y;
       gint row;
       gint column;
-
+      
       x = event->x;
       y = event->y;
-
+      
       if (!gtk_clist_get_selection_info (clist, x, y, &row, &column))
 	return FALSE;
-
+      
       work = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
-	  
+      
       if (button_actions & GTK_BUTTON_EXPANDS &&
 	  (GTK_CTREE_ROW (work)->children && !GTK_CTREE_ROW (work)->is_leaf  &&
 	   (event->type == GDK_2BUTTON_PRESS ||
@@ -792,7 +791,7 @@ gtk_ctree_button_press (GtkWidget      *widget,
 	    gtk_ctree_collapse (ctree, work);
 	  else
 	    gtk_ctree_expand (ctree, work);
-
+	  
 	  return FALSE;
 	}
     }
@@ -810,16 +809,16 @@ draw_drag_highlight (GtkCList        *clist,
   gint level;
   gint i;
   gint y = 0;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
-
+  
   ctree = GTK_CTREE (clist);
-
+  
   level = ((GtkCTreeRow *)(dest_row))->level;
-
+  
   y = ROW_TOP_YPIXEL (clist, dest_row_number) - 1;
-
+  
   switch (drag_pos)
     {
     case GTK_CLIST_DRAG_NONE:
@@ -840,7 +839,7 @@ draw_drag_highlight (GtkCList        *clist,
 			     COLUMN_LEFT_XPIXEL(clist, ctree->tree_column - 1)+
 			     clist->column[ctree->tree_column - 1].area.width,
 			     y);
-
+	    
 	    gdk_draw_line (clist->clist_window, clist->xor_gc, 
 			   COLUMN_LEFT_XPIXEL(clist, ctree->tree_column) + 
 			   ctree->tree_indent * level -
@@ -854,7 +853,7 @@ draw_drag_highlight (GtkCList        *clist,
 			     y,
 			     COLUMN_LEFT_XPIXEL(clist, clist->columns - 1) +
 			     clist->column[clist->columns - 1].area.width, y);
-      
+	    
 	    gdk_draw_line (clist->clist_window, clist->xor_gc, 
 			   0, y, COLUMN_LEFT_XPIXEL(clist, ctree->tree_column)
 			   + clist->column[ctree->tree_column].area.width -
@@ -868,7 +867,7 @@ draw_drag_highlight (GtkCList        *clist,
       break;
     case GTK_CLIST_DRAG_INTO:
       y = ROW_TOP_YPIXEL (clist, dest_row_number) + clist->row_height;
-
+      
       if (clist->column[ctree->tree_column].visible)
 	switch (clist->column[ctree->tree_column].justification)
 	  {
@@ -884,12 +883,12 @@ draw_drag_highlight (GtkCList        *clist,
 	    points[1].y = points[0].y;
 	    points[2].x = points[1].x;
 	    points[2].y = points[3].y;
-
+	    
 	    for (i = 0; i < 3; i++)
 	      gdk_draw_line (clist->clist_window, clist->xor_gc,
 			     points[i].x, points[i].y,
 			     points[i+1].x, points[i+1].y);
-
+	    
 	    if (ctree->tree_column > 0)
 	      {
 		points[0].x = COLUMN_LEFT_XPIXEL(clist,
@@ -902,7 +901,7 @@ draw_drag_highlight (GtkCList        *clist,
 		points[1].y = points[0].y;
 		points[2].x = 0;
 		points[2].y = points[3].y;
-
+		
 		for (i = 0; i < 3; i++)
 		  gdk_draw_line (clist->clist_window, clist->xor_gc,
 				 points[i].x, points[i].y, points[i+1].x, 
@@ -920,12 +919,12 @@ draw_drag_highlight (GtkCList        *clist,
 	    points[1].y = points[0].y;
 	    points[2].x = 0;
 	    points[2].y = points[3].y;
-
+	    
 	    for (i = 0; i < 3; i++)
 	      gdk_draw_line (clist->clist_window, clist->xor_gc,
 			     points[i].x, points[i].y,
 			     points[i+1].x, points[i+1].y);
-
+	    
 	    if (ctree->tree_column < clist->columns - 1)
 	      {
 		points[0].x = COLUMN_LEFT_XPIXEL(clist, ctree->tree_column +1);
@@ -936,7 +935,7 @@ draw_drag_highlight (GtkCList        *clist,
 		points[1].y = points[0].y;
 		points[2].x = points[1].x;
 		points[2].y = points[3].y;
-
+		
 		for (i = 0; i < 3; i++)
 		  gdk_draw_line (clist->clist_window, clist->xor_gc,
 				 points[i].x, points[i].y,
@@ -965,7 +964,7 @@ draw_cell_pixmap (GdkWindow    *window,
 {
   gint xsrc = 0;
   gint ysrc = 0;
-
+  
   if (mask)
     {
       gdk_gc_set_clip_mask (fg_gc, mask);
@@ -979,7 +978,7 @@ draw_cell_pixmap (GdkWindow    *window,
     }
   if (x + width > clip_rectangle->x + clip_rectangle->width)
     width = clip_rectangle->x + clip_rectangle->width - x;
-
+  
   if (y < clip_rectangle->y)
     {
       ysrc = clip_rectangle->y - y;
@@ -988,16 +987,16 @@ draw_cell_pixmap (GdkWindow    *window,
     }
   if (y + height > clip_rectangle->y + clip_rectangle->height)
     height = clip_rectangle->y + clip_rectangle->height - y;
-
+  
   if (width > 0 && height > 0)
     gdk_draw_pixmap (window, fg_gc, pixmap, xsrc, ysrc, x, y, width, height);
-
+  
   if (mask)
     {
       gdk_gc_set_clip_rectangle (fg_gc, NULL);
       gdk_gc_set_clip_origin (fg_gc, 0, 0);
     }
-
+  
   return x + MAX (width, 0);
 }
 
@@ -1011,13 +1010,13 @@ get_cell_style (GtkCList     *clist,
 		GdkGC       **bg_gc)
 {
   gint fg_state;
-
+  
   if ((state == GTK_STATE_NORMAL) &&
       (GTK_WIDGET (clist)->state == GTK_STATE_INSENSITIVE))
     fg_state = GTK_STATE_INSENSITIVE;
   else
     fg_state = state;
-
+  
   if (clist_row->cell[column].style)
     {
       if (style)
@@ -1056,7 +1055,7 @@ get_cell_style (GtkCList     *clist,
 	else
 	  *bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
       }
-
+      
       if (state != GTK_STATE_SELECTED)
 	{
 	  if (fg_gc && clist_row->fg_set)
@@ -1078,10 +1077,10 @@ gtk_ctree_draw_expander (GtkCTree     *ctree,
   GdkPoint points[3];
   gint justification_factor;
   gint y;
-
- if (ctree->expander_style == GTK_CTREE_EXPANDER_NONE)
-   return x;
-
+  
+  if (ctree->expander_style == GTK_CTREE_EXPANDER_NONE)
+    return x;
+  
   clist = GTK_CLIST (ctree);
   if (clist->column[ctree->tree_column].justification == GTK_JUSTIFY_RIGHT)
     justification_factor = -1;
@@ -1089,7 +1088,7 @@ gtk_ctree_draw_expander (GtkCTree     *ctree,
     justification_factor = 1;
   y = (clip_rectangle->y + (clip_rectangle->height - PM_SIZE) / 2 -
        (clip_rectangle->height + 1) % 2);
-
+  
   if (!ctree_row->children)
     {
       switch (ctree->expander_style)
@@ -1103,10 +1102,10 @@ gtk_ctree_draw_expander (GtkCTree     *ctree,
 	  return x + justification_factor * (PM_SIZE + 1);
 	}
     }
-
+  
   gdk_gc_set_clip_rectangle (style->fg_gc[GTK_STATE_NORMAL], clip_rectangle);
   gdk_gc_set_clip_rectangle (style->base_gc[GTK_STATE_NORMAL], clip_rectangle);
-
+  
   switch (ctree->expander_style)
     {
     case GTK_CTREE_EXPANDER_NONE:
@@ -1132,19 +1131,19 @@ gtk_ctree_draw_expander (GtkCTree     *ctree,
 			 justification_factor * (2 * (PM_SIZE + 2) / 3 - 1));
 	  points[2].y = points[0].y + (PM_SIZE + 2) / 2;
 	}
-
+      
       gdk_draw_polygon (clist->clist_window, style->base_gc[GTK_STATE_NORMAL],
 			TRUE, points, 3);
       gdk_draw_polygon (clist->clist_window, style->fg_gc[GTK_STATE_NORMAL],
 			FALSE, points, 3);
-
+      
       x += justification_factor * (PM_SIZE + 3);
       break;
     case GTK_CTREE_EXPANDER_SQUARE:
     case GTK_CTREE_EXPANDER_CIRCULAR:
       if (justification_factor == -1)
 	x += justification_factor * (PM_SIZE + 1);
-
+      
       if (ctree->expander_style == GTK_CTREE_EXPANDER_CIRCULAR)
 	{
 	  gdk_draw_arc (clist->clist_window, style->base_gc[GTK_STATE_NORMAL],
@@ -1161,23 +1160,23 @@ gtk_ctree_draw_expander (GtkCTree     *ctree,
 			      style->fg_gc[GTK_STATE_NORMAL], FALSE,
 			      x, y, PM_SIZE, PM_SIZE);
 	}
-
+      
       gdk_draw_line (clist->clist_window, style->fg_gc[GTK_STATE_NORMAL], 
 		     x + 2, y + PM_SIZE / 2, x + PM_SIZE - 2, y + PM_SIZE / 2);
-
+      
       if (!ctree_row->expanded)
 	gdk_draw_line (clist->clist_window, style->fg_gc[GTK_STATE_NORMAL],
 		       x + PM_SIZE / 2, y + 2,
 		       x + PM_SIZE / 2, y + PM_SIZE - 2);
-
+      
       if (justification_factor == 1)
 	x += justification_factor * (PM_SIZE + 1);
       break;
     }
-
+  
   gdk_gc_set_clip_rectangle (style->fg_gc[GTK_STATE_NORMAL], NULL);
   gdk_gc_set_clip_rectangle (style->base_gc[GTK_STATE_NORMAL], NULL);
-
+  
   return x;
 }
 
@@ -1214,7 +1213,7 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
   clist = GTK_CLIST (ctree);
   ycenter = clip_rectangle->y + (clip_rectangle->height / 2);
   justify_right = (clist->column[column].justification == GTK_JUSTIFY_RIGHT);
-
+  
   if (justify_right)
     {
       offset = (clip_rectangle->x + clip_rectangle->width - 1 -
@@ -1226,25 +1225,25 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
       offset = clip_rectangle->x + ctree->tree_indent * (ctree_row->level - 1);
       justification_factor = 1;
     }
-
+  
   switch (ctree->line_style)
     {
     case GTK_CTREE_LINES_NONE:
       break;
     case GTK_CTREE_LINES_TABBED:
       xcenter = offset + justification_factor * TAB_SIZE;
-
+      
       column_right = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) +
 		      clist->column[ctree->tree_column].area.width +
 		      COLUMN_INSET);
       column_left = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) -
 		     COLUMN_INSET - CELL_SPACING);
-
+      
       if (area)
 	{
 	  tree_rectangle.y = crect->y;
 	  tree_rectangle.height = crect->height;
-
+	  
 	  if (justify_right)
 	    {
 	      tree_rectangle.x = xcenter;
@@ -1255,18 +1254,18 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 	      tree_rectangle.x = column_left;
 	      tree_rectangle.width = xcenter - column_left;
 	    }
-
+	  
 	  if (!gdk_rectangle_intersect (area, &tree_rectangle, &tc_rectangle))
 	    {
 	      offset += justification_factor * 3;
 	      break;
 	    }
 	}
-
+      
       gdk_gc_set_clip_rectangle (ctree->lines_gc, crect);
-
+      
       next_level = ctree_row->level;
-
+      
       if (!ctree_row->sibling || (ctree_row->children && ctree_row->expanded))
 	{
 	  node = gtk_ctree_find_node_ptr (ctree, ctree_row);
@@ -1275,21 +1274,21 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 	  else
 	    next_level = 0;
 	}
-
+      
       if (ctree->tree_indent > 0)
 	{
 	  node = ctree_row->parent;
 	  while (node)
 	    {
 	      xcenter -= (justification_factor * ctree->tree_indent);
-
+	      
 	      if ((justify_right && xcenter < column_left) ||
 		  (!justify_right && xcenter > column_right))
 		{
 		  node = GTK_CTREE_ROW (node)->parent;
 		  continue;
 		}
-
+	      
 	      tree_rectangle.y = cell_rectangle->y;
 	      tree_rectangle.height = cell_rectangle->height;
 	      if (justify_right)
@@ -1305,17 +1304,17 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 		  tree_rectangle.width = MIN (column_right - xcenter,
 					      ctree->tree_indent);
 		}
-
+	      
 	      if (!area || gdk_rectangle_intersect (area, &tree_rectangle,
 						    &tc_rectangle))
 		{
 		  get_cell_style (clist, &GTK_CTREE_ROW (node)->row,
 				  state, column, NULL, NULL, &bg_gc);
-
+		  
 		  if (bg_gc == clist->bg_gc)
 		    gdk_gc_set_foreground
 		      (clist->bg_gc, &GTK_CTREE_ROW (node)->row.background);
-
+		  
 		  if (!area)
 		    gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
 					tree_rectangle.x,
@@ -1336,16 +1335,16 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 	      else
 		{
 		  gint width;
-
+		  
 		  offset_x = MIN (ctree->tree_indent, 2 * TAB_SIZE);
 		  width = offset_x / 2 + offset_x % 2;
-
+		  
 		  parent = GTK_CTREE_ROW (node)->parent;
-
+		  
 		  tree_rectangle.y = ycenter;
 		  tree_rectangle.height = (cell_rectangle->y - ycenter +
 					   cell_rectangle->height);
-
+		  
 		  if (justify_right)
 		    {
 		      tree_rectangle.x = MAX(xcenter + 1 - width, column_left);
@@ -1358,7 +1357,7 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 		      tree_rectangle.width = MIN (column_right - xcenter,
 						  width);
 		    }
-
+		  
 		  if (!area ||
 		      gdk_rectangle_intersect (area, &tree_rectangle,
 					       &tc_rectangle))
@@ -1376,7 +1375,7 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 			bg_gc = style->base_gc[state];
 		      else
 			bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
-
+		      
 		      if (!area)
 			gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
 					    tree_rectangle.x,
@@ -1391,13 +1390,13 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 					    tc_rectangle.width,
 					    tc_rectangle.height);
 		    }
-
+		  
 		  get_cell_style (clist, &GTK_CTREE_ROW (node)->row,
 				  state, column, NULL, NULL, &bg_gc);
 		  if (bg_gc == clist->bg_gc)
 		    gdk_gc_set_foreground
 		      (clist->bg_gc, &GTK_CTREE_ROW (node)->row.background);
-
+		  
 		  gdk_gc_set_clip_rectangle (bg_gc, crect);
 		  gdk_draw_arc (clist->clist_window, bg_gc, TRUE,
 				xcenter - (justify_right * offset_x),
@@ -1405,10 +1404,10 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 				offset_x, clist->row_height,
 				(180 + (justify_right * 90)) * 64, 90 * 64);
 		  gdk_gc_set_clip_rectangle (bg_gc, NULL);
-
+		  
 		  gdk_draw_line (clist->clist_window, ctree->lines_gc, 
 				 xcenter, cell_rectangle->y, xcenter, ycenter);
-
+		  
 		  if (justify_right)
 		    gdk_draw_arc (clist->clist_window, ctree->lines_gc, FALSE,
 				  xcenter - offset_x, cell_rectangle->y,
@@ -1423,7 +1422,7 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 	      node = GTK_CTREE_ROW (node)->parent;
 	    }
 	}
-
+      
       if (state != GTK_STATE_SELECTED)
 	{
 	  tree_rectangle.y = clip_rectangle->y;
@@ -1431,12 +1430,12 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 	  tree_rectangle.width = COLUMN_INSET + CELL_SPACING +
 	    MIN (clist->column[ctree->tree_column].area.width + COLUMN_INSET,
 		 TAB_SIZE);
-
+	  
 	  if (justify_right)
 	    tree_rectangle.x = MAX (xcenter + 1, column_left);
 	  else
 	    tree_rectangle.x = column_left;
-
+	  
 	  if (!area)
 	    gdk_draw_rectangle (clist->clist_window,
 				GTK_WIDGET
@@ -1457,37 +1456,37 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 				tc_rectangle.width,
 				tc_rectangle.height);
 	}
-
+      
       xcenter = offset + (justification_factor * ctree->tree_indent / 2);
-
+      
       get_cell_style (clist, &ctree_row->row, state, column, NULL, NULL,
 		      &bg_gc);
       if (bg_gc == clist->bg_gc)
 	gdk_gc_set_foreground (clist->bg_gc, &ctree_row->row.background);
-
+      
       gdk_gc_set_clip_rectangle (bg_gc, crect);
       if (ctree_row->is_leaf)
 	{
 	  GdkPoint points[6];
-
+	  
 	  points[0].x = offset + justification_factor * TAB_SIZE;
 	  points[0].y = cell_rectangle->y;
-
+	  
 	  points[1].x = points[0].x - justification_factor * 4;
 	  points[1].y = points[0].y;
-
+	  
 	  points[2].x = points[1].x - justification_factor * 2;
 	  points[2].y = points[1].y + 3;
-
+	  
 	  points[3].x = points[2].x;
 	  points[3].y = points[2].y + clist->row_height - 5;
-
+	  
 	  points[4].x = points[3].x + justification_factor * 2;
 	  points[4].y = points[3].y + 3;
-
+	  
 	  points[5].x = points[4].x + justification_factor * 4;
 	  points[5].y = points[4].y;
-
+	  
 	  gdk_draw_polygon (clist->clist_window, bg_gc, TRUE, points, 6);
 	  gdk_draw_lines (clist->clist_window, ctree->lines_gc, points, 6);
 	}
@@ -1506,17 +1505,17 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 	}
       gdk_gc_set_clip_rectangle (bg_gc, NULL);
       gdk_gc_set_clip_rectangle (ctree->lines_gc, NULL);
-
+      
       offset += justification_factor * 3;
       break;
     default:
       xcenter = offset + justification_factor * PM_SIZE / 2;
-
+      
       if (area)
 	{
 	  tree_rectangle.y = crect->y;
 	  tree_rectangle.height = crect->height;
-
+	  
 	  if (justify_right)
 	    {
 	      tree_rectangle.x = xcenter - PM_SIZE / 2 - 2;
@@ -1529,11 +1528,11 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 	      tree_rectangle.width = (xcenter + PM_SIZE / 2 + 2 -
 				      clip_rectangle->x);
 	    }
-
+	  
 	  if (!gdk_rectangle_intersect (area, &tree_rectangle, &tc_rectangle))
 	    break;
 	}
-
+      
       offset_x = 1;
       offset_y = 0;
       if (ctree->line_style == GTK_CTREE_LINES_DOTTED)
@@ -1541,7 +1540,7 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 	  offset_x += abs((clip_rectangle->x + clist->hoffset) % 2);
 	  offset_y  = abs((cell_rectangle->y + clist->voffset) % 2);
 	}
-
+      
       clip_rectangle->y--;
       clip_rectangle->height++;
       gdk_gc_set_clip_rectangle (ctree->lines_gc, clip_rectangle);
@@ -1551,17 +1550,17 @@ gtk_ctree_draw_lines (GtkCTree     *ctree,
 		     cell_rectangle->y + offset_y : ycenter,
 		     xcenter,
 		     (ctree_row->sibling) ? crect->y +crect->height : ycenter);
-
+      
       gdk_draw_line (clist->clist_window, ctree->lines_gc,
 		     xcenter + (justification_factor * offset_x), ycenter,
 		     xcenter + (justification_factor * (PM_SIZE / 2 + 2)),
 		     ycenter);
-
+      
       node = ctree_row->parent;
       while (node)
 	{
 	  xcenter -= (justification_factor * ctree->tree_indent);
-
+	  
 	  if (GTK_CTREE_ROW (node)->sibling)
 	    gdk_draw_line (clist->clist_window, ctree->lines_gc, 
 			   xcenter, cell_rectangle->y + offset_y,
@@ -1596,40 +1595,40 @@ draw_row (GtkCList     *clist,
   gint offset = 0;
   gint state;
   gint i;
-
+  
   g_return_if_fail (clist != NULL);
-
+  
   /* bail now if we arn't drawable yet */
   if (!GTK_WIDGET_DRAWABLE (clist) || row < 0 || row >= clist->rows)
     return;
-
+  
   widget = GTK_WIDGET (clist);
   ctree  = GTK_CTREE  (clist);
-
+  
   /* if the function is passed the pointer to the row instead of null,
    * it avoids this expensive lookup */
   if (!clist_row)
     clist_row = (g_list_nth (clist->row_list, row))->data;
-
+  
   /* rectangle of the entire row */
   row_rectangle.x = 0;
   row_rectangle.y = ROW_TOP_YPIXEL (clist, row);
   row_rectangle.width = clist->clist_window_width;
   row_rectangle.height = clist->row_height;
-
+  
   /* rectangle of the cell spacing above the row */
   cell_rectangle.x = 0;
   cell_rectangle.y = row_rectangle.y - CELL_SPACING;
   cell_rectangle.width = row_rectangle.width;
   cell_rectangle.height = CELL_SPACING;
-
+  
   /* rectangle used to clip drawing operations, its y and height
    * positions only need to be set once, so we set them once here. 
    * the x and width are set withing the drawing loop below once per
    * column */
   clip_rectangle.y = row_rectangle.y;
   clip_rectangle.height = row_rectangle.height;
-
+  
   if (clist_row->state == GTK_STATE_NORMAL)
     {
       if (clist_row->fg_set)
@@ -1639,16 +1638,16 @@ draw_row (GtkCList     *clist,
     }
   
   state = clist_row->state;
-
+  
   gdk_gc_set_foreground (ctree->lines_gc,
 			 &widget->style->fg[clist_row->state]);
-
+  
   /* draw the cell borders */
   if (area)
     {
       rect = &intersect_rectangle;
       crect = &intersect_rectangle;
-
+      
       if (gdk_rectangle_intersect (area, &cell_rectangle, crect))
 	gdk_draw_rectangle (clist->clist_window,
 			    widget->style->base_gc[GTK_STATE_ACTIVE], TRUE,
@@ -1658,22 +1657,22 @@ draw_row (GtkCList     *clist,
     {
       rect = &clip_rectangle;
       crect = &cell_rectangle;
-
+      
       gdk_draw_rectangle (clist->clist_window,
 			  widget->style->base_gc[GTK_STATE_ACTIVE], TRUE,
 			  crect->x, crect->y, crect->width, crect->height);
     }
-
+  
   /* horizontal black lines */
   if (ctree->line_style == GTK_CTREE_LINES_TABBED)
     { 
-
+      
       column_right = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) +
 		      clist->column[ctree->tree_column].area.width +
 		      COLUMN_INSET);
       column_left = (COLUMN_LEFT_XPIXEL (clist, ctree->tree_column) -
 		     COLUMN_INSET - (ctree->tree_column != 0) * CELL_SPACING);
-
+      
       switch (clist->column[ctree->tree_column].justification)
 	{
 	case GTK_JUSTIFY_CENTER:
@@ -1681,7 +1680,7 @@ draw_row (GtkCList     *clist,
 	case GTK_JUSTIFY_LEFT:
 	  offset = (column_left + ctree->tree_indent *
 		    (((GtkCTreeRow *)clist_row)->level - 1));
-
+	  
 	  gdk_draw_line (clist->clist_window, ctree->lines_gc, 
 			 MIN (offset + TAB_SIZE, column_right),
 			 cell_rectangle.y,
@@ -1690,7 +1689,7 @@ draw_row (GtkCList     *clist,
 	case GTK_JUSTIFY_RIGHT:
 	  offset = (column_right - 1 - ctree->tree_indent *
 		    (((GtkCTreeRow *)clist_row)->level - 1));
-
+	  
 	  gdk_draw_line (clist->clist_window, ctree->lines_gc,
 			 -1, cell_rectangle.y,
 			 MAX (offset - TAB_SIZE, column_left),
@@ -1698,18 +1697,18 @@ draw_row (GtkCList     *clist,
 	  break;
 	}
     }
-
+  
   /* the last row has to clear its bottom cell spacing too */
   if (clist_row == clist->row_list_end->data)
     {
       cell_rectangle.y += clist->row_height + CELL_SPACING;
-
+      
       if (!area || gdk_rectangle_intersect (area, &cell_rectangle, crect))
 	{
 	  gdk_draw_rectangle (clist->clist_window,
 			      widget->style->base_gc[GTK_STATE_ACTIVE], TRUE,
 			      crect->x, crect->y, crect->width, crect->height);
-
+	  
 	  /* horizontal black lines */
 	  if (ctree->line_style == GTK_CTREE_LINES_TABBED)
 	    { 
@@ -1739,43 +1738,43 @@ draw_row (GtkCList     *clist,
 	    }
 	}
     }	  
-
+  
   for (last_column = clist->columns - 1;
        last_column >= 0 && !clist->column[last_column].visible; last_column--)
     ;
-
+  
   /* iterate and draw all the columns (row cells) and draw their contents */
   for (i = 0; i < clist->columns; i++)
     {
       GtkStyle *style;
       GdkGC *fg_gc; 
       GdkGC *bg_gc;
-
+      
       gint width;
       gint height;
       gint pixmap_width;
       gint string_width;
       gint old_offset;
       gint row_center_offset;
-
+      
       if (!clist->column[i].visible)
 	continue;
-
+      
       get_cell_style (clist, clist_row, state, i, &style, &fg_gc, &bg_gc);
-
+      
       /* calculate clipping region */
       clip_rectangle.x = clist->column[i].area.x + clist->hoffset;
       clip_rectangle.width = clist->column[i].area.width;
-
+      
       cell_rectangle.x = clip_rectangle.x - COLUMN_INSET - CELL_SPACING;
       cell_rectangle.width = (clip_rectangle.width + 2 * COLUMN_INSET +
 			      (1 + (i == last_column)) * CELL_SPACING);
       cell_rectangle.y = clip_rectangle.y;
       cell_rectangle.height = clip_rectangle.height;
-
+      
       string_width = 0;
       pixmap_width = 0;
-
+      
       if (area && !gdk_rectangle_intersect (area, &cell_rectangle,
 					    &intersect_rectangle))
 	{
@@ -1786,7 +1785,7 @@ draw_row (GtkCList     *clist,
 	{
 	  gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
 			      crect->x, crect->y, crect->width, crect->height);
-
+	  
 	  /* calculate real width for column justification */
 	  switch (clist_row->cell[i].type)
 	    {
@@ -1805,20 +1804,20 @@ draw_row (GtkCList     *clist,
 		gdk_window_get_size
 		  (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap,
 		   &pixmap_width, &height);
-
+	      
 	      width = pixmap_width;
-
+	      
 	      if (GTK_CELL_PIXTEXT (clist_row->cell[i])->text)
 		{
 		  string_width = gdk_string_width
 		    (style->font, GTK_CELL_PIXTEXT (clist_row->cell[i])->text);
 		  width += string_width;
 		}
-
+	      
 	      if (GTK_CELL_PIXTEXT (clist_row->cell[i])->text &&
 		  GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
 		width +=  GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
-
+	      
 	      if (i == ctree->tree_column)
 		width += (ctree->tree_indent *
 			  ((GtkCTreeRow *)clist_row)->level);
@@ -1827,7 +1826,7 @@ draw_row (GtkCList     *clist,
 	      continue;
 	      break;
 	    }
-
+	  
 	  switch (clist->column[i].justification)
 	    {
 	    case GTK_JUSTIFY_LEFT:
@@ -1843,7 +1842,7 @@ draw_row (GtkCList     *clist,
 			(clip_rectangle.width / 2) - (width / 2));
 	      break;
 	    };
-
+	  
 	  if (i != ctree->tree_column)
 	    {
 	      offset += clist_row->cell[i].horizontal;
@@ -1877,7 +1876,7 @@ draw_row (GtkCList     *clist,
 					 1.5 + style->font->ascent);
 		  else
 		    row_center_offset = clist->row_center_offset;
-
+		  
 		  gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
 		  gdk_draw_string
 		    (clist->clist_window, style->font, fg_gc,
@@ -1895,37 +1894,37 @@ draw_row (GtkCList     *clist,
 	      continue;
 	    }
 	}
-
+      
       if (bg_gc == clist->bg_gc)
 	gdk_gc_set_background (ctree->lines_gc, &clist_row->background);
-
+      
       /* draw ctree->tree_column */
       cell_rectangle.y -= CELL_SPACING;
       cell_rectangle.height += CELL_SPACING;
-
+      
       if (area && !gdk_rectangle_intersect (area, &cell_rectangle,
 					    &intersect_rectangle))
 	continue;
-
+      
       /* draw lines */
       offset = gtk_ctree_draw_lines (ctree, (GtkCTreeRow *)clist_row, row, i,
 				     state, &clip_rectangle, &cell_rectangle,
 				     crect, area, style);
-
+      
       /* draw expander */
       offset = gtk_ctree_draw_expander (ctree, (GtkCTreeRow *)clist_row,
 					style, &clip_rectangle, offset);
-
+      
       if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
 	offset -= ctree->tree_spacing;
       else
 	offset += ctree->tree_spacing;
-
+      
       if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
 	offset -= (pixmap_width + clist_row->cell[i].horizontal);
       else
 	offset += clist_row->cell[i].horizontal;
-
+      
       old_offset = offset;
       offset = draw_cell_pixmap (clist->clist_window, &clip_rectangle, fg_gc,
 				 GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap,
@@ -1934,7 +1933,7 @@ draw_row (GtkCList     *clist,
 				 clip_rectangle.y + clist_row->cell[i].vertical
 				 + (clip_rectangle.height - height) / 2,
 				 pixmap_width, height);
-
+      
       if (string_width)
 	{ 
 	  if (clist->column[i].justification == GTK_JUSTIFY_RIGHT)
@@ -1948,7 +1947,7 @@ draw_row (GtkCList     *clist,
 	      if (GTK_CELL_PIXTEXT (clist_row->cell[i])->pixmap)
 		offset += GTK_CELL_PIXTEXT (clist_row->cell[i])->spacing;
 	    }
-
+	  
 	  if (style != GTK_WIDGET (clist)->style)
 	    row_center_offset = (((clist->row_height - style->font->ascent -
 				   style->font->descent - 1) / 2) +
@@ -1964,7 +1963,7 @@ draw_row (GtkCList     *clist,
 	}
       gdk_gc_set_clip_rectangle (fg_gc, NULL);
     }
-
+  
   /* draw focus rectangle */
   if (clist->focus_row == row &&
       GTK_WIDGET_CAN_FOCUS (widget) && GTK_WIDGET_HAS_FOCUS (widget))
@@ -1993,7 +1992,7 @@ tree_draw_node (GtkCTree     *ctree,
   GtkCList *clist;
   
   clist = GTK_CLIST (ctree);
-
+  
   if (CLIST_UNFROZEN (clist) && gtk_ctree_is_viewable (ctree, node))
     {
       GtkCTreeNode *work;
@@ -2006,7 +2005,7 @@ tree_draw_node (GtkCTree     *ctree,
 	  num++;
 	}
       if (work && gtk_clist_row_is_visible (clist, num) != GTK_VISIBILITY_NONE)
-	GTK_CLIST_CLASS_FW (clist)->draw_row
+	GTK_CLIST_GET_CLASS (clist)->draw_row
 	  (clist, NULL, num, GTK_CLIST_ROW ((GList *) node));
     }
 }
@@ -2019,15 +2018,15 @@ gtk_ctree_last_visible (GtkCTree     *ctree,
   
   if (!node)
     return NULL;
-
+  
   work = GTK_CTREE_ROW (node)->children;
-
+  
   if (!work || !GTK_CTREE_ROW (node)->expanded)
     return node;
-
+  
   while (GTK_CTREE_ROW (work)->sibling)
     work = GTK_CTREE_ROW (work)->sibling;
-
+  
   return gtk_ctree_last_visible (ctree, work);
 }
 
@@ -2050,38 +2049,38 @@ gtk_ctree_link (GtkCTree     *ctree,
   g_return_if_fail (node != NULL);
   g_return_if_fail (node != sibling);
   g_return_if_fail (node != parent);
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (update_focus_row && clist->selection_mode == GTK_SELECTION_EXTENDED)
     {
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
       
       g_list_free (clist->undo_selection);
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
     }
-
+  
   for (rows = 1, list_end = (GList *)node; list_end->next;
        list_end = list_end->next)
     rows++;
-
+  
   GTK_CTREE_ROW (node)->parent = parent;
   GTK_CTREE_ROW (node)->sibling = sibling;
-
+  
   if (!parent || (parent && (gtk_ctree_is_viewable (ctree, parent) &&
 			     GTK_CTREE_ROW (parent)->expanded)))
     {
       visible = TRUE;
       clist->rows += rows;
     }
-
+  
   if (parent)
     work = (GList *)(GTK_CTREE_ROW (parent)->children);
   else
     work = clist->row_list;
-
+  
   if (sibling)
     {
       if (work != (GList *)sibling)
@@ -2090,7 +2089,7 @@ gtk_ctree_link (GtkCTree     *ctree,
 	    work = (GList *)(GTK_CTREE_ROW (work)->sibling);
 	  GTK_CTREE_ROW (work)->sibling = node;
 	}
-
+      
       if (sibling == GTK_CTREE_NODE (clist->row_list))
 	clist->row_list = (GList *) node;
       if (GTK_CTREE_NODE_PREV (sibling) &&
@@ -2158,19 +2157,19 @@ gtk_ctree_link (GtkCTree     *ctree,
 	    }
 	}
     }
-
+  
   gtk_ctree_pre_recursive (ctree, node, tree_update_level, NULL); 
-
+  
   if (clist->row_list_end == NULL ||
       clist->row_list_end->next == (GList *)node)
     clist->row_list_end = list_end;
-
+  
   if (visible && update_focus_row)
     {
       gint pos;
-	  
+      
       pos = g_list_position (clist->row_list, (GList *)node);
-  
+      
       if (pos <= clist->focus_row)
 	{
 	  clist->focus_row += rows;
@@ -2191,25 +2190,25 @@ gtk_ctree_unlink (GtkCTree     *ctree,
   GtkCTreeNode *work;
   GtkCTreeNode *parent;
   GList *list;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   clist = GTK_CLIST (ctree);
   
   if (update_focus_row && clist->selection_mode == GTK_SELECTION_EXTENDED)
     {
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
       
       g_list_free (clist->undo_selection);
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
     }
-
+  
   visible = gtk_ctree_is_viewable (ctree, node);
-
+  
   /* clist->row_list_end unlinked ? */
   if (visible &&
       (GTK_CTREE_NODE_NEXT (node) == NULL ||
@@ -2217,7 +2216,7 @@ gtk_ctree_unlink (GtkCTree     *ctree,
 	gtk_ctree_is_ancestor (ctree, node,
 			       GTK_CTREE_NODE (clist->row_list_end)))))
     clist->row_list_end = (GList *) (GTK_CTREE_NODE_PREV (node));
-
+  
   /* update list */
   rows = 0;
   level = GTK_CTREE_ROW (node)->level;
@@ -2227,11 +2226,11 @@ gtk_ctree_unlink (GtkCTree     *ctree,
       work = GTK_CTREE_NODE_NEXT (work);
       rows++;
     }
-
+  
   if (visible)
     {
       clist->rows -= (rows + 1);
-
+      
       if (update_focus_row)
 	{
 	  gint pos;
@@ -2251,7 +2250,7 @@ gtk_ctree_unlink (GtkCTree     *ctree,
 	  clist->undo_anchor = clist->focus_row;
 	}
     }
-
+  
   if (work)
     {
       list = (GList *)GTK_CTREE_NODE_PREV (work);
@@ -2259,14 +2258,14 @@ gtk_ctree_unlink (GtkCTree     *ctree,
       list = (GList *)work;
       list->prev = (GList *)GTK_CTREE_NODE_PREV (node);
     }
-
+  
   if (GTK_CTREE_NODE_PREV (node) &&
       GTK_CTREE_NODE_NEXT (GTK_CTREE_NODE_PREV (node)) == node)
     {
       list = (GList *)GTK_CTREE_NODE_PREV (node);
       list->next = (GList *)work;
     }
-
+  
   /* update tree */
   parent = GTK_CTREE_ROW (node)->parent;
   if (parent)
@@ -2280,7 +2279,7 @@ gtk_ctree_unlink (GtkCTree     *ctree,
       else
 	{
 	  GtkCTreeNode *sibling;
-
+	  
 	  sibling = GTK_CTREE_ROW (parent)->children;
 	  while (GTK_CTREE_ROW (sibling)->sibling != node)
 	    sibling = GTK_CTREE_ROW (sibling)->sibling;
@@ -2294,7 +2293,7 @@ gtk_ctree_unlink (GtkCTree     *ctree,
       else
 	{
 	  GtkCTreeNode *sibling;
-
+	  
 	  sibling = GTK_CTREE_NODE (clist->row_list);
 	  while (GTK_CTREE_ROW (sibling)->sibling != node)
 	    sibling = GTK_CTREE_ROW (sibling)->sibling;
@@ -2310,42 +2309,42 @@ real_row_move (GtkCList *clist,
 {
   GtkCTree *ctree;
   GtkCTreeNode *node;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
-
+  
   if (GTK_CLIST_AUTO_SORT (clist))
     return;
-
+  
   if (source_row < 0 || source_row >= clist->rows ||
       dest_row   < 0 || dest_row   >= clist->rows ||
       source_row == dest_row)
     return;
-
+  
   ctree = GTK_CTREE (clist);
   node = GTK_CTREE_NODE (g_list_nth (clist->row_list, source_row));
-
+  
   if (source_row < dest_row)
     {
       GtkCTreeNode *work; 
-
+      
       dest_row++;
       work = GTK_CTREE_ROW (node)->children;
-
+      
       while (work && GTK_CTREE_ROW (work)->level > GTK_CTREE_ROW (node)->level)
 	{
 	  work = GTK_CTREE_NODE_NEXT (work);
 	  dest_row++;
 	}
-
+      
       if (dest_row > clist->rows)
 	dest_row = clist->rows;
     }
-
+  
   if (dest_row < clist->rows)
     {
       GtkCTreeNode *sibling;
-
+      
       sibling = GTK_CTREE_NODE (g_list_nth (clist->row_list, dest_row));
       gtk_ctree_move (ctree, node, GTK_CTREE_ROW (sibling)->parent, sibling);
     }
@@ -2362,34 +2361,34 @@ real_tree_move (GtkCTree     *ctree,
   GtkCList *clist;
   GtkCTreeNode *work;
   gboolean visible = FALSE;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (node != NULL);
   g_return_if_fail (!new_sibling || 
 		    GTK_CTREE_ROW (new_sibling)->parent == new_parent);
-
+  
   if (new_parent && GTK_CTREE_ROW (new_parent)->is_leaf)
     return;
-
+  
   /* new_parent != child of child */
   for (work = new_parent; work; work = GTK_CTREE_ROW (work)->parent)
     if (work == node)
       return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   visible = gtk_ctree_is_viewable (ctree, node);
-
+  
   if (clist->selection_mode == GTK_SELECTION_EXTENDED)
     {
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
       
       g_list_free (clist->undo_selection);
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
     }
-
+  
   if (GTK_CLIST_AUTO_SORT (clist))
     {
       if (new_parent == GTK_CTREE_ROW (node)->parent)
@@ -2399,23 +2398,23 @@ real_tree_move (GtkCTree     *ctree,
 	new_sibling = GTK_CTREE_ROW (new_parent)->children;
       else
 	new_sibling = GTK_CTREE_NODE (clist->row_list);
-
+      
       while (new_sibling && clist->compare
 	     (clist, GTK_CTREE_ROW (node), GTK_CTREE_ROW (new_sibling)) > 0)
 	new_sibling = GTK_CTREE_ROW (new_sibling)->sibling;
     }
-
+  
   if (new_parent == GTK_CTREE_ROW (node)->parent && 
       new_sibling == GTK_CTREE_ROW (node)->sibling)
     return;
-
+  
   gtk_clist_freeze (clist);
-
+  
   work = NULL;
   if (gtk_ctree_is_viewable (ctree, node) ||
       gtk_ctree_is_viewable (ctree, new_sibling))
     work = GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
-      
+  
   gtk_ctree_unlink (ctree, node, FALSE);
   gtk_ctree_link (ctree, node, new_parent, new_sibling, FALSE);
   
@@ -2426,14 +2425,14 @@ real_tree_move (GtkCTree     *ctree,
       clist->focus_row = g_list_position (clist->row_list, (GList *)work);
       clist->undo_anchor = clist->focus_row;
     }
-
+  
   if (clist->column[ctree->tree_column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist) &&
       (visible || gtk_ctree_is_viewable (ctree, node)))
     gtk_clist_set_column_width
       (clist, ctree->tree_column,
        gtk_clist_optimal_column_width (clist, ctree->tree_column));
-
+  
   gtk_clist_thaw (clist);
 }
 
@@ -2443,12 +2442,12 @@ change_focus_row_expansion (GtkCTree          *ctree,
 {
   GtkCList *clist;
   GtkCTreeNode *node;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (ctree))
     return;
   
@@ -2456,7 +2455,7 @@ change_focus_row_expansion (GtkCTree          *ctree,
 	GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row))) ||
       GTK_CTREE_ROW (node)->is_leaf || !(GTK_CTREE_ROW (node)->children))
     return;
-
+  
   switch (action)
     {
     case GTK_CTREE_EXPANSION_EXPAND:
@@ -2489,27 +2488,27 @@ real_tree_expand (GtkCTree     *ctree,
   GtkRequisition requisition;
   gboolean visible;
   gint level;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   if (!node || GTK_CTREE_ROW (node)->expanded || GTK_CTREE_ROW (node)->is_leaf)
     return;
-
+  
   clist = GTK_CLIST (ctree);
   
-  GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
-
+  GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
+  
   GTK_CTREE_ROW (node)->expanded = TRUE;
   level = GTK_CTREE_ROW (node)->level;
-
+  
   visible = gtk_ctree_is_viewable (ctree, node);
   /* get cell width if tree_column is auto resized */
   if (visible && clist->column[ctree->tree_column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
-    GTK_CLIST_CLASS_FW (clist)->cell_size_request
+    GTK_CLIST_GET_CLASS (clist)->cell_size_request
       (clist, &GTK_CTREE_ROW (node)->row, ctree->tree_column, &requisition);
-
+  
   /* unref/unset closed pixmap */
   if (GTK_CELL_PIXTEXT 
       (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap)
@@ -2531,21 +2530,21 @@ real_tree_expand (GtkCTree     *ctree,
 	    (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask = NULL;
 	}
     }
-
+  
   /* set/ref opened pixmap */
   if (GTK_CTREE_ROW (node)->pixmap_opened)
     {
       GTK_CELL_PIXTEXT 
 	(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap = 
 	gdk_pixmap_ref (GTK_CTREE_ROW (node)->pixmap_opened);
-
+      
       if (GTK_CTREE_ROW (node)->mask_opened) 
 	GTK_CELL_PIXTEXT 
 	  (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask = 
 	  gdk_pixmap_ref (GTK_CTREE_ROW (node)->mask_opened);
     }
-
-
+  
+  
   work = GTK_CTREE_ROW (node)->children;
   if (work)
     {
@@ -2559,19 +2558,19 @@ real_tree_expand (GtkCTree     *ctree,
 	{
 	  cell_width = g_new0 (gint, clist->columns);
 	  if (clist->column[ctree->tree_column].auto_resize)
-	      cell_width[ctree->tree_column] = requisition.width;
-
+	    cell_width[ctree->tree_column] = requisition.width;
+	  
 	  while (work)
 	    {
 	      /* search maximum cell widths of auto_resize columns */
 	      for (i = 0; i < clist->columns; i++)
 		if (clist->column[i].auto_resize)
 		  {
-		    GTK_CLIST_CLASS_FW (clist)->cell_size_request
+		    GTK_CLIST_GET_CLASS (clist)->cell_size_request
 		      (clist, &GTK_CTREE_ROW (work)->row, i, &requisition);
 		    cell_width[i] = MAX (requisition.width, cell_width[i]);
 		  }
-
+	      
 	      list = (GList *)work;
 	      work = GTK_CTREE_NODE_NEXT (work);
 	      tmp++;
@@ -2584,22 +2583,22 @@ real_tree_expand (GtkCTree     *ctree,
 	    work = GTK_CTREE_NODE_NEXT (work);
 	    tmp++;
 	  }
-
+      
       list->next = (GList *)GTK_CTREE_NODE_NEXT (node);
-
+      
       if (GTK_CTREE_NODE_NEXT (node))
 	{
 	  GList *tmp_list;
-
+	  
 	  tmp_list = (GList *)GTK_CTREE_NODE_NEXT (node);
 	  tmp_list->prev = list;
 	}
       else
 	clist->row_list_end = list;
-
+      
       list = (GList *)node;
       list->next = (GList *)(GTK_CTREE_ROW (node)->children);
-
+      
       if (visible)
 	{
 	  /* resize auto_resize columns if needed */
@@ -2608,12 +2607,12 @@ real_tree_expand (GtkCTree     *ctree,
 		cell_width[i] > clist->column[i].width)
 	      gtk_clist_set_column_width (clist, i, cell_width[i]);
 	  g_free (cell_width);
-
+	  
 	  /* update focus_row position */
 	  row = g_list_position (clist->row_list, (GList *)node);
 	  if (row < clist->focus_row)
 	    clist->focus_row += tmp;
-
+	  
 	  clist->rows += tmp;
 	  CLIST_REFRESH (clist);
 	}
@@ -2633,28 +2632,28 @@ real_tree_collapse (GtkCTree     *ctree,
   GtkRequisition requisition;
   gboolean visible;
   gint level;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   if (!node || !GTK_CTREE_ROW (node)->expanded ||
       GTK_CTREE_ROW (node)->is_leaf)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
-  GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+  
+  GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
   
   GTK_CTREE_ROW (node)->expanded = FALSE;
   level = GTK_CTREE_ROW (node)->level;
-
+  
   visible = gtk_ctree_is_viewable (ctree, node);
   /* get cell width if tree_column is auto resized */
   if (visible && clist->column[ctree->tree_column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
-    GTK_CLIST_CLASS_FW (clist)->cell_size_request
+    GTK_CLIST_GET_CLASS (clist)->cell_size_request
       (clist, &GTK_CTREE_ROW (node)->row, ctree->tree_column, &requisition);
-
+  
   /* unref/unset opened pixmap */
   if (GTK_CELL_PIXTEXT 
       (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap)
@@ -2676,33 +2675,33 @@ real_tree_collapse (GtkCTree     *ctree,
 	    (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask = NULL;
 	}
     }
-
+  
   /* set/ref closed pixmap */
   if (GTK_CTREE_ROW (node)->pixmap_closed)
     {
       GTK_CELL_PIXTEXT 
 	(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap = 
 	gdk_pixmap_ref (GTK_CTREE_ROW (node)->pixmap_closed);
-
+      
       if (GTK_CTREE_ROW (node)->mask_closed) 
 	GTK_CELL_PIXTEXT 
 	  (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask = 
 	  gdk_pixmap_ref (GTK_CTREE_ROW (node)->mask_closed);
     }
-
+  
   work = GTK_CTREE_ROW (node)->children;
   if (work)
     {
       gint tmp = 0;
       gint row;
       GList *list;
-
+      
       while (work && GTK_CTREE_ROW (work)->level > level)
 	{
 	  work = GTK_CTREE_NODE_NEXT (work);
 	  tmp++;
 	}
-
+      
       if (work)
 	{
 	  list = (GList *)node;
@@ -2718,12 +2717,12 @@ real_tree_collapse (GtkCTree     *ctree,
 	  list->next = NULL;
 	  clist->row_list_end = (GList *)node;
 	}
-
+      
       if (visible)
 	{
 	  /* resize auto_resize columns if needed */
 	  auto_resize_columns (clist);
-
+	  
 	  row = g_list_position (clist->row_list, (GList *)node);
 	  if (row < clist->focus_row)
 	    clist->focus_row -= tmp;
@@ -2736,7 +2735,7 @@ real_tree_collapse (GtkCTree     *ctree,
     /* resize tree_column if needed */
     column_auto_resize (clist, &GTK_CTREE_ROW (node)->row, ctree->tree_column,
 			requisition.width);
-    
+  
 }
 
 static void
@@ -2747,17 +2746,17 @@ column_auto_resize (GtkCList    *clist,
 {
   /* resize column if needed for auto_resize */
   GtkRequisition requisition;
-
+  
   if (!clist->column[column].auto_resize ||
       GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
     return;
-
+  
   if (clist_row)
-    GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
-						   column, &requisition);
+    GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+						    column, &requisition);
   else
     requisition.width = 0;
-
+  
   if (requisition.width > clist->column[column].width)
     gtk_clist_set_column_width (clist, column, requisition.width);
   else if (requisition.width < old_width &&
@@ -2765,7 +2764,7 @@ column_auto_resize (GtkCList    *clist,
     {
       GList *list;
       gint new_width;
-
+      
       /* run a "gtk_clist_optimal_column_width" but break, if
        * the column doesn't shrink */
       if (GTK_CLIST_SHOW_TITLES (clist) && clist->column[column].button)
@@ -2773,10 +2772,10 @@ column_auto_resize (GtkCList    *clist,
 		     (CELL_SPACING + (2 * COLUMN_INSET)));
       else
 	new_width = 0;
-
+      
       for (list = clist->row_list; list; list = list->next)
 	{
-	  GTK_CLIST_CLASS_FW (clist)->cell_size_request
+	  GTK_CLIST_GET_CLASS (clist)->cell_size_request
 	    (clist, GTK_CLIST_ROW (list), column, &requisition);
 	  new_width = MAX (new_width, requisition.width);
 	  if (new_width == clist->column[column].width)
@@ -2791,10 +2790,10 @@ static void
 auto_resize_columns (GtkCList *clist)
 {
   gint i;
-
+  
   if (GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
     return;
-
+  
   for (i = 0; i < clist->columns; i++)
     column_auto_resize (clist, NULL, i, clist->column[i].width);
 }
@@ -2809,16 +2808,16 @@ cell_size_request (GtkCList       *clist,
   GtkStyle *style;
   gint width;
   gint height;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
   g_return_if_fail (requisition != NULL);
-
+  
   ctree = GTK_CTREE (clist);
-
+  
   get_cell_style (clist, clist_row, GTK_STATE_NORMAL, column, &style,
 		  NULL, NULL);
-
+  
   switch (clist_row->cell[column].type)
     {
     case GTK_CELL_TEXT:
@@ -2837,11 +2836,11 @@ cell_size_request (GtkCList       *clist,
 	}
       else
 	width = height = 0;
-	  
+      
       requisition->width = width +
 	gdk_string_width (style->font,
 			  GTK_CELL_TEXT (clist_row->cell[column])->text);
-
+      
       requisition->height = MAX (style->font->ascent + style->font->descent,
 				 height);
       if (column == ctree->tree_column)
@@ -2875,7 +2874,7 @@ cell_size_request (GtkCList       *clist,
       requisition->height = 0;
       break;
     }
-
+  
   requisition->width  += clist_row->cell[column].horizontal;
   requisition->height += clist_row->cell[column].vertical;
 }
@@ -2893,28 +2892,28 @@ set_cell_contents (GtkCList    *clist,
   gboolean visible = FALSE;
   GtkCTree *ctree;
   GtkRequisition requisition;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
   g_return_if_fail (clist_row != NULL);
-
+  
   ctree = GTK_CTREE (clist);
-
+  
   if (clist->column[column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
     {
       GtkCTreeNode *parent;
-
+      
       parent = ((GtkCTreeRow *)clist_row)->parent;
       if (!parent || (parent && GTK_CTREE_ROW (parent)->expanded &&
 		      gtk_ctree_is_viewable (ctree, parent)))
 	{
 	  visible = TRUE;
-	  GTK_CLIST_CLASS_FW (clist)->cell_size_request (clist, clist_row,
-							 column, &requisition);
+	  GTK_CLIST_GET_CLASS (clist)->cell_size_request (clist, clist_row,
+							  column, &requisition);
 	}
     }
-
+  
   switch (clist_row->cell[column].type)
     {
     case GTK_CELL_EMPTY:
@@ -2947,11 +2946,11 @@ set_cell_contents (GtkCList    *clist,
     default:
       break;
     }
-
+  
   clist_row->cell[column].type = GTK_CELL_EMPTY;
   if (column == ctree->tree_column && type != GTK_CELL_EMPTY)
     type = GTK_CELL_PIXTEXT;
-
+  
   switch (type)
     {
     case GTK_CELL_TEXT:
@@ -3032,12 +3031,12 @@ set_node_info (GtkCTree     *ctree,
       if (GTK_CTREE_ROW (node)->mask_closed) 
 	gdk_bitmap_unref (GTK_CTREE_ROW (node)->mask_closed);
     }
-
+  
   GTK_CTREE_ROW (node)->pixmap_opened = NULL;
   GTK_CTREE_ROW (node)->mask_opened   = NULL;
   GTK_CTREE_ROW (node)->pixmap_closed = NULL;
   GTK_CTREE_ROW (node)->mask_closed   = NULL;
-
+  
   if (pixmap_closed)
     {
       GTK_CTREE_ROW (node)->pixmap_closed = gdk_pixmap_ref (pixmap_closed);
@@ -3050,10 +3049,10 @@ set_node_info (GtkCTree     *ctree,
       if (mask_opened) 
 	GTK_CTREE_ROW (node)->mask_opened = gdk_bitmap_ref (mask_opened);
     }
-
+  
   GTK_CTREE_ROW (node)->is_leaf  = is_leaf;
   GTK_CTREE_ROW (node)->expanded = (is_leaf) ? FALSE : expanded;
-
+  
   if (GTK_CTREE_ROW (node)->expanded)
     gtk_ctree_node_set_pixtext (ctree, node, ctree->tree_column,
 				text, spacing, pixmap_opened, mask_opened);
@@ -3088,12 +3087,12 @@ tree_update_level (GtkCTree     *ctree,
 {
   if (!node)
     return;
-
+  
   if (GTK_CTREE_ROW (node)->parent)
-      GTK_CTREE_ROW (node)->level = 
-	GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->level + 1;
+    GTK_CTREE_ROW (node)->level = 
+      GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->level + 1;
   else
-      GTK_CTREE_ROW (node)->level = 1;
+    GTK_CTREE_ROW (node)->level = 1;
 }
 
 static void
@@ -3151,7 +3150,7 @@ tree_toggle_expansion (GtkCTree     *ctree,
 {
   if (!node)
     return;
-
+  
   if (GTK_CTREE_ROW (node)->expanded)
     gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_COLLAPSE], node);
   else
@@ -3164,11 +3163,11 @@ row_new (GtkCTree *ctree)
   GtkCList *clist;
   GtkCTreeRow *ctree_row;
   int i;
-
+  
   clist = GTK_CLIST (ctree);
   ctree_row = g_chunk_new (GtkCTreeRow, clist->row_mem_chunk);
   ctree_row->row.cell = g_chunk_new (GtkCell, clist->cell_mem_chunk);
-
+  
   for (i = 0; i < clist->columns; i++)
     {
       ctree_row->row.cell[i].type = GTK_CELL_EMPTY;
@@ -3176,9 +3175,9 @@ row_new (GtkCTree *ctree)
       ctree_row->row.cell[i].horizontal = 0;
       ctree_row->row.cell[i].style = NULL;
     }
-
+  
   GTK_CELL_PIXTEXT (ctree_row->row.cell[ctree->tree_column])->text = NULL;
-
+  
   ctree_row->row.fg_set     = FALSE;
   ctree_row->row.bg_set     = FALSE;
   ctree_row->row.style      = NULL;
@@ -3186,7 +3185,7 @@ row_new (GtkCTree *ctree)
   ctree_row->row.state      = GTK_STATE_NORMAL;
   ctree_row->row.data       = NULL;
   ctree_row->row.destroy    = NULL;
-
+  
   ctree_row->level         = 0;
   ctree_row->expanded      = FALSE;
   ctree_row->parent        = NULL;
@@ -3206,12 +3205,12 @@ row_delete (GtkCTree    *ctree,
 {
   GtkCList *clist;
   gint i;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   for (i = 0; i < clist->columns; i++)
     {
-      GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+      GTK_CLIST_GET_CLASS (clist)->set_cell_contents
 	(clist, &(ctree_row->row), i, GTK_CELL_EMPTY, NULL, 0, NULL, NULL);
       if (ctree_row->row.cell[i].style)
 	{
@@ -3220,39 +3219,39 @@ row_delete (GtkCTree    *ctree,
 	  gtk_style_unref (ctree_row->row.cell[i].style);
 	}
     }
-
+  
   if (ctree_row->row.style)
     {
       if (GTK_WIDGET_REALIZED (ctree))
 	gtk_style_detach (ctree_row->row.style);
       gtk_style_unref (ctree_row->row.style);
     }
-
+  
   if (ctree_row->pixmap_closed)
     {
       gdk_pixmap_unref (ctree_row->pixmap_closed);
       if (ctree_row->mask_closed)
 	gdk_bitmap_unref (ctree_row->mask_closed);
     }
-
+  
   if (ctree_row->pixmap_opened)
     {
       gdk_pixmap_unref (ctree_row->pixmap_opened);
       if (ctree_row->mask_opened)
 	gdk_bitmap_unref (ctree_row->mask_opened);
     }
-
+  
   if (ctree_row->row.destroy)
     {
       GtkDestroyNotify dnotify = ctree_row->row.destroy;
       gpointer ddata = ctree_row->row.data;
-
+      
       ctree_row->row.destroy = NULL;
       ctree_row->row.data = NULL;
-
+      
       dnotify (ddata);
     }
-
+  
   g_mem_chunk_free (clist->cell_mem_chunk, ctree_row->row.cell);
   g_mem_chunk_free (clist->row_mem_chunk, ctree_row);
 }
@@ -3264,7 +3263,7 @@ real_select_row (GtkCList *clist,
 		 GdkEvent *event)
 {
   GList *node;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
   
@@ -3281,10 +3280,10 @@ real_unselect_row (GtkCList *clist,
 		   GdkEvent *event)
 {
   GList *node;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
-
+  
   if ((node = g_list_nth (clist->row_list, row)))
     gtk_signal_emit (GTK_OBJECT (clist), ctree_signals[TREE_UNSELECT_ROW],
 		     node, column);
@@ -3299,24 +3298,24 @@ real_tree_select (GtkCTree     *ctree,
   GList *list;
   GtkCTreeNode *sel_row;
   gboolean node_selected;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   if (!node || GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED ||
       !GTK_CTREE_ROW (node)->row.selectable)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   switch (clist->selection_mode)
     {
     case GTK_SELECTION_SINGLE:
     case GTK_SELECTION_BROWSE:
-
+      
       node_selected = FALSE;
       list = clist->selection;
-
+      
       while (list)
 	{
 	  sel_row = list->data;
@@ -3328,16 +3327,16 @@ real_tree_select (GtkCTree     *ctree,
 	    gtk_signal_emit (GTK_OBJECT (ctree),
 			     ctree_signals[TREE_UNSELECT_ROW], sel_row, column);
 	}
-
+      
       if (node_selected)
 	return;
-
+      
     default:
       break;
     }
-
+  
   GTK_CTREE_ROW (node)->row.state = GTK_STATE_SELECTED;
-
+  
   if (!clist->selection)
     {
       clist->selection = g_list_append (clist->selection, node);
@@ -3345,7 +3344,7 @@ real_tree_select (GtkCTree     *ctree,
     }
   else
     clist->selection_end = g_list_append (clist->selection_end, node)->next;
-
+  
   tree_draw_node (ctree, node);
 }
 
@@ -3355,22 +3354,22 @@ real_tree_unselect (GtkCTree     *ctree,
 		    gint          column)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   if (!node || GTK_CTREE_ROW (node)->row.state != GTK_STATE_SELECTED)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (clist->selection_end && clist->selection_end->data == node)
     clist->selection_end = clist->selection_end->prev;
-
+  
   clist->selection = g_list_remove (clist->selection, node);
   
   GTK_CTREE_ROW (node)->row.state = GTK_STATE_NORMAL;
-
+  
   tree_draw_node (ctree, node);
 }
 
@@ -3382,7 +3381,7 @@ select_row_recursive (GtkCTree     *ctree,
   if (!node || GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED ||
       !GTK_CTREE_ROW (node)->row.selectable)
     return;
-
+  
   GTK_CLIST (ctree)->undo_unselection = 
     g_list_prepend (GTK_CLIST (ctree)->undo_unselection, node);
   gtk_ctree_select (ctree, node);
@@ -3396,40 +3395,40 @@ real_select_all (GtkCList *clist)
   
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
-
+  
   ctree = GTK_CTREE (clist);
-
+  
   switch (clist->selection_mode)
     {
     case GTK_SELECTION_SINGLE:
     case GTK_SELECTION_BROWSE:
       return;
-
+      
     case GTK_SELECTION_EXTENDED:
-
+      
       gtk_clist_freeze (clist);
-
+      
       g_list_free (clist->undo_selection);
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
-	  
+      
       clist->anchor_state = GTK_STATE_SELECTED;
       clist->anchor = -1;
       clist->drag_pos = -1;
       clist->undo_anchor = clist->focus_row;
-
+      
       for (node = GTK_CTREE_NODE (clist->row_list); node;
 	   node = GTK_CTREE_NODE_NEXT (node))
 	gtk_ctree_pre_recursive (ctree, node, select_row_recursive, NULL);
-
+      
       gtk_clist_thaw (clist);
       break;
-
+      
     case GTK_SELECTION_MULTIPLE:
       gtk_ctree_select_recursive (ctree, NULL);
       break;
-
+      
     default:
       /* do nothing */
       break;
@@ -3442,12 +3441,12 @@ real_unselect_all (GtkCList *clist)
   GtkCTree *ctree;
   GtkCTreeNode *node;
   GList *list;
- 
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
   
   ctree = GTK_CTREE (clist);
-
+  
   switch (clist->selection_mode)
     {
     case GTK_SELECTION_BROWSE:
@@ -3459,24 +3458,24 @@ real_unselect_all (GtkCList *clist)
 	  return;
 	}
       break;
-
+      
     case GTK_SELECTION_EXTENDED:
       g_list_free (clist->undo_selection);
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
-
+      
       clist->anchor = -1;
       clist->drag_pos = -1;
       clist->undo_anchor = clist->focus_row;
       break;
-
+      
     default:
       break;
     }
-
+  
   list = clist->selection;
-
+  
   while (list)
     {
       node = list->data;
@@ -3501,20 +3500,20 @@ ctree_is_hot_spot (GtkCTree     *ctree,
   g_return_val_if_fail (ctree != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
   g_return_val_if_fail (node != NULL, FALSE);
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (!clist->column[ctree->tree_column].visible ||
       ctree->expander_style == GTK_CTREE_EXPANDER_NONE)
     return FALSE;
-
+  
   tree_row = GTK_CTREE_ROW (node);
-
+  
   cell = GTK_CELL_PIXTEXT(tree_row->row.cell[ctree->tree_column]);
-
+  
   yu = (ROW_TOP_YPIXEL (clist, row) + (clist->row_height - PM_SIZE) / 2 -
 	(clist->row_height - 1) % 2);
-
+  
   if (clist->column[ctree->tree_column].justification == GTK_JUSTIFY_RIGHT)
     xl = (clist->column[ctree->tree_column].area.x + 
 	  clist->column[ctree->tree_column].area.width - 1 + clist->hoffset -
@@ -3524,7 +3523,7 @@ ctree_is_hot_spot (GtkCTree     *ctree,
     xl = (clist->column[ctree->tree_column].area.x + clist->hoffset +
 	  (tree_row->level - 1) * ctree->tree_indent +
 	  (ctree->line_style == GTK_CTREE_LINES_TABBED) * 3);
-
+  
   return (x >= xl && x <= xl + PM_SIZE && y >= yu && y <= yu + PM_SIZE);
 }
 
@@ -3546,27 +3545,27 @@ gtk_ctree_construct (GtkCTree    *ctree,
 		     gchar       *titles[])
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (GTK_OBJECT_CONSTRUCTED (ctree) == FALSE);
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   clist->row_mem_chunk = g_mem_chunk_new ("ctree row mem chunk",
 					  sizeof (GtkCTreeRow),
 					  sizeof (GtkCTreeRow)
 					  * CLIST_OPTIMUM_SIZE, 
 					  G_ALLOC_AND_FREE);
-
+  
   clist->cell_mem_chunk = g_mem_chunk_new ("ctree cell mem chunk",
 					   sizeof (GtkCell) * columns,
 					   sizeof (GtkCell) * columns
 					   * CLIST_OPTIMUM_SIZE, 
 					   G_ALLOC_AND_FREE);
-
+  
   ctree->tree_column = tree_column;
-
+  
   gtk_clist_construct (clist, columns, titles);
 }
 
@@ -3576,13 +3575,13 @@ gtk_ctree_new_with_titles (gint         columns,
 			   gchar       *titles[])
 {
   GtkWidget *widget;
-
+  
   g_return_val_if_fail (columns > 0, NULL);
   g_return_val_if_fail (tree_column >= 0 && tree_column < columns, NULL);
-
+  
   widget = gtk_type_new (GTK_TYPE_CTREE);
   gtk_ctree_construct (GTK_CTREE (widget), columns, tree_column, titles);
-
+  
   return widget;
 }
 
@@ -3601,17 +3600,17 @@ real_insert_row (GtkCList *clist,
   GtkCTreeNode *parent = NULL;
   GtkCTreeNode *sibling;
   GtkCTreeNode *node;
-
+  
   g_return_val_if_fail (clist != NULL, -1);
   g_return_val_if_fail (GTK_IS_CTREE (clist), -1);
-
+  
   sibling = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
   if (sibling)
     parent = GTK_CTREE_ROW (sibling)->parent;
-
+  
   node = gtk_ctree_insert_node (GTK_CTREE (clist), parent, sibling, text, 5,
 				NULL, NULL, NULL, NULL, TRUE, FALSE);
-
+  
   if (GTK_CLIST_AUTO_SORT (clist) || !sibling)
     return g_list_position (clist->row_list, (GList *) node);
   
@@ -3636,33 +3635,33 @@ gtk_ctree_insert_node (GtkCTree     *ctree,
   GtkCTreeNode *node;
   GList *list;
   gint i;
-
+  
   g_return_val_if_fail (ctree != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
   if (sibling)
     g_return_val_if_fail (GTK_CTREE_ROW (sibling)->parent == parent, NULL);
-
+  
   if (parent && GTK_CTREE_ROW (parent)->is_leaf)
     return NULL;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   /* create the row */
   new_row = row_new (ctree);
   list = g_list_alloc ();
   list->data = new_row;
   node = GTK_CTREE_NODE (list);
-
+  
   if (text)
     for (i = 0; i < clist->columns; i++)
       if (text[i] && i != ctree->tree_column)
-	GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+	GTK_CLIST_GET_CLASS (clist)->set_cell_contents
 	  (clist, &(new_row->row), i, GTK_CELL_TEXT, text[i], 0, NULL, NULL);
-
+  
   set_node_info (ctree, node, text ?
 		 text[ctree->tree_column] : NULL, spacing, pixmap_closed,
 		 mask_closed, pixmap_opened, mask_opened, is_leaf, expanded);
-
+  
   /* sorted insertion */
   if (GTK_CLIST_AUTO_SORT (clist))
     {
@@ -3670,14 +3669,14 @@ gtk_ctree_insert_node (GtkCTree     *ctree,
 	sibling = GTK_CTREE_ROW (parent)->children;
       else
 	sibling = GTK_CTREE_NODE (clist->row_list);
-
+      
       while (sibling && clist->compare
 	     (clist, GTK_CTREE_ROW (node), GTK_CTREE_ROW (sibling)) > 0)
 	sibling = GTK_CTREE_ROW (sibling)->sibling;
     }
-
+  
   gtk_ctree_link (ctree, node, parent, sibling, TRUE);
-
+  
   if (text && !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist) &&
       gtk_ctree_is_viewable (ctree, node))
     {
@@ -3685,17 +3684,17 @@ gtk_ctree_insert_node (GtkCTree     *ctree,
 	if (clist->column[i].auto_resize)
 	  column_auto_resize (clist, &(new_row->row), i, 0);
     }
-
+  
   if (clist->rows == 1)
     {
       clist->focus_row = 0;
       if (clist->selection_mode == GTK_SELECTION_BROWSE)
 	gtk_ctree_select (ctree, node);
     }
-
-
+  
+  
   CLIST_REFRESH (clist);
-
+  
   return node;
 }
 
@@ -3714,7 +3713,7 @@ gtk_ctree_insert_gnode (GtkCTree          *ctree,
   GList *list;
   GNode *work;
   guint depth = 1;
-
+  
   g_return_val_if_fail (ctree != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
   g_return_val_if_fail (gnode != NULL, NULL);
@@ -3723,38 +3722,38 @@ gtk_ctree_insert_gnode (GtkCTree          *ctree,
     g_return_val_if_fail (GTK_CTREE_ROW (sibling)->parent == parent, NULL);
   
   clist = GTK_CLIST (ctree);
-
+  
   if (parent)
     depth = GTK_CTREE_ROW (parent)->level + 1;
-
+  
   list = g_list_alloc ();
   list->data = row_new (ctree);
   cnode = GTK_CTREE_NODE (list);
-
+  
   gtk_clist_freeze (clist);
-
+  
   set_node_info (ctree, cnode, "", 0, NULL, NULL, NULL, NULL, TRUE, FALSE);
-
+  
   if (!func (ctree, depth, gnode, cnode, data))
     {
       tree_delete_row (ctree, cnode, NULL);
       return NULL;
     }
-
+  
   if (GTK_CLIST_AUTO_SORT (clist))
     {
       if (parent)
 	sibling = GTK_CTREE_ROW (parent)->children;
       else
 	sibling = GTK_CTREE_NODE (clist->row_list);
-
+      
       while (sibling && clist->compare
 	     (clist, GTK_CTREE_ROW (cnode), GTK_CTREE_ROW (sibling)) > 0)
 	sibling = GTK_CTREE_ROW (sibling)->sibling;
     }
-
+  
   gtk_ctree_link (ctree, cnode, parent, sibling, TRUE);
-
+  
   for (work = g_node_last_child (gnode); work; work = work->prev)
     {
       new_child = gtk_ctree_insert_gnode (ctree, cnode, child,
@@ -3764,7 +3763,7 @@ gtk_ctree_insert_gnode (GtkCTree          *ctree,
     }	
   
   gtk_clist_thaw (clist);
-
+  
   return cnode;
 }
 
@@ -3779,7 +3778,7 @@ gtk_ctree_export_to_gnode (GtkCTree          *ctree,
   GtkCTreeNode *work;
   GNode *gnode;
   gint depth;
-
+  
   g_return_val_if_fail (ctree != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
   g_return_val_if_fail (node != NULL, NULL);
@@ -3789,7 +3788,7 @@ gtk_ctree_export_to_gnode (GtkCTree          *ctree,
       g_return_val_if_fail (parent != NULL, NULL);
       g_return_val_if_fail (sibling->parent == parent, NULL);
     }
-
+  
   gnode = g_node_new (NULL);
   depth = g_node_depth (parent) + 1;
   
@@ -3798,36 +3797,36 @@ gtk_ctree_export_to_gnode (GtkCTree          *ctree,
       g_node_destroy (gnode);
       return NULL;
     }
-
+  
   if (parent)
     g_node_insert_before (parent, sibling, gnode);
-
+  
   if (!GTK_CTREE_ROW (node)->is_leaf)
     {
       GNode *new_sibling = NULL;
-
+      
       for (work = GTK_CTREE_ROW (node)->children; work;
 	   work = GTK_CTREE_ROW (work)->sibling)
 	new_sibling = gtk_ctree_export_to_gnode (ctree, gnode, new_sibling,
 						 work, func, data);
-
+      
       g_node_reverse_children (gnode);
     }
-
+  
   return gnode;
 }
-  
+
 static void
 real_remove_row (GtkCList *clist,
 		 gint      row)
 {
   GtkCTreeNode *node;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
-
+  
   node = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
-
+  
   if (node)
     gtk_ctree_remove_node (GTK_CTREE (clist), node);
 }
@@ -3837,18 +3836,18 @@ gtk_ctree_remove_node (GtkCTree     *ctree,
 		       GtkCTreeNode *node)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   gtk_clist_freeze (clist);
-
+  
   if (node)
     {
       gboolean visible;
-
+      
       visible = gtk_ctree_is_viewable (ctree, node);
       gtk_ctree_unlink (ctree, node, TRUE);
       gtk_ctree_post_recursive (ctree, node, GTK_CTREE_FUNC (tree_delete),
@@ -3856,12 +3855,12 @@ gtk_ctree_remove_node (GtkCTree     *ctree,
       if (clist->selection_mode == GTK_SELECTION_BROWSE && !clist->selection &&
 	  clist->focus_row >= 0)
 	gtk_clist_select_row (clist, clist->focus_row, -1);
-
+      
       auto_resize_columns (clist);
     }
   else
     gtk_clist_clear (clist);
-
+  
   gtk_clist_thaw (clist);
 }
 
@@ -3871,17 +3870,17 @@ real_clear (GtkCList *clist)
   GtkCTree *ctree;
   GtkCTreeNode *work;
   GtkCTreeNode *ptr;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
-
+  
   ctree = GTK_CTREE (clist);
-
+  
   /* remove all rows */
   work = GTK_CTREE_NODE (clist->row_list);
   clist->row_list = NULL;
   clist->row_list_end = NULL;
-
+  
   GTK_CLIST_SET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
   while (work)
     {
@@ -3891,7 +3890,7 @@ real_clear (GtkCList *clist)
 				NULL);
     }
   GTK_CLIST_UNSET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
-
+  
   parent_class->clear (clist);
 }
 
@@ -3910,23 +3909,23 @@ gtk_ctree_post_recursive (GtkCTree     *ctree,
 {
   GtkCTreeNode *work;
   GtkCTreeNode *tmp;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (func != NULL);
-
+  
   if (node)
     work = GTK_CTREE_ROW (node)->children;
   else
     work = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+  
   while (work)
     {
       tmp = GTK_CTREE_ROW (work)->sibling;
       gtk_ctree_post_recursive (ctree, work, func, data);
       work = tmp;
     }
-
+  
   if (node)
     func (ctree, node, data);
 }
@@ -3940,22 +3939,22 @@ gtk_ctree_post_recursive_to_depth (GtkCTree     *ctree,
 {
   GtkCTreeNode *work;
   GtkCTreeNode *tmp;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (func != NULL);
-
+  
   if (depth < 0)
     {
       gtk_ctree_post_recursive (ctree, node, func, data);
       return;
     }
-
+  
   if (node)
     work = GTK_CTREE_ROW (node)->children;
   else
     work = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+  
   if (work && GTK_CTREE_ROW (work)->level <= depth)
     {
       while (work)
@@ -3965,7 +3964,7 @@ gtk_ctree_post_recursive_to_depth (GtkCTree     *ctree,
 	  work = tmp;
 	}
     }
-
+  
   if (node && GTK_CTREE_ROW (node)->level <= depth)
     func (ctree, node, data);
 }
@@ -3978,11 +3977,11 @@ gtk_ctree_pre_recursive (GtkCTree     *ctree,
 {
   GtkCTreeNode *work;
   GtkCTreeNode *tmp;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (func != NULL);
-
+  
   if (node)
     {
       work = GTK_CTREE_ROW (node)->children;
@@ -3990,7 +3989,7 @@ gtk_ctree_pre_recursive (GtkCTree     *ctree,
     }
   else
     work = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+  
   while (work)
     {
       tmp = GTK_CTREE_ROW (work)->sibling;
@@ -4008,17 +4007,17 @@ gtk_ctree_pre_recursive_to_depth (GtkCTree     *ctree,
 {
   GtkCTreeNode *work;
   GtkCTreeNode *tmp;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (func != NULL);
-
+  
   if (depth < 0)
     {
       gtk_ctree_pre_recursive (ctree, node, func, data);
       return;
     }
-
+  
   if (node)
     {
       work = GTK_CTREE_ROW (node)->children;
@@ -4027,7 +4026,7 @@ gtk_ctree_pre_recursive_to_depth (GtkCTree     *ctree,
     }
   else
     work = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+  
   if (work && GTK_CTREE_ROW (work)->level <= depth)
     {
       while (work)
@@ -4044,19 +4043,19 @@ gtk_ctree_is_viewable (GtkCTree     *ctree,
 		       GtkCTreeNode *node)
 { 
   GtkCTreeRow *work;
-
+  
   g_return_val_if_fail (ctree != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
   g_return_val_if_fail (node != NULL, FALSE);
-
+  
   work = GTK_CTREE_ROW (node);
-
+  
   while (work->parent && GTK_CTREE_ROW (work->parent)->expanded)
     work = GTK_CTREE_ROW (work->parent);
-
+  
   if (!work->parent)
     return TRUE;
-
+  
   return FALSE;
 }
 
@@ -4066,10 +4065,10 @@ gtk_ctree_last (GtkCTree     *ctree,
 {
   g_return_val_if_fail (ctree != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
-
+  
   if (!node) 
     return NULL;
-
+  
   while (GTK_CTREE_ROW (node)->sibling)
     node = GTK_CTREE_ROW (node)->sibling;
   
@@ -4093,7 +4092,7 @@ gtk_ctree_find_node_ptr (GtkCTree    *ctree,
     node = GTK_CTREE_ROW(ctree_row->parent)->children;
   else
     node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+  
   while (GTK_CTREE_ROW (node) != ctree_row)
     node = GTK_CTREE_ROW (node)->sibling;
   
@@ -4106,10 +4105,10 @@ gtk_ctree_node_nth (GtkCTree *ctree,
 {
   g_return_val_if_fail (ctree != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
-
+  
   if ((row < 0) || (row >= GTK_CLIST(ctree)->rows))
     return NULL;
- 
+  
   return GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list, row));
 }
 
@@ -4120,10 +4119,10 @@ gtk_ctree_find (GtkCTree     *ctree,
 {
   if (!child)
     return FALSE;
-
+  
   if (!node)
     node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+  
   while (node)
     {
       if (node == child) 
@@ -4145,10 +4144,10 @@ gtk_ctree_is_ancestor (GtkCTree     *ctree,
 {
   g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
   g_return_val_if_fail (node != NULL, FALSE);
-
+  
   if (GTK_CTREE_ROW (node)->children)
     return gtk_ctree_find (ctree, GTK_CTREE_ROW (node)->children, child);
-
+  
   return FALSE;
 }
 
@@ -4181,23 +4180,23 @@ gtk_ctree_find_all_by_row_data (GtkCTree     *ctree,
 				gpointer      data)
 {
   GList *list = NULL;
-
+  
   g_return_val_if_fail (ctree != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
-
+  
   /* if node == NULL then look in the whole tree */
   if (!node)
     node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+  
   while (node)
     {
       if (GTK_CTREE_ROW (node)->row.data == data)
         list = g_list_append (list, node);
-
+      
       if (GTK_CTREE_ROW (node)->children)
         {
 	  GList *sub_list;
-
+	  
           sub_list = gtk_ctree_find_all_by_row_data (ctree,
 						     GTK_CTREE_ROW
 						     (node)->children,
@@ -4216,12 +4215,12 @@ gtk_ctree_find_by_row_data_custom (GtkCTree     *ctree,
 				   GCompareFunc  func)
 {
   GtkCTreeNode *work;
-
+  
   g_return_val_if_fail (func != NULL, NULL);
-
+  
   if (!node)
     node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+  
   while (node)
     {
       if (!func (GTK_CTREE_ROW (node)->row.data, data))
@@ -4242,24 +4241,24 @@ gtk_ctree_find_all_by_row_data_custom (GtkCTree     *ctree,
 				       GCompareFunc  func)
 {
   GList *list = NULL;
-
+  
   g_return_val_if_fail (ctree != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
   g_return_val_if_fail (func != NULL, NULL);
-
+  
   /* if node == NULL then look in the whole tree */
   if (!node)
     node = GTK_CTREE_NODE (GTK_CLIST (ctree)->row_list);
-
+  
   while (node)
     {
       if (!func (GTK_CTREE_ROW (node)->row.data, data))
         list = g_list_append (list, node);
-
+      
       if (GTK_CTREE_ROW (node)->children)
         {
 	  GList *sub_list;
-
+	  
           sub_list = gtk_ctree_find_all_by_row_data_custom (ctree,
 							    GTK_CTREE_ROW
 							    (node)->children,
@@ -4283,11 +4282,11 @@ gtk_ctree_is_hot_spot (GtkCTree *ctree,
   
   g_return_val_if_fail (ctree != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
-
+  
   if (gtk_clist_get_selection_info (GTK_CLIST (ctree), x, y, &row, &column))
     if ((node = GTK_CTREE_NODE(g_list_nth (GTK_CLIST (ctree)->row_list, row))))
       return ctree_is_hot_spot (ctree, node, row, x, y);
-
+  
   return FALSE;
 }
 
@@ -4321,7 +4320,7 @@ gtk_ctree_expand (GtkCTree     *ctree,
   
   if (GTK_CTREE_ROW (node)->is_leaf)
     return;
-
+  
   gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_EXPAND], node);
 }
 
@@ -4331,23 +4330,23 @@ gtk_ctree_expand_recursive (GtkCTree     *ctree,
 {
   GtkCList *clist;
   gboolean thaw = FALSE;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (node && GTK_CTREE_ROW (node)->is_leaf)
     return;
-
+  
   if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
     {
       gtk_clist_freeze (clist);
       thaw = TRUE;
     }
-
+  
   gtk_ctree_post_recursive (ctree, node, GTK_CTREE_FUNC (tree_expand), NULL);
-
+  
   if (thaw)
     gtk_clist_thaw (clist);
 }
@@ -4359,24 +4358,24 @@ gtk_ctree_expand_to_depth (GtkCTree     *ctree,
 {
   GtkCList *clist;
   gboolean thaw = FALSE;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (node && GTK_CTREE_ROW (node)->is_leaf)
     return;
-
+  
   if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
     {
       gtk_clist_freeze (clist);
       thaw = TRUE;
     }
-
+  
   gtk_ctree_post_recursive_to_depth (ctree, node, depth,
 				     GTK_CTREE_FUNC (tree_expand), NULL);
-
+  
   if (thaw)
     gtk_clist_thaw (clist);
 }
@@ -4391,7 +4390,7 @@ gtk_ctree_collapse (GtkCTree     *ctree,
   
   if (GTK_CTREE_ROW (node)->is_leaf)
     return;
-
+  
   gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_COLLAPSE], node);
 }
 
@@ -4402,21 +4401,21 @@ gtk_ctree_collapse_recursive (GtkCTree     *ctree,
   GtkCList *clist;
   gboolean thaw = FALSE;
   gint i;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   if (node && GTK_CTREE_ROW (node)->is_leaf)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
     {
       gtk_clist_freeze (clist);
       thaw = TRUE;
     }
-
+  
   GTK_CLIST_SET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
   gtk_ctree_post_recursive (ctree, node, GTK_CTREE_FUNC (tree_collapse), NULL);
   GTK_CLIST_UNSET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
@@ -4424,7 +4423,7 @@ gtk_ctree_collapse_recursive (GtkCTree     *ctree,
     if (clist->column[i].auto_resize)
       gtk_clist_set_column_width (clist, i,
 				  gtk_clist_optimal_column_width (clist, i));
-
+  
   if (thaw)
     gtk_clist_thaw (clist);
 }
@@ -4437,21 +4436,21 @@ gtk_ctree_collapse_to_depth (GtkCTree     *ctree,
   GtkCList *clist;
   gboolean thaw = FALSE;
   gint i;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   if (node && GTK_CTREE_ROW (node)->is_leaf)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
     {
       gtk_clist_freeze (clist);
       thaw = TRUE;
     }
-
+  
   GTK_CLIST_SET_FLAG (clist, CLIST_AUTO_RESIZE_BLOCKED);
   gtk_ctree_post_recursive_to_depth (ctree, node, depth,
 				     GTK_CTREE_FUNC (tree_collapse_to_depth),
@@ -4461,7 +4460,7 @@ gtk_ctree_collapse_to_depth (GtkCTree     *ctree,
     if (clist->column[i].auto_resize)
       gtk_clist_set_column_width (clist, i,
 				  gtk_clist_optimal_column_width (clist, i));
-
+  
   if (thaw)
     gtk_clist_thaw (clist);
 }
@@ -4476,7 +4475,7 @@ gtk_ctree_toggle_expansion (GtkCTree     *ctree,
   
   if (GTK_CTREE_ROW (node)->is_leaf)
     return;
-
+  
   tree_toggle_expansion (ctree, node, NULL);
 }
 
@@ -4486,15 +4485,15 @@ gtk_ctree_toggle_expansion_recursive (GtkCTree     *ctree,
 {
   GtkCList *clist;
   gboolean thaw = FALSE;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   
   if (node && GTK_CTREE_ROW (node)->is_leaf)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
     {
       gtk_clist_freeze (clist);
@@ -4503,7 +4502,7 @@ gtk_ctree_toggle_expansion_recursive (GtkCTree     *ctree,
   
   gtk_ctree_post_recursive (ctree, node,
 			    GTK_CTREE_FUNC (tree_toggle_expansion), NULL);
-
+  
   if (thaw)
     gtk_clist_thaw (clist);
 }
@@ -4515,7 +4514,7 @@ gtk_ctree_select (GtkCTree     *ctree,
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   if (GTK_CTREE_ROW (node)->row.selectable)
     gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_SELECT_ROW],
 		     node, -1);
@@ -4528,7 +4527,7 @@ gtk_ctree_unselect (GtkCTree     *ctree,
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   gtk_signal_emit (GTK_OBJECT (ctree), ctree_signals[TREE_UNSELECT_ROW],
 		   node, -1);
 }
@@ -4554,34 +4553,34 @@ gtk_ctree_real_select_recursive (GtkCTree     *ctree,
 {
   GtkCList *clist;
   gboolean thaw = FALSE;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if ((state && 
        (clist->selection_mode ==  GTK_SELECTION_BROWSE ||
 	clist->selection_mode == GTK_SELECTION_SINGLE)) ||
       (!state && clist->selection_mode ==  GTK_SELECTION_BROWSE))
     return;
-
+  
   if (CLIST_UNFROZEN (clist) && (!node || gtk_ctree_is_viewable (ctree, node)))
     {
       gtk_clist_freeze (clist);
       thaw = TRUE;
     }
-
+  
   if (clist->selection_mode == GTK_SELECTION_EXTENDED)
     {
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
       
       g_list_free (clist->undo_selection);
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
     }
-
+  
   if (state)
     gtk_ctree_post_recursive (ctree, node,
 			      GTK_CTREE_FUNC (tree_select), NULL);
@@ -4606,20 +4605,20 @@ gtk_ctree_node_set_text (GtkCTree     *ctree,
 			 const gchar  *text)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   if (column < 0 || column >= GTK_CLIST (ctree)->columns)
     return;
   
   clist = GTK_CLIST (ctree);
-
-  GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+  
+  GTK_CLIST_GET_CLASS (clist)->set_cell_contents
     (clist, &(GTK_CTREE_ROW(node)->row), column, GTK_CELL_TEXT,
      text, 0, NULL, NULL);
-
+  
   tree_draw_node (ctree, node);
 }
 
@@ -4631,25 +4630,25 @@ gtk_ctree_node_set_pixmap (GtkCTree     *ctree,
 			   GdkBitmap    *mask)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
   g_return_if_fail (pixmap != NULL);
-
+  
   if (column < 0 || column >= GTK_CLIST (ctree)->columns)
     return;
-
+  
   gdk_pixmap_ref (pixmap);
   if (mask) 
     gdk_pixmap_ref (mask);
-
+  
   clist = GTK_CLIST (ctree);
-
-  GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+  
+  GTK_CLIST_GET_CLASS (clist)->set_cell_contents
     (clist, &(GTK_CTREE_ROW (node)->row), column, GTK_CELL_PIXMAP,
      NULL, 0, pixmap, mask);
-
+  
   tree_draw_node (ctree, node);
 }
 
@@ -4663,7 +4662,7 @@ gtk_ctree_node_set_pixtext (GtkCTree     *ctree,
 			    GdkBitmap    *mask)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
@@ -4671,20 +4670,20 @@ gtk_ctree_node_set_pixtext (GtkCTree     *ctree,
     g_return_if_fail (pixmap != NULL);
   if (column < 0 || column >= GTK_CLIST (ctree)->columns)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (pixmap)
     {
       gdk_pixmap_ref (pixmap);
       if (mask) 
 	gdk_pixmap_ref (mask);
     }
-
-  GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+  
+  GTK_CLIST_GET_CLASS (clist)->set_cell_contents
     (clist, &(GTK_CTREE_ROW (node)->row), column, GTK_CELL_PIXTEXT,
      text, spacing, pixmap, mask);
-
+  
   tree_draw_node (ctree, node);
 }
 
@@ -4702,14 +4701,14 @@ gtk_ctree_set_node_info (GtkCTree     *ctree,
 {
   gboolean old_leaf;
   gboolean old_expanded;
- 
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   old_leaf = GTK_CTREE_ROW (node)->is_leaf;
   old_expanded = GTK_CTREE_ROW (node)->expanded;
-
+  
   if (is_leaf && GTK_CTREE_ROW (node)->children)
     {
       GtkCTreeNode *work;
@@ -4723,10 +4722,10 @@ gtk_ctree_set_node_info (GtkCTree     *ctree,
 	  gtk_ctree_remove_node (ctree, ptr);
 	}
     }
-
+  
   set_node_info (ctree, node, text, spacing, pixmap_closed, mask_closed,
 		 pixmap_opened, mask_opened, is_leaf, expanded);
-
+  
   if (!is_leaf && !old_leaf)
     {
       GTK_CTREE_ROW (node)->expanded = old_expanded;
@@ -4735,7 +4734,7 @@ gtk_ctree_set_node_info (GtkCTree     *ctree,
       else if (!expanded && old_expanded)
 	gtk_ctree_collapse (ctree, node);
     }
-
+  
   GTK_CTREE_ROW (node)->expanded = (is_leaf) ? FALSE : expanded;
   
   tree_draw_node (ctree, node);
@@ -4751,32 +4750,32 @@ gtk_ctree_node_set_shift (GtkCTree     *ctree,
   GtkCList *clist;
   GtkRequisition requisition;
   gboolean visible = FALSE;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   if (column < 0 || column >= GTK_CLIST (ctree)->columns)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (clist->column[column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
     {
       visible = gtk_ctree_is_viewable (ctree, node);
       if (visible)
-	GTK_CLIST_CLASS_FW (clist)->cell_size_request
+	GTK_CLIST_GET_CLASS (clist)->cell_size_request
 	  (clist, &GTK_CTREE_ROW (node)->row, column, &requisition);
     }
-
+  
   GTK_CTREE_ROW (node)->row.cell[column].vertical   = vertical;
   GTK_CTREE_ROW (node)->row.cell[column].horizontal = horizontal;
-
+  
   if (visible)
     column_auto_resize (clist, &GTK_CTREE_ROW (node)->row,
 			column, requisition.width);
-
+  
   tree_draw_node (ctree, node);
 }
 
@@ -4788,13 +4787,13 @@ remove_grab (GtkCList *clist)
       gtk_grab_remove (GTK_WIDGET (clist));
       gdk_pointer_ungrab (GDK_CURRENT_TIME);
     }
-
+  
   if (clist->htimer)
     {
       gtk_timeout_remove (clist->htimer);
       clist->htimer = 0;
     }
-
+  
   if (clist->vtimer)
     {
       gtk_timeout_remove (clist->vtimer);
@@ -4810,25 +4809,25 @@ gtk_ctree_node_set_selectable (GtkCTree     *ctree,
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   if (selectable == GTK_CTREE_ROW (node)->row.selectable)
     return;
-
+  
   GTK_CTREE_ROW (node)->row.selectable = selectable;
-
+  
   if (!selectable && GTK_CTREE_ROW (node)->row.state == GTK_STATE_SELECTED)
     {
       GtkCList *clist;
-
+      
       clist = GTK_CLIST (ctree);
-
+      
       if (clist->anchor >= 0 &&
 	  clist->selection_mode == GTK_SELECTION_EXTENDED)
 	{
 	  clist->drag_button = 0;
 	  remove_grab (clist);
-
-	  GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+	  
+	  GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
 	}
       gtk_ctree_unselect (ctree, node);
     }      
@@ -4839,7 +4838,7 @@ gtk_ctree_node_get_selectable (GtkCTree     *ctree,
 			       GtkCTreeNode *node)
 {
   g_return_val_if_fail (node != NULL, FALSE);
-
+  
   return GTK_CTREE_ROW (node)->row.selectable;
 }
 
@@ -4851,10 +4850,10 @@ gtk_ctree_node_get_cell_type (GtkCTree     *ctree,
   g_return_val_if_fail (ctree != NULL, -1);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), -1);
   g_return_val_if_fail (node != NULL, -1);
-
+  
   if (column < 0 || column >= GTK_CLIST (ctree)->columns)
     return -1;
-
+  
   return GTK_CTREE_ROW (node)->row.cell[column].type;
 }
 
@@ -4867,16 +4866,16 @@ gtk_ctree_node_get_text (GtkCTree      *ctree,
   g_return_val_if_fail (ctree != NULL, 0);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
   g_return_val_if_fail (node != NULL, 0);
-
+  
   if (column < 0 || column >= GTK_CLIST (ctree)->columns)
     return 0;
-
+  
   if (GTK_CTREE_ROW (node)->row.cell[column].type != GTK_CELL_TEXT)
     return 0;
-
+  
   if (text)
     *text = GTK_CELL_TEXT (GTK_CTREE_ROW (node)->row.cell[column])->text;
-
+  
   return 1;
 }
 
@@ -4890,18 +4889,18 @@ gtk_ctree_node_get_pixmap (GtkCTree     *ctree,
   g_return_val_if_fail (ctree != NULL, 0);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
   g_return_val_if_fail (node != NULL, 0);
-
+  
   if (column < 0 || column >= GTK_CLIST (ctree)->columns)
     return 0;
-
+  
   if (GTK_CTREE_ROW (node)->row.cell[column].type != GTK_CELL_PIXMAP)
     return 0;
-
+  
   if (pixmap)
     *pixmap = GTK_CELL_PIXMAP (GTK_CTREE_ROW(node)->row.cell[column])->pixmap;
   if (mask)
     *mask = GTK_CELL_PIXMAP (GTK_CTREE_ROW (node)->row.cell[column])->mask;
-
+  
   return 1;
 }
 
@@ -4985,37 +4984,37 @@ gtk_ctree_node_set_cell_style (GtkCTree     *ctree,
   GtkCList *clist;
   GtkRequisition requisition;
   gboolean visible = FALSE;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (column < 0 || column >= clist->columns)
     return;
-
+  
   if (GTK_CTREE_ROW (node)->row.cell[column].style == style)
     return;
-
+  
   if (clist->column[column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
     {
       visible = gtk_ctree_is_viewable (ctree, node);
       if (visible)
-	GTK_CLIST_CLASS_FW (clist)->cell_size_request
+	GTK_CLIST_GET_CLASS (clist)->cell_size_request
 	  (clist, &GTK_CTREE_ROW (node)->row, column, &requisition);
     }
-
+  
   if (GTK_CTREE_ROW (node)->row.cell[column].style)
     {
       if (GTK_WIDGET_REALIZED (ctree))
         gtk_style_detach (GTK_CTREE_ROW (node)->row.cell[column].style);
       gtk_style_unref (GTK_CTREE_ROW (node)->row.cell[column].style);
     }
-
+  
   GTK_CTREE_ROW (node)->row.cell[column].style = style;
-
+  
   if (GTK_CTREE_ROW (node)->row.cell[column].style)
     {
       gtk_style_ref (GTK_CTREE_ROW (node)->row.cell[column].style);
@@ -5025,11 +5024,11 @@ gtk_ctree_node_set_cell_style (GtkCTree     *ctree,
 	  gtk_style_attach (GTK_CTREE_ROW (node)->row.cell[column].style,
 			    clist->clist_window);
     }
-
+  
   if (visible)
     column_auto_resize (clist, &GTK_CTREE_ROW (node)->row, column,
 			requisition.width);
-
+  
   tree_draw_node (ctree, node);
 }
 
@@ -5041,10 +5040,10 @@ gtk_ctree_node_get_cell_style (GtkCTree     *ctree,
   g_return_val_if_fail (ctree != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
   g_return_val_if_fail (node != NULL, NULL);
-
+  
   if (column < 0 || column >= GTK_CLIST (ctree)->columns)
     return NULL;
-
+  
   return GTK_CTREE_ROW (node)->row.cell[column].style;
 }
 
@@ -5058,13 +5057,13 @@ gtk_ctree_node_set_row_style (GtkCTree     *ctree,
   gboolean visible;
   gint *old_width = NULL;
   gint i;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (GTK_CTREE_ROW (node)->row.style == style)
     return;
   
@@ -5075,21 +5074,21 @@ gtk_ctree_node_set_row_style (GtkCTree     *ctree,
       for (i = 0; i < clist->columns; i++)
 	if (clist->column[i].auto_resize)
 	  {
-	    GTK_CLIST_CLASS_FW (clist)->cell_size_request
+	    GTK_CLIST_GET_CLASS (clist)->cell_size_request
 	      (clist, &GTK_CTREE_ROW (node)->row, i, &requisition);
 	    old_width[i] = requisition.width;
 	  }
     }
-
+  
   if (GTK_CTREE_ROW (node)->row.style)
     {
       if (GTK_WIDGET_REALIZED (ctree))
         gtk_style_detach (GTK_CTREE_ROW (node)->row.style);
       gtk_style_unref (GTK_CTREE_ROW (node)->row.style);
     }
-
+  
   GTK_CTREE_ROW (node)->row.style = style;
-
+  
   if (GTK_CTREE_ROW (node)->row.style)
     {
       gtk_style_ref (GTK_CTREE_ROW (node)->row.style);
@@ -5099,7 +5098,7 @@ gtk_ctree_node_set_row_style (GtkCTree     *ctree,
 	  gtk_style_attach (GTK_CTREE_ROW (node)->row.style,
 			    clist->clist_window);
     }
-
+  
   if (visible && !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
     {
       for (i = 0; i < clist->columns; i++)
@@ -5118,7 +5117,7 @@ gtk_ctree_node_get_row_style (GtkCTree     *ctree,
   g_return_val_if_fail (ctree != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
   g_return_val_if_fail (node != NULL, NULL);
-
+  
   return GTK_CTREE_ROW (node)->row.style;
 }
 
@@ -5130,7 +5129,7 @@ gtk_ctree_node_set_foreground (GtkCTree     *ctree,
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   if (color)
     {
       GTK_CTREE_ROW (node)->row.foreground = *color;
@@ -5141,7 +5140,7 @@ gtk_ctree_node_set_foreground (GtkCTree     *ctree,
     }
   else
     GTK_CTREE_ROW (node)->row.fg_set = FALSE;
-
+  
   tree_draw_node (ctree, node);
 }
 
@@ -5153,7 +5152,7 @@ gtk_ctree_node_set_background (GtkCTree     *ctree,
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   if (color)
     {
       GTK_CTREE_ROW (node)->row.background = *color;
@@ -5164,7 +5163,7 @@ gtk_ctree_node_set_background (GtkCTree     *ctree,
     }
   else
     GTK_CTREE_ROW (node)->row.bg_set = FALSE;
-
+  
   tree_draw_node (ctree, node);
 }
 
@@ -5188,13 +5187,13 @@ gtk_ctree_node_set_row_data_full (GtkCTree         *ctree,
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (node != NULL);
-
+  
   dnotify = GTK_CTREE_ROW (node)->row.destroy;
   ddata = GTK_CTREE_ROW (node)->row.data;
   
   GTK_CTREE_ROW (node)->row.data = data;
   GTK_CTREE_ROW (node)->row.destroy = destroy;
-
+  
   if (dnotify)
     dnotify (ddata);
 }
@@ -5205,7 +5204,7 @@ gtk_ctree_node_get_row_data (GtkCTree     *ctree,
 {
   g_return_val_if_fail (ctree != NULL, NULL);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
-
+  
   return node ? GTK_CTREE_ROW (node)->row.data : NULL;
 }
 
@@ -5218,15 +5217,15 @@ gtk_ctree_node_moveto (GtkCTree     *ctree,
 {
   gint row = -1;
   GtkCList *clist;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   while (node && !gtk_ctree_is_viewable (ctree, node))
     node = GTK_CTREE_ROW (node)->parent;
-
+  
   if (node)
     row = g_list_position (clist->row_list, (GList *)node);
   
@@ -5255,17 +5254,17 @@ gtk_ctree_set_indent (GtkCTree *ctree,
                       gint      indent)
 {
   GtkCList *clist;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (indent >= 0);
-
+  
   if (indent == ctree->tree_indent)
     return;
-
+  
   clist = GTK_CLIST (ctree);
   ctree->tree_indent = indent;
-
+  
   if (clist->column[ctree->tree_column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
     gtk_clist_set_column_width
@@ -5281,19 +5280,19 @@ gtk_ctree_set_spacing (GtkCTree *ctree,
 {
   GtkCList *clist;
   gint old_spacing;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
   g_return_if_fail (spacing >= 0);
-
+  
   if (spacing == ctree->tree_spacing)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   old_spacing = ctree->tree_spacing;
   ctree->tree_spacing = spacing;
-
+  
   if (clist->column[ctree->tree_column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
     gtk_clist_set_column_width (clist, ctree->tree_column,
@@ -5309,19 +5308,19 @@ gtk_ctree_set_show_stub (GtkCTree *ctree,
 {
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   show_stub = show_stub != FALSE;
-
+  
   if (show_stub != ctree->show_stub)
     {
       GtkCList *clist;
-
+      
       clist = GTK_CLIST (ctree);
       ctree->show_stub = show_stub;
-
+      
       if (CLIST_UNFROZEN (clist) && clist->rows &&
 	  gtk_clist_row_is_visible (clist, 0) != GTK_VISIBILITY_NONE)
-	GTK_CLIST_CLASS_FW (clist)->draw_row
+	GTK_CLIST_GET_CLASS (clist)->draw_row
 	  (clist, NULL, 0, GTK_CLIST_ROW (clist->row_list));
     }
 }
@@ -5332,18 +5331,18 @@ gtk_ctree_set_line_style (GtkCTree          *ctree,
 {
   GtkCList *clist;
   GtkCTreeLineStyle old_style;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   if (line_style == ctree->line_style)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   old_style = ctree->line_style;
   ctree->line_style = line_style;
-
+  
   if (clist->column[ctree->tree_column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
     {
@@ -5356,7 +5355,7 @@ gtk_ctree_set_line_style (GtkCTree          *ctree,
 	  (clist, ctree->tree_column,
 	   clist->column[ctree->tree_column].width + 3);
     }
-
+  
   if (GTK_WIDGET_REALIZED (ctree))
     {
       switch (line_style)
@@ -5392,23 +5391,23 @@ gtk_ctree_set_expander_style (GtkCTree              *ctree,
 {
   GtkCList *clist;
   GtkCTreeExpanderStyle old_style;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   if (expander_style == ctree->expander_style)
     return;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   old_style = ctree->expander_style;
   ctree->expander_style = expander_style;
-
+  
   if (clist->column[ctree->tree_column].auto_resize &&
       !GTK_CLIST_AUTO_RESIZE_BLOCKED (clist))
     {
       gint new_width;
-
+      
       new_width = clist->column[ctree->tree_column].width;
       switch (old_style)
 	{
@@ -5422,7 +5421,7 @@ gtk_ctree_set_expander_style (GtkCTree              *ctree,
 	  new_width -= PM_SIZE + 1;
 	  break;
 	}
-
+      
       switch (expander_style)
 	{
 	case GTK_CTREE_EXPANDER_NONE:
@@ -5435,10 +5434,10 @@ gtk_ctree_set_expander_style (GtkCTree              *ctree,
 	  new_width += PM_SIZE + 1;
 	  break;
 	}
-
+      
       gtk_clist_set_column_width (clist, ctree->tree_column, new_width);
     }
-
+  
   if (GTK_WIDGET_DRAWABLE (clist))
     CLIST_REFRESH (clist);
 }
@@ -5458,14 +5457,14 @@ tree_sort (GtkCTree     *ctree,
   GtkCTreeNode *cmp;
   GtkCTreeNode *work;
   GtkCList *clist;
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   if (node)
     list_start = GTK_CTREE_ROW (node)->children;
   else
     list_start = GTK_CTREE_NODE (clist->row_list);
-
+  
   while (list_start)
     {
       cmp = list_start;
@@ -5502,39 +5501,39 @@ gtk_ctree_sort_recursive (GtkCTree     *ctree,
 {
   GtkCList *clist;
   GtkCTreeNode *focus_node = NULL;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   gtk_clist_freeze (clist);
-
+  
   if (clist->selection_mode == GTK_SELECTION_EXTENDED)
     {
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
       
       g_list_free (clist->undo_selection);
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
     }
-
+  
   if (!node || (node && gtk_ctree_is_viewable (ctree, node)))
     focus_node =
       GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
-      
+  
   gtk_ctree_post_recursive (ctree, node, GTK_CTREE_FUNC (tree_sort), NULL);
-
+  
   if (!node)
     tree_sort (ctree, NULL, NULL);
-
+  
   if (focus_node)
     {
       clist->focus_row = g_list_position (clist->row_list,(GList *)focus_node);
       clist->undo_anchor = clist->focus_row;
     }
-
+  
   gtk_clist_thaw (clist);
 }
 
@@ -5550,36 +5549,36 @@ gtk_ctree_sort_node (GtkCTree     *ctree,
 {
   GtkCList *clist;
   GtkCTreeNode *focus_node = NULL;
-
+  
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   clist = GTK_CLIST (ctree);
-
+  
   gtk_clist_freeze (clist);
-
+  
   if (clist->selection_mode == GTK_SELECTION_EXTENDED)
     {
-      GTK_CLIST_CLASS_FW (clist)->resync_selection (clist, NULL);
+      GTK_CLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
       
       g_list_free (clist->undo_selection);
       g_list_free (clist->undo_unselection);
       clist->undo_selection = NULL;
       clist->undo_unselection = NULL;
     }
-
+  
   if (!node || (node && gtk_ctree_is_viewable (ctree, node)))
     focus_node = GTK_CTREE_NODE
       (g_list_nth (clist->row_list, clist->focus_row));
-
+  
   tree_sort (ctree, node, NULL);
-
+  
   if (focus_node)
     {
       clist->focus_row = g_list_position (clist->row_list,(GList *)focus_node);
       clist->undo_anchor = clist->focus_row;
     }
-
+  
   gtk_clist_thaw (clist);
 }
 
@@ -5591,7 +5590,7 @@ fake_unselect_all (GtkCList *clist,
 {
   GList *list;
   GList *focus_node = NULL;
-
+  
   if (row >= 0 && (focus_node = g_list_nth (clist->row_list, row)))
     {
       if (GTK_CTREE_ROW (focus_node)->row.state == GTK_STATE_NORMAL &&
@@ -5601,11 +5600,11 @@ fake_unselect_all (GtkCList *clist,
 	  
 	  if (CLIST_UNFROZEN (clist) &&
 	      gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE)
-	    GTK_CLIST_CLASS_FW (clist)->draw_row (clist, NULL, row,
-						  GTK_CLIST_ROW (focus_node));
+	    GTK_CLIST_GET_CLASS (clist)->draw_row (clist, NULL, row,
+						   GTK_CLIST_ROW (focus_node));
 	}  
     }
-
+  
   clist->undo_selection = clist->selection;
   clist->selection = NULL;
   clist->selection_end = NULL;
@@ -5614,7 +5613,7 @@ fake_unselect_all (GtkCList *clist,
     {
       if (list->data == focus_node)
 	continue;
-
+      
       GTK_CTREE_ROW ((GList *)(list->data))->row.state = GTK_STATE_NORMAL;
       tree_draw_node (GTK_CTREE (clist), GTK_CTREE_NODE (list->data));
     }
@@ -5638,23 +5637,23 @@ resync_selection (GtkCList *clist, GdkEvent *event)
   gint e;
   gint row;
   gboolean unselect;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
-
+  
   if (clist->selection_mode != GTK_SELECTION_EXTENDED)
     return;
-
+  
   if (clist->anchor < 0 || clist->drag_pos < 0)
     return;
-
+  
   ctree = GTK_CTREE (clist);
   
   clist->freeze_count++;
-
+  
   i = MIN (clist->anchor, clist->drag_pos);
   e = MAX (clist->anchor, clist->drag_pos);
-
+  
   if (clist->undo_selection)
     {
       list = clist->selection;
@@ -5662,14 +5661,14 @@ resync_selection (GtkCList *clist, GdkEvent *event)
       clist->selection_end = g_list_last (clist->selection);
       clist->undo_selection = list;
       list = clist->selection;
-
+      
       while (list)
 	{
 	  node = list->data;
 	  list = list->next;
 	  
 	  unselect = TRUE;
-
+	  
 	  if (gtk_ctree_is_viewable (ctree, node))
 	    {
 	      row = g_list_position (clist->row_list, (GList *)node);
@@ -5685,7 +5684,7 @@ resync_selection (GtkCList *clist, GdkEvent *event)
 	    }
 	}
     }    
-
+  
   if (clist->anchor < clist->drag_pos)
     {
       for (node = GTK_CTREE_NODE (g_list_nth (clist->row_list, i)); i <= e;
@@ -5734,14 +5733,14 @@ resync_selection (GtkCList *clist, GdkEvent *event)
 	      }
 	  }
     }
-
+  
   clist->undo_unselection = g_list_reverse (clist->undo_unselection);
   for (list = clist->undo_unselection; list; list = list->next)
     gtk_ctree_select (ctree, list->data);
-
+  
   clist->anchor = -1;
   clist->drag_pos = -1;
-
+  
   if (!CLIST_UNFROZEN (clist))
     clist->freeze_count--;
 }
@@ -5751,29 +5750,29 @@ real_undo_selection (GtkCList *clist)
 {
   GtkCTree *ctree;
   GList *work;
-
+  
   g_return_if_fail (clist != NULL);
   g_return_if_fail (GTK_IS_CTREE (clist));
-
+  
   if (clist->selection_mode != GTK_SELECTION_EXTENDED)
     return;
-
+  
   if (!(clist->undo_selection || clist->undo_unselection))
     {
       gtk_clist_unselect_all (clist);
       return;
     }
-
+  
   ctree = GTK_CTREE (clist);
-
+  
   for (work = clist->undo_selection; work; work = work->next)
     if (GTK_CTREE_ROW (work->data)->row.selectable)
       gtk_ctree_select (ctree, GTK_CTREE_NODE (work->data));
-
+  
   for (work = clist->undo_unselection; work; work = work->next)
     if (GTK_CTREE_ROW (work->data)->row.selectable)
       gtk_ctree_unselect (ctree, GTK_CTREE_NODE (work->data));
-
+  
   if (GTK_WIDGET_HAS_FOCUS (clist) && clist->focus_row != clist->undo_anchor)
     {
       gtk_widget_draw_focus (GTK_WIDGET (clist));
@@ -5784,18 +5783,18 @@ real_undo_selection (GtkCList *clist)
     clist->focus_row = clist->undo_anchor;
   
   clist->undo_anchor = -1;
- 
+  
   g_list_free (clist->undo_selection);
   g_list_free (clist->undo_unselection);
   clist->undo_selection = NULL;
   clist->undo_unselection = NULL;
-
+  
   if (ROW_TOP_YPIXEL (clist, clist->focus_row) + clist->row_height >
       clist->clist_window_height)
     gtk_clist_moveto (clist, clist->focus_row, -1, 1, 0);
   else if (ROW_TOP_YPIXEL (clist, clist->focus_row) < 0)
     gtk_clist_moveto (clist, clist->focus_row, -1, 0, 0);
-
+  
 }
 
 void
@@ -5804,7 +5803,7 @@ gtk_ctree_set_drag_compare_func (GtkCTree                *ctree,
 {
   g_return_if_fail (ctree != NULL);
   g_return_if_fail (GTK_IS_CTREE (ctree));
-
+  
   ctree->drag_compare = cmp_func;
 }
 
@@ -5816,7 +5815,7 @@ check_drag (GtkCTree        *ctree,
 {
   g_return_val_if_fail (ctree != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CTREE (ctree), FALSE);
-
+  
   if (drag_source && drag_source != drag_target &&
       (!GTK_CTREE_ROW (drag_source)->children ||
        !gtk_ctree_is_ancestor (ctree, drag_source, drag_target)))
@@ -5862,7 +5861,7 @@ static void
 drag_dest_info_destroy (gpointer data)
 {
   GtkCListDestInfo *info = data;
-
+  
   g_free (info);
 }
 
@@ -5873,15 +5872,15 @@ drag_dest_cell (GtkCList         *clist,
 		GtkCListDestInfo *dest_info)
 {
   GtkWidget *widget;
-
+  
   widget = GTK_WIDGET (clist);
-
+  
   dest_info->insert_pos = GTK_CLIST_DRAG_NONE;
-
+  
   y -= (GTK_CONTAINER (widget)->border_width +
 	widget->style->klass->ythickness + clist->column_title_area.height);
   dest_info->cell.row = ROW_FROM_YPIXEL (clist, y);
-
+  
   if (dest_info->cell.row >= clist->rows)
     {
       dest_info->cell.row = clist->rows - 1;
@@ -5889,15 +5888,15 @@ drag_dest_cell (GtkCList         *clist,
     }
   if (dest_info->cell.row < -1)
     dest_info->cell.row = -1;
-
+  
   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)
     {
       gint y_delta;
       gint h = 0;
-
+      
       y_delta = y - ROW_TOP_YPIXEL (clist, dest_info->cell.row);
       
       if (GTK_CLIST_DRAW_DRAG_RECT(clist) &&
@@ -5912,7 +5911,7 @@ drag_dest_cell (GtkCList         *clist,
 	  dest_info->insert_pos = GTK_CLIST_DRAG_BEFORE;
 	  h = clist->row_height / 2;
 	}
-
+      
       if (GTK_CLIST_DRAW_DRAG_LINE(clist))
 	{
 	  if (y_delta < h)
@@ -5930,22 +5929,22 @@ gtk_ctree_drag_begin (GtkWidget	     *widget,
   GtkCList *clist;
   GtkCTree *ctree;
   gboolean use_icons;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CTREE (widget));
   g_return_if_fail (context != NULL);
-
+  
   clist = GTK_CLIST (widget);
   ctree = GTK_CTREE (widget);
-
+  
   use_icons = GTK_CLIST_USE_DRAG_ICONS (clist);
   GTK_CLIST_UNSET_FLAG (clist, CLIST_USE_DRAG_ICONS);
   GTK_WIDGET_CLASS (parent_class)->drag_begin (widget, context);
-
+  
   if (use_icons)
     {
       GtkCTreeNode *node;
-
+      
       GTK_CLIST_SET_FLAG (clist, CLIST_USE_DRAG_ICONS);
       node = GTK_CTREE_NODE (g_list_nth (clist->row_list,
 					 clist->click_cell.row));
@@ -5980,34 +5979,34 @@ gtk_ctree_drag_motion (GtkWidget      *widget,
   GtkCTree *ctree;
   GtkCListDestInfo new_info;
   GtkCListDestInfo *dest_info;
-
+  
   g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_CTREE (widget), FALSE);
-
+  
   clist = GTK_CLIST (widget);
   ctree = GTK_CTREE (widget);
-
+  
   dest_info = g_dataset_get_data (context, "gtk-clist-drag-dest");
-
+  
   if (!dest_info)
     {
       dest_info = g_new (GtkCListDestInfo, 1);
-	  
+      
       dest_info->cell.row    = -1;
       dest_info->cell.column = -1;
       dest_info->insert_pos  = GTK_CLIST_DRAG_NONE;
-
+      
       g_dataset_set_data_full (context, "gtk-clist-drag-dest", dest_info,
 			       drag_dest_info_destroy);
     }
-
+  
   drag_dest_cell (clist, x, y, &new_info);
-
+  
   if (GTK_CLIST_REORDERABLE (clist))
     {
       GList *list;
       GdkAtom atom = gdk_atom_intern ("gtk-clist-drag-reorder", FALSE);
-
+      
       list = context->targets;
       while (list)
 	{
@@ -6015,17 +6014,17 @@ gtk_ctree_drag_motion (GtkWidget      *widget,
 	    break;
 	  list = list->next;
 	}
-
+      
       if (list)
 	{
 	  GtkCTreeNode *drag_source;
 	  GtkCTreeNode *drag_target;
-
+	  
 	  drag_source = GTK_CTREE_NODE (g_list_nth (clist->row_list,
 						    clist->click_cell.row));
 	  drag_target = GTK_CTREE_NODE (g_list_nth (clist->row_list,
 						    new_info.cell.row));
-
+	  
 	  if (gtk_drag_get_source_widget (context) != widget ||
 	      !check_drag (ctree, drag_source, drag_target,
 			   new_info.insert_pos))
@@ -6037,32 +6036,32 @@ gtk_ctree_drag_motion (GtkWidget      *widget,
 		}
 	      return TRUE;
 	    }
-
+	  
 	  if (new_info.cell.row != dest_info->cell.row ||
 	      (new_info.cell.row == dest_info->cell.row &&
 	       dest_info->insert_pos != new_info.insert_pos))
 	    {
 	      if (dest_info->cell.row >= 0)
-		GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+		GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
 		  (clist,
 		   g_list_nth (clist->row_list, dest_info->cell.row)->data,
 		   dest_info->cell.row, dest_info->insert_pos);
-
+	      
 	      dest_info->insert_pos  = new_info.insert_pos;
 	      dest_info->cell.row    = new_info.cell.row;
 	      dest_info->cell.column = new_info.cell.column;
-
-	      GTK_CLIST_CLASS_FW (clist)->draw_drag_highlight
+	      
+	      GTK_CLIST_GET_CLASS (clist)->draw_drag_highlight
 		(clist,
 		 g_list_nth (clist->row_list, dest_info->cell.row)->data,
 		 dest_info->cell.row, dest_info->insert_pos);
-
+	      
 	      gdk_drag_status (context, context->suggested_action, time);
 	    }
 	  return TRUE;
 	}
     }
-
+  
   dest_info->insert_pos  = new_info.insert_pos;
   dest_info->cell.row    = new_info.cell.row;
   dest_info->cell.column = new_info.cell.column;
@@ -6080,15 +6079,15 @@ gtk_ctree_drag_data_received (GtkWidget        *widget,
 {
   GtkCTree *ctree;
   GtkCList *clist;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_CTREE (widget));
   g_return_if_fail (context != NULL);
   g_return_if_fail (selection_data != NULL);
-
+  
   ctree = GTK_CTREE (widget);
   clist = GTK_CLIST (widget);
-
+  
   if (GTK_CLIST_REORDERABLE (clist) &&
       gtk_drag_get_source_widget (context) == widget &&
       selection_data->target ==
@@ -6097,24 +6096,24 @@ gtk_ctree_drag_data_received (GtkWidget        *widget,
       selection_data->length == sizeof (GtkCListCellInfo))
     {
       GtkCListCellInfo *source_info;
-
+      
       source_info = (GtkCListCellInfo *)(selection_data->data);
       if (source_info)
 	{
 	  GtkCListDestInfo dest_info;
 	  GtkCTreeNode *source_node;
 	  GtkCTreeNode *dest_node;
-
+	  
 	  drag_dest_cell (clist, x, y, &dest_info);
 	  
 	  source_node = GTK_CTREE_NODE (g_list_nth (clist->row_list,
 						    source_info->row));
 	  dest_node = GTK_CTREE_NODE (g_list_nth (clist->row_list,
 						  dest_info.cell.row));
-
+	  
 	  if (!source_node || !dest_node)
 	    return;
-
+	  
 	  switch (dest_info.insert_pos)
 	    {
 	    case GTK_CLIST_DRAG_NONE:
diff --git a/gtk/gtkcurve.c b/gtk/gtkcurve.c
index 2e19e0a90..f2622a324 100644
--- a/gtk/gtkcurve.c
+++ b/gtk/gtkcurve.c
@@ -68,7 +68,7 @@ static void gtk_curve_set_arg     (GtkObject      *object,
 static void gtk_curve_get_arg     (GtkObject      *object,
 				   GtkArg         *arg,
 				   guint           arg_id);
-static void gtk_curve_finalize     (GtkObject     *object);
+static void gtk_curve_finalize     (GObject       *object);
 static gint gtk_curve_graph_events (GtkWidget     *widget, 
 				    GdkEvent      *event, 
 				    GtkCurve      *c);
@@ -101,18 +101,18 @@ gtk_curve_get_type (void)
 static void
 gtk_curve_class_init (GtkCurveClass *class)
 {
-  GtkObjectClass *object_class;
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+  GtkObjectClass *object_class = GTK_OBJECT_CLASS (class);
   
   parent_class = gtk_type_class (GTK_TYPE_DRAWING_AREA);
   
-  object_class = (GtkObjectClass *) class;
-  
+  gobject_class->finalize = gtk_curve_finalize;
+
   object_class->set_arg = gtk_curve_set_arg;
   object_class->get_arg = gtk_curve_get_arg;
-  object_class->finalize = gtk_curve_finalize;
   
   curve_type_changed_signal =
-    gtk_signal_new ("curve_type_changed", GTK_RUN_FIRST, object_class->type,
+    gtk_signal_new ("curve_type_changed", GTK_RUN_FIRST, GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkCurveClass, curve_type_changed),
 		    gtk_marshal_NONE__NONE, GTK_TYPE_NONE, 0);
   gtk_object_class_add_signals (object_class, &curve_type_changed_signal, 1);
@@ -942,7 +942,7 @@ gtk_curve_new (void)
 }
 
 static void
-gtk_curve_finalize (GtkObject *object)
+gtk_curve_finalize (GObject *object)
 {
   GtkCurve *curve;
 
@@ -957,5 +957,5 @@ gtk_curve_finalize (GtkObject *object)
   if (curve->ctlpoint)
     g_free (curve->ctlpoint);
 
-  (*GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
diff --git a/gtk/gtkdata.c b/gtk/gtkdata.c
index b285d42a4..c2dcf6383 100644
--- a/gtk/gtkdata.c
+++ b/gtk/gtkdata.c
@@ -75,7 +75,7 @@ gtk_data_class_init (GtkDataClass *class)
   data_signals[DISCONNECT] =
     gtk_signal_new ("disconnect",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkDataClass, disconnect),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
diff --git a/gtk/gtkeditable.c b/gtk/gtkeditable.c
index 04d64a50a..87bfe85fb 100644
--- a/gtk/gtkeditable.c
+++ b/gtk/gtkeditable.c
@@ -148,7 +148,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[CHANGED] =
     gtk_signal_new ("changed",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, changed),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
@@ -156,7 +156,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[INSERT_TEXT] =
     gtk_signal_new ("insert_text",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, insert_text),
 		    gtk_marshal_NONE__POINTER_INT_POINTER,
 		    GTK_TYPE_NONE,
@@ -168,7 +168,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[DELETE_TEXT] =
     gtk_signal_new ("delete_text",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, delete_text),
 		    gtk_marshal_NONE__INT_INT,
 		    GTK_TYPE_NONE,
@@ -179,7 +179,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[ACTIVATE] =
     gtk_signal_new ("activate",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, activate),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
@@ -188,7 +188,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[SET_EDITABLE] =
     gtk_signal_new ("set-editable",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, set_editable),
 		    gtk_marshal_NONE__BOOL,
 		    GTK_TYPE_NONE, 1,
@@ -197,7 +197,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[MOVE_CURSOR] =
     gtk_signal_new ("move_cursor",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, move_cursor),
 		    gtk_marshal_NONE__INT_INT,
 		    GTK_TYPE_NONE, 2, 
@@ -207,7 +207,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[MOVE_WORD] =
     gtk_signal_new ("move_word",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, move_word),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1, 
@@ -216,7 +216,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[MOVE_PAGE] =
     gtk_signal_new ("move_page",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, move_page),
 		    gtk_marshal_NONE__INT_INT,
 		    GTK_TYPE_NONE, 2, 
@@ -226,7 +226,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[MOVE_TO_ROW] =
     gtk_signal_new ("move_to_row",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, move_to_row),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1, 
@@ -235,7 +235,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[MOVE_TO_COLUMN] =
     gtk_signal_new ("move_to_column",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, move_to_column),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1, 
@@ -244,7 +244,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[KILL_CHAR] =
     gtk_signal_new ("kill_char",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, kill_char),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1, 
@@ -253,7 +253,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[KILL_WORD] =
     gtk_signal_new ("kill_word",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, kill_word),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1, 
@@ -262,7 +262,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[KILL_LINE] =
     gtk_signal_new ("kill_line",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, kill_line),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1, 
@@ -271,7 +271,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[CUT_CLIPBOARD] =
     gtk_signal_new ("cut_clipboard",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, cut_clipboard),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
@@ -279,7 +279,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[COPY_CLIPBOARD] =
     gtk_signal_new ("copy_clipboard",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, copy_clipboard),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
@@ -287,7 +287,7 @@ gtk_editable_class_init (GtkEditableClass *class)
   editable_signals[PASTE_CLIPBOARD] =
     gtk_signal_new ("paste_clipboard",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkEditableClass, paste_clipboard),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
@@ -422,7 +422,7 @@ gtk_editable_insert_text (GtkEditable *editable,
 
   gtk_widget_ref (GTK_WIDGET (editable));
 
-  klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+  klass = GTK_EDITABLE_GET_CLASS (editable);
 
   if (new_text_length <= 64)
     text = buf;
@@ -452,7 +452,7 @@ gtk_editable_delete_text (GtkEditable *editable,
 
   gtk_widget_ref (GTK_WIDGET (editable));
 
-  klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+  klass = GTK_EDITABLE_GET_CLASS (editable);
 
   gtk_signal_emit (GTK_OBJECT (editable), editable_signals[DELETE_TEXT], start_pos, end_pos);
   gtk_signal_emit (GTK_OBJECT (editable), editable_signals[CHANGED]);
@@ -470,7 +470,7 @@ gtk_editable_update_text (GtkEditable *editable,
   g_return_if_fail (editable != NULL);
   g_return_if_fail (GTK_IS_EDITABLE (editable));
 
-  klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+  klass = GTK_EDITABLE_GET_CLASS (editable);
 
   klass->update_text (editable, start_pos, end_pos);
 }
@@ -485,7 +485,7 @@ gtk_editable_get_chars      (GtkEditable      *editable,
   g_return_val_if_fail (editable != NULL, NULL);
   g_return_val_if_fail (GTK_IS_EDITABLE (editable), NULL);
 
-  klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+  klass = GTK_EDITABLE_GET_CLASS (editable);
 
   return klass->get_chars (editable, start, end);
 }
@@ -529,7 +529,7 @@ gtk_editable_set_selection (GtkEditable *editable,
   g_return_if_fail (editable != NULL);
   g_return_if_fail (GTK_IS_EDITABLE (editable));
 
-  klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+  klass = GTK_EDITABLE_GET_CLASS (editable);
 
   klass->set_selection (editable, start_pos, end_pos);
 }
@@ -543,7 +543,7 @@ gtk_editable_set_position (GtkEditable      *editable,
   g_return_if_fail (editable != NULL);
   g_return_if_fail (GTK_IS_EDITABLE (editable));
 
-  klass = GTK_EDITABLE_CLASS (GTK_OBJECT (editable)->klass);
+  klass = GTK_EDITABLE_GET_CLASS (editable);
 
   klass->set_position (editable, position);
 }
diff --git a/gtk/gtkentry.c b/gtk/gtkentry.c
index 50db536b0..3f9eec91b 100644
--- a/gtk/gtkentry.c
+++ b/gtk/gtkentry.c
@@ -55,7 +55,7 @@ static void gtk_entry_set_arg      	  (GtkObject         *object,
 static void gtk_entry_get_arg		  (GtkObject         *object,
 					   GtkArg            *arg,
 					   guint              arg_id);
-static void gtk_entry_finalize            (GtkObject         *object);
+static void gtk_entry_finalize            (GObject           *object);
 static void gtk_entry_realize             (GtkWidget         *widget);
 static void gtk_entry_unrealize           (GtkWidget         *widget);
 static void gtk_entry_draw_focus          (GtkWidget         *widget);
@@ -249,6 +249,7 @@ gtk_entry_get_type (void)
 static void
 gtk_entry_class_init (GtkEntryClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkEditableClass *editable_class;
@@ -258,12 +259,13 @@ gtk_entry_class_init (GtkEntryClass *class)
   editable_class = (GtkEditableClass*) class;
   parent_class = gtk_type_class (GTK_TYPE_EDITABLE);
 
+  gobject_class->finalize = gtk_entry_finalize;
+
   gtk_object_add_arg_type ("GtkEntry::max_length", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_MAX_LENGTH);
   gtk_object_add_arg_type ("GtkEntry::visibility", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_VISIBILITY);
 
   object_class->set_arg = gtk_entry_set_arg;
   object_class->get_arg = gtk_entry_get_arg;
-  object_class->finalize = gtk_entry_finalize;
 
   widget_class->realize = gtk_entry_realize;
   widget_class->unrealize = gtk_entry_unrealize;
@@ -513,11 +515,10 @@ gtk_entry_get_text (GtkEntry *entry)
 }
 
 static void
-gtk_entry_finalize (GtkObject *object)
+gtk_entry_finalize (GObject *object)
 {
   GtkEntry *entry;
 
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_ENTRY (object));
 
   entry = GTK_ENTRY (object);
@@ -540,7 +541,7 @@ gtk_entry_finalize (GtkObject *object)
   if (entry->backing_pixmap)
     gdk_pixmap_unref (entry->backing_pixmap);
 
-  (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
diff --git a/gtk/gtkfilesel.c b/gtk/gtkfilesel.c
index 11d85c3f0..1a656256c 100644
--- a/gtk/gtkfilesel.c
+++ b/gtk/gtkfilesel.c
@@ -673,10 +673,7 @@ gtk_file_selection_hide_fileop_buttons (GtkFileSelection *filesel)
   g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
     
   if (filesel->fileop_ren_file) 
-    {
-      gtk_widget_destroy (filesel->fileop_ren_file);
-      filesel->fileop_ren_file = NULL;
-    }
+    gtk_widget_destroy (filesel->fileop_ren_file);
 
   if (filesel->fileop_del_file)
     {
@@ -770,14 +767,16 @@ gtk_file_selection_destroy (GtkObject *object)
   GtkFileSelection *filesel;
   GList *list;
   HistoryCallbackArg *callback_arg;
-
-  g_return_if_fail (object != NULL);
+  
   g_return_if_fail (GTK_IS_FILE_SELECTION (object));
-
+  
   filesel = GTK_FILE_SELECTION (object);
   
   if (filesel->fileop_dialog)
-	  gtk_widget_destroy (filesel->fileop_dialog);
+    {
+      gtk_widget_destroy (filesel->fileop_dialog);
+      filesel->fileop_dialog = NULL;
+    }
   
   if (filesel->history_list)
     {
@@ -792,12 +791,14 @@ gtk_file_selection_destroy (GtkObject *object)
       g_list_free (filesel->history_list);
       filesel->history_list = NULL;
     }
-  
-  cmpl_free_state (filesel->cmpl_state);
-  filesel->cmpl_state = NULL;
 
-  if (GTK_OBJECT_CLASS (parent_class)->destroy)
-    (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+  if (filesel->cmpl_state)
+    {
+      cmpl_free_state (filesel->cmpl_state);
+      filesel->cmpl_state = NULL;
+    }
+  
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 /* Begin file operations callbacks */
@@ -910,10 +911,11 @@ gtk_file_selection_create_dir (GtkWidget *widget, gpointer data)
   g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
 
   if (fs->fileop_dialog)
-	  return;
+    return;
   
   /* main dialog */
-  fs->fileop_dialog = dialog = gtk_dialog_new ();
+  dialog = gtk_dialog_new ();
+  fs->fileop_dialog = dialog;
   gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
 		      (GtkSignalFunc) gtk_file_selection_fileop_destroy, 
 		      (gpointer) fs);
@@ -1818,6 +1820,8 @@ cmpl_free_dir_sent_list(GList* dp0)
 static void
 cmpl_free_state (CompletionState* cmpl_state)
 {
+  g_return_if_fail (cmpl_state != NULL);
+
   cmpl_free_dir_list (cmpl_state->directory_storage);
   cmpl_free_dir_sent_list (cmpl_state->directory_sent_storage);
 
diff --git a/gtk/gtkframe.c b/gtk/gtkframe.c
index dc3ca9788..453519efa 100644
--- a/gtk/gtkframe.c
+++ b/gtk/gtkframe.c
@@ -44,7 +44,7 @@ static void gtk_frame_set_arg       (GtkObject      *object,
 static void gtk_frame_get_arg       (GtkObject      *object,
 				     GtkArg         *arg,
 				     guint           arg_id);
-static void gtk_frame_finalize      (GtkObject      *object);
+static void gtk_frame_finalize      (GObject        *object);
 static void gtk_frame_paint         (GtkWidget      *widget,
 				     GdkRectangle   *area);
 static void gtk_frame_draw          (GtkWidget      *widget,
@@ -90,6 +90,7 @@ gtk_frame_get_type (void)
 static void
 gtk_frame_class_init (GtkFrameClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
 
@@ -98,6 +99,8 @@ gtk_frame_class_init (GtkFrameClass *class)
 
   parent_class = gtk_type_class (gtk_bin_get_type ());
 
+  gobject_class->finalize = gtk_frame_finalize;
+
   gtk_object_add_arg_type ("GtkFrame::label", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL);
   gtk_object_add_arg_type ("GtkFrame::label_xalign", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_LABEL_XALIGN);
   gtk_object_add_arg_type ("GtkFrame::label_yalign", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_LABEL_YALIGN);
@@ -105,7 +108,6 @@ gtk_frame_class_init (GtkFrameClass *class)
 
   object_class->set_arg = gtk_frame_set_arg;
   object_class->get_arg = gtk_frame_get_arg;
-  object_class->finalize = gtk_frame_finalize;
 
   widget_class->draw = gtk_frame_draw;
   widget_class->expose_event = gtk_frame_expose;
@@ -314,11 +316,10 @@ gtk_frame_set_shadow_type (GtkFrame      *frame,
 
 
 static void
-gtk_frame_finalize (GtkObject *object)
+gtk_frame_finalize (GObject *object)
 {
   GtkFrame *frame;
 
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_FRAME (object));
 
   frame = GTK_FRAME (object);
@@ -326,7 +327,7 @@ gtk_frame_finalize (GtkObject *object)
   if (frame->label)
     g_free (frame->label);
 
-  (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
diff --git a/gtk/gtkhandlebox.c b/gtk/gtkhandlebox.c
index e35ca9962..ef2d7ad0c 100644
--- a/gtk/gtkhandlebox.c
+++ b/gtk/gtkhandlebox.c
@@ -181,7 +181,7 @@ gtk_handle_box_class_init (GtkHandleBoxClass *class)
   handle_box_signals[SIGNAL_CHILD_ATTACHED] =
     gtk_signal_new ("child_attached",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkHandleBoxClass, child_attached),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -189,7 +189,7 @@ gtk_handle_box_class_init (GtkHandleBoxClass *class)
   handle_box_signals[SIGNAL_CHILD_DETACHED] =
     gtk_signal_new ("child_detached",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkHandleBoxClass, child_detached),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
diff --git a/gtk/gtkhscale.c b/gtk/gtkhscale.c
index 51037cb57..94ba294b0 100644
--- a/gtk/gtkhscale.c
+++ b/gtk/gtkhscale.c
@@ -30,8 +30,8 @@
 #include "gdk/gdkkeysyms.h"
 
 
-#define SCALE_CLASS(w)  GTK_SCALE_CLASS (GTK_OBJECT (w)->klass)
-#define RANGE_CLASS(w)  GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+#define SCALE_CLASS(w)  GTK_SCALE_GET_CLASS (w)
+#define RANGE_CLASS(w)  GTK_RANGE_GET_CLASS (w)
 
 enum {
   ARG_0,
@@ -111,7 +111,7 @@ gtk_hscale_class_init (GtkHScaleClass *class)
   
   gtk_object_add_arg_type ("GtkHScale::adjustment",
                            GTK_TYPE_ADJUSTMENT,
-                           GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+                           GTK_ARG_READWRITE,
                            ARG_ADJUSTMENT);
   
   object_class->set_arg = gtk_hscale_set_arg;
diff --git a/gtk/gtkhscrollbar.c b/gtk/gtkhscrollbar.c
index 9ab5fa875..e506ff0ae 100644
--- a/gtk/gtkhscrollbar.c
+++ b/gtk/gtkhscrollbar.c
@@ -31,7 +31,7 @@
 
 #define EPSILON 0.01
 
-#define RANGE_CLASS(w)  GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+#define RANGE_CLASS(w)  GTK_RANGE_GET_CLASS (w)
 
 enum {
   ARG_0,
@@ -97,7 +97,7 @@ gtk_hscrollbar_class_init (GtkHScrollbarClass *class)
   
   gtk_object_add_arg_type ("GtkHScrollbar::adjustment",
                            GTK_TYPE_ADJUSTMENT,
-                           GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+                           GTK_ARG_READWRITE,
                            ARG_ADJUSTMENT);
   
   object_class->set_arg = gtk_hscrollbar_set_arg;
diff --git a/gtk/gtkhsv.c b/gtk/gtkhsv.c
index 568a14089..8ca57b66f 100644
--- a/gtk/gtkhsv.c
+++ b/gtk/gtkhsv.c
@@ -26,7 +26,12 @@
 #include "gtksignal.h"
 #include "gtkhsv.h"
 
-
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
 
 /* Default width/height */
 #define DEFAULT_SIZE 100
@@ -34,34 +39,33 @@
 /* Default ring width */
 #define DEFAULT_RING_WIDTH 10
 
-
 
 /* Dragging modes */
 typedef enum {
-	DRAG_NONE,
-	DRAG_H,
-	DRAG_SV
+  DRAG_NONE,
+  DRAG_H,
+  DRAG_SV
 } DragMode;
 
 /* Private part of the GtkHSV structure */
 typedef struct {
-	/* Color value */
-	double h;
-	double s;
-	double v;
-
-	/* Size and ring width */
-	int size;
-	int ring_width;
-
-	/* Window for capturing events */
-	GdkWindow *window;
-
-	/* GC for drawing */
-	GdkGC *gc;
-
-	/* Dragging mode */
-	DragMode mode;
+  /* Color value */
+  double h;
+  double s;
+  double v;
+  
+  /* Size and ring width */
+  int size;
+  int ring_width;
+  
+  /* Window for capturing events */
+  GdkWindow *window;
+  
+  /* GC for drawing */
+  GdkGC *gc;
+  
+  /* Dragging mode */
+  DragMode mode;
 } HSVPrivate;
 
 
@@ -69,30 +73,33 @@ typedef struct {
 /* Signal IDs */
 
 enum {
-	CHANGED,
-	LAST_SIGNAL
+  CHANGED,
+  LAST_SIGNAL
 };
 
-static void gtk_hsv_class_init (GtkHSVClass *class);
-static void gtk_hsv_init (GtkHSV *hsv);
-static void gtk_hsv_destroy (GtkObject *object);
-
-static void gtk_hsv_map (GtkWidget *widget);
-static void gtk_hsv_unmap (GtkWidget *widget);
-static void gtk_hsv_realize (GtkWidget *widget);
-static void gtk_hsv_unrealize (GtkWidget *widget);
-static void gtk_hsv_size_request (GtkWidget *widget, GtkRequisition *requisition);
-static void gtk_hsv_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
-static gint gtk_hsv_button_press (GtkWidget *widget, GdkEventButton *event);
-static gint gtk_hsv_button_release (GtkWidget *widget, GdkEventButton *event);
-static gint gtk_hsv_motion (GtkWidget *widget, GdkEventMotion *event);
-static gint gtk_hsv_expose (GtkWidget *widget, GdkEventExpose *event);
+static void gtk_hsv_class_init     (GtkHSVClass    *class);
+static void gtk_hsv_init           (GtkHSV         *hsv);
+static void gtk_hsv_destroy        (GtkObject      *object);
+static void gtk_hsv_map            (GtkWidget      *widget);
+static void gtk_hsv_unmap          (GtkWidget      *widget);
+static void gtk_hsv_realize        (GtkWidget      *widget);
+static void gtk_hsv_unrealize      (GtkWidget      *widget);
+static void gtk_hsv_size_request   (GtkWidget      *widget,
+				    GtkRequisition *requisition);
+static void gtk_hsv_size_allocate  (GtkWidget      *widget,
+				    GtkAllocation  *allocation);
+static gint gtk_hsv_button_press   (GtkWidget      *widget,
+				    GdkEventButton *event);
+static gint gtk_hsv_button_release (GtkWidget      *widget,
+				    GdkEventButton *event);
+static gint gtk_hsv_motion         (GtkWidget      *widget,
+				    GdkEventMotion *event);
+static gint gtk_hsv_expose         (GtkWidget      *widget,
+				    GdkEventExpose *event);
 
 static guint hsv_signals[LAST_SIGNAL];
-
 static GtkWidgetClass *parent_class;
 
-
 
 /**
  * gtk_hsv_get_type:
@@ -106,241 +113,239 @@ static GtkWidgetClass *parent_class;
 GtkType
 gtk_hsv_get_type (void)
 {
-	static GtkType hsv_type = 0;
-
-	if (!hsv_type) {
-		static const GtkTypeInfo hsv_info = {
-			"GtkHSV",
-			sizeof (GtkHSV),
-			sizeof (GtkHSVClass),
-			(GtkClassInitFunc) gtk_hsv_class_init,
-			(GtkObjectInitFunc) gtk_hsv_init,
-			NULL, /* reserved_1 */
-			NULL, /* reserved_2 */
-			(GtkClassInitFunc) NULL
-		};
-
-		hsv_type = gtk_type_unique (gtk_widget_get_type (), &hsv_info);
-	}
-
-	return hsv_type;
+  static GtkType hsv_type = 0;
+  
+  if (!hsv_type) {
+    static const GtkTypeInfo hsv_info = {
+      "GtkHSV",
+      sizeof (GtkHSV),
+      sizeof (GtkHSVClass),
+      (GtkClassInitFunc) gtk_hsv_class_init,
+      (GtkObjectInitFunc) gtk_hsv_init,
+      NULL, /* reserved_1 */
+      NULL, /* reserved_2 */
+      (GtkClassInitFunc) NULL
+    };
+    
+    hsv_type = gtk_type_unique (GTK_TYPE_WIDGET, &hsv_info);
+  }
+  
+  return hsv_type;
 }
 
 /* Class initialization function for the HSV color selector */
 static void
 gtk_hsv_class_init (GtkHSVClass *class)
 {
-	GtkObjectClass *object_class;
-	GtkWidgetClass *widget_class;
-
-	object_class = (GtkObjectClass *) class;
-	widget_class = (GtkWidgetClass *) class;
-
-	parent_class = gtk_type_class (gtk_widget_get_type ());
-
-	hsv_signals[CHANGED] =
-		gtk_signal_new ("changed",
-				GTK_RUN_FIRST,
-				object_class->type,
-				GTK_SIGNAL_OFFSET (GtkHSVClass, changed),
-				gtk_marshal_NONE__NONE,
-				GTK_TYPE_NONE, 0);
-
-	gtk_object_class_add_signals (object_class, hsv_signals, LAST_SIGNAL);
-
-	object_class->destroy = gtk_hsv_destroy;
-
-	widget_class->map = gtk_hsv_map;
-	widget_class->unmap = gtk_hsv_unmap;
-	widget_class->realize = gtk_hsv_realize;
-	widget_class->unrealize = gtk_hsv_unrealize;
-	widget_class->size_request = gtk_hsv_size_request;
-	widget_class->size_allocate = gtk_hsv_size_allocate;
-	widget_class->button_press_event = gtk_hsv_button_press;
-	widget_class->button_release_event = gtk_hsv_button_release;
-	widget_class->motion_notify_event = gtk_hsv_motion;
-	widget_class->expose_event = gtk_hsv_expose;
+  GtkObjectClass *object_class;
+  GtkWidgetClass *widget_class;
+  
+  object_class = (GtkObjectClass *) class;
+  widget_class = (GtkWidgetClass *) class;
+  
+  parent_class = gtk_type_class (GTK_TYPE_WIDGET);
+  
+  hsv_signals[CHANGED] =
+    gtk_signal_new ("changed",
+		    GTK_RUN_FIRST,
+		    GTK_CLASS_TYPE (object_class),
+		    GTK_SIGNAL_OFFSET (GtkHSVClass, changed),
+		    gtk_marshal_NONE__NONE,
+		    GTK_TYPE_NONE, 0);
+  gtk_object_class_add_signals (object_class, hsv_signals, LAST_SIGNAL);
+  
+  object_class->destroy = gtk_hsv_destroy;
+  
+  widget_class->map = gtk_hsv_map;
+  widget_class->unmap = gtk_hsv_unmap;
+  widget_class->realize = gtk_hsv_realize;
+  widget_class->unrealize = gtk_hsv_unrealize;
+  widget_class->size_request = gtk_hsv_size_request;
+  widget_class->size_allocate = gtk_hsv_size_allocate;
+  widget_class->button_press_event = gtk_hsv_button_press;
+  widget_class->button_release_event = gtk_hsv_button_release;
+  widget_class->motion_notify_event = gtk_hsv_motion;
+  widget_class->expose_event = gtk_hsv_expose;
 }
 
 /* Object initialization function for the HSV color selector */
 static void
 gtk_hsv_init (GtkHSV *hsv)
 {
-	HSVPrivate *priv;
-
-	priv = g_new0 (HSVPrivate, 1);
-	hsv->priv = priv;
-
-	GTK_WIDGET_SET_FLAGS (hsv, GTK_NO_WINDOW);
-
-	priv->h = 0.0;
-	priv->s = 0.0;
-	priv->v = 0.0;
-
-	priv->size = DEFAULT_SIZE;
-	priv->ring_width = DEFAULT_RING_WIDTH;
+  HSVPrivate *priv;
+  
+  priv = g_new0 (HSVPrivate, 1);
+  hsv->priv = priv;
+  
+  GTK_WIDGET_SET_FLAGS (hsv, GTK_NO_WINDOW);
+  
+  priv->h = 0.0;
+  priv->s = 0.0;
+  priv->v = 0.0;
+  
+  priv->size = DEFAULT_SIZE;
+  priv->ring_width = DEFAULT_RING_WIDTH;
 }
 
 /* Destroy handler for the HSV color selector */
 static void
 gtk_hsv_destroy (GtkObject *object)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-
-	g_return_if_fail (object != NULL);
-	g_return_if_fail (GTK_IS_HSV (object));
-
-	hsv = GTK_HSV (object);
-	priv = hsv->priv;
-
-	g_free (priv);
-
-	if (GTK_OBJECT_CLASS (parent_class)->destroy)
-		(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+  GtkHSV *hsv;
+  
+  g_return_if_fail (GTK_IS_HSV (object));
+  
+  hsv = GTK_HSV (object);
+
+  if (hsv->priv)
+    {
+      g_free (hsv->priv);
+      hsv->priv = NULL;
+    }
+
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
-
-
 /* Default signal handlers */
 
 /* Map handler for the HSV color selector */
 static void
 gtk_hsv_map (GtkWidget *widget)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-
-	hsv = GTK_HSV (widget);
-	priv = hsv->priv;
-
-	if (GTK_WIDGET_MAPPED (widget))
-		return;
-
-	GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
-
-	gdk_window_show (priv->window);
+  GtkHSV *hsv;
+  HSVPrivate *priv;
+  
+  hsv = GTK_HSV (widget);
+  priv = hsv->priv;
+  
+  if (GTK_WIDGET_MAPPED (widget))
+    return;
+  
+  GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+  
+  gdk_window_show (priv->window);
 }
 
 /* Unmap handler for the HSV color selector */
 static void
 gtk_hsv_unmap (GtkWidget *widget)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-
-	hsv = GTK_HSV (widget);
-	priv = hsv->priv;
-
-	if (!GTK_WIDGET_MAPPED (widget))
-		return;
-
-	GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
-
-	gdk_window_hide (priv->window);
+  GtkHSV *hsv;
+  HSVPrivate *priv;
+  
+  hsv = GTK_HSV (widget);
+  priv = hsv->priv;
+  
+  if (!GTK_WIDGET_MAPPED (widget))
+    return;
+  
+  GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+  
+  gdk_window_hide (priv->window);
 }
 
 /* Realize handler for the HSV color selector */
 static void
 gtk_hsv_realize (GtkWidget *widget)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-	GdkWindowAttr attr;
-	int attr_mask;
-	GdkWindow *parent_window;
-
-	hsv = GTK_HSV (widget);
-	priv = hsv->priv;
-
-	GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
-
-	/* Create window */
-
-	attr.window_type = GDK_WINDOW_CHILD;
-	attr.x = widget->allocation.x;
-	attr.y = widget->allocation.y;
-	attr.width = widget->allocation.width;
-	attr.height = widget->allocation.height;
-	attr.wclass = GDK_INPUT_ONLY;
-	attr.event_mask = gtk_widget_get_events (widget);
-	attr.event_mask |= (GDK_BUTTON_PRESS_MASK
-			    | GDK_BUTTON_RELEASE_MASK
-			    | GDK_POINTER_MOTION_MASK);
-
-	attr_mask = GDK_WA_X | GDK_WA_Y;
-
-	parent_window = gtk_widget_get_parent_window (widget);
-
-	widget->window = parent_window;
-	gdk_window_ref (widget->window);
-
-	priv->window = gdk_window_new (parent_window, &attr, attr_mask);
-	gdk_window_set_user_data (priv->window, hsv);
-
-	widget->style = gtk_style_attach (widget->style, widget->window);
-
-	/* Create GC */
-
-	priv->gc = gdk_gc_new (parent_window);
+  GtkHSV *hsv;
+  HSVPrivate *priv;
+  GdkWindowAttr attr;
+  int attr_mask;
+  GdkWindow *parent_window;
+  
+  hsv = GTK_HSV (widget);
+  priv = hsv->priv;
+  
+  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+  
+  /* Create window */
+  
+  attr.window_type = GDK_WINDOW_CHILD;
+  attr.x = widget->allocation.x;
+  attr.y = widget->allocation.y;
+  attr.width = widget->allocation.width;
+  attr.height = widget->allocation.height;
+  attr.wclass = GDK_INPUT_ONLY;
+  attr.event_mask = gtk_widget_get_events (widget);
+  attr.event_mask |= (GDK_BUTTON_PRESS_MASK
+		      | GDK_BUTTON_RELEASE_MASK
+		      | GDK_POINTER_MOTION_MASK);
+  
+  attr_mask = GDK_WA_X | GDK_WA_Y;
+  
+  parent_window = gtk_widget_get_parent_window (widget);
+  
+  widget->window = parent_window;
+  gdk_window_ref (widget->window);
+  
+  priv->window = gdk_window_new (parent_window, &attr, attr_mask);
+  gdk_window_set_user_data (priv->window, hsv);
+  
+  widget->style = gtk_style_attach (widget->style, widget->window);
+  
+  /* Create GC */
+  
+  priv->gc = gdk_gc_new (parent_window);
 }
 
 /* Unrealize handler for the HSV color selector */
 static void
 gtk_hsv_unrealize (GtkWidget *widget)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-
-	hsv = GTK_HSV (widget);
-	priv = hsv->priv;
-
-	gdk_window_set_user_data (priv->window, NULL);
-	gdk_window_destroy (priv->window);
-	priv->window = NULL;
-
-	gdk_gc_unref (priv->gc);
-	priv->gc = NULL;
-
-	if (GTK_WIDGET_CLASS (parent_class)->unrealize)
-		(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
+  GtkHSV *hsv;
+  HSVPrivate *priv;
+  
+  hsv = GTK_HSV (widget);
+  priv = hsv->priv;
+  
+  gdk_window_set_user_data (priv->window, NULL);
+  gdk_window_destroy (priv->window);
+  priv->window = NULL;
+  
+  gdk_gc_unref (priv->gc);
+  priv->gc = NULL;
+  
+  if (GTK_WIDGET_CLASS (parent_class)->unrealize)
+    GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
 }
 
 /* Size_request handler for the HSV color selector */
 static void
-gtk_hsv_size_request (GtkWidget *widget, GtkRequisition *requisition)
+gtk_hsv_size_request (GtkWidget      *widget,
+		      GtkRequisition *requisition)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-
-	hsv = GTK_HSV (widget);
-	priv = hsv->priv;
-
-	requisition->width = priv->size;
-	requisition->height = priv->size;
+  GtkHSV *hsv;
+  HSVPrivate *priv;
+  
+  hsv = GTK_HSV (widget);
+  priv = hsv->priv;
+  
+  requisition->width = priv->size;
+  requisition->height = priv->size;
 }
 
 /* Size_allocate handler for the HSV color selector */
 static void
-gtk_hsv_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
+gtk_hsv_size_allocate (GtkWidget     *widget,
+		       GtkAllocation *allocation)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-
-	hsv = GTK_HSV (widget);
-	priv = hsv->priv;
-
-	widget->allocation = *allocation;
-
-	if (GTK_WIDGET_REALIZED (widget))
-		gdk_window_move_resize (priv->window,
-					allocation->x,
-					allocation->y,
-					allocation->width,
-					allocation->height);
+  GtkHSV *hsv;
+  HSVPrivate *priv;
+  
+  hsv = GTK_HSV (widget);
+  priv = hsv->priv;
+  
+  widget->allocation = *allocation;
+  
+  if (GTK_WIDGET_REALIZED (widget))
+    gdk_window_move_resize (priv->window,
+			    allocation->x,
+			    allocation->y,
+			    allocation->width,
+			    allocation->height);
 }
 
-
 
 /* Utility functions */
 
@@ -348,588 +353,647 @@ gtk_hsv_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
 
 /* Converts from HSV to RGB */
 static void
-hsv_to_rgb (double *h, double *s, double *v)
+hsv_to_rgb (gdouble *h,
+	    gdouble *s,
+	    gdouble *v)
 {
-	double hue, saturation, value;
-	double f, p, q, t;
-
-	if (*s == 0.0) {
-		*h = *v;
-		*s = *v;
-		*v = *v; /* heh */
-	} else {
-		hue = *h * 6.0;
-		saturation = *s;
-		value = *v;
-
-		if (hue == 6.0)
-			hue = 0.0;
-
-		f = hue - (int) hue;
-		p = value * (1.0 - saturation);
-		q = value * (1.0 - saturation * f);
-		t = value * (1.0 - saturation * (1.0 - f));
-
-		switch ((int) hue) {
-		case 0:
-			*h = value;
-			*s = t;
-			*v = p;
-			break;
-
-		case 1:
-			*h = q;
-			*s = value;
-			*v = p;
-			break;
-
-		case 2:
-			*h = p;
-			*s = value;
-			*v = t;
-			break;
-
-		case 3:
-			*h = p;
-			*s = q;
-			*v = value;
-			break;
-
-		case 4:
-			*h = t;
-			*s = p;
-			*v = value;
-			break;
-
-		case 5:
-			*h = value;
-			*s = p;
-			*v = q;
-			break;
-
-		default:
-			g_assert_not_reached ();
-		}
+  gdouble hue, saturation, value;
+  gdouble f, p, q, t;
+  
+  if (*s == 0.0)
+    {
+      *h = *v;
+      *s = *v;
+      *v = *v; /* heh */
+    }
+  else
+    {
+      hue = *h * 6.0;
+      saturation = *s;
+      value = *v;
+      
+      if (hue == 6.0)
+	hue = 0.0;
+      
+      f = hue - (int) hue;
+      p = value * (1.0 - saturation);
+      q = value * (1.0 - saturation * f);
+      t = value * (1.0 - saturation * (1.0 - f));
+      
+      switch ((int) hue)
+	{
+	case 0:
+	  *h = value;
+	  *s = t;
+	  *v = p;
+	  break;
+	  
+	case 1:
+	  *h = q;
+	  *s = value;
+	  *v = p;
+	  break;
+	  
+	case 2:
+	  *h = p;
+	  *s = value;
+	  *v = t;
+	  break;
+	  
+	case 3:
+	  *h = p;
+	  *s = q;
+	  *v = value;
+	  break;
+	  
+	case 4:
+	  *h = t;
+	  *s = p;
+	  *v = value;
+	  break;
+	  
+	case 5:
+	  *h = value;
+	  *s = p;
+	  *v = q;
+	  break;
+	  
+	default:
+	  g_assert_not_reached ();
 	}
+    }
 }
 
 /* Converts from RGB to HSV */
 static void
-rgb_to_hsv (double *r, double *g, double *b)
+rgb_to_hsv (gdouble *r,
+	    gdouble *g,
+	    gdouble *b)
 {
-	double red, green, blue;
-	double h, s, v;
-	double min, max;
-	double delta;
-
-	red = *r;
-	green = *g;
-	blue = *b;
-
-	h = 0.0;
-
-	if (red > green) {
-		if (red > blue)
-			max = red;
-		else
-			max = blue;
-
-		if (green < blue)
-			min = green;
-		else
-			min = blue;
-	} else {
-		if (green > blue)
-			max = green;
-		else
-			max = blue;
-
-		if (red < blue)
-			min = red;
-		else
-			min = blue;
-	}
-
-	v = max;
-
-	if (max != 0.0)
-		s = (max - min) / max;
-	else
-		s = 0.0;
-
-	if (s == 0.0)
-		h = 0.0;
-	else {
-		delta = max - min;
-
-		if (red == max)
-			h = (green - blue) / delta;
-		else if (green == max)
-			h = 2 + (blue - red) / delta;
-		else if (blue == max)
-			h = 4 + (red - green) / delta;
-
-		h /= 6.0;
-
-		if (h < 0.0)
-			h += 1.0;
-		else if (h > 1.0)
-			h -= 1.0;
-	}
-
-	*r = h;
-	*g = s;
-	*b = v;
+  gdouble red, green, blue;
+  gdouble h, s, v;
+  gdouble min, max;
+  gdouble delta;
+  
+  red = *r;
+  green = *g;
+  blue = *b;
+  
+  h = 0.0;
+  
+  if (red > green)
+    {
+      if (red > blue)
+	max = red;
+      else
+	max = blue;
+      
+      if (green < blue)
+	min = green;
+      else
+	min = blue;
+    }
+  else
+    {
+      if (green > blue)
+	max = green;
+      else
+	max = blue;
+      
+      if (red < blue)
+	min = red;
+      else
+	min = blue;
+    }
+  
+  v = max;
+  
+  if (max != 0.0)
+    s = (max - min) / max;
+  else
+    s = 0.0;
+  
+  if (s == 0.0)
+    h = 0.0;
+  else
+    {
+      delta = max - min;
+      
+      if (red == max)
+	h = (green - blue) / delta;
+      else if (green == max)
+	h = 2 + (blue - red) / delta;
+      else if (blue == max)
+	h = 4 + (red - green) / delta;
+      
+      h /= 6.0;
+      
+      if (h < 0.0)
+	h += 1.0;
+      else if (h > 1.0)
+	h -= 1.0;
+    }
+  
+  *r = h;
+  *g = s;
+  *b = v;
 }
 
 /* Computes the vertices of the saturation/value triangle */
 static void
-compute_triangle (GtkHSV *hsv, int *hx, int *hy, int *sx, int *sy, int *vx, int *vy)
+compute_triangle (GtkHSV *hsv,
+		  gint   *hx,
+		  gint   *hy,
+		  gint   *sx,
+		  gint   *sy,
+		  gint   *vx,
+		  gint   *vy)
 {
-	HSVPrivate *priv;
-	double center;
-	double inner, outer;
-	double angle;
-
-	priv = hsv->priv;
-
-	center = priv->size / 2.0;
-	outer = priv->size / 2.0;
-	inner = outer - priv->ring_width;
-	angle = priv->h * 2.0 * M_PI;
-
-	*hx = floor (center + cos (angle) * inner + 0.5);
-	*hy = floor (center - sin (angle) * inner + 0.5);
-	*sx = floor (center + cos (angle + 2.0 * M_PI / 3.0) * inner + 0.5);
-	*sy = floor (center - sin (angle + 2.0 * M_PI / 3.0) * inner + 0.5);
-	*vx = floor (center + cos (angle + 4.0 * M_PI / 3.0) * inner + 0.5);
-	*vy = floor (center - sin (angle + 4.0 * M_PI / 3.0) * inner + 0.5);
+  HSVPrivate *priv;
+  gdouble center;
+  gdouble inner, outer;
+  gdouble angle;
+  
+  priv = hsv->priv;
+  
+  center = priv->size / 2.0;
+  outer = priv->size / 2.0;
+  inner = outer - priv->ring_width;
+  angle = priv->h * 2.0 * M_PI;
+  
+  *hx = floor (center + cos (angle) * inner + 0.5);
+  *hy = floor (center - sin (angle) * inner + 0.5);
+  *sx = floor (center + cos (angle + 2.0 * M_PI / 3.0) * inner + 0.5);
+  *sy = floor (center - sin (angle + 2.0 * M_PI / 3.0) * inner + 0.5);
+  *vx = floor (center + cos (angle + 4.0 * M_PI / 3.0) * inner + 0.5);
+  *vy = floor (center - sin (angle + 4.0 * M_PI / 3.0) * inner + 0.5);
 }
 
 /* Computes whether a point is inside the hue ring */
 static gboolean
-is_in_ring (GtkHSV *hsv, double x, double y)
+is_in_ring (GtkHSV *hsv,
+	    gdouble x,
+	    gdouble y)
 {
-	HSVPrivate *priv;
-	double dx, dy, dist;
-	double center, inner, outer;
-
-	priv = hsv->priv;
-
-	center = priv->size / 2.0;
-	outer = priv->size / 2.0;
-	inner = outer - priv->ring_width;
-
-	dx = x - center;
-	dy = center - y;
-	dist = dx * dx + dy * dy;
-
-	return (dist >= inner * inner && dist <= outer * outer);
+  HSVPrivate *priv;
+  gdouble dx, dy, dist;
+  gdouble center, inner, outer;
+  
+  priv = hsv->priv;
+  
+  center = priv->size / 2.0;
+  outer = priv->size / 2.0;
+  inner = outer - priv->ring_width;
+  
+  dx = x - center;
+  dy = center - y;
+  dist = dx * dx + dy * dy;
+  
+  return (dist >= inner * inner && dist <= outer * outer);
 }
 
 /* Computes a saturation/value pair based on the mouse coordinates */
 static void
-compute_sv (GtkHSV *hsv, double x, double y, double *s, double *v)
+compute_sv (GtkHSV  *hsv,
+	    gdouble  x,
+	    gdouble  y,
+	    gdouble *s,
+	    gdouble *v)
 {
-	HSVPrivate *priv;
-	int ihx, ihy, isx, isy, ivx, ivy;
-	double hx, hy, sx, sy, vx, vy;
-	double center;
-
-	priv = hsv->priv;
-
-	compute_triangle (hsv, &ihx, &ihy, &isx, &isy, &ivx, &ivy);
-	center = priv->size / 2.0;
-	hx = ihx - center;
-	hy = center - ihy;
-	sx = isx - center;
-	sy = center - isy;
-	vx = ivx - center;
-	vy = center - ivy;
-	x -= center;
-	y = center - y;
-
-	if (vx * (x - sx) + vy * (y - sy) < 0.0) {
-		*s = 1.0;
-		*v = (((x - sx) * (hx - sx) + (y - sy) * (hy-sy))
-		      / ((hx - sx) * (hx - sx) + (hy - sy) * (hy - sy)));
-
-		if (*v < 0.0)
-			*v = 0.0;
-		else if (*v > 1.0)
-			*v = 1.0;
-	} else if (hx * (x - sx) + hy * (y - sy) < 0.0) {
-		*s = 0.0;
-		*v = (((x - sx) * (vx - sx) + (y - sy) * (vy - sy))
-		      / ((vx - sx) * (vx - sx) + (vy - sy) * (vy - sy)));
-
-		if (*v < 0.0)
-			*v = 0.0;
-		else if (*v > 1.0)
-			*v = 1.0;
-	} else if (sx * (x - hx) + sy * (y - hy) < 0.0) {
-		*v = 1.0;
-		*s = (((x - vx) * (hx - vx) + (y - vy) * (hy - vy)) /
-		      ((hx - vx) * (hx - vx) + (hy - vy) * (hy - vy)));
-
-		if (*s < 0.0)
-			*s = 0.0;
-		else if (*s > 1.0)
-			*s = 1.0;
-	} else {
-		*v = (((x - sx) * (hy - vy) - (y - sy) * (hx - vx))
-		      / ((vx - sx) * (hy - vy) - (vy - sy) * (hx - vx)));
-
-		if (*v<= 0.0) {
-			*v = 0.0;
-			*s = 0.0;
-		} else {
-			if (*v > 1.0)
-				*v = 1.0;
-
-			*s = (y - sy - *v * (vy - sy)) / (*v * (hy - vy));
-			if (*s < 0.0)
-				*s = 0.0;
-			else if (*s > 1.0)
-				*s = 1.0;
-		}
+  HSVPrivate *priv;
+  int ihx, ihy, isx, isy, ivx, ivy;
+  double hx, hy, sx, sy, vx, vy;
+  double center;
+  
+  priv = hsv->priv;
+  
+  compute_triangle (hsv, &ihx, &ihy, &isx, &isy, &ivx, &ivy);
+  center = priv->size / 2.0;
+  hx = ihx - center;
+  hy = center - ihy;
+  sx = isx - center;
+  sy = center - isy;
+  vx = ivx - center;
+  vy = center - ivy;
+  x -= center;
+  y = center - y;
+  
+  if (vx * (x - sx) + vy * (y - sy) < 0.0)
+    {
+      *s = 1.0;
+      *v = (((x - sx) * (hx - sx) + (y - sy) * (hy-sy))
+	    / ((hx - sx) * (hx - sx) + (hy - sy) * (hy - sy)));
+      
+      if (*v < 0.0)
+	*v = 0.0;
+      else if (*v > 1.0)
+	*v = 1.0;
+    }
+  else if (hx * (x - sx) + hy * (y - sy) < 0.0)
+    {
+      *s = 0.0;
+      *v = (((x - sx) * (vx - sx) + (y - sy) * (vy - sy))
+	    / ((vx - sx) * (vx - sx) + (vy - sy) * (vy - sy)));
+      
+      if (*v < 0.0)
+	*v = 0.0;
+      else if (*v > 1.0)
+	*v = 1.0;
+    }
+  else if (sx * (x - hx) + sy * (y - hy) < 0.0)
+    {
+      *v = 1.0;
+      *s = (((x - vx) * (hx - vx) + (y - vy) * (hy - vy)) /
+	    ((hx - vx) * (hx - vx) + (hy - vy) * (hy - vy)));
+      
+      if (*s < 0.0)
+	*s = 0.0;
+      else if (*s > 1.0)
+	*s = 1.0;
+    }
+  else
+    {
+      *v = (((x - sx) * (hy - vy) - (y - sy) * (hx - vx))
+	    / ((vx - sx) * (hy - vy) - (vy - sy) * (hx - vx)));
+      
+      if (*v<= 0.0)
+	{
+	  *v = 0.0;
+	  *s = 0.0;
+	}
+      else
+	{
+	  if (*v > 1.0)
+	    *v = 1.0;
+	  
+	  *s = (y - sy - *v * (vy - sy)) / (*v * (hy - vy));
+	  if (*s < 0.0)
+	    *s = 0.0;
+	  else if (*s > 1.0)
+	    *s = 1.0;
 	}
+    }
 }
 
 /* Computes whether a point is inside the saturation/value triangle */
 static gboolean
-is_in_triangle (GtkHSV *hsv, double x, double y)
+is_in_triangle (GtkHSV *hsv,
+		gdouble x,
+		gdouble y)
 {
-	int hx, hy, sx, sy, vx, vy;
-	double det, s, v;
-
-	compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
-
-	det = (vx - sx) * (hy - sy) - (vy - sy) * (hx - sx);
-
-	s = ((x - sx) * (hy - sy) - (y - sy) * (hx - sx)) / det;
-	v = ((vx - sx) * (y - sy) - (vy - sy) * (x - sx)) / det;
-
-	return (s >= 0.0 && v >= 0.0 && s + v <= 1.0);
+  int hx, hy, sx, sy, vx, vy;
+  double det, s, v;
+  
+  compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
+  
+  det = (vx - sx) * (hy - sy) - (vy - sy) * (hx - sx);
+  
+  s = ((x - sx) * (hy - sy) - (y - sy) * (hx - sx)) / det;
+  v = ((vx - sx) * (y - sy) - (vy - sy) * (x - sx)) / det;
+  
+  return (s >= 0.0 && v >= 0.0 && s + v <= 1.0);
 }
 
 /* Computes a value based on the mouse coordinates */
 static double
-compute_v (GtkHSV *hsv, double x, double y)
+compute_v (GtkHSV *hsv,
+	   gdouble x,
+	   gdouble y)
 {
-	HSVPrivate *priv;
-	double center;
-	double dx, dy;
-	double angle;
-
-	priv = hsv->priv;
-
-	center = priv->size / 2.0;
-	dx = x - center;
-	dy = center - y;
-
-	angle = atan2 (dy, dx);
-	if (angle < 0.0)
-		angle += 2.0 * M_PI;
-
-	return angle / (2.0 * M_PI);
+  HSVPrivate *priv;
+  double center;
+  double dx, dy;
+  double angle;
+  
+  priv = hsv->priv;
+  
+  center = priv->size / 2.0;
+  dx = x - center;
+  dy = center - y;
+  
+  angle = atan2 (dy, dx);
+  if (angle < 0.0)
+    angle += 2.0 * M_PI;
+  
+  return angle / (2.0 * M_PI);
 }
 
-
-
 /* Event handlers */
 
 static void
-set_cross_grab (GtkHSV *hsv, guint32 time)
+set_cross_grab (GtkHSV *hsv,
+		guint32 time)
 {
-	HSVPrivate *priv;
-	GdkCursor *cursor;
-
-	priv = hsv->priv;
-
-	cursor = gdk_cursor_new (GDK_CROSSHAIR);
-	gdk_pointer_grab (priv->window, FALSE,
-			  (GDK_POINTER_MOTION_MASK
-			   | GDK_POINTER_MOTION_HINT_MASK
-			   | GDK_BUTTON_RELEASE_MASK),
-			  NULL,
-			  cursor,
-			  time);
-	gdk_cursor_destroy (cursor);
-
+  HSVPrivate *priv;
+  GdkCursor *cursor;
+  
+  priv = hsv->priv;
+  
+  cursor = gdk_cursor_new (GDK_CROSSHAIR);
+  gdk_pointer_grab (priv->window, FALSE,
+		    (GDK_POINTER_MOTION_MASK
+		     | GDK_POINTER_MOTION_HINT_MASK
+		     | GDK_BUTTON_RELEASE_MASK),
+		    NULL,
+		    cursor,
+		    time);
+  gdk_cursor_destroy (cursor);
 }
 
 /* Button_press_event handler for the HSV color selector */
 static gint
-gtk_hsv_button_press (GtkWidget *widget, GdkEventButton *event)
+gtk_hsv_button_press (GtkWidget      *widget,
+		      GdkEventButton *event)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-	double x, y;
-
-	hsv = GTK_HSV (widget);
-	priv = hsv->priv;
-
-	if (priv->mode != DRAG_NONE || event->button != 1)
-		return FALSE;
-
-	x = event->x;
-	y = event->y;
-
-	if (is_in_ring (hsv, x, y)) {
-		priv->mode = DRAG_H;
-		set_cross_grab (hsv, event->time);
-
-		gtk_hsv_set_color (hsv,
-				   compute_v (hsv, x, y),
-				   priv->s,
-				   priv->v);
-
-		return TRUE;
-	}
-
-	if (is_in_triangle (hsv, x, y)) {
-		double s, v;
-
-		priv->mode = DRAG_SV;
-		set_cross_grab (hsv, event->time);
-
-		compute_sv (hsv, x, y, &s, &v);
-		gtk_hsv_set_color (hsv, priv->h, s, v);
-		return TRUE;
-	}
-
-	return FALSE;
+  GtkHSV *hsv;
+  HSVPrivate *priv;
+  double x, y;
+  
+  hsv = GTK_HSV (widget);
+  priv = hsv->priv;
+  
+  if (priv->mode != DRAG_NONE || event->button != 1)
+    return FALSE;
+  
+  x = event->x;
+  y = event->y;
+  
+  if (is_in_ring (hsv, x, y))
+    {
+      priv->mode = DRAG_H;
+      set_cross_grab (hsv, event->time);
+      
+      gtk_hsv_set_color (hsv,
+			 compute_v (hsv, x, y),
+			 priv->s,
+			 priv->v);
+      
+      return TRUE;
+    }
+  
+  if (is_in_triangle (hsv, x, y))
+    {
+      gdouble s, v;
+      
+      priv->mode = DRAG_SV;
+      set_cross_grab (hsv, event->time);
+      
+      compute_sv (hsv, x, y, &s, &v);
+      gtk_hsv_set_color (hsv, priv->h, s, v);
+      return TRUE;
+    }
+  
+  return FALSE;
 }
 
 /* Button_release_event handler for the HSV color selector */
 static gint
-gtk_hsv_button_release (GtkWidget *widget, GdkEventButton *event)
+gtk_hsv_button_release (GtkWidget      *widget,
+			GdkEventButton *event)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-	DragMode mode;
-	double x, y;
-
-	hsv = GTK_HSV (widget);
-	priv = hsv->priv;
-
-	if (priv->mode == DRAG_NONE || event->button != 1)
-		return FALSE;
-
-	/* Set the drag mode to DRAG_NONE so that signal handlers for "catched"
-	 * can see that this is the final color state.
-	 */
-
-	mode = priv->mode;
-	priv->mode = DRAG_NONE;
-
-	x = event->x;
-	y = event->y;
-
-	if (mode == DRAG_H)
-		gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
-	else if (mode == DRAG_SV) {
-		double s, v;
-
-		compute_sv (hsv, x, y, &s, &v);
-		gtk_hsv_set_color (hsv, priv->h, s, v);
-	} else
-		g_assert_not_reached ();
-
-	gdk_pointer_ungrab (event->time);
-
-	return TRUE;
+  GtkHSV *hsv;
+  HSVPrivate *priv;
+  DragMode mode;
+  gdouble x, y;
+  
+  hsv = GTK_HSV (widget);
+  priv = hsv->priv;
+  
+  if (priv->mode == DRAG_NONE || event->button != 1)
+    return FALSE;
+  
+  /* Set the drag mode to DRAG_NONE so that signal handlers for "catched"
+   * can see that this is the final color state.
+   */
+  
+  mode = priv->mode;
+  priv->mode = DRAG_NONE;
+  
+  x = event->x;
+  y = event->y;
+  
+  if (mode == DRAG_H)
+    gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
+  else if (mode == DRAG_SV) {
+    double s, v;
+    
+    compute_sv (hsv, x, y, &s, &v);
+    gtk_hsv_set_color (hsv, priv->h, s, v);
+  } else
+    g_assert_not_reached ();
+  
+  gdk_pointer_ungrab (event->time);
+  
+  return TRUE;
 }
 
 /* Motion_notify_event handler for the HSV color selector */
 static gint
-gtk_hsv_motion (GtkWidget *widget, GdkEventMotion *event)
+gtk_hsv_motion (GtkWidget      *widget,
+		GdkEventMotion *event)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-	double x, y;
-	gint ix, iy;
-	GdkModifierType mods;
-
-	hsv = GTK_HSV (widget);
-	priv = hsv->priv;
-
-	if (priv->mode == DRAG_NONE)
-		return FALSE;
-
-	if (event->is_hint) {
-		gdk_window_get_pointer (priv->window, &ix, &iy, &mods);
-		x = ix;
-		y = iy;
-	} else {
-		x = event->x;
-		y = event->y;
-	}
-
-	if (priv->mode == DRAG_H) {
-		gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
-		return TRUE;
-	} else if (priv->mode == DRAG_SV) {
-		double s, v;
-
-		compute_sv (hsv, x, y, &s, &v);
-		gtk_hsv_set_color (hsv, priv->h, s, v);
-		return TRUE;
-	}
-
-	g_assert_not_reached ();
-	return FALSE;
+  GtkHSV *hsv;
+  HSVPrivate *priv;
+  double x, y;
+  gint ix, iy;
+  GdkModifierType mods;
+  
+  hsv = GTK_HSV (widget);
+  priv = hsv->priv;
+  
+  if (priv->mode == DRAG_NONE)
+    return FALSE;
+  
+  if (event->is_hint)
+    {
+      gdk_window_get_pointer (priv->window, &ix, &iy, &mods);
+      x = ix;
+      y = iy;
+    }
+  else
+    {
+      x = event->x;
+      y = event->y;
+    }
+  
+  if (priv->mode == DRAG_H)
+    {
+      gtk_hsv_set_color (hsv, compute_v (hsv, x, y), priv->s, priv->v);
+      return TRUE;
+    }
+  else if (priv->mode == DRAG_SV)
+    {
+      double s, v;
+      
+      compute_sv (hsv, x, y, &s, &v);
+      gtk_hsv_set_color (hsv, priv->h, s, v);
+      return TRUE;
+    }
+  
+  g_assert_not_reached ();
+  return FALSE;
 }
 
-
 
 /* Redrawing */
 
 /* Paints the hue ring */
 static void
-paint_ring (GtkHSV *hsv, GdkDrawable *drawable, int x, int y, int width, int height)
+paint_ring (GtkHSV      *hsv,
+	    GdkDrawable *drawable,
+	    gint         x,
+	    gint         y,
+	    gint         width,
+	    gint         height)
 {
-	HSVPrivate *priv;
-	int xx, yy;
-	double dx, dy, dist;
-	double center;
-	double inner, outer;
-	guchar *buf, *p;
-	double angle;
-	double hue;
-	double r, g, b;
-	GdkBitmap *mask;
-	GdkGC *gc;
-	GdkColor color;
-
-	priv = hsv->priv;
-
-	center = priv->size / 2.0;
-
-	outer = priv->size / 2.0;
-	inner = outer - priv->ring_width;
-
-	/* Paint the ring */
-
-	buf = g_new (guchar, width * height * 3);
-
-	for (yy = 0; yy < height; yy++) {
-		p = buf + yy * width * 3;
-
-		dy = -(yy + y - center);
-
-		for (xx = 0; xx < width; xx++) {
-			dx = xx + x - center;
-
-			dist = dx * dx + dy * dy;
-			if (dist < (inner * inner) || dist > (outer * outer)) {
-				*p++ = 0;
-				*p++ = 0;
-				*p++ = 0;
-				continue;
-			}
-
-			angle = atan2 (dy, dx);
-			if (angle < 0.0)
-				angle += 2.0 * M_PI;
-
-			hue = angle / (2.0 * M_PI);
-
-			r = hue;
-			g = 1.0;
-			b = 1.0;
-			hsv_to_rgb (&r, &g, &b);
-
-			*p++ = floor (r * 255 + 0.5);
-			*p++ = floor (g * 255 + 0.5);
-			*p++ = floor (b * 255 + 0.5);
-		}
+  HSVPrivate *priv;
+  int xx, yy;
+  gdouble dx, dy, dist;
+  gdouble center;
+  gdouble inner, outer;
+  guchar *buf, *p;
+  gdouble angle;
+  gdouble hue;
+  gdouble r, g, b;
+  GdkBitmap *mask;
+  GdkGC *gc;
+  GdkColor color;
+  
+  priv = hsv->priv;
+  
+  center = priv->size / 2.0;
+  
+  outer = priv->size / 2.0;
+  inner = outer - priv->ring_width;
+  
+  /* Paint the ring */
+  
+  buf = g_new (guchar, width * height * 3);
+  
+  for (yy = 0; yy < height; yy++)
+    {
+      p = buf + yy * width * 3;
+      
+      dy = -(yy + y - center);
+      
+      for (xx = 0; xx < width; xx++)
+	{
+	  dx = xx + x - center;
+	  
+	  dist = dx * dx + dy * dy;
+	  if (dist < (inner * inner) || dist > (outer * outer))
+	    {
+	      *p++ = 0;
+	      *p++ = 0;
+	      *p++ = 0;
+	      continue;
+	    }
+	  
+	  angle = atan2 (dy, dx);
+	  if (angle < 0.0)
+	    angle += 2.0 * M_PI;
+	  
+	  hue = angle / (2.0 * M_PI);
+	  
+	  r = hue;
+	  g = 1.0;
+	  b = 1.0;
+	  hsv_to_rgb (&r, &g, &b);
+	  
+	  *p++ = floor (r * 255 + 0.5);
+	  *p++ = floor (g * 255 + 0.5);
+	  *p++ = floor (b * 255 + 0.5);
 	}
-
-	/* Create clipping mask */
-
-	mask = gdk_pixmap_new (NULL, width, height, 1);
-	gc = gdk_gc_new (mask);
-
-	color.pixel = 0;
-	gdk_gc_set_foreground (gc, &color);
-	gdk_draw_rectangle (mask, gc, TRUE,
-			    0, 0, width, height);
-
-
-	color.pixel = 1;
-	gdk_gc_set_foreground (gc, &color);
-	gdk_draw_arc (mask, gc, TRUE,
-		      -x, -y,
-		      priv->size - 1, priv->size - 1,
-		      0, 360 * 64);
-
-	color.pixel = 0;
-	gdk_gc_set_foreground (gc, &color);
-	gdk_draw_arc (mask, gc, TRUE,
-		      -x + priv->ring_width - 1, -y + priv->ring_width - 1,
-		      priv->size - 2 * priv->ring_width + 1, priv->size - 2 * priv->ring_width + 1,
-		      0, 360 * 64);
-
-	gdk_gc_unref (gc);
-
-	gdk_gc_set_clip_mask (priv->gc, mask);
-	gdk_gc_set_clip_origin (priv->gc, 0, 0);
-
-	/* Draw ring */
-
-	gdk_draw_rgb_image_dithalign (drawable, priv->gc, 0, 0, width, height,
-				      GDK_RGB_DITHER_MAX,
-				      buf,
-				      width * 3,
-				      x, y);
-
-	/* Draw value marker */
-
-	r = priv->h;
-	g = 1.0;
-	b = 1.0;
-	hsv_to_rgb (&r, &g, &b);
-
-	if (INTENSITY (r, g, b) > 0.5)
-		gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
-	else
-		gdk_rgb_gc_set_foreground (priv->gc, 0xffffff);
-
-	gdk_draw_line (drawable, priv->gc,
-		       -x + center, -y + center,
-		       -x + center + cos (priv->h * 2.0 * M_PI) * center,
-		       -y + center - sin (priv->h * 2.0 * M_PI) * center);
-
-	gdk_gc_set_clip_mask (priv->gc, NULL);
-	gdk_bitmap_unref (mask);
-
-	g_free (buf);
-
-	/* Draw ring outline */
-
-	gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
-
-	gdk_draw_arc (drawable, priv->gc, FALSE,
-		      -x, -y,
-		      priv->size - 1, priv->size - 1,
-		      0, 360 * 64);
-	gdk_draw_arc (drawable, priv->gc, FALSE,
-		      -x + priv->ring_width - 1, -y + priv->ring_width - 1,
-		      priv->size - 2 * priv->ring_width + 1, priv->size - 2 * priv->ring_width + 1,
-		      0, 360 * 64);
+    }
+  
+  /* Create clipping mask */
+  
+  mask = gdk_pixmap_new (NULL, width, height, 1);
+  gc = gdk_gc_new (mask);
+  
+  color.pixel = 0;
+  gdk_gc_set_foreground (gc, &color);
+  gdk_draw_rectangle (mask, gc, TRUE,
+		      0, 0, width, height);
+  
+  
+  color.pixel = 1;
+  gdk_gc_set_foreground (gc, &color);
+  gdk_draw_arc (mask, gc, TRUE,
+		-x, -y,
+		priv->size - 1, priv->size - 1,
+		0, 360 * 64);
+  
+  color.pixel = 0;
+  gdk_gc_set_foreground (gc, &color);
+  gdk_draw_arc (mask, gc, TRUE,
+		-x + priv->ring_width - 1, -y + priv->ring_width - 1,
+		priv->size - 2 * priv->ring_width + 1, priv->size - 2 * priv->ring_width + 1,
+		0, 360 * 64);
+  
+  gdk_gc_unref (gc);
+  
+  gdk_gc_set_clip_mask (priv->gc, mask);
+  gdk_gc_set_clip_origin (priv->gc, 0, 0);
+  
+  /* Draw ring */
+  
+  gdk_draw_rgb_image_dithalign (drawable, priv->gc, 0, 0, width, height,
+				GDK_RGB_DITHER_MAX,
+				buf,
+				width * 3,
+				x, y);
+  
+  /* Draw value marker */
+  
+  r = priv->h;
+  g = 1.0;
+  b = 1.0;
+  hsv_to_rgb (&r, &g, &b);
+  
+  if (INTENSITY (r, g, b) > 0.5)
+    gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
+  else
+    gdk_rgb_gc_set_foreground (priv->gc, 0xffffff);
+  
+  gdk_draw_line (drawable, priv->gc,
+		 -x + center, -y + center,
+		 -x + center + cos (priv->h * 2.0 * M_PI) * center,
+		 -y + center - sin (priv->h * 2.0 * M_PI) * center);
+  
+  gdk_gc_set_clip_mask (priv->gc, NULL);
+  gdk_bitmap_unref (mask);
+  
+  g_free (buf);
+  
+  /* Draw ring outline */
+  
+  gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
+  
+  gdk_draw_arc (drawable, priv->gc, FALSE,
+		-x, -y,
+		priv->size - 1, priv->size - 1,
+		0, 360 * 64);
+  gdk_draw_arc (drawable, priv->gc, FALSE,
+		-x + priv->ring_width - 1, -y + priv->ring_width - 1,
+		priv->size - 2 * priv->ring_width + 1, priv->size - 2 * priv->ring_width + 1,
+		0, 360 * 64);
 }
 
 /* Converts an HSV triplet to an integer RGB triplet */
 static void
-get_color (double h, double s, double v, int *r, int *g, int *b)
+get_color (gdouble h,
+	   gdouble s,
+	   gdouble v,
+	   gint   *r,
+	   gint   *g,
+	   gint   *b)
 {
-	hsv_to_rgb (&h, &s, &v);
-
-	*r = floor (h * 255 + 0.5);
-	*g = floor (s * 255 + 0.5);
-	*b = floor (v * 255 + 0.5);
+  hsv_to_rgb (&h, &s, &v);
+  
+  *r = floor (h * 255 + 0.5);
+  *g = floor (s * 255 + 0.5);
+  *b = floor (v * 255 + 0.5);
 }
 
 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
@@ -940,250 +1004,273 @@ get_color (double h, double s, double v, int *r, int *g, int *b)
 
 /* Paints the HSV triangle */
 static void
-paint_triangle (GtkHSV *hsv, GdkDrawable *drawable, int x, int y, int width, int height)
+paint_triangle (GtkHSV      *hsv,
+		GdkDrawable *drawable,
+		gint         x,
+		gint         y,
+		gint         width,
+		gint         height)
 {
-	HSVPrivate *priv;
-	int hx, hy, sx, sy, vx, vy; /* HSV vertices */
-	int x1, y1, r1, g1, b1; /* First vertex in scanline order */
-	int x2, y2, r2, g2, b2; /* Second vertex */
-	int x3, y3, r3, g3, b3; /* Third vertex */
-	int t;
-	guchar *buf, *p;
-	int xl, xr, rl, rr, gl, gr, bl, br; /* Scanline data */
-	int xx, yy;
-	GdkBitmap *mask;
-	GdkGC *gc;
-	GdkColor color;
-	GdkPoint points[3];
-	double r, g, b;
-
-	priv = hsv->priv;
-
-	/* Compute triangle's vertices */
-
-	compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
-
-	x1 = hx;
-	y1 = hy;
-	get_color (priv->h, 1.0, 1.0, &r1, &g1, &b1);
-
-	x2 = sx;
-	y2 = sy;
-	get_color (priv->h, 1.0, 0.0, &r2, &g2, &b2);
-
-	x3 = vx;
-	y3 = vy;
-	get_color (priv->h, 0.0, 1.0, &r3, &g3, &b3);
-
-	if (y2 > y3) {
-		SWAP (x2, x3, t);
-		SWAP (y2, y3, t);
-		SWAP (r2, r3, t);
-		SWAP (g2, g3, t);
-		SWAP (b2, b3, t);
-	}
-
-	if (y1 > y3) {
-		SWAP (x1, x3, t);
-		SWAP (y1, y3, t);
-		SWAP (r1, r3, t);
-		SWAP (g1, g3, t);
-		SWAP (b1, b3, t);
-	}
-
-	if (y1 > y2) {
-		SWAP (x1, x2, t);
-		SWAP (y1, y2, t);
-		SWAP (r1, r2, t);
-		SWAP (g1, g2, t);
-		SWAP (b1, b2, t);
-	}
-
-	/* Shade the triangle */
-
-	buf = g_new (guchar, width * height * 3);
-
-	for (yy = 0; yy < height; yy++) {
-		p = buf + yy * width * 3;
-
-		if (yy + y < y1 || yy + y > y3)
-			for (xx = 0; xx < width; xx++) {
-				*p++ = 0;
-				*p++ = 0;
-				*p++ = 0;
-			}
-		else {
-			if (yy + y < y2) {
-				xl = LERP (x1, x2, y1, y2, yy + y);
-
-				rl = LERP (r1, r2, y1, y2, yy + y);
-				gl = LERP (g1, g2, y1, y2, yy + y);
-				bl = LERP (b1, b2, y1, y2, yy + y);
-			} else {
-				xl = LERP (x2, x3, y2, y3, yy + y);
-
-				rl = LERP (r2, r3, y2, y3, yy + y);
-				gl = LERP (g2, g3, y2, y3, yy + y);
-				bl = LERP (b2, b3, y2, y3, yy + y);
-			}
-
-			xr = LERP (x1, x3, y1, y3, yy + y);
-
-			rr = LERP (r1, r3, y1, y3, yy + y);
-			gr = LERP (g1, g3, y1, y3, yy + y);
-			br = LERP (b1, b3, y1, y3, yy + y);
-
-			if (xl > xr) {
-				SWAP (xl, xr, t);
-				SWAP (rl, rr, t);
-				SWAP (gl, gr, t);
-				SWAP (bl, br, t);
-			}
-
-			for (xx = 0; xx < width; xx++) {
-				if (xx + x < xl || xx + x > xr) {
-					*p++ = 0;
-					*p++ = 0;
-					*p++ = 0;
-				} else {
-					*p++ = LERP (rl, rr, xl, xr, xx + x);
-					*p++ = LERP (gl, gr, xl, xr, xx + x);
-					*p++ = LERP (bl, br, xl, xr, xx + x);
-				}
-			}
-		}
-	}
-
-	/* Create clipping mask */
-
-	mask = gdk_pixmap_new (NULL, width, height, 1);
-	gc = gdk_gc_new (mask);
-
-	color.pixel = 0;
-	gdk_gc_set_foreground (gc, &color);
-	gdk_draw_rectangle (mask, gc, TRUE,
-			    0, 0, width, height);
-
-	color.pixel = 1;
-	gdk_gc_set_foreground (gc, &color);
-
-	points[0].x = x1 - x;
-	points[0].y = y1 - y;
-	points[1].x = x2 - x;
-	points[1].y = y2 - y;
-	points[2].x = x3 - x;
-	points[2].y = y3 - y;
-	gdk_draw_polygon (mask, gc, TRUE, points, 3);
-
-	gdk_gc_unref (gc);
-
-	gdk_gc_set_clip_mask (priv->gc, mask);
-	gdk_gc_set_clip_origin (priv->gc, 0, 0);
-
-	/* Draw triangle */
-
-	gdk_draw_rgb_image_dithalign (drawable, priv->gc, 0, 0, width, height,
-				      GDK_RGB_DITHER_MAX,
-				      buf,
-				      width * 3,
-				      x, y);
-
-	gdk_gc_set_clip_mask (priv->gc, NULL);
-	gdk_bitmap_unref (mask);
-
-	g_free (buf);
-
-	/* Draw triangle outline */
-
-	gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
-
-	gdk_draw_polygon (drawable, priv->gc, FALSE, points, 3);
-
-	/* Draw value marker */
-
-	xx = floor (sx + (vx - sx) * priv->v + (hx - vx) * priv->s * priv->v + 0.5);
-	yy = floor (sy + (vy - sy) * priv->v + (hy - vy) * priv->s * priv->v + 0.5);
-
-	r = priv->h;
-	g = priv->s;
-	b = priv->v;
-	hsv_to_rgb (&r, &g, &b);
-
-	if (INTENSITY (r, g, b) > 0.5)
-		gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
+  HSVPrivate *priv;
+  gint hx, hy, sx, sy, vx, vy; /* HSV vertices */
+  gint x1, y1, r1, g1, b1; /* First vertex in scanline order */
+  gint x2, y2, r2, g2, b2; /* Second vertex */
+  gint x3, y3, r3, g3, b3; /* Third vertex */
+  gint t;
+  guchar *buf, *p;
+  gint xl, xr, rl, rr, gl, gr, bl, br; /* Scanline data */
+  gint xx, yy;
+  GdkBitmap *mask;
+  GdkGC *gc;
+  GdkColor color;
+  GdkPoint points[3];
+  gdouble r, g, b;
+  
+  priv = hsv->priv;
+  
+  /* Compute triangle's vertices */
+  
+  compute_triangle (hsv, &hx, &hy, &sx, &sy, &vx, &vy);
+  
+  x1 = hx;
+  y1 = hy;
+  get_color (priv->h, 1.0, 1.0, &r1, &g1, &b1);
+  
+  x2 = sx;
+  y2 = sy;
+  get_color (priv->h, 1.0, 0.0, &r2, &g2, &b2);
+  
+  x3 = vx;
+  y3 = vy;
+  get_color (priv->h, 0.0, 1.0, &r3, &g3, &b3);
+  
+  if (y2 > y3)
+    {
+      SWAP (x2, x3, t);
+      SWAP (y2, y3, t);
+      SWAP (r2, r3, t);
+      SWAP (g2, g3, t);
+      SWAP (b2, b3, t);
+    }
+  
+  if (y1 > y3)
+    {
+      SWAP (x1, x3, t);
+      SWAP (y1, y3, t);
+      SWAP (r1, r3, t);
+      SWAP (g1, g3, t);
+      SWAP (b1, b3, t);
+    }
+  
+  if (y1 > y2)
+    {
+      SWAP (x1, x2, t);
+      SWAP (y1, y2, t);
+      SWAP (r1, r2, t);
+      SWAP (g1, g2, t);
+      SWAP (b1, b2, t);
+    }
+  
+  /* Shade the triangle */
+  
+  buf = g_new (guchar, width * height * 3);
+  
+  for (yy = 0; yy < height; yy++)
+    {
+      p = buf + yy * width * 3;
+      
+      if (yy + y < y1 || yy + y > y3)
+	for (xx = 0; xx < width; xx++)
+	  {
+	    *p++ = 0;
+	    *p++ = 0;
+	    *p++ = 0;
+	  }
+      else {
+	if (yy + y < y2)
+	  {
+	    xl = LERP (x1, x2, y1, y2, yy + y);
+	    
+	    rl = LERP (r1, r2, y1, y2, yy + y);
+	    gl = LERP (g1, g2, y1, y2, yy + y);
+	    bl = LERP (b1, b2, y1, y2, yy + y);
+	  }
 	else
-		gdk_rgb_gc_set_foreground (priv->gc, 0xffffff);
-
-	gdk_draw_arc (drawable, priv->gc, FALSE,
-		      xx - 3, yy - 3,
-		      6, 6,
-		      0, 360 * 64);
-	gdk_draw_arc (drawable, priv->gc, FALSE,
-		      xx - 2, yy - 2,
-		      4, 4,
-		      0, 360 * 64);
+	  {
+	    xl = LERP (x2, x3, y2, y3, yy + y);
+	    
+	    rl = LERP (r2, r3, y2, y3, yy + y);
+	    gl = LERP (g2, g3, y2, y3, yy + y);
+	    bl = LERP (b2, b3, y2, y3, yy + y);
+	  }
+	
+	xr = LERP (x1, x3, y1, y3, yy + y);
+	
+	rr = LERP (r1, r3, y1, y3, yy + y);
+	gr = LERP (g1, g3, y1, y3, yy + y);
+	br = LERP (b1, b3, y1, y3, yy + y);
+	
+	if (xl > xr)
+	  {
+	    SWAP (xl, xr, t);
+	    SWAP (rl, rr, t);
+	    SWAP (gl, gr, t);
+	    SWAP (bl, br, t);
+	  }
+	
+	for (xx = 0; xx < width; xx++)
+	  {
+	    if (xx + x < xl || xx + x > xr)
+	      {
+		*p++ = 0;
+		*p++ = 0;
+		*p++ = 0;
+	      }
+	    else
+	      {
+		*p++ = LERP (rl, rr, xl, xr, xx + x);
+		*p++ = LERP (gl, gr, xl, xr, xx + x);
+		*p++ = LERP (bl, br, xl, xr, xx + x);
+	      }
+	  }
+      }
+    }
+  
+  /* Create clipping mask */
+  
+  mask = gdk_pixmap_new (NULL, width, height, 1);
+  gc = gdk_gc_new (mask);
+  
+  color.pixel = 0;
+  gdk_gc_set_foreground (gc, &color);
+  gdk_draw_rectangle (mask, gc, TRUE,
+		      0, 0, width, height);
+  
+  color.pixel = 1;
+  gdk_gc_set_foreground (gc, &color);
+  
+  points[0].x = x1 - x;
+  points[0].y = y1 - y;
+  points[1].x = x2 - x;
+  points[1].y = y2 - y;
+  points[2].x = x3 - x;
+  points[2].y = y3 - y;
+  gdk_draw_polygon (mask, gc, TRUE, points, 3);
+  
+  gdk_gc_unref (gc);
+  
+  gdk_gc_set_clip_mask (priv->gc, mask);
+  gdk_gc_set_clip_origin (priv->gc, 0, 0);
+  
+  /* Draw triangle */
+  
+  gdk_draw_rgb_image_dithalign (drawable, priv->gc, 0, 0, width, height,
+				GDK_RGB_DITHER_MAX,
+				buf,
+				width * 3,
+				x, y);
+  
+  gdk_gc_set_clip_mask (priv->gc, NULL);
+  gdk_bitmap_unref (mask);
+  
+  g_free (buf);
+  
+  /* Draw triangle outline */
+  
+  gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
+  
+  gdk_draw_polygon (drawable, priv->gc, FALSE, points, 3);
+  
+  /* Draw value marker */
+  
+  xx = floor (sx + (vx - sx) * priv->v + (hx - vx) * priv->s * priv->v + 0.5);
+  yy = floor (sy + (vy - sy) * priv->v + (hy - vy) * priv->s * priv->v + 0.5);
+  
+  r = priv->h;
+  g = priv->s;
+  b = priv->v;
+  hsv_to_rgb (&r, &g, &b);
+  
+  if (INTENSITY (r, g, b) > 0.5)
+    gdk_rgb_gc_set_foreground (priv->gc, 0x000000);
+  else
+    gdk_rgb_gc_set_foreground (priv->gc, 0xffffff);
+  
+  gdk_draw_arc (drawable, priv->gc, FALSE,
+		xx - 3, yy - 3,
+		6, 6,
+		0, 360 * 64);
+  gdk_draw_arc (drawable, priv->gc, FALSE,
+		xx - 2, yy - 2,
+		4, 4,
+		0, 360 * 64);
 }
 
 /* Paints the contents of the HSV color selector */
 static void
-paint (GtkHSV *hsv, GdkDrawable *drawable, int x, int y, int width, int height)
+paint (GtkHSV      *hsv,
+       GdkDrawable *drawable,
+       gint         x,
+       gint         y,
+       gint         width,
+       gint         height)
 {
-	paint_ring (hsv, drawable, x, y, width, height);
-	paint_triangle (hsv, drawable, x, y, width, height);
+  paint_ring (hsv, drawable, x, y, width, height);
+  paint_triangle (hsv, drawable, x, y, width, height);
 }
 
 /* Expose_event handler for the HSV color selector */
 static gint
-gtk_hsv_expose (GtkWidget *widget, GdkEventExpose *event)
+gtk_hsv_expose (GtkWidget      *widget,
+		GdkEventExpose *event)
 {
-	GtkHSV *hsv;
-	HSVPrivate *priv;
-	GdkRectangle rect, dest;
-	GdkPixmap *pixmap;
-
-	hsv = GTK_HSV (widget);
-	priv = hsv->priv;
-
-	if (!(GTK_WIDGET_DRAWABLE (widget) && event->window == widget->window))
-		return FALSE;
-
-	rect.x = widget->allocation.x;
-	rect.y = widget->allocation.y;
-	rect.width = widget->allocation.width;
-	rect.height = widget->allocation.height;
-
-	if (!gdk_rectangle_intersect (&event->area, &rect, &dest))
-		return FALSE;
-
-	pixmap = gdk_pixmap_new (widget->window, dest.width, dest.height,
-				 gtk_widget_get_visual (widget)->depth);
-
-	rect = dest;
-	rect.x = 0;
-	rect.y = 0;
-
-	gdk_draw_rectangle (pixmap,
-			    widget->style->bg_gc[GTK_WIDGET_STATE (widget)],
-			    TRUE,
-			    0, 0, dest.width, dest.height);
-	paint (hsv, pixmap,
-	       dest.x - widget->allocation.x, dest.y - widget->allocation.y,
-	       dest.width, dest.height);
-
-	gdk_draw_pixmap (widget->window,
-			 priv->gc,
-			 pixmap,
-			 0, 0,
-			 dest.x,
-			 dest.y,
-			 event->area.width, event->area.height);
-
-	gdk_pixmap_unref (pixmap);
-
-	return FALSE;
+  GtkHSV *hsv;
+  HSVPrivate *priv;
+  GdkRectangle rect, dest;
+  GdkPixmap *pixmap;
+  
+  hsv = GTK_HSV (widget);
+  priv = hsv->priv;
+  
+  if (!(GTK_WIDGET_DRAWABLE (widget) && event->window == widget->window))
+    return FALSE;
+  
+  rect.x = widget->allocation.x;
+  rect.y = widget->allocation.y;
+  rect.width = widget->allocation.width;
+  rect.height = widget->allocation.height;
+  
+  if (!gdk_rectangle_intersect (&event->area, &rect, &dest))
+    return FALSE;
+  
+  pixmap = gdk_pixmap_new (widget->window, dest.width, dest.height,
+			   gtk_widget_get_visual (widget)->depth);
+  
+  rect = dest;
+  rect.x = 0;
+  rect.y = 0;
+  
+  gdk_draw_rectangle (pixmap,
+		      widget->style->bg_gc[GTK_WIDGET_STATE (widget)],
+		      TRUE,
+		      0, 0, dest.width, dest.height);
+  paint (hsv, pixmap,
+	 dest.x - widget->allocation.x, dest.y - widget->allocation.y,
+	 dest.width, dest.height);
+  
+  gdk_draw_pixmap (widget->window,
+		   priv->gc,
+		   pixmap,
+		   0, 0,
+		   dest.x,
+		   dest.y,
+		   event->area.width, event->area.height);
+  
+  gdk_pixmap_unref (pixmap);
+  
+  return FALSE;
 }
 
-
 
 /**
  * gtk_hsv_new:
@@ -1193,10 +1280,10 @@ gtk_hsv_expose (GtkWidget *widget, GdkEventExpose *event)
  *
  * Return value: A newly-created HSV color selector.
  **/
-GtkWidget *
+GtkWidget*
 gtk_hsv_new (void)
 {
-	return GTK_WIDGET (gtk_type_new (gtk_hsv_get_type ()));
+  return GTK_WIDGET (gtk_type_new (GTK_TYPE_HSV));
 }
 
 /**
@@ -1210,25 +1297,28 @@ gtk_hsv_new (void)
  * be in the [0.0, 1.0] range.
  **/
 void
-gtk_hsv_set_color (GtkHSV *hsv, double h, double s, double v)
+gtk_hsv_set_color (GtkHSV *hsv,
+		   gdouble h,
+		   gdouble s,
+		   gdouble v)
 {
-	HSVPrivate *priv;
-
-	g_return_if_fail (hsv != NULL);
-	g_return_if_fail (GTK_IS_HSV (hsv));
-	g_return_if_fail (h >= 0.0 && h <= 1.0);
-	g_return_if_fail (s >= 0.0 && s <= 1.0);
-	g_return_if_fail (v >= 0.0 && v <= 1.0);
-
-	priv = hsv->priv;
-
-	priv->h = h;
-	priv->s = s;
-	priv->v = v;
-
-	gtk_signal_emit (GTK_OBJECT (hsv), hsv_signals[CHANGED]);
-
-	gtk_widget_queue_draw (GTK_WIDGET (hsv));
+  HSVPrivate *priv;
+  
+  g_return_if_fail (hsv != NULL);
+  g_return_if_fail (GTK_IS_HSV (hsv));
+  g_return_if_fail (h >= 0.0 && h <= 1.0);
+  g_return_if_fail (s >= 0.0 && s <= 1.0);
+  g_return_if_fail (v >= 0.0 && v <= 1.0);
+  
+  priv = hsv->priv;
+  
+  priv->h = h;
+  priv->s = s;
+  priv->v = v;
+  
+  gtk_signal_emit (GTK_OBJECT (hsv), hsv_signals[CHANGED]);
+  
+  gtk_widget_queue_draw (GTK_WIDGET (hsv));
 }
 
 /**
@@ -1244,21 +1334,21 @@ gtk_hsv_set_color (GtkHSV *hsv, double h, double s, double v)
 void
 gtk_hsv_get_color (GtkHSV *hsv, double *h, double *s, double *v)
 {
-	HSVPrivate *priv;
-
-	g_return_if_fail (hsv != NULL);
-	g_return_if_fail (GTK_IS_HSV (hsv));
-
-	priv = hsv->priv;
-
-	if (h)
-		*h = priv->h;
-
-	if (s)
-		*s = priv->s;
-
-	if (v)
-		*v = priv->v;
+  HSVPrivate *priv;
+  
+  g_return_if_fail (hsv != NULL);
+  g_return_if_fail (GTK_IS_HSV (hsv));
+  
+  priv = hsv->priv;
+  
+  if (h)
+    *h = priv->h;
+  
+  if (s)
+    *s = priv->s;
+  
+  if (v)
+    *v = priv->v;
 }
 
 /**
@@ -1270,28 +1360,30 @@ gtk_hsv_get_color (GtkHSV *hsv, double *h, double *s, double *v)
  * Sets the size and ring width of an HSV color selector.
  **/
 void
-gtk_hsv_set_metrics (GtkHSV *hsv, int size, int ring_width)
+gtk_hsv_set_metrics (GtkHSV *hsv,
+		     gint    size,
+		     gint    ring_width)
 {
-	HSVPrivate *priv;
-	int same_size;
-
-	g_return_if_fail (hsv != NULL);
-	g_return_if_fail (GTK_IS_HSV (hsv));
-	g_return_if_fail (size > 0);
-	g_return_if_fail (ring_width > 0);
-	g_return_if_fail (2 * ring_width + 1 <= size);
-
-	priv = hsv->priv;
-
-	same_size = (priv->size == size);
-
-	priv->size = size;
-	priv->ring_width = ring_width;
-
-	if (same_size)
-		gtk_widget_queue_draw (GTK_WIDGET (hsv));
-	else
-		gtk_widget_queue_resize (GTK_WIDGET (hsv));
+  HSVPrivate *priv;
+  int same_size;
+  
+  g_return_if_fail (hsv != NULL);
+  g_return_if_fail (GTK_IS_HSV (hsv));
+  g_return_if_fail (size > 0);
+  g_return_if_fail (ring_width > 0);
+  g_return_if_fail (2 * ring_width + 1 <= size);
+  
+  priv = hsv->priv;
+  
+  same_size = (priv->size == size);
+  
+  priv->size = size;
+  priv->ring_width = ring_width;
+  
+  if (same_size)
+    gtk_widget_queue_draw (GTK_WIDGET (hsv));
+  else
+    gtk_widget_queue_resize (GTK_WIDGET (hsv));
 }
 
 /**
@@ -1303,20 +1395,22 @@ gtk_hsv_set_metrics (GtkHSV *hsv, int size, int ring_width)
  * Queries the size and ring width of an HSV color selector.
  **/
 void
-gtk_hsv_get_metrics (GtkHSV *hsv, int *size, int *ring_width)
+gtk_hsv_get_metrics (GtkHSV *hsv,
+		     gint   *size,
+		     gint   *ring_width)
 {
-	HSVPrivate *priv;
-
-	g_return_if_fail (hsv != NULL);
-	g_return_if_fail (GTK_IS_HSV (hsv));
-
-	priv = hsv->priv;
-
-	if (size)
-		*size = priv->size;
-
-	if (ring_width)
-		*ring_width = priv->ring_width;
+  HSVPrivate *priv;
+  
+  g_return_if_fail (hsv != NULL);
+  g_return_if_fail (GTK_IS_HSV (hsv));
+  
+  priv = hsv->priv;
+  
+  if (size)
+    *size = priv->size;
+  
+  if (ring_width)
+    *ring_width = priv->ring_width;
 }
 
 /**
@@ -1335,13 +1429,14 @@ gtk_hsv_get_metrics (GtkHSV *hsv, int *size, int *ring_width)
 gboolean
 gtk_hsv_is_adjusting (GtkHSV *hsv)
 {
-	HSVPrivate *priv;
-
-	g_return_val_if_fail (hsv != NULL, FALSE);
-	g_return_val_if_fail (GTK_IS_HSV (hsv), FALSE);
-
-	priv = hsv->priv;
-	return (priv->mode != DRAG_NONE);
+  HSVPrivate *priv;
+  
+  g_return_val_if_fail (hsv != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_HSV (hsv), FALSE);
+  
+  priv = hsv->priv;
+
+  return priv->mode != DRAG_NONE;
 }
 
 /**
@@ -1357,22 +1452,27 @@ gtk_hsv_is_adjusting (GtkHSV *hsv)
  * [0.0, 1.0] range; output values will be in the same range.
  **/
 void
-gtk_hsv_to_rgb (double h, double s, double v, double *r, double *g, double *b)
+gtk_hsv_to_rgb (gdouble  h,
+		gdouble  s,
+		gdouble  v,
+		gdouble *r,
+		gdouble *g,
+		gdouble *b)
 {
-	g_return_if_fail (h >= 0.0 && h <= 1.0);
-	g_return_if_fail (s >= 0.0 && s <= 1.0);
-	g_return_if_fail (v >= 0.0 && v <= 1.0);
-
-	hsv_to_rgb (&h, &s, &v);
-
-	if (r)
-		*r = h;
-
-	if (g)
-		*g = s;
-
-	if (b)
-		*b = v;
+  g_return_if_fail (h >= 0.0 && h <= 1.0);
+  g_return_if_fail (s >= 0.0 && s <= 1.0);
+  g_return_if_fail (v >= 0.0 && v <= 1.0);
+  
+  hsv_to_rgb (&h, &s, &v);
+  
+  if (r)
+    *r = h;
+  
+  if (g)
+    *g = s;
+  
+  if (b)
+    *b = v;
 }
 
 /**
@@ -1388,20 +1488,25 @@ gtk_hsv_to_rgb (double h, double s, double v, double *r, double *g, double *b)
  * [0.0, 1.0] range; output values will be in the same range.
  **/
 void
-gtk_rgb_to_hsv (double r, double g, double b, double *h, double *s, double *v)
+gtk_rgb_to_hsv (gdouble  r,
+		gdouble  g,
+		gdouble  b,
+		gdouble *h,
+		gdouble *s,
+		gdouble *v)
 {
-	g_return_if_fail (r >= 0.0 && r <= 1.0);
-	g_return_if_fail (g >= 0.0 && g <= 1.0);
-	g_return_if_fail (b >= 0.0 && b <= 1.0);
-
-	rgb_to_hsv (&r, &g, &b);
-
-	if (h)
-		*h = r;
-
-	if (s)
-		*s = g;
-
-	if (v)
-		*v = b;
+  g_return_if_fail (r >= 0.0 && r <= 1.0);
+  g_return_if_fail (g >= 0.0 && g <= 1.0);
+  g_return_if_fail (b >= 0.0 && b <= 1.0);
+  
+  rgb_to_hsv (&r, &g, &b);
+  
+  if (h)
+    *h = r;
+  
+  if (s)
+    *s = g;
+  
+  if (v)
+    *v = b;
 }
diff --git a/gtk/gtkhsv.h b/gtk/gtkhsv.h
index ffe6ff7fc..396821bed 100644
--- a/gtk/gtkhsv.h
+++ b/gtk/gtkhsv.h
@@ -21,63 +21,86 @@
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */
-
 #ifndef __GTK_HSV_H__
 #define __GTK_HSV_H__
 
+/*
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GTK+ Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #include <gtk/gtkwidget.h>
 
-
 
 #define GTK_TYPE_HSV            (gtk_hsv_get_type ())
 #define GTK_HSV(obj)            (GTK_CHECK_CAST ((obj), GTK_TYPE_HSV, GtkHSV))
 #define GTK_HSV_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_HSV, GtkHSV))
 #define GTK_IS_HSV(obj)         (GTK_CHECK_TYPE ((obj), GTK_TYPE_HSV))
 #define GTK_IS_HSV_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HSV))
+#define GTK_HSV_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_HSV, GtkHSVClass))
 
 
-typedef struct _GtkHSV GtkHSV;
+typedef struct _GtkHSV      GtkHSV;
 typedef struct _GtkHSVClass GtkHSVClass;
 
-struct _GtkHSV {
-	GtkWidget widget;
-
-	/* Private data */
-	gpointer priv;
+struct _GtkHSV
+{
+  GtkWidget parent_instance;
+  
+  /* Private data */
+  gpointer priv;
 };
 
-struct _GtkHSVClass {
-	GtkWidgetClass parent_class;
-
-	/* Notification signals */
-
-	void (* changed) (GtkHSV *hsv);
+struct _GtkHSVClass
+{
+  GtkWidgetClass parent_class;
+  
+  /* Notification signals */
+  
+  void (*changed) (GtkHSV *hsv);
 };
 
 
-GtkType gtk_hsv_get_type (void);
+GtkType    gtk_hsv_get_type     (void);
+GtkWidget* gtk_hsv_new          (void);
+void       gtk_hsv_set_color    (GtkHSV    *hsv,
+				 double     h,
+				 double     s,
+				 double     v);
+void       gtk_hsv_get_color    (GtkHSV    *hsv,
+				 gdouble   *h,
+				 gdouble   *s,
+				 gdouble   *v);
+void       gtk_hsv_set_metrics  (GtkHSV    *hsv,
+				 gint       size,
+				 gint       ring_width);
+void       gtk_hsv_get_metrics  (GtkHSV    *hsv,
+				 gint      *size,
+				 gint      *ring_width);
+gboolean   gtk_hsv_is_adjusting (GtkHSV    *hsv);
+void       gtk_hsv_to_rgb       (gdouble    h,
+				 gdouble    s,
+				 gdouble    v,
+				 gdouble   *r,
+				 gdouble   *g,
+				 gdouble   *b);
+void       gtk_rgb_to_hsv       (gdouble    r,
+				 gdouble    g,
+				 gdouble    b,
+				 gdouble   *h,
+				 gdouble   *s,
+				 gdouble   *v);
 
-GtkWidget *gtk_hsv_new (void);
-
-void gtk_hsv_set_color (GtkHSV *hsv, double h, double s, double v);
-void gtk_hsv_get_color (GtkHSV *hsv, double *h, double *s, double *v);
-
-void gtk_hsv_set_metrics (GtkHSV *hsv, int size, int ring_width);
-void gtk_hsv_get_metrics (GtkHSV *hsv, int *size, int *ring_width);
-
-gboolean gtk_hsv_is_adjusting (GtkHSV *hsv);
-
-void gtk_hsv_to_rgb (double h, double s, double v, double *r, double *g, double *b);
-void gtk_rgb_to_hsv (double r, double g, double b, double *h, double *s, double *v);
-
-
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif
+#endif /* __GTK_HSV_H__ */
diff --git a/gtk/gtkinputdialog.c b/gtk/gtkinputdialog.c
index 263729b6c..aca117055 100644
--- a/gtk/gtkinputdialog.c
+++ b/gtk/gtkinputdialog.c
@@ -81,7 +81,6 @@ static void gtk_input_dialog_class_init (GtkInputDialogClass *klass);
 static void gtk_input_dialog_init (GtkInputDialog *inputd);
 static GdkDeviceInfo *gtk_input_dialog_get_device_info(guint32 deviceid);
 static void gtk_input_dialog_set_device(GtkWidget *widget, gpointer data);
-static void gtk_input_dialog_finalize (GtkObject *object);
 static void gtk_input_dialog_set_mapping_mode(GtkWidget *w,
 					      gpointer data);
 static void gtk_input_dialog_set_axis(GtkWidget *widget, gpointer data);
@@ -155,7 +154,7 @@ gtk_input_dialog_class_init (GtkInputDialogClass *klass)
   input_dialog_signals[ENABLE_DEVICE] =
     gtk_signal_new ("enable_device",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkInputDialogClass, enable_device),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1, GTK_TYPE_INT);
@@ -163,7 +162,7 @@ gtk_input_dialog_class_init (GtkInputDialogClass *klass)
   input_dialog_signals[DISABLE_DEVICE] =
     gtk_signal_new ("disable_device",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkInputDialogClass, disable_device),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1, GTK_TYPE_INT);
@@ -172,7 +171,6 @@ gtk_input_dialog_class_init (GtkInputDialogClass *klass)
 				LAST_SIGNAL);
 
 
-  object_class->finalize = gtk_input_dialog_finalize;
   klass->enable_device = NULL;
   klass->disable_device = NULL;
 }
@@ -393,16 +391,6 @@ gtk_input_dialog_set_device(GtkWidget *widget, gpointer data)
 }
 
 static void
-gtk_input_dialog_finalize (GtkObject *object)
-{
-  /*  GtkInputDialog *inputd = GTK_INPUT_DIALOG (object); */
-
-  /* Clean up ? */
-
-  (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
-}
-
-static void
 gtk_input_dialog_set_mapping_mode(GtkWidget *w,
 				  gpointer data)
 {
diff --git a/gtk/gtkitem.c b/gtk/gtkitem.c
index d9df4607f..0dae0e2b1 100644
--- a/gtk/gtkitem.c
+++ b/gtk/gtkitem.c
@@ -87,21 +87,21 @@ gtk_item_class_init (GtkItemClass *class)
   item_signals[SELECT] =
     gtk_signal_new ("select",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkItemClass, select),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   item_signals[DESELECT] =
     gtk_signal_new ("deselect",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkItemClass, deselect),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   item_signals[TOGGLE] =
     gtk_signal_new ("toggle",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkItemClass, toggle),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
diff --git a/gtk/gtkitemfactory.c b/gtk/gtkitemfactory.c
index 82a849e17..329f0cf88 100644
--- a/gtk/gtkitemfactory.c
+++ b/gtk/gtkitemfactory.c
@@ -85,12 +85,12 @@ struct _GtkIFDumpData
 static void	gtk_item_factory_class_init		(GtkItemFactoryClass  *klass);
 static void	gtk_item_factory_init			(GtkItemFactory	      *ifactory);
 static void	gtk_item_factory_destroy		(GtkObject	      *object);
-static void	gtk_item_factory_finalize		(GtkObject	      *object);
+static void	gtk_item_factory_finalize		(GObject	      *object);
 
 
 /* --- static variables --- */
 static GtkItemFactoryClass *gtk_item_factory_class = NULL;
-static GtkObjectClass	*parent_class = NULL;
+static gpointer          parent_class = NULL;
 static const gchar	*item_factory_string = "Gtk-<ItemFactory>";
 static GMemChunk	*ifactory_item_chunks = NULL;
 static GMemChunk	*ifactory_cb_data_chunks = NULL;
@@ -181,6 +181,7 @@ gtk_item_factory_get_type (void)
 static void
 gtk_item_factory_class_init (GtkItemFactoryClass  *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
 
   gtk_item_factory_class = class;
@@ -189,8 +190,9 @@ gtk_item_factory_class_init (GtkItemFactoryClass  *class)
 
   object_class = (GtkObjectClass*) class;
 
+  gobject_class->finalize = gtk_item_factory_finalize;
+
   object_class->destroy = gtk_item_factory_destroy;
-  object_class->finalize = gtk_item_factory_finalize;
 
   class->cpair_comment_single = g_strdup (";\n");
 
@@ -511,7 +513,7 @@ gtk_item_factory_add_item (GtkItemFactory		*ifactory,
   g_return_if_fail (widget != NULL);
   g_return_if_fail (item_type != NULL);
 
-  class = GTK_ITEM_FACTORY_CLASS (GTK_OBJECT (ifactory)->klass);
+  class = GTK_ITEM_FACTORY_GET_CLASS (ifactory);
 
   /* set accelerator group on menu widgets
    */
@@ -681,11 +683,11 @@ gtk_item_factory_destroy (GtkObject *object)
   g_slist_free (ifactory->items);
   ifactory->items = NULL;
 
-  parent_class->destroy (object);
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 static void
-gtk_item_factory_finalize (GtkObject		  *object)
+gtk_item_factory_finalize (GObject *object)
 {
   GtkItemFactory *ifactory;
 
@@ -701,7 +703,7 @@ gtk_item_factory_finalize (GtkObject		  *object)
   if (ifactory->translate_notify)
     ifactory->translate_notify (ifactory->translate_data);
   
-  parent_class->finalize (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 GtkItemFactory*
@@ -859,7 +861,7 @@ gtk_item_factory_get_widget (GtkItemFactory *ifactory,
   g_return_val_if_fail (GTK_IS_ITEM_FACTORY (ifactory), NULL);
   g_return_val_if_fail (path != NULL, NULL);
 
-  class = GTK_ITEM_FACTORY_CLASS (GTK_OBJECT (ifactory)->klass);
+  class = GTK_ITEM_FACTORY_GET_CLASS (ifactory);
 
   if (path[0] == '<')
     item = g_hash_table_lookup (class->item_ht, (gpointer) path);
@@ -1323,7 +1325,7 @@ gtk_item_factory_delete_item (GtkItemFactory         *ifactory,
   g_return_if_fail (GTK_IS_ITEM_FACTORY (ifactory));
   g_return_if_fail (path != NULL);
 
-  class = GTK_ITEM_FACTORY_CLASS (GTK_OBJECT (ifactory)->klass);
+  class = GTK_ITEM_FACTORY_GET_CLASS (ifactory);
 
   fpath = g_strconcat (ifactory->path, path, NULL);
   item = g_hash_table_lookup (class->item_ht, fpath);
diff --git a/gtk/gtklabel.c b/gtk/gtklabel.c
index 0f16212b0..d6b64572c 100644
--- a/gtk/gtklabel.c
+++ b/gtk/gtklabel.c
@@ -74,7 +74,7 @@ static void gtk_label_set_arg	   (GtkObject	   *object,
 static void gtk_label_get_arg	   (GtkObject      *object,
 				    GtkArg	   *arg,
 				    guint	    arg_id);
-static void gtk_label_finalize	   (GtkObject	   *object);
+static void gtk_label_finalize	   (GObject	   *object);
 static void gtk_label_size_request (GtkWidget	   *widget,
 				    GtkRequisition *requisition);
 static void gtk_label_style_set    (GtkWidget      *widget,
@@ -101,20 +101,20 @@ gtk_label_get_type (void)
   
   if (!label_type)
     {
-      static const GtkTypeInfo label_info =
+      static const GTypeInfo label_info =
       {
-	"GtkLabel",
-	sizeof (GtkLabel),
 	sizeof (GtkLabelClass),
-	(GtkClassInitFunc) gtk_label_class_init,
-	(GtkObjectInitFunc) gtk_label_init,
-        /* reserved_1 */ NULL,
-	/* reserved_2 */ NULL,
-	(GtkClassInitFunc) NULL,
+	NULL,           /* base_init */
+	NULL,           /* base_finalize */
+	(GClassInitFunc) gtk_label_class_init,
+	NULL,           /* class_finalize */
+	NULL,           /* class_data */
+	sizeof (GtkLabel),
+	32,             /* n_preallocs */
+	(GInstanceInitFunc) gtk_label_init,
       };
-      
-      label_type = gtk_type_unique (GTK_TYPE_MISC, &label_info);
-      gtk_type_set_chunk_alloc (label_type, 32);
+
+      label_type = g_type_register_static (GTK_TYPE_MISC, "GtkLabel", &label_info);
     }
   
   return label_type;
@@ -123,6 +123,7 @@ gtk_label_get_type (void)
 static void
 gtk_label_class_init (GtkLabelClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   
@@ -136,9 +137,10 @@ gtk_label_class_init (GtkLabelClass *class)
   gtk_object_add_arg_type ("GtkLabel::justify", GTK_TYPE_JUSTIFICATION, GTK_ARG_READWRITE, ARG_JUSTIFY);
   gtk_object_add_arg_type ("GtkLabel::wrap", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_WRAP);
   
+  gobject_class->finalize = gtk_label_finalize;
+
   object_class->set_arg = gtk_label_set_arg;
   object_class->get_arg = gtk_label_get_arg;
-  object_class->finalize = gtk_label_finalize;
   
   widget_class->size_request = gtk_label_size_request;
   widget_class->style_set = gtk_label_style_set;
@@ -347,11 +349,10 @@ gtk_label_get_text (GtkLabel *label)
 }
 
 static void
-gtk_label_finalize (GtkObject *object)
+gtk_label_finalize (GObject *object)
 {
   GtkLabel *label;
   
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_LABEL (object));
   
   label = GTK_LABEL (object);
@@ -362,7 +363,7 @@ gtk_label_finalize (GtkObject *object)
 
   gtk_label_free_words (label);
 
-  GTK_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static GtkLabelULine*
diff --git a/gtk/gtklayout.c b/gtk/gtklayout.c
index a57e52df1..f551a80bf 100644
--- a/gtk/gtklayout.c
+++ b/gtk/gtklayout.c
@@ -45,7 +45,7 @@ struct _GtkLayoutChild {
 static void     gtk_layout_class_init         (GtkLayoutClass *class);
 static void     gtk_layout_init               (GtkLayout      *layout);
 
-static void     gtk_layout_finalize           (GtkObject      *object);
+static void     gtk_layout_finalize           (GObject        *object);
 static void     gtk_layout_realize            (GtkWidget      *widget);
 static void     gtk_layout_unrealize          (GtkWidget      *widget);
 static void     gtk_layout_map                (GtkWidget      *widget);
@@ -170,14 +170,14 @@ gtk_layout_set_adjustments (GtkLayout     *layout,
 }
 
 static void
-gtk_layout_finalize (GtkObject *object)
+gtk_layout_finalize (GObject *object)
 {
   GtkLayout *layout = GTK_LAYOUT (object);
 
   gtk_object_unref (GTK_OBJECT (layout->hadjustment));
   gtk_object_unref (GTK_OBJECT (layout->vadjustment));
 
-  GTK_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 void           
@@ -320,18 +320,20 @@ gtk_layout_get_type (void)
 
   if (!layout_type)
     {
-      static const GtkTypeInfo layout_info =
+      static const GTypeInfo layout_info =
       {
-	"GtkLayout",
-	sizeof (GtkLayout),
 	sizeof (GtkLayoutClass),
-	(GtkClassInitFunc) gtk_layout_class_init,
-	(GtkObjectInitFunc) gtk_layout_init,
-	(GtkArgSetFunc) NULL,
-        (GtkArgGetFunc) NULL,
+	NULL,           /* base_init */
+	NULL,           /* base_finalize */
+	(GClassInitFunc) gtk_layout_class_init,
+	NULL,           /* class_finalize */
+	NULL,           /* class_data */
+	sizeof (GtkLayout),
+	16,             /* n_preallocs */
+	(GInstanceInitFunc) gtk_layout_init,
       };
 
-      layout_type = gtk_type_unique (GTK_TYPE_CONTAINER, &layout_info);
+      layout_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkLayout", &layout_info);
     }
 
   return layout_type;
@@ -340,6 +342,7 @@ gtk_layout_get_type (void)
 static void
 gtk_layout_class_init (GtkLayoutClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;
@@ -350,7 +353,7 @@ gtk_layout_class_init (GtkLayoutClass *class)
 
   parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
 
-  object_class->finalize = gtk_layout_finalize;
+  gobject_class->finalize = gtk_layout_finalize;
 
   widget_class->realize = gtk_layout_realize;
   widget_class->unrealize = gtk_layout_unrealize;
@@ -368,7 +371,7 @@ gtk_layout_class_init (GtkLayoutClass *class)
   widget_class->set_scroll_adjustments_signal =
     gtk_signal_new ("set_scroll_adjustments",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkLayoutClass, set_scroll_adjustments),
 		    gtk_marshal_NONE__POINTER_POINTER,
 		    GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
diff --git a/gtk/gtklist.c b/gtk/gtklist.c
index a114dcad7..0c532b4ed 100644
--- a/gtk/gtklist.c
+++ b/gtk/gtklist.c
@@ -54,7 +54,7 @@ static void gtk_list_get_arg         (GtkObject      *object,
 				      GtkArg         *arg,
 				      guint           arg_id);
 /** GtkObject Methods **/
-static void gtk_list_shutdown	     (GtkObject	     *object);
+static void gtk_list_shutdown	     (GObject	     *object);
 
 /** GtkWidget Methods **/
 static void gtk_list_size_request    (GtkWidget	     *widget,
@@ -200,6 +200,7 @@ gtk_list_get_type (void)
 static void
 gtk_list_class_init (GtkListClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;
@@ -213,17 +214,19 @@ gtk_list_class_init (GtkListClass *class)
   vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
   hadjustment_key_id = g_quark_from_static_string (hadjustment_key);
 
+  gobject_class->shutdown = gtk_list_shutdown;
+
   list_signals[SELECTION_CHANGED] =
     gtk_signal_new ("selection_changed",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkListClass, selection_changed),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   list_signals[SELECT_CHILD] =
     gtk_signal_new ("select_child",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkListClass, select_child),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -231,7 +234,7 @@ gtk_list_class_init (GtkListClass *class)
   list_signals[UNSELECT_CHILD] =
     gtk_signal_new ("unselect_child",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkListClass, unselect_child),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -239,7 +242,6 @@ gtk_list_class_init (GtkListClass *class)
 
   gtk_object_class_add_signals (object_class, list_signals, LAST_SIGNAL);
 
-  object_class->shutdown = gtk_list_shutdown;
   object_class->set_arg = gtk_list_set_arg;
   object_class->get_arg = gtk_list_get_arg;
 
@@ -341,10 +343,11 @@ gtk_list_new (void)
  * gtk_list_shutdown
  */
 static void
-gtk_list_shutdown (GtkObject *object)
+gtk_list_shutdown (GObject *object)
 {
   gtk_list_clear_items (GTK_LIST (object), 0, -1);
-  GTK_OBJECT_CLASS (parent_class)->shutdown (object);
+
+  G_OBJECT_CLASS (parent_class)->shutdown (object);
 }
 
 
diff --git a/gtk/gtklistitem.c b/gtk/gtklistitem.c
index 4c215e5d2..8482cde21 100644
--- a/gtk/gtklistitem.c
+++ b/gtk/gtklistitem.c
@@ -118,56 +118,56 @@ gtk_list_item_class_init (GtkListItemClass *class)
   list_item_signals[TOGGLE_FOCUS_ROW] =
     gtk_signal_new ("toggle_focus_row",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkListItemClass, toggle_focus_row),
                     gtk_marshal_NONE__NONE,
                     GTK_TYPE_NONE, 0);
   list_item_signals[SELECT_ALL] =
     gtk_signal_new ("select_all",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkListItemClass, select_all),
                     gtk_marshal_NONE__NONE,
                     GTK_TYPE_NONE, 0);
   list_item_signals[UNSELECT_ALL] =
     gtk_signal_new ("unselect_all",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkListItemClass, unselect_all),
                     gtk_marshal_NONE__NONE,
                     GTK_TYPE_NONE, 0);
   list_item_signals[UNDO_SELECTION] =
     gtk_signal_new ("undo_selection",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkListItemClass, undo_selection),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   list_item_signals[START_SELECTION] =
     gtk_signal_new ("start_selection",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkListItemClass, start_selection),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   list_item_signals[END_SELECTION] =
     gtk_signal_new ("end_selection",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkListItemClass, end_selection),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   list_item_signals[TOGGLE_ADD_MODE] =
     gtk_signal_new ("toggle_add_mode",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkListItemClass, toggle_add_mode),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   list_item_signals[EXTEND_SELECTION] =
     gtk_signal_new ("extend_selection",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkListItemClass, extend_selection),
                     gtk_marshal_NONE__ENUM_FLOAT_BOOL,
                     GTK_TYPE_NONE, 3,
@@ -175,14 +175,14 @@ gtk_list_item_class_init (GtkListItemClass *class)
   list_item_signals[SCROLL_VERTICAL] =
     gtk_signal_new ("scroll_vertical",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkListItemClass, scroll_vertical),
                     gtk_marshal_NONE__ENUM_FLOAT,
                     GTK_TYPE_NONE, 2, GTK_TYPE_ENUM, GTK_TYPE_FLOAT);
   list_item_signals[SCROLL_HORIZONTAL] =
     gtk_signal_new ("scroll_horizontal",
                     GTK_RUN_LAST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkListItemClass, scroll_horizontal),
                     gtk_marshal_NONE__ENUM_FLOAT,
                     GTK_TYPE_NONE, 2, GTK_TYPE_ENUM, GTK_TYPE_FLOAT);
diff --git a/gtk/gtkmain.c b/gtk/gtkmain.c
index d80dfb24c..5eca47c7b 100644
--- a/gtk/gtkmain.c
+++ b/gtk/gtkmain.c
@@ -197,7 +197,6 @@ gboolean
 gtk_init_check (int	 *argc,
 		char   ***argv)
 {
-  extern void gtk_object_post_arg_parsing_init (void);
   GSList *gtk_modules = NULL;
   GSList *slist;
   gchar *env_string = NULL;
@@ -422,7 +421,6 @@ gtk_init_check (int	 *argc,
   gtk_colormap = gdk_colormap_get_system ();
 
   gtk_type_init ();
-  gtk_object_post_arg_parsing_init ();
   gtk_signal_init ();
   gtk_rc_init ();
   
diff --git a/gtk/gtkmarshal.list b/gtk/gtkmarshal.list
index 92a110a03..a016dffc6 100644
--- a/gtk/gtkmarshal.list
+++ b/gtk/gtkmarshal.list
@@ -9,8 +9,6 @@ INT:POINTER
 INT:POINTER,CHAR,CHAR
 NONE:BOOL
 NONE:BOXED
-NONE:C_CALLBACK
-NONE:C_CALLBACK,C_CALLBACK
 NONE:ENUM
 NONE:ENUM,FLOAT
 NONE:ENUM,FLOAT,BOOL
diff --git a/gtk/gtkmarshalers.list b/gtk/gtkmarshalers.list
index 92a110a03..a016dffc6 100644
--- a/gtk/gtkmarshalers.list
+++ b/gtk/gtkmarshalers.list
@@ -9,8 +9,6 @@ INT:POINTER
 INT:POINTER,CHAR,CHAR
 NONE:BOOL
 NONE:BOXED
-NONE:C_CALLBACK
-NONE:C_CALLBACK,C_CALLBACK
 NONE:ENUM
 NONE:ENUM,FLOAT
 NONE:ENUM,FLOAT,BOOL
diff --git a/gtk/gtkmenu.c b/gtk/gtkmenu.c
index 15ac8813e..f74a3255c 100644
--- a/gtk/gtkmenu.c
+++ b/gtk/gtkmenu.c
@@ -35,7 +35,7 @@
 #include "gtkwindow.h"
 
 
-#define MENU_ITEM_CLASS(w)   GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
+#define MENU_ITEM_CLASS(w)   GTK_MENU_ITEM_GET_CLASS (w)
 #define	MENU_NEEDS_RESIZE(m) GTK_MENU_SHELL (m)->menu_flag
 
 typedef struct _GtkMenuAttachData	GtkMenuAttachData;
@@ -192,20 +192,20 @@ gtk_menu_init (GtkMenu *menu)
   menu->position_func = NULL;
   menu->position_func_data = NULL;
 
-  menu->toplevel = gtk_window_new (GTK_WINDOW_POPUP);
-  gtk_signal_connect (GTK_OBJECT (menu->toplevel),
-		      "event",
-		      GTK_SIGNAL_FUNC (gtk_menu_window_event), 
-		      GTK_OBJECT (menu));
+  menu->toplevel = gtk_widget_new (GTK_TYPE_WINDOW,
+				   "type", GTK_WINDOW_POPUP,
+				   "signal::event", gtk_menu_window_event, menu,
+				   "signal::destroy", gtk_widget_destroyed, &menu->toplevel,
+				   "child", menu,
+				   NULL);
   gtk_window_set_policy (GTK_WINDOW (menu->toplevel),
 			 FALSE, FALSE, TRUE);
 
-  gtk_container_add (GTK_CONTAINER (menu->toplevel), GTK_WIDGET (menu));
-
   /* Refloat the menu, so that reference counting for the menu isn't
    * affected by it being a child of the toplevel
    */
   GTK_WIDGET_SET_FLAGS (menu, GTK_FLOATING);
+  menu->needs_destruction_ref_count = TRUE;
 
   menu->tearoff_window = NULL;
   menu->torn_off = FALSE;
@@ -214,18 +214,15 @@ gtk_menu_init (GtkMenu *menu)
 }
 
 static void
-gtk_menu_destroy (GtkObject	    *object)
+gtk_menu_destroy (GtkObject *object)
 {
   GtkMenu *menu;
   GtkMenuAttachData *data;
   
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_MENU (object));
 
   menu = GTK_MENU (object);
   
-  gtk_object_ref (object);
-  
   data = gtk_object_get_data (object, attach_data_key);
   if (data)
     gtk_menu_detach (menu);
@@ -239,16 +236,18 @@ gtk_menu_destroy (GtkObject	    *object)
     }
 
   /* Add back the reference count for being a child */
-  gtk_object_ref (object);
+  if (menu->needs_destruction_ref_count)
+    {
+      menu->needs_destruction_ref_count = FALSE;
+      gtk_object_ref (object);
+    }
   
-  gtk_widget_destroy (menu->toplevel);
+  if (menu->toplevel)
+    gtk_widget_destroy (menu->toplevel);
   if (menu->tearoff_window)
     gtk_widget_destroy (menu->tearoff_window);
 
-  if (GTK_OBJECT_CLASS (parent_class)->destroy)
-    (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
-  
-  gtk_object_unref (object);
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 
@@ -293,7 +292,7 @@ gtk_menu_attach_to_widget (GtkMenu	       *menu,
 }
 
 GtkWidget*
-gtk_menu_get_attach_widget (GtkMenu		*menu)
+gtk_menu_get_attach_widget (GtkMenu *menu)
 {
   GtkMenuAttachData *data;
   
@@ -307,7 +306,7 @@ gtk_menu_get_attach_widget (GtkMenu		*menu)
 }
 
 void
-gtk_menu_detach (GtkMenu	     *menu)
+gtk_menu_detach (GtkMenu *menu)
 {
   GtkMenuAttachData *data;
   
@@ -708,7 +707,10 @@ gtk_menu_set_tearoff_state (GtkMenu  *menu,
 	      GtkWidget *attach_widget;
 	      gchar *title;
 	      
-	      menu->tearoff_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+	      menu->tearoff_window = gtk_widget_new (GTK_TYPE_WINDOW,
+						     "type", GTK_WINDOW_TOPLEVEL,
+						     "signal::destroy", gtk_widget_destroyed, &menu->tearoff_window,
+						     NULL);
 	      gtk_widget_set_app_paintable (menu->tearoff_window, TRUE);
 	      gtk_signal_connect (GTK_OBJECT (menu->tearoff_window),  
 				  "event",
diff --git a/gtk/gtkmenu.h b/gtk/gtkmenu.h
index cd51c1e55..3a393473d 100644
--- a/gtk/gtkmenu.h
+++ b/gtk/gtkmenu.h
@@ -74,6 +74,7 @@ struct _GtkMenu
   GtkWidget *toplevel;
   GtkWidget *tearoff_window;
 
+  guint needs_destruction_ref_count : 1;
   guint torn_off : 1;
 };
 
diff --git a/gtk/gtkmenuitem.c b/gtk/gtkmenuitem.c
index ec7efd62a..c8e0cfd2f 100644
--- a/gtk/gtkmenuitem.c
+++ b/gtk/gtkmenuitem.c
@@ -88,20 +88,20 @@ gtk_menu_item_get_type (void)
 
   if (!menu_item_type)
     {
-      static const GtkTypeInfo menu_item_info =
+      static const GTypeInfo menu_item_info =
       {
-	"GtkMenuItem",
-	sizeof (GtkMenuItem),
 	sizeof (GtkMenuItemClass),
-	(GtkClassInitFunc) gtk_menu_item_class_init,
-	(GtkObjectInitFunc) gtk_menu_item_init,
-	/* reserved_1 */ NULL,
-        /* reserved_2 */ NULL,
-        (GtkClassInitFunc) NULL,
+	NULL,           /* base_init */
+	NULL,           /* base_finalize */
+	(GClassInitFunc) gtk_menu_item_class_init,
+	NULL,           /* class_finalize */
+	NULL,           /* class_data */
+	sizeof (GtkMenuItem),
+	16,             /* n_preallocs */
+	(GInstanceInitFunc) gtk_menu_item_init,
       };
 
-      menu_item_type = gtk_type_unique (gtk_item_get_type (), &menu_item_info);
-      gtk_type_set_chunk_alloc (menu_item_type, 16);
+      menu_item_type = g_type_register_static (GTK_TYPE_ITEM, "GtkMenuItem", &menu_item_info);
     }
 
   return menu_item_type;
@@ -125,7 +125,7 @@ gtk_menu_item_class_init (GtkMenuItemClass *klass)
   menu_item_signals[ACTIVATE] =
     gtk_signal_new ("activate",
                     GTK_RUN_FIRST | GTK_RUN_ACTION,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
@@ -133,7 +133,7 @@ gtk_menu_item_class_init (GtkMenuItemClass *klass)
   menu_item_signals[ACTIVATE_ITEM] =
     gtk_signal_new ("activate_item",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate_item),
                     gtk_signal_default_marshaller,
 		    GTK_TYPE_NONE, 0);
diff --git a/gtk/gtkmenushell.c b/gtk/gtkmenushell.c
index e60f73b4c..b76ccf681 100644
--- a/gtk/gtkmenushell.c
+++ b/gtk/gtkmenushell.c
@@ -34,7 +34,6 @@
 
 
 #define MENU_SHELL_TIMEOUT   500
-#define MENU_SHELL_CLASS(w)  GTK_MENU_SHELL_CLASS (GTK_OBJECT (w)->klass)
 
 
 enum {
@@ -191,21 +190,21 @@ gtk_menu_shell_class_init (GtkMenuShellClass *klass)
   menu_shell_signals[DEACTIVATE] =
     gtk_signal_new ("deactivate",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkMenuShellClass, deactivate),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   menu_shell_signals[SELECTION_DONE] =
     gtk_signal_new ("selection-done",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkMenuShellClass, selection_done),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   menu_shell_signals[MOVE_CURRENT] =
     gtk_signal_new ("move_current",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkMenuShellClass, move_current),
 		    gtk_marshal_NONE__ENUM,
 		    GTK_TYPE_NONE, 1, 
@@ -213,7 +212,7 @@ gtk_menu_shell_class_init (GtkMenuShellClass *klass)
   menu_shell_signals[ACTIVATE_CURRENT] =
     gtk_signal_new ("activate_current",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkMenuShellClass, activate_current),
 		    gtk_marshal_NONE__BOOL,
 		    GTK_TYPE_NONE, 1, 
@@ -221,7 +220,7 @@ gtk_menu_shell_class_init (GtkMenuShellClass *klass)
   menu_shell_signals[CANCEL] =
     gtk_signal_new ("cancel",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkMenuShellClass, cancel),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
@@ -786,7 +785,7 @@ gtk_menu_shell_select_item (GtkMenuShell *menu_shell,
   
   menu_shell->active_menu_item = menu_item;
   gtk_menu_item_set_placement (GTK_MENU_ITEM (menu_shell->active_menu_item),
-			       MENU_SHELL_CLASS (menu_shell)->submenu_placement);
+			       GTK_MENU_SHELL_GET_CLASS (menu_shell)->submenu_placement);
   gtk_menu_item_select (GTK_MENU_ITEM (menu_shell->active_menu_item));
 
   /* This allows the bizarre radio buttons-with-submenus-display-history
@@ -822,7 +821,7 @@ gtk_menu_shell_activate_item (GtkMenuShell      *menu_shell,
   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 
   if (!deactivate)
-    deactivate = GTK_MENU_ITEM_CLASS (GTK_OBJECT (menu_item)->klass)->hide_on_activate;
+    deactivate = GTK_MENU_ITEM_GET_CLASS (menu_item)->hide_on_activate;
 
   gtk_widget_ref (GTK_WIDGET (menu_shell));
 
@@ -936,8 +935,8 @@ gtk_real_menu_shell_move_current (GtkMenuShell      *menu_shell,
     case GTK_MENU_DIR_PARENT:
       if (parent_menu_shell)
 	{
-	  if (GTK_MENU_SHELL_CLASS (GTK_OBJECT (parent_menu_shell)->klass)->submenu_placement == 
-		       GTK_MENU_SHELL_CLASS (GTK_OBJECT (menu_shell)->klass)->submenu_placement)
+	  if (GTK_MENU_SHELL_GET_CLASS (parent_menu_shell)->submenu_placement == 
+		       GTK_MENU_SHELL_GET_CLASS (menu_shell)->submenu_placement)
 	    gtk_menu_shell_deselect (menu_shell);
 	  else 
 	    {
@@ -960,8 +959,8 @@ gtk_real_menu_shell_move_current (GtkMenuShell      *menu_shell,
 	{
 	  /* Try to find a menu running the opposite direction */
 	  while (parent_menu_shell && 
-		 (GTK_MENU_SHELL_CLASS (GTK_OBJECT (parent_menu_shell)->klass)->submenu_placement ==
-		  GTK_MENU_SHELL_CLASS (GTK_OBJECT (menu_shell)->klass)->submenu_placement))
+		 (GTK_MENU_SHELL_GET_CLASS (parent_menu_shell)->submenu_placement ==
+		  GTK_MENU_SHELL_GET_CLASS (menu_shell)->submenu_placement))
 	    parent_menu_shell = GTK_MENU_SHELL (parent_menu_shell->parent_menu_shell);
 	  
 	  if (parent_menu_shell)
diff --git a/gtk/gtknotebook.c b/gtk/gtknotebook.c
index 676cade04..be49dc6ea 100644
--- a/gtk/gtknotebook.c
+++ b/gtk/gtknotebook.c
@@ -271,7 +271,7 @@ gtk_notebook_class_init (GtkNotebookClass *class)
   notebook_signals[SWITCH_PAGE] =
     gtk_signal_new ("switch_page",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkNotebookClass, switch_page),
 		    gtk_marshal_NONE__POINTER_UINT,
 		    GTK_TYPE_NONE, 2,
diff --git a/gtk/gtkobject.c b/gtk/gtkobject.c
index c043561a8..887036537 100644
--- a/gtk/gtkobject.c
+++ b/gtk/gtkobject.c
@@ -45,95 +45,60 @@ enum {
 };
 
 
-void		      gtk_object_init_type       (void);
-static void           gtk_object_base_class_init (GtkObjectClass *klass);
-static void           gtk_object_class_init      (GtkObjectClass *klass);
-static void           gtk_object_init            (GtkObject      *object,
+extern void	  gtk_object_init_type           (void);	/* for gtktypeutils.h */
+static void       gtk_object_base_class_init     (GtkObjectClass *class);
+static void       gtk_object_base_class_finalize (GtkObjectClass *class);
+static void       gtk_object_class_init          (GtkObjectClass *klass);
+static void       gtk_object_init                (GtkObject      *object,
 						  GtkObjectClass *klass);
-static void           gtk_object_set_arg         (GtkObject      *object,
+static void       gtk_object_set_arg             (GtkObject      *object,
 						  GtkArg         *arg,
 						  guint		  arg_id);
-static void           gtk_object_get_arg         (GtkObject      *object,
+static void       gtk_object_get_arg             (GtkObject      *object,
 						  GtkArg         *arg,
 						  guint		  arg_id);
-static void           gtk_object_shutdown        (GtkObject      *object);
-static void           gtk_object_real_destroy    (GtkObject      *object);
-static void           gtk_object_finalize        (GtkObject      *object);
-static void           gtk_object_notify_weaks    (GtkObject      *object);
-
-static guint object_signals[LAST_SIGNAL] = { 0 };
+static void       gtk_object_shutdown            (GObject        *object);
+static void       gtk_object_real_destroy        (GtkObject      *object);
+static void       gtk_object_finalize            (GObject        *object);
+static void       gtk_object_notify_weaks        (GtkObject      *object);
 
+static gpointer    parent_class = NULL;
+static guint       object_signals[LAST_SIGNAL] = { 0 };
 static GHashTable *object_arg_info_ht = NULL;
+static GQuark      quark_user_data = 0;
+static GQuark      quark_weakrefs = 0;
+static GQuark      quark_carg_history = 0;
 
-static GQuark quark_user_data = 0;
-static GQuark quark_weakrefs = 0;
-static GQuark quark_carg_history = 0;
-
-
-#ifdef G_ENABLE_DEBUG
-static guint obj_count = 0;
-static GHashTable *living_objs_ht = NULL;
-static void
-gtk_object_debug_foreach (gpointer key, gpointer value, gpointer user_data)
-{
-  GtkObject *object;
-  
-  object = (GtkObject*) value;
-  g_message ("[%p] %s\tref_count=%d%s%s",
-	     object,
-	     gtk_type_name (GTK_OBJECT_TYPE (object)),
-	     object->ref_count,
-	     GTK_OBJECT_FLOATING (object) ? " (floating)" : "",
-	     GTK_OBJECT_DESTROYED (object) ? " (destroyed)" : "");
-}
-static void
-gtk_object_debug (void)
-{
-  if (living_objs_ht)
-    g_hash_table_foreach (living_objs_ht, gtk_object_debug_foreach, NULL);
-  
-  g_message ("living objects count = %d", obj_count);
-}
-#endif	/* G_ENABLE_DEBUG */
-
-void
-gtk_object_post_arg_parsing_init (void)
-{
-#ifdef G_ENABLE_DEBUG
-  if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
-    g_atexit (gtk_object_debug);
-#endif	/* G_ENABLE_DEBUG */
-}
 
 /****************************************************
  * GtkObject type, class and instance initialization
  *
  ****************************************************/
 
-void
-gtk_object_init_type (void)
-{
-  static const GtkTypeInfo object_info =
-  {
-    "GtkObject",
-    sizeof (GtkObject),
-    sizeof (GtkObjectClass),
-    (GtkClassInitFunc) gtk_object_class_init,
-    (GtkObjectInitFunc) gtk_object_init,
-    /* reserved_1 */ NULL,
-    /* reserved_2 */ NULL,
-    (GtkClassInitFunc) gtk_object_base_class_init,
-  };
-  GtkType object_type;
-
-  object_type = gtk_type_unique (0, &object_info);
-  g_assert (object_type == GTK_TYPE_OBJECT);
-}
-
 GtkType
 gtk_object_get_type (void)
 {
-  return GTK_TYPE_OBJECT;
+  static GtkType object_type = 0;
+
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+	sizeof (GtkObjectClass),
+	(GBaseInitFunc) gtk_object_base_class_init,
+	(GBaseFinalizeFunc) gtk_object_base_class_finalize,
+	(GClassInitFunc) gtk_object_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkObject),
+	16,			/* n_preallocs */
+	(GInstanceInitFunc) gtk_object_init,
+      };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT, "GtkObject", &object_info);
+    }
+
+  return object_type;
 }
 
 static void
@@ -151,8 +116,26 @@ gtk_object_base_class_init (GtkObjectClass *class)
 }
 
 static void
+gtk_object_base_class_finalize (GtkObjectClass *class)
+{
+  g_free (class->signals);
+  g_return_if_fail (class->construct_args == NULL);
+}
+
+static void
 gtk_object_class_init (GtkObjectClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+
+  parent_class = g_type_class_ref (G_TYPE_OBJECT);
+
+  gobject_class->shutdown = gtk_object_shutdown;
+  gobject_class->finalize = gtk_object_finalize;
+
+  class->get_arg = gtk_object_get_arg;
+  class->set_arg = gtk_object_set_arg;
+  class->destroy = gtk_object_real_destroy;
+
   quark_carg_history = g_quark_from_static_string ("gtk-construct-arg-history");
 
   gtk_object_add_arg_type ("GtkObject::user_data",
@@ -179,18 +162,12 @@ gtk_object_class_init (GtkObjectClass *class)
   object_signals[DESTROY] =
     gtk_signal_new ("destroy",
                     GTK_RUN_LAST | GTK_RUN_NO_HOOKS,
-                    class->type,
+                    GTK_CLASS_TYPE (class),
                     GTK_SIGNAL_OFFSET (GtkObjectClass, destroy),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
 
   gtk_object_class_add_signals (class, object_signals, LAST_SIGNAL);
-
-  class->get_arg = gtk_object_get_arg;
-  class->set_arg = gtk_object_set_arg;
-  class->shutdown = gtk_object_shutdown;
-  class->destroy = gtk_object_real_destroy;
-  class->finalize = gtk_object_finalize;
 }
 
 static void
@@ -203,26 +180,11 @@ gtk_object_init (GtkObject      *object,
   do
     {
       needs_construction |= klass->construct_args != NULL;
-      klass = gtk_type_parent_class (klass->type);
+      klass = g_type_class_peek_parent (klass);
     }
   while (klass && !needs_construction);
   if (!needs_construction)
     GTK_OBJECT_FLAGS (object) |= GTK_CONSTRUCTED;
-
-  object->ref_count = 1;
-  g_datalist_init (&object->object_data);
-
-#ifdef G_ENABLE_DEBUG
-  if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
-    {
-      obj_count++;
-      
-      if (!living_objs_ht)
-	living_objs_ht = g_hash_table_new (g_direct_hash, NULL);
-
-      g_hash_table_insert (living_objs_ht, object, object);
-    }
-#endif /* G_ENABLE_DEBUG */
 }
 
 /********************************************
@@ -238,21 +200,26 @@ gtk_object_destroy (GtkObject *object)
   
   if (!GTK_OBJECT_DESTROYED (object))
     {
-      /* we will hold a reference on the object in this place, so
-       * to ease all classes shutdown and destroy implementations.
-       * i.e. they don't have to bother about referencing at all.
+      /* need to hold a reference count around all class method
+       * invocations. we guard against reinvocations during
+       * destruction with the GTK_DESTROYED flag.
        */
       gtk_object_ref (object);
-      object->klass->shutdown (object);
+      GTK_OBJECT_SET_FLAGS (object, GTK_DESTROYED);
+      G_OBJECT_GET_CLASS (object)->shutdown (G_OBJECT (object));
+      GTK_OBJECT_UNSET_FLAGS (object, GTK_DESTROYED);
       gtk_object_unref (object);
     }
 }
 
 static void
-gtk_object_shutdown (GtkObject *object)
+gtk_object_shutdown (GObject *gobject)
 {
-  GTK_OBJECT_SET_FLAGS (object, GTK_DESTROYED);
+  GtkObject *object = GTK_OBJECT (gobject);
+
   gtk_signal_emit (object, object_signals[DESTROY]);
+
+  G_OBJECT_CLASS (parent_class)->shutdown (gobject);
 }
 
 static void
@@ -263,13 +230,13 @@ gtk_object_real_destroy (GtkObject *object)
 }
 
 static void
-gtk_object_finalize (GtkObject *object)
+gtk_object_finalize (GObject *gobject)
 {
-  gtk_object_notify_weaks (object);
+  GtkObject *object = GTK_OBJECT (gobject);
 
-  g_datalist_clear (&object->object_data);
+  gtk_object_notify_weaks (object);
   
-  gtk_type_free (GTK_OBJECT_TYPE (object), object);
+  G_OBJECT_CLASS (parent_class)->finalize (gobject);
 }
 
 /*****************************************
@@ -396,7 +363,7 @@ gtk_object_class_user_signal_new (GtkObjectClass     *class,
 
   signal_id = gtk_signal_newv (name,
 			       signal_flags,
-			       class->type,
+			       GTK_CLASS_TYPE (class),
 			       0,
 			       marshaller,
 			       return_val,
@@ -429,7 +396,7 @@ gtk_object_class_user_signal_newv (GtkObjectClass     *class,
 
   signal_id = gtk_signal_newv (name,
 			       signal_flags,
-			       class->type,
+			       GTK_CLASS_TYPE (class),
 			       0,
 			       marshaller,
 			       return_val,
@@ -576,7 +543,7 @@ gtk_object_new (GtkType      object_type,
   GSList *info_list = NULL;
   gchar *error;
 
-  g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (object_type) == GTK_TYPE_OBJECT, NULL);
+  g_return_val_if_fail (GTK_TYPE_IS_OBJECT (object_type), NULL);
 
   object = gtk_type_new (object_type);
 
@@ -623,7 +590,7 @@ gtk_object_newv (GtkType  object_type,
   GtkObject *object;
   GtkArg *max_args;
   
-  g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (object_type) == GTK_TYPE_OBJECT, NULL);
+  g_return_val_if_fail (GTK_TYPE_IS_OBJECT (object_type), NULL);
   if (n_args)
     g_return_val_if_fail (args != NULL, NULL);
   
@@ -872,7 +839,7 @@ gtk_object_default_construct (GtkObject *object)
 
   if (!GTK_OBJECT_CONSTRUCTED (object))
     {
-      for (slist = object->klass->construct_args;
+      for (slist = GTK_OBJECT_GET_CLASS (object)->construct_args;
 	   slist && !GTK_OBJECT_CONSTRUCTED (object);
 	   slist = slist->next)
 	{
@@ -888,7 +855,7 @@ gtk_object_default_construct (GtkObject *object)
 	      /* default application */
 	      arg.type = info->type;
 	      arg.name = info->name;
-	      switch (gtk_type_get_varargs_type (arg.type))
+	      switch (G_TYPE_FUNDAMENTAL (arg.type))
 		{
 		case GTK_TYPE_FLOAT:
 		  GTK_VALUE_FLOAT (arg) = 0.0;
@@ -899,7 +866,7 @@ gtk_object_default_construct (GtkObject *object)
 		case GTK_TYPE_BOXED:
 		case GTK_TYPE_STRING:
 		case GTK_TYPE_POINTER:
-		case GTK_TYPE_OBJECT:
+		case G_TYPE_OBJECT:
 		  GTK_VALUE_POINTER (arg) = NULL;
 		  break;
 		default:
@@ -1004,7 +971,7 @@ gtk_object_query_args (GtkType        class_type,
 {
   g_return_val_if_fail (n_args != NULL, NULL);
   *n_args = 0;
-  g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (class_type) == GTK_TYPE_OBJECT, NULL);
+  g_return_val_if_fail (GTK_TYPE_IS_OBJECT (class_type), NULL);
 
   return gtk_args_query (class_type, object_arg_info_ht, arg_flags, n_args);
 }
@@ -1019,10 +986,9 @@ gtk_object_set_data_by_id (GtkObject        *object,
 			   GQuark	     data_id,
 			   gpointer          data)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_OBJECT (object));
   
-  g_datalist_id_set_data (&object->object_data, data_id, data);
+  g_datalist_id_set_data (&G_OBJECT (object)->qdata, data_id, data);
 }
 
 void
@@ -1030,11 +996,10 @@ gtk_object_set_data (GtkObject        *object,
 		     const gchar      *key,
 		     gpointer          data)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_OBJECT (object));
   g_return_if_fail (key != NULL);
   
-  g_datalist_set_data (&object->object_data, key, data);
+  g_datalist_set_data (&G_OBJECT (object)->qdata, key, data);
 }
 
 void
@@ -1043,10 +1008,9 @@ gtk_object_set_data_by_id_full (GtkObject        *object,
 				gpointer          data,
 				GtkDestroyNotify  destroy)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_OBJECT (object));
 
-  g_datalist_id_set_data_full (&object->object_data, data_id, data, destroy);
+  g_datalist_id_set_data_full (&G_OBJECT (object)->qdata, data_id, data, destroy);
 }
 
 void
@@ -1055,186 +1019,101 @@ gtk_object_set_data_full (GtkObject        *object,
 			  gpointer          data,
 			  GtkDestroyNotify  destroy)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_OBJECT (object));
   g_return_if_fail (key != NULL);
 
-  g_datalist_set_data_full (&object->object_data, key, data, destroy);
+  g_datalist_set_data_full (&G_OBJECT (object)->qdata, key, data, destroy);
 }
 
 gpointer
 gtk_object_get_data_by_id (GtkObject   *object,
 			   GQuark       data_id)
 {
-  g_return_val_if_fail (object != NULL, NULL);
   g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
 
-  return g_datalist_id_get_data (&object->object_data, data_id);
+  return g_datalist_id_get_data (&G_OBJECT (object)->qdata, data_id);
 }
 
 gpointer
 gtk_object_get_data (GtkObject   *object,
 		     const gchar *key)
 {
-  g_return_val_if_fail (object != NULL, NULL);
   g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
   g_return_val_if_fail (key != NULL, NULL);
 
-  return g_datalist_get_data (&object->object_data, key);
+  return g_datalist_get_data (&G_OBJECT (object)->qdata, key);
 }
 
 void
 gtk_object_remove_data_by_id (GtkObject   *object,
 			      GQuark       data_id)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_OBJECT (object));
 
-  g_datalist_id_remove_data (&object->object_data, data_id);
+  g_datalist_id_remove_data (&G_OBJECT (object)->qdata, data_id);
 }
 
 void
 gtk_object_remove_data (GtkObject   *object,
 			const gchar *key)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_OBJECT (object));
   g_return_if_fail (key != NULL);
 
-  g_datalist_remove_data (&object->object_data, key);
+  g_datalist_remove_data (&G_OBJECT (object)->qdata, key);
 }
 
 void
 gtk_object_remove_no_notify_by_id (GtkObject      *object,
 				   GQuark          key_id)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_OBJECT (object));
 
-  g_datalist_id_remove_no_notify (&object->object_data, key_id);
+  g_datalist_id_remove_no_notify (&G_OBJECT (object)->qdata, key_id);
 }
 
 void
 gtk_object_remove_no_notify (GtkObject       *object,
 			     const gchar     *key)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_OBJECT (object));
   g_return_if_fail (key != NULL);
 
-  g_datalist_remove_no_notify (&object->object_data, key);
+  g_datalist_remove_no_notify (&G_OBJECT (object)->qdata, key);
 }
 
 void
 gtk_object_set_user_data (GtkObject *object,
 			  gpointer   data)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_OBJECT (object));
 
   if (!quark_user_data)
     quark_user_data = g_quark_from_static_string ("user_data");
 
-  g_datalist_id_set_data (&object->object_data, quark_user_data, data);
+  g_datalist_id_set_data (&G_OBJECT (object)->qdata, quark_user_data, data);
 }
 
 gpointer
 gtk_object_get_user_data (GtkObject *object)
 {
-  g_return_val_if_fail (object != NULL, NULL);
   g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
 
-  return g_datalist_id_get_data (&object->object_data, quark_user_data);
+  return g_datalist_id_get_data (&G_OBJECT (object)->qdata, quark_user_data);
 }
 
-/*******************************************
- * GtkObject referencing and unreferencing
- *
- *******************************************/
-
-#undef	gtk_object_ref
-#undef	gtk_object_unref
-
-void
+GtkObject*
 gtk_object_ref (GtkObject *object)
 {
-  g_return_if_fail (object != NULL);
-  g_return_if_fail (GTK_IS_OBJECT (object));
-  g_return_if_fail (object->ref_count > 0);
+  g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
 
-  object->ref_count += 1;
+  return (GtkObject*) g_object_ref ((GObject*) object);
 }
 
 void
 gtk_object_unref (GtkObject *object)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_OBJECT (object));
-  g_return_if_fail (object->ref_count > 0);
-  
-  if (object->ref_count == 1)
-    {
-      gtk_object_destroy (object);
-  
-      g_return_if_fail (object->ref_count > 0);
-    }
-
-  object->ref_count -= 1;
-
-  if (object->ref_count == 0)
-    {
-#ifdef G_ENABLE_DEBUG
-      if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
-	{
-	  g_assert (g_hash_table_lookup (living_objs_ht, object) == object);
-	  g_hash_table_remove (living_objs_ht, object);
-	  obj_count--;
-	}
-#endif /* G_ENABLE_DEBUG */      
-      object->klass->finalize (object);
-    }
-}
-
-static GtkObject *gtk_trace_object = NULL;
-void
-gtk_trace_referencing (GtkObject   *object,
-		       const gchar *func,
-		       guint	   dummy,
-		       guint	   line,
-		       gboolean	   do_ref)
-{
-  if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
-    {
-      gboolean exists = TRUE;
 
-      g_return_if_fail (object != NULL);
-      g_return_if_fail (GTK_IS_OBJECT (object));
-
-#ifdef	G_ENABLE_DEBUG
-      exists = g_hash_table_lookup (living_objs_ht, object) != NULL;
-#endif	/* G_ENABLE_DEBUG */
-      
-      if (exists &&
-	  (object == gtk_trace_object ||
-	   gtk_trace_object == (void*)42))
-	fprintf (stdout, "trace: object_%s: (%s:%p)->ref_count=%d %s (%s:%d)\n",
-		 do_ref ? "ref" : "unref",
-		 gtk_type_name (GTK_OBJECT_TYPE (object)),
-		 object,
-		 object->ref_count,
-		 do_ref ? "+ 1" : "- 1",
-		 func,
-		 line);
-      else if (!exists)
-	fprintf (stdout, "trace: object_%s(%p): no such object! (%s:%d)\n",
-		 do_ref ? "ref" : "unref",
-		 object,
-		 func,
-		 line);
-    }
-  
-  if (do_ref)
-    gtk_object_ref (object);
-  else
-    gtk_object_unref (object);
+  g_object_unref ((GObject*) object);
 }
diff --git a/gtk/gtkobject.h b/gtk/gtkobject.h
index b2515cd32..f1af29d66 100644
--- a/gtk/gtkobject.h
+++ b/gtk/gtkobject.h
@@ -39,38 +39,21 @@ extern "C" {
 #endif /* __cplusplus */
 
 
-
-/* Macro for casting a pointer to a GtkObject or GtkObjectClass pointer.
- * The second portion of the ?: statments are just in place to offer
- * descriptive warning message.
- */
-#define GTK_OBJECT(object)		( \
-  GTK_IS_OBJECT (object) ? \
-    (GtkObject*) (object) : \
-    (GtkObject*) gtk_type_check_object_cast ((GtkTypeObject*) (object), GTK_TYPE_OBJECT) \
-)
-#define GTK_OBJECT_CLASS(klass)		( \
-  GTK_IS_OBJECT_CLASS (klass) ? \
-    (GtkObjectClass*) (klass) : \
-    (GtkObjectClass*) gtk_type_check_class_cast ((GtkTypeClass*) (klass), GTK_TYPE_OBJECT) \
-)
-
-/* Macro for testing whether `object' and `klass' are of type GTK_TYPE_OBJECT.
+/* macros for casting a pointer to a GtkObject or GtkObjectClass pointer,
+ * and to test whether `object' and `klass' are of type GTK_TYPE_OBJECT.
+ * these are the standard macros for all GtkObject-derived classes.
  */
-#define GTK_IS_OBJECT(object)		( \
-  (object) != NULL && \
-  GTK_IS_OBJECT_CLASS (((GtkObject*) (object))->klass) \
-)
-#define GTK_IS_OBJECT_CLASS(klass)	( \
-  (klass) != NULL && \
-  GTK_FUNDAMENTAL_TYPE (((GtkObjectClass*) (klass))->type) == GTK_TYPE_OBJECT \
-)
+#define	GTK_TYPE_OBJECT			(gtk_object_get_type ())
+#define GTK_OBJECT(object)		(GTK_CHECK_CAST ((object), GTK_TYPE_OBJECT, GtkObject))
+#define GTK_OBJECT_CLASS(klass)		(GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_OBJECT, GtkObjectClass))
+#define GTK_IS_OBJECT(object)		(GTK_CHECK_TYPE ((object), GTK_TYPE_OBJECT))
+#define GTK_IS_OBJECT_CLASS(klass)	(GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_OBJECT))
+#define	GTK_OBJECT_GET_CLASS(object)	(GTK_CHECK_GET_CLASS ((object), GTK_TYPE_OBJECT, GtkObjectClass))
 
 /* Macros for extracting various fields from GtkObject and GtkObjectClass.
  */
-#define GTK_OBJECT_TYPE(obj)		  (GTK_OBJECT (obj)->klass->type)
-#define GTK_OBJECT_SIGNALS(obj)		  (GTK_OBJECT (obj)->klass->signals)
-#define GTK_OBJECT_NSIGNALS(obj)	  (GTK_OBJECT (obj)->klass->nsignals)
+#define GTK_OBJECT_TYPE(object)		  (G_TYPE_FROM_INSTANCE (object))
+#define GTK_OBJECT_TYPE_NAME(object)	  (g_type_name (GTK_OBJECT_TYPE (object)))
 
 /* GtkObject only uses the first 4 bits of the flags field.
  * Derived objects may use the remaining bits. Though this
@@ -124,9 +107,7 @@ typedef struct _GtkObjectClass	GtkObjectClass;
  */
 struct _GtkObject
 {
-  /* GtkTypeObject related fields: */
-  GtkObjectClass *klass;
-  
+  GObject parent_instance;
   
   /* 32 bits of flags. GtkObject only uses 4 of these bits and
    *  GtkWidget uses the rest. This is done because structs are
@@ -134,16 +115,6 @@ struct _GtkObject
    *  used in GtkWidget much space would be wasted.
    */
   guint32 flags;
-  
-  /* reference count.
-   * refer to the file docs/refcounting.txt on this issue.
-   */
-  guint ref_count;
-  
-  /* A list of keyed data pointers, used for e.g. the list of signal
-   * handlers or an object's user_data.
-   */
-  GData *object_data;
 };
 
 /* The GtkObjectClass is the base of the Gtk+ objects classes hierarchy,
@@ -155,9 +126,7 @@ struct _GtkObject
  */
 struct _GtkObjectClass
 {
-  /* GtkTypeClass fields: */
-  GtkType type;
-  
+  GObjectClass parent_class;
   
   /* The signals this object class handles. "signals" is an
    *  array of signal ID's.
@@ -181,7 +150,7 @@ struct _GtkObjectClass
 		   GtkArg    *arg,
 		   guint      arg_id);
   
-  /* The functions that will end an objects life time. In one way ore
+  /* The function that will end an objects life time. In one way ore
    *  another all three of them are defined for all objects. If an
    *  object class overrides one of the methods in order to perform class
    *  specific destruction then it must still invoke its superclass'
@@ -189,10 +158,7 @@ struct _GtkObjectClass
    *  own cleanup. (See the destroy function for GtkWidget for
    *  an example of how to do this).
    */
-  void (* shutdown) (GtkObject *object);
   void (* destroy)  (GtkObject *object);
-  
-  void (* finalize) (GtkObject *object);
 };
 
 
@@ -222,11 +188,11 @@ GtkObject*	gtk_object_new		  (GtkType	       type,
 GtkObject*	gtk_object_newv		  (GtkType	       object_type,
 					   guint	       n_args,
 					   GtkArg	      *args);
+GtkObject*	gtk_object_ref		  (GtkObject	      *object);
+void		gtk_object_unref	  (GtkObject	      *object);
 void gtk_object_default_construct         (GtkObject	      *object);
 void gtk_object_constructed		  (GtkObject	      *object);
 void gtk_object_sink	  (GtkObject	    *object);
-void gtk_object_ref	  (GtkObject	    *object);
-void gtk_object_unref	  (GtkObject	    *object);
 void gtk_object_weakref	  (GtkObject	    *object,
 			   GtkDestroyNotify  notify,
 			   gpointer	     data);
@@ -358,16 +324,6 @@ gchar*	gtk_object_args_collect (GtkType      object_type,
 gchar*	gtk_object_arg_get_info (GtkType      object_type,
 				 const gchar *arg_name,
 				 GtkArgInfo **info_p);
-void	gtk_trace_referencing	(GtkObject   *object,
-				 const gchar *func,
-				 guint	      dummy,
-				 guint	      line,
-				 gboolean     do_ref);
-#if	G_ENABLE_DEBUG
-#  define gtk_object_ref(o)   G_STMT_START{gtk_trace_referencing((o),G_GNUC_PRETTY_FUNCTION,0,__LINE__,1);}G_STMT_END
-#  define gtk_object_unref(o) G_STMT_START{gtk_trace_referencing((o),G_GNUC_PRETTY_FUNCTION,0,__LINE__,0);}G_STMT_END
-#endif	/* G_ENABLE_DEBUG */
-
 
 
 
diff --git a/gtk/gtkpixmap.c b/gtk/gtkpixmap.c
index f095454d3..94605e707 100644
--- a/gtk/gtkpixmap.c
+++ b/gtk/gtkpixmap.c
@@ -35,7 +35,7 @@ static void gtk_pixmap_class_init (GtkPixmapClass  *klass);
 static void gtk_pixmap_init       (GtkPixmap       *pixmap);
 static gint gtk_pixmap_expose     (GtkWidget       *widget,
 				   GdkEventExpose  *event);
-static void gtk_pixmap_finalize   (GtkObject       *object);
+static void gtk_pixmap_finalize   (GObject         *object);
 static void build_insensitive_pixmap (GtkPixmap *gtkpixmap);
 
 static GtkWidgetClass *parent_class;
@@ -68,6 +68,7 @@ gtk_pixmap_get_type (void)
 static void
 gtk_pixmap_class_init (GtkPixmapClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
 
@@ -75,7 +76,8 @@ gtk_pixmap_class_init (GtkPixmapClass *class)
   widget_class = (GtkWidgetClass*) class;
   parent_class = gtk_type_class (gtk_widget_get_type ());
 
-  object_class->finalize = gtk_pixmap_finalize;
+  gobject_class->finalize = gtk_pixmap_finalize;
+
   widget_class->expose_event = gtk_pixmap_expose;
 }
 
@@ -105,10 +107,11 @@ gtk_pixmap_new (GdkPixmap *val,
 }
 
 static void
-gtk_pixmap_finalize (GtkObject *object)
+gtk_pixmap_finalize (GObject *object)
 {
   gtk_pixmap_set (GTK_PIXMAP (object), NULL, NULL);
-  (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 void
diff --git a/gtk/gtkplug.c b/gtk/gtkplug.c
index 116e8e35f..3329218f6 100644
--- a/gtk/gtkplug.c
+++ b/gtk/gtkplug.c
@@ -64,18 +64,20 @@ gtk_plug_get_type ()
 
   if (!plug_type)
     {
-      static const GtkTypeInfo plug_info =
+      static const GTypeInfo plug_info =
       {
-	"GtkPlug",
-	sizeof (GtkPlug),
 	sizeof (GtkPlugClass),
-	(GtkClassInitFunc) gtk_plug_class_init,
-	(GtkObjectInitFunc) gtk_plug_init,
-	(GtkArgSetFunc) NULL,
-	(GtkArgGetFunc) NULL
+	NULL,           /* base_init */
+	NULL,           /* base_finalize */
+	(GClassInitFunc) gtk_plug_class_init,
+	NULL,           /* class_finalize */
+	NULL,           /* class_data */
+	sizeof (GtkPlug),
+	16,             /* n_preallocs */
+	(GInstanceInitFunc) gtk_plug_init,
       };
 
-      plug_type = gtk_type_unique (GTK_TYPE_WINDOW, &plug_info);
+      plug_type = g_type_register_static (GTK_TYPE_WINDOW, "GtkPlug", &plug_info);
     }
 
   return plug_type;
diff --git a/gtk/gtkpreview.c b/gtk/gtkpreview.c
index 39d2618a0..0d323c475 100644
--- a/gtk/gtkpreview.c
+++ b/gtk/gtkpreview.c
@@ -53,7 +53,7 @@ static void   gtk_preview_set_arg	(GtkObject        *object,
 static void   gtk_preview_get_arg	(GtkObject        *object,
 					 GtkArg           *arg,
 					 guint             arg_id);
-static void   gtk_preview_finalize      (GtkObject        *object);
+static void   gtk_preview_finalize      (GObject          *object);
 static void   gtk_preview_realize       (GtkWidget        *widget);
 static void   gtk_preview_size_allocate (GtkWidget        *widget,
 					 GtkAllocation    *allocation);
@@ -95,6 +95,7 @@ gtk_preview_get_type (void)
 static void
 gtk_preview_class_init (GtkPreviewClass *klass)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
 
@@ -104,9 +105,10 @@ gtk_preview_class_init (GtkPreviewClass *klass)
   parent_class = gtk_type_class (GTK_TYPE_WIDGET);
   preview_class = klass;
 
+  gobject_class->finalize = gtk_preview_finalize;
+
   object_class->set_arg = gtk_preview_set_arg;
   object_class->get_arg = gtk_preview_get_arg;
-  object_class->finalize = gtk_preview_finalize;
 
   widget_class->realize = gtk_preview_realize;
   widget_class->size_allocate = gtk_preview_size_allocate;
@@ -438,11 +440,10 @@ gtk_preview_get_info (void)
 
 
 static void
-gtk_preview_finalize (GtkObject *object)
+gtk_preview_finalize (GObject *object)
 {
   GtkPreview *preview;
 
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_PREVIEW (object));
 
   preview = GTK_PREVIEW (object);
@@ -450,7 +451,7 @@ gtk_preview_finalize (GtkObject *object)
     g_free (preview->buffer);
   preview->type = (GtkPreviewType) -1;
 
-  (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
diff --git a/gtk/gtkprogress.c b/gtk/gtkprogress.c
index 8129bb41c..44ed4f4e8 100644
--- a/gtk/gtkprogress.c
+++ b/gtk/gtkprogress.c
@@ -50,7 +50,7 @@ static void gtk_progress_get_arg	 (GtkObject        *object,
 					  GtkArg           *arg,
 					  guint             arg_id);
 static void gtk_progress_destroy         (GtkObject        *object);
-static void gtk_progress_finalize        (GtkObject        *object);
+static void gtk_progress_finalize        (GObject          *object);
 static void gtk_progress_realize         (GtkWidget        *widget);
 static gint gtk_progress_expose          (GtkWidget        *widget,
 				 	  GdkEventExpose   *event);
@@ -90,6 +90,7 @@ gtk_progress_get_type (void)
 static void
 gtk_progress_class_init (GtkProgressClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
 
@@ -97,6 +98,21 @@ gtk_progress_class_init (GtkProgressClass *class)
   widget_class = (GtkWidgetClass *) class;
   parent_class = gtk_type_class (GTK_TYPE_WIDGET);
 
+  gobject_class->finalize = gtk_progress_finalize;
+
+  object_class->set_arg = gtk_progress_set_arg;
+  object_class->get_arg = gtk_progress_get_arg;
+  object_class->destroy = gtk_progress_destroy;
+
+  widget_class->realize = gtk_progress_realize;
+  widget_class->expose_event = gtk_progress_expose;
+  widget_class->size_allocate = gtk_progress_size_allocate;
+
+  /* to be overridden */
+  class->paint = NULL;
+  class->update = NULL;
+  class->act_mode_enter = NULL;
+
   gtk_object_add_arg_type ("GtkProgress::activity_mode",
 			   GTK_TYPE_BOOL,
 			   GTK_ARG_READWRITE,
@@ -113,20 +129,6 @@ gtk_progress_class_init (GtkProgressClass *class)
 			   GTK_TYPE_FLOAT,
 			   GTK_ARG_READWRITE,
 			   ARG_TEXT_YALIGN);
-
-  object_class->set_arg = gtk_progress_set_arg;
-  object_class->get_arg = gtk_progress_get_arg;
-  object_class->destroy = gtk_progress_destroy;
-  object_class->finalize = gtk_progress_finalize;
-
-  widget_class->realize = gtk_progress_realize;
-  widget_class->expose_event = gtk_progress_expose;
-  widget_class->size_allocate = gtk_progress_size_allocate;
-
-  /* to be overridden */
-  class->paint = NULL;
-  class->update = NULL;
-  class->act_mode_enter = NULL;
 }
 
 static void
@@ -245,32 +247,32 @@ gtk_progress_destroy (GtkObject *object)
   progress = GTK_PROGRESS (object);
 
   if (progress->adjustment)
-    gtk_signal_disconnect_by_data (GTK_OBJECT (progress->adjustment),
-				   progress);
+    {
+      gtk_signal_disconnect_by_data (GTK_OBJECT (progress->adjustment),
+				     progress);
+      gtk_object_unref (GTK_OBJECT (progress->adjustment));
+      progress->adjustment = NULL;
+    }
 
   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 static void
-gtk_progress_finalize (GtkObject *object)
+gtk_progress_finalize (GObject *object)
 {
   GtkProgress *progress;
 
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_PROGRESS (object));
 
   progress = GTK_PROGRESS (object);
 
-  if (progress->adjustment)
-    gtk_object_unref (GTK_OBJECT (GTK_PROGRESS (object)->adjustment));
-  
   if (progress->offscreen_pixmap)
     gdk_pixmap_unref (progress->offscreen_pixmap);
 
   if (progress->format)
     g_free (progress->format);
 
-  GTK_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static gint
@@ -332,7 +334,7 @@ gtk_progress_create_pixmap (GtkProgress *progress)
 						   widget->allocation.width,
 						   widget->allocation.height,
 						   -1);
-      GTK_PROGRESS_CLASS (GTK_OBJECT (progress)->klass)->paint (progress);
+      GTK_PROGRESS_GET_CLASS (progress)->paint (progress);
     }
 }
 
@@ -340,7 +342,7 @@ static void
 gtk_progress_value_changed (GtkAdjustment *adjustment,
 			    GtkProgress   *progress)
 {
-  GTK_PROGRESS_CLASS (GTK_OBJECT (progress)->klass)->update (progress);
+  GTK_PROGRESS_GET_CLASS (progress)->update (progress);
 }
 
 static gchar *
@@ -495,6 +497,8 @@ gtk_progress_configure (GtkProgress *progress,
   g_return_if_fail (min <= max);
   g_return_if_fail (value >= min && value <= max);
 
+  if (!progress->adjustment)
+    gtk_progress_set_adjustment (progress, NULL);
   adj = progress->adjustment;
 
   if (fabs (adj->lower - min) > EPSILON || fabs (adj->upper - max) > EPSILON)
@@ -517,6 +521,8 @@ gtk_progress_set_percentage (GtkProgress *progress,
   g_return_if_fail (GTK_IS_PROGRESS (progress));
   g_return_if_fail (percentage >= 0 && percentage <= 1.0);
 
+  if (!progress->adjustment)
+    gtk_progress_set_adjustment (progress, NULL);
   gtk_progress_set_value (progress, progress->adjustment->lower + percentage * 
 		 (progress->adjustment->upper - progress->adjustment->lower));
 }
@@ -527,8 +533,11 @@ gtk_progress_get_current_percentage (GtkProgress *progress)
   g_return_val_if_fail (progress != NULL, 0);
   g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
 
-  return (progress->adjustment->value - progress->adjustment->lower) /
-    (progress->adjustment->upper - progress->adjustment->lower);
+  if (!progress->adjustment)
+    gtk_progress_set_adjustment (progress, NULL);
+
+  return ((progress->adjustment->value - progress->adjustment->lower) /
+	  (progress->adjustment->upper - progress->adjustment->lower));
 }
 
 gfloat
@@ -538,6 +547,9 @@ gtk_progress_get_percentage_from_value (GtkProgress *progress,
   g_return_val_if_fail (progress != NULL, 0);
   g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
 
+  if (!progress->adjustment)
+    gtk_progress_set_adjustment (progress, NULL);
+
   if (value >= progress->adjustment->lower &&
       value <= progress->adjustment->upper)
     return (value - progress->adjustment->lower) /
@@ -553,6 +565,9 @@ gtk_progress_set_value (GtkProgress *progress,
   g_return_if_fail (progress != NULL);
   g_return_if_fail (GTK_IS_PROGRESS (progress));
 
+  if (!progress->adjustment)
+    gtk_progress_set_adjustment (progress, NULL);
+
   if (fabs (progress->adjustment->value - value) > EPSILON)
     gtk_adjustment_set_value (progress->adjustment, value);
 }
@@ -563,7 +578,7 @@ gtk_progress_get_value (GtkProgress *progress)
   g_return_val_if_fail (progress != NULL, 0);
   g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
 
-  return progress->adjustment->value;
+  return progress->adjustment ? progress->adjustment->value : 0;
 }
 
 void
@@ -626,8 +641,11 @@ gtk_progress_get_current_text (GtkProgress *progress)
   g_return_val_if_fail (progress != NULL, 0);
   g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
 
+  if (!progress->adjustment)
+    gtk_progress_set_adjustment (progress, NULL);
+
   return gtk_progress_build_string (progress, progress->adjustment->value,
-		    gtk_progress_get_current_percentage (progress));
+				    gtk_progress_get_current_percentage (progress));
 }
 
 gchar *
@@ -637,8 +655,11 @@ gtk_progress_get_text_from_value (GtkProgress *progress,
   g_return_val_if_fail (progress != NULL, 0);
   g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
 
+  if (!progress->adjustment)
+    gtk_progress_set_adjustment (progress, NULL);
+
   return gtk_progress_build_string (progress, value,
-		    gtk_progress_get_percentage_from_value (progress, value));
+				    gtk_progress_get_percentage_from_value (progress, value));
 }
 
 void
@@ -653,8 +674,7 @@ gtk_progress_set_activity_mode (GtkProgress *progress,
       progress->activity_mode = (activity_mode != 0);
 
       if (progress->activity_mode)
-	GTK_PROGRESS_CLASS 
-	  (GTK_OBJECT (progress)->klass)->act_mode_enter (progress);
+	GTK_PROGRESS_GET_CLASS (progress)->act_mode_enter (progress);
 
       if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (progress)))
 	gtk_widget_queue_resize (GTK_WIDGET (progress));
diff --git a/gtk/gtkprogressbar.c b/gtk/gtkprogressbar.c
index 1905f31a8..c0e9af202 100644
--- a/gtk/gtkprogressbar.c
+++ b/gtk/gtkprogressbar.c
@@ -108,7 +108,7 @@ gtk_progress_bar_class_init (GtkProgressBarClass *class)
   
   gtk_object_add_arg_type ("GtkProgressBar::adjustment",
 			   GTK_TYPE_ADJUSTMENT,
-			   GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+			   GTK_ARG_READWRITE,
 			   ARG_ADJUSTMENT);
   gtk_object_add_arg_type ("GtkProgressBar::orientation",
 			   GTK_TYPE_PROGRESS_BAR_ORIENTATION,
diff --git a/gtk/gtkradiobutton.c b/gtk/gtkradiobutton.c
index 1c8ffc511..04da03fd0 100644
--- a/gtk/gtkradiobutton.c
+++ b/gtk/gtkradiobutton.c
@@ -34,8 +34,6 @@ enum {
   ARG_GROUP
 };
 
-#define CHECK_BUTTON_CLASS(w)  GTK_CHECK_BUTTON_CLASS (GTK_OBJECT (w)->klass)
-
 
 static void gtk_radio_button_class_init     (GtkRadioButtonClass  *klass);
 static void gtk_radio_button_init           (GtkRadioButton       *radio_button);
@@ -409,10 +407,10 @@ gtk_radio_button_draw_indicator (GtkCheckButton *check_button,
 				new_area.width, new_area.height);
 	}
       
-      x = widget->allocation.x + CHECK_BUTTON_CLASS (widget)->indicator_spacing + GTK_CONTAINER (widget)->border_width;
-      y = widget->allocation.y + (widget->allocation.height - CHECK_BUTTON_CLASS (widget)->indicator_size) / 2;
-      width = CHECK_BUTTON_CLASS (widget)->indicator_size;
-      height = CHECK_BUTTON_CLASS (widget)->indicator_size;
+      x = widget->allocation.x + GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_spacing + GTK_CONTAINER (widget)->border_width;
+      y = widget->allocation.y + (widget->allocation.height - GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size) / 2;
+      width = GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size;
+      height = GTK_CHECK_BUTTON_GET_CLASS (widget)->indicator_size;
       
       if (GTK_TOGGLE_BUTTON (widget)->active)
 	shadow_type = GTK_SHADOW_IN;
diff --git a/gtk/gtkrange.c b/gtk/gtkrange.c
index 180562911..92f49210c 100644
--- a/gtk/gtkrange.c
+++ b/gtk/gtkrange.c
@@ -34,7 +34,7 @@
 #define SCROLL_INITIAL_DELAY 100
 #define SCROLL_DELAY_LENGTH  300
 
-#define RANGE_CLASS(w)  GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+#define RANGE_CLASS(w)  GTK_RANGE_GET_CLASS (w)
 
 enum {
   ARG_0,
@@ -50,7 +50,6 @@ static void gtk_range_get_arg		       (GtkObject        *object,
 						GtkArg           *arg,
 						guint             arg_id);
 static void gtk_range_destroy                  (GtkObject        *object);
-static void gtk_range_finalize                 (GtkObject        *object);
 static void gtk_range_draw                     (GtkWidget        *widget,
 						GdkRectangle     *area);
 static void gtk_range_draw_focus               (GtkWidget        *widget);
@@ -138,15 +137,9 @@ gtk_range_class_init (GtkRangeClass *class)
 
   parent_class = gtk_type_class (GTK_TYPE_WIDGET);
 
-  gtk_object_add_arg_type ("GtkRange::update_policy",
-			   GTK_TYPE_UPDATE_TYPE,
-			   GTK_ARG_READWRITE,
-			   ARG_UPDATE_POLICY);
-
   object_class->set_arg = gtk_range_set_arg;
   object_class->get_arg = gtk_range_get_arg;
   object_class->destroy = gtk_range_destroy;
-  object_class->finalize = gtk_range_finalize;
 
   widget_class->draw = gtk_range_draw;
   widget_class->draw_focus = gtk_range_draw_focus;
@@ -181,6 +174,11 @@ gtk_range_class_init (GtkRangeClass *class)
   class->trough_keys = NULL;
   class->motion = NULL;
   class->timer = gtk_real_range_timer;
+
+  gtk_object_add_arg_type ("GtkRange::update_policy",
+			   GTK_TYPE_UPDATE_TYPE,
+			   GTK_ARG_READWRITE,
+			   ARG_UPDATE_POLICY);
 }
 
 static void
@@ -253,6 +251,9 @@ gtk_range_get_adjustment (GtkRange *range)
   g_return_val_if_fail (range != NULL, NULL);
   g_return_val_if_fail (GTK_IS_RANGE (range), NULL);
 
+  if (!range->adjustment)
+    gtk_range_set_adjustment (range, NULL);
+
   return range->adjustment;
 }
 
@@ -573,8 +574,8 @@ gtk_range_default_hmotion (GtkRange *range,
   gint slider_x, slider_y;
   gint new_pos;
 
-  g_return_if_fail (range != NULL);
   g_return_if_fail (GTK_IS_RANGE (range));
+  g_return_if_fail (GTK_WIDGET_REALIZED (range));
 
   range = GTK_RANGE (range);
 
@@ -638,8 +639,8 @@ gtk_range_default_vmotion (GtkRange *range,
   gint slider_x, slider_y;
   gint new_pos;
 
-  g_return_if_fail (range != NULL);
   g_return_if_fail (GTK_IS_RANGE (range));
+  g_return_if_fail (GTK_WIDGET_REALIZED (range));
 
   range = GTK_RANGE (range);
 
@@ -704,30 +705,20 @@ gtk_range_destroy (GtkObject *object)
 
   range = GTK_RANGE (object);
 
+  gtk_range_remove_timer (range);
   if (range->adjustment)
-    gtk_signal_disconnect_by_data (GTK_OBJECT (range->adjustment),
-				   (gpointer) range);
+    {
+      if (range->adjustment)
+	gtk_signal_disconnect_by_data (GTK_OBJECT (range->adjustment),
+				       (gpointer) range);
+      gtk_object_unref (GTK_OBJECT (range->adjustment));
+      range->adjustment = NULL;
+    }
 
   (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 }
 
 static void
-gtk_range_finalize (GtkObject *object)
-{
-  GtkRange *range;
-
-  g_return_if_fail (object != NULL);
-  g_return_if_fail (GTK_IS_RANGE (object));
-
-  range = GTK_RANGE (object);
-
-  if (range->adjustment)
-    gtk_object_unref (GTK_OBJECT (range->adjustment));
-
-  (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
-}
-
-static void
 gtk_range_draw (GtkWidget    *widget,
 		GdkRectangle *area)
 {
@@ -737,7 +728,7 @@ gtk_range_draw (GtkWidget    *widget,
   g_return_if_fail (GTK_IS_RANGE (widget));
   g_return_if_fail (area != NULL);
 
-  if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget))
+  if (GTK_WIDGET_DRAWABLE (widget))
     {
       range = GTK_RANGE (widget);
 
@@ -844,7 +835,6 @@ gtk_range_button_press (GtkWidget      *widget,
   gint trough_part;
   gfloat jump_perc;
 
-  g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
@@ -919,7 +909,6 @@ gtk_range_button_release (GtkWidget      *widget,
 {
   GtkRange *range;
 
-  g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
@@ -976,20 +965,20 @@ gtk_range_scroll_event (GtkWidget      *widget,
 {
   GtkRange *range;
 
-  g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
   range = GTK_RANGE (widget);
 
-  if (GTK_WIDGET_VISIBLE (range)) {
-    GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
-    gfloat new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ? 
-				     -adj->page_increment / 2: 
-				     adj->page_increment / 2);
-    new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
-    gtk_adjustment_set_value (adj, new_value);
-  }
+  if (GTK_WIDGET_REALIZED (range))
+    {
+      GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
+      gfloat new_value = adj->value + ((event->direction == GDK_SCROLL_UP) ? 
+				       -adj->page_increment / 2: 
+				       adj->page_increment / 2);
+      new_value = CLAMP (new_value, adj->lower, adj->upper - adj->page_size);
+      gtk_adjustment_set_value (adj, new_value);
+    }
 
   return TRUE;
 }
@@ -1002,7 +991,6 @@ gtk_range_motion_notify (GtkWidget      *widget,
   GdkModifierType mods;
   gint x, y, mask;
 
-  g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
@@ -1053,7 +1041,6 @@ gtk_range_key_press (GtkWidget   *widget,
   GtkScrollType scroll = GTK_SCROLL_NONE;
   GtkTroughType pos = GTK_TROUGH_NONE;
 
-  g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
@@ -1110,7 +1097,6 @@ gtk_range_enter_notify (GtkWidget        *widget,
 {
   GtkRange *range;
 
-  g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
@@ -1154,7 +1140,6 @@ gtk_range_leave_notify (GtkWidget        *widget,
 {
   GtkRange *range;
 
-  g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
@@ -1191,7 +1176,6 @@ static gint
 gtk_range_focus_in (GtkWidget     *widget,
 		    GdkEventFocus *event)
 {
-  g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
@@ -1205,7 +1189,6 @@ static gint
 gtk_range_focus_out (GtkWidget     *widget,
 		     GdkEventFocus *event)
 {
-  g_return_val_if_fail (widget != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
@@ -1218,7 +1201,6 @@ gtk_range_focus_out (GtkWidget     *widget,
 static void
 gtk_real_range_draw_trough (GtkRange *range)
 {
-  g_return_if_fail (range != NULL);
   g_return_if_fail (GTK_IS_RANGE (range));
 
   if (range->trough)
@@ -1240,7 +1222,6 @@ gtk_real_range_draw_slider (GtkRange *range)
 {
   GtkStateType state_type;
    
-  g_return_if_fail (range != NULL);
   g_return_if_fail (GTK_IS_RANGE (range));
    
   if (range->slider)
@@ -1324,7 +1305,6 @@ gtk_range_scroll (GtkRange *range,
   gfloat new_value;
   gint return_val;
 
-  g_return_val_if_fail (range != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_RANGE (range), FALSE);
 
   new_value = range->adjustment->value;
@@ -1408,7 +1388,6 @@ gtk_range_scroll (GtkRange *range,
 static void
 gtk_range_add_timer (GtkRange *range)
 {
-  g_return_if_fail (range != NULL);
   g_return_if_fail (GTK_IS_RANGE (range));
 
   if (!range->timer)
@@ -1423,7 +1402,6 @@ gtk_range_add_timer (GtkRange *range)
 static void
 gtk_range_remove_timer (GtkRange *range)
 {
-  g_return_if_fail (range != NULL);
   g_return_if_fail (GTK_IS_RANGE (range));
 
   if (range->timer)
diff --git a/gtk/gtkruler.c b/gtk/gtkruler.c
index e9481a921..221b4fffc 100644
--- a/gtk/gtkruler.c
+++ b/gtk/gtkruler.c
@@ -226,8 +226,8 @@ gtk_ruler_draw_ticks (GtkRuler *ruler)
   g_return_if_fail (ruler != NULL);
   g_return_if_fail (GTK_IS_RULER (ruler));
 
-  if (GTK_RULER_CLASS (GTK_OBJECT (ruler)->klass)->draw_ticks)
-    (* GTK_RULER_CLASS (GTK_OBJECT (ruler)->klass)->draw_ticks) (ruler);
+  if (GTK_RULER_GET_CLASS (ruler)->draw_ticks)
+    GTK_RULER_GET_CLASS (ruler)->draw_ticks (ruler);
 }
 
 void
@@ -236,8 +236,8 @@ gtk_ruler_draw_pos (GtkRuler *ruler)
   g_return_if_fail (ruler != NULL);
   g_return_if_fail (GTK_IS_RULER (ruler));
 
-  if (GTK_RULER_CLASS (GTK_OBJECT (ruler)->klass)->draw_pos)
-    (* GTK_RULER_CLASS (GTK_OBJECT (ruler)->klass)->draw_pos) (ruler);
+  if (GTK_RULER_GET_CLASS (ruler)->draw_pos)
+     GTK_RULER_GET_CLASS (ruler)->draw_pos (ruler);
 }
 
 
diff --git a/gtk/gtkscale.c b/gtk/gtkscale.c
index e4cc0aada..34e312741 100644
--- a/gtk/gtkscale.c
+++ b/gtk/gtkscale.c
@@ -29,8 +29,6 @@
 #include "gtkscale.h"
 
 
-#define SCALE_CLASS(w)  GTK_SCALE_CLASS (GTK_OBJECT (w)->klass)
-
 enum {
   ARG_0,
   ARG_DIGITS,
@@ -330,8 +328,8 @@ gtk_scale_draw_value (GtkScale *scale)
   g_return_if_fail (scale != NULL);
   g_return_if_fail (GTK_IS_SCALE (scale));
 
-  if (SCALE_CLASS (scale)->draw_value)
-    (* SCALE_CLASS (scale)->draw_value) (scale);
+  if (GTK_SCALE_GET_CLASS (scale)->draw_value)
+    GTK_SCALE_GET_CLASS (scale)->draw_value (scale);
 }
 
 
diff --git a/gtk/gtkscrolledwindow.c b/gtk/gtkscrolledwindow.c
index a4529521f..934e712c5 100644
--- a/gtk/gtkscrolledwindow.c
+++ b/gtk/gtkscrolledwindow.c
@@ -63,7 +63,7 @@
  *    under A) at least correspond to the space taken up by its scrollbars.
  */
 
-#define SCROLLBAR_SPACING(w) (GTK_SCROLLED_WINDOW_CLASS (GTK_OBJECT (w)->klass)->scrollbar_spacing)
+#define SCROLLBAR_SPACING(w) (GTK_SCROLLED_WINDOW_GET_CLASS (w)->scrollbar_spacing)
 
 #define DEFAULT_SCROLLBAR_SPACING  3
 
@@ -86,7 +86,7 @@ static void gtk_scrolled_window_get_arg		   (GtkObject              *object,
 						    GtkArg                 *arg,
 						    guint                   arg_id);
 static void gtk_scrolled_window_destroy            (GtkObject              *object);
-static void gtk_scrolled_window_finalize           (GtkObject              *object);
+static void gtk_scrolled_window_finalize           (GObject                *object);
 static void gtk_scrolled_window_map                (GtkWidget              *widget);
 static void gtk_scrolled_window_unmap              (GtkWidget              *widget);
 static void gtk_scrolled_window_draw               (GtkWidget              *widget,
@@ -141,6 +141,7 @@ gtk_scrolled_window_get_type (void)
 static void
 gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;
@@ -150,6 +151,25 @@ gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
   container_class = (GtkContainerClass*) class;
   parent_class = gtk_type_class (GTK_TYPE_BIN);
 
+  gobject_class->finalize = gtk_scrolled_window_finalize;
+
+  object_class->set_arg = gtk_scrolled_window_set_arg;
+  object_class->get_arg = gtk_scrolled_window_get_arg;
+  object_class->destroy = gtk_scrolled_window_destroy;
+
+  widget_class->map = gtk_scrolled_window_map;
+  widget_class->unmap = gtk_scrolled_window_unmap;
+  widget_class->draw = gtk_scrolled_window_draw;
+  widget_class->size_request = gtk_scrolled_window_size_request;
+  widget_class->size_allocate = gtk_scrolled_window_size_allocate;
+  widget_class->scroll_event = gtk_scrolled_window_scroll_event;
+
+  container_class->add = gtk_scrolled_window_add;
+  container_class->remove = gtk_scrolled_window_remove;
+  container_class->forall = gtk_scrolled_window_forall;
+
+  class->scrollbar_spacing = DEFAULT_SCROLLBAR_SPACING;
+
   gtk_object_add_arg_type ("GtkScrolledWindow::hadjustment",
 			   GTK_TYPE_ADJUSTMENT,
 			   GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
@@ -170,24 +190,6 @@ gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
 			   GTK_TYPE_CORNER_TYPE,
 			   GTK_ARG_READWRITE,
 			   ARG_WINDOW_PLACEMENT);
-
-  object_class->set_arg = gtk_scrolled_window_set_arg;
-  object_class->get_arg = gtk_scrolled_window_get_arg;
-  object_class->destroy = gtk_scrolled_window_destroy;
-  object_class->finalize = gtk_scrolled_window_finalize;
-
-  widget_class->map = gtk_scrolled_window_map;
-  widget_class->unmap = gtk_scrolled_window_unmap;
-  widget_class->draw = gtk_scrolled_window_draw;
-  widget_class->size_request = gtk_scrolled_window_size_request;
-  widget_class->size_allocate = gtk_scrolled_window_size_allocate;
-  widget_class->scroll_event = gtk_scrolled_window_scroll_event;
-
-  container_class->add = gtk_scrolled_window_add;
-  container_class->remove = gtk_scrolled_window_remove;
-  container_class->forall = gtk_scrolled_window_forall;
-
-  class->scrollbar_spacing = DEFAULT_SCROLLBAR_SPACING;
 }
 
 static void
@@ -475,16 +477,14 @@ gtk_scrolled_window_destroy (GtkObject *object)
 }
 
 static void
-gtk_scrolled_window_finalize (GtkObject *object)
+gtk_scrolled_window_finalize (GObject *object)
 {
-  GtkScrolledWindow *scrolled_window;
-
-  scrolled_window = GTK_SCROLLED_WINDOW (object);
+  GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
 
   gtk_widget_unref (scrolled_window->hscrollbar);
   gtk_widget_unref (scrolled_window->vscrollbar);
 
-  GTK_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
diff --git a/gtk/gtksignal.c b/gtk/gtksignal.c
index 00326f483..da6cedd6f 100644
--- a/gtk/gtksignal.c
+++ b/gtk/gtksignal.c
@@ -435,7 +435,7 @@ gtk_signal_lookup (const gchar *name,
   gpointer class = NULL;
 
   g_return_val_if_fail (name != NULL, 0);
-  g_return_val_if_fail (gtk_type_is_a (object_type, GTK_TYPE_OBJECT), 0);
+  g_return_val_if_fail (GTK_TYPE_IS_OBJECT (object_type), 0);
   
  relookup:
 
@@ -1393,7 +1393,7 @@ gtk_signal_real_emit (GtkObject *object,
    */
   signal = *LOOKUP_SIGNAL_ID (signal_id);
   if (signal.function_offset)
-    signal_func = G_STRUCT_MEMBER (GtkSignalFunc, object->klass, signal.function_offset);
+    signal_func = G_STRUCT_MEMBER (GtkSignalFunc, ((GTypeInstance*) object)->g_class, signal.function_offset);
   else
     signal_func = NULL;
   
@@ -1723,8 +1723,7 @@ gtk_signal_connect_by_type (GtkObject	    *object,
   gint found_it;
   GtkSignal *signal;
  
-  g_return_val_if_fail (object != NULL, 0);
-  g_return_val_if_fail (object->klass != NULL, 0);
+  g_return_val_if_fail (GTK_IS_OBJECT (object), 0);
   
   signal = LOOKUP_SIGNAL_ID (signal_id);
 
@@ -1737,7 +1736,7 @@ gtk_signal_connect_by_type (GtkObject	    *object,
    *  return correct signal ids per class-branch.
    */
   found_it = FALSE;
-  class = object->klass;
+  class = GTK_OBJECT_GET_CLASS (object);
   while (class)
     {
       GtkType parent;
@@ -1755,9 +1754,9 @@ gtk_signal_connect_by_type (GtkObject	    *object,
 	    break;
 	  }
       
-      parent = gtk_type_parent (class->type);
-      if (parent)
-	class = gtk_type_class (parent);
+      parent = g_type_parent (GTK_CLASS_TYPE (class));
+      if (GTK_TYPE_IS_OBJECT (parent))
+	class = g_type_class_peek (parent);
       else
 	class = NULL;
     }
@@ -1766,7 +1765,7 @@ gtk_signal_connect_by_type (GtkObject	    *object,
     {
       g_warning ("gtk_signal_connect_by_type(): could not find signal id (%u) in the `%s' class ancestry",
 		 signal_id,
-		 gtk_type_name (object->klass->type));
+		 GTK_OBJECT_TYPE_NAME (object));
       return 0;
     }
   
@@ -1987,9 +1986,7 @@ gtk_signal_collect_params (GtkArg	       *params,
   return_type = GTK_FUNDAMENTAL_TYPE (return_type);
   if (return_type != GTK_TYPE_NONE)
     {
-      if ((return_type >= GTK_TYPE_FLAT_FIRST &&
-	   return_type <= GTK_TYPE_FLAT_LAST) ||
-	  (return_type == GTK_TYPE_OBJECT))
+      if (return_type != 0) // FIXME: check for IS_PARAM
 	{
 	  GTK_VALUE_POINTER (*params) = va_arg (var_args, gpointer);
 	  
diff --git a/gtk/gtksocket.c b/gtk/gtksocket.c
index 6be2af88e..860e06817 100644
--- a/gtk/gtksocket.c
+++ b/gtk/gtksocket.c
@@ -77,18 +77,20 @@ gtk_socket_get_type (void)
 
   if (!socket_type)
     {
-      static const GtkTypeInfo socket_info =
+      static const GTypeInfo socket_info =
       {
-	"GtkSocket",
-	sizeof (GtkSocket),
 	sizeof (GtkSocketClass),
-	(GtkClassInitFunc) gtk_socket_class_init,
-	(GtkObjectInitFunc) gtk_socket_init,
-	(GtkArgSetFunc) NULL,
-	(GtkArgGetFunc) NULL
+	NULL,           /* base_init */
+	NULL,           /* base_finalize */
+	(GClassInitFunc) gtk_socket_class_init,
+	NULL,           /* class_finalize */
+	NULL,           /* class_data */
+	sizeof (GtkSocket),
+	16,             /* n_preallocs */
+	(GInstanceInitFunc) gtk_socket_init,
       };
 
-      socket_type = gtk_type_unique (GTK_TYPE_CONTAINER, &socket_info);
+      socket_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkSocket", &socket_info);
     }
 
   return socket_type;
diff --git a/gtk/gtkspinbutton.c b/gtk/gtkspinbutton.c
index 15f7555dc..47fccb3a5 100644
--- a/gtk/gtkspinbutton.c
+++ b/gtk/gtkspinbutton.c
@@ -69,7 +69,7 @@ enum
 
 static void gtk_spin_button_class_init     (GtkSpinButtonClass *klass);
 static void gtk_spin_button_init           (GtkSpinButton      *spin_button);
-static void gtk_spin_button_finalize       (GtkObject          *object);
+static void gtk_spin_button_finalize       (GObject            *object);
 static void gtk_spin_button_set_arg        (GtkObject          *object,
 					    GtkArg             *arg,
 					    guint               arg_id);
@@ -158,6 +158,7 @@ gtk_spin_button_get_type (void)
 static void
 gtk_spin_button_class_init (GtkSpinButtonClass *class)
 {
+  GObjectClass     *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass   *object_class;
   GtkWidgetClass   *widget_class;
   GtkEditableClass *editable_class;
@@ -168,6 +169,35 @@ gtk_spin_button_class_init (GtkSpinButtonClass *class)
 
   parent_class = gtk_type_class (GTK_TYPE_ENTRY);
 
+  gobject_class->finalize = gtk_spin_button_finalize;
+
+  object_class->set_arg = gtk_spin_button_set_arg;
+  object_class->get_arg = gtk_spin_button_get_arg;
+
+  widget_class->map = gtk_spin_button_map;
+  widget_class->unmap = gtk_spin_button_unmap;
+  widget_class->realize = gtk_spin_button_realize;
+  widget_class->unrealize = gtk_spin_button_unrealize;
+  widget_class->size_request = gtk_spin_button_size_request;
+  widget_class->size_allocate = gtk_spin_button_size_allocate;
+  widget_class->draw = gtk_spin_button_draw;
+  widget_class->expose_event = gtk_spin_button_expose;
+  widget_class->scroll_event = gtk_spin_button_scroll;
+  widget_class->button_press_event = gtk_spin_button_button_press;
+  widget_class->button_release_event = gtk_spin_button_button_release;
+  widget_class->motion_notify_event = gtk_spin_button_motion_notify;
+  widget_class->key_press_event = gtk_spin_button_key_press;
+  widget_class->key_release_event = gtk_spin_button_key_release;
+  widget_class->enter_notify_event = gtk_spin_button_enter_notify;
+  widget_class->leave_notify_event = gtk_spin_button_leave_notify;
+  widget_class->focus_out_event = gtk_spin_button_focus_out;
+
+  editable_class->insert_text = gtk_spin_button_insert_text;
+  editable_class->activate = gtk_spin_button_activate;
+
+  class->input = NULL;
+  class->output = NULL;
+
   gtk_object_add_arg_type ("GtkSpinButton::adjustment",
 			   GTK_TYPE_ADJUSTMENT,
 			   GTK_ARG_READWRITE,
@@ -205,14 +235,10 @@ gtk_spin_button_class_init (GtkSpinButtonClass *class)
 			   GTK_ARG_READWRITE,
 			   ARG_VALUE);
 
-  object_class->set_arg = gtk_spin_button_set_arg;
-  object_class->get_arg = gtk_spin_button_get_arg;
-  object_class->finalize = gtk_spin_button_finalize;
-
   spinbutton_signals[INPUT] =
     gtk_signal_new ("input",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkSpinButtonClass, input),
 		    gtk_marshal_INT__POINTER,
 		    GTK_TYPE_INT, 1, GTK_TYPE_POINTER);
@@ -220,36 +246,12 @@ gtk_spin_button_class_init (GtkSpinButtonClass *class)
   spinbutton_signals[OUTPUT] =
     gtk_signal_new ("output",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkSpinButtonClass, output),
 		    gtk_marshal_BOOL__NONE,
 		    GTK_TYPE_BOOL, 0);
 
   gtk_object_class_add_signals (object_class, spinbutton_signals, LAST_SIGNAL);
-
-  widget_class->map = gtk_spin_button_map;
-  widget_class->unmap = gtk_spin_button_unmap;
-  widget_class->realize = gtk_spin_button_realize;
-  widget_class->unrealize = gtk_spin_button_unrealize;
-  widget_class->size_request = gtk_spin_button_size_request;
-  widget_class->size_allocate = gtk_spin_button_size_allocate;
-  widget_class->draw = gtk_spin_button_draw;
-  widget_class->expose_event = gtk_spin_button_expose;
-  widget_class->scroll_event = gtk_spin_button_scroll;
-  widget_class->button_press_event = gtk_spin_button_button_press;
-  widget_class->button_release_event = gtk_spin_button_button_release;
-  widget_class->motion_notify_event = gtk_spin_button_motion_notify;
-  widget_class->key_press_event = gtk_spin_button_key_press;
-  widget_class->key_release_event = gtk_spin_button_key_release;
-  widget_class->enter_notify_event = gtk_spin_button_enter_notify;
-  widget_class->leave_notify_event = gtk_spin_button_leave_notify;
-  widget_class->focus_out_event = gtk_spin_button_focus_out;
-
-  editable_class->insert_text = gtk_spin_button_insert_text;
-  editable_class->activate = gtk_spin_button_activate;
-
-  class->input = NULL;
-  class->output = NULL;
 }
 
 static void
@@ -375,14 +377,13 @@ gtk_spin_button_init (GtkSpinButton *spin_button)
 }
 
 static void
-gtk_spin_button_finalize (GtkObject *object)
+gtk_spin_button_finalize (GObject *object)
 {
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_SPIN_BUTTON (object));
 
   gtk_object_unref (GTK_OBJECT (GTK_SPIN_BUTTON (object)->adjustment));
   
-  GTK_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
@@ -1408,7 +1409,6 @@ void
 gtk_spin_button_set_adjustment (GtkSpinButton *spin_button,
 				GtkAdjustment *adjustment)
 {
-  g_return_if_fail (spin_button != NULL);
   g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
 
   if (spin_button->adjustment != adjustment)
diff --git a/gtk/gtkstatusbar.c b/gtk/gtkstatusbar.c
index 34603573f..f0826a7d8 100644
--- a/gtk/gtkstatusbar.c
+++ b/gtk/gtkstatusbar.c
@@ -41,7 +41,6 @@ enum
 static void gtk_statusbar_class_init               (GtkStatusbarClass *class);
 static void gtk_statusbar_init                     (GtkStatusbar      *statusbar);
 static void gtk_statusbar_destroy                  (GtkObject         *object);
-static void gtk_statusbar_finalize                 (GtkObject         *object);
 static void gtk_statusbar_update		   (GtkStatusbar      *statusbar,
 						    guint	       context_id,
 						    const gchar       *text);
@@ -86,11 +85,21 @@ gtk_statusbar_class_init (GtkStatusbarClass *class)
   container_class = (GtkContainerClass *) class;
 
   parent_class = gtk_type_class (GTK_TYPE_HBOX);
+  
+  object_class->destroy = gtk_statusbar_destroy;
+
+  class->messages_mem_chunk = g_mem_chunk_new ("GtkStatusBar messages mem chunk",
+					       sizeof (GtkStatusbarMsg),
+					       sizeof (GtkStatusbarMsg) * 64,
+					       G_ALLOC_AND_FREE);
+
+  class->text_pushed = gtk_statusbar_update;
+  class->text_popped = gtk_statusbar_update;
 
   statusbar_signals[SIGNAL_TEXT_PUSHED] =
     gtk_signal_new ("text_pushed",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkStatusbarClass, text_pushed),
 		    gtk_marshal_NONE__UINT_STRING,
 		    GTK_TYPE_NONE, 2,
@@ -99,24 +108,13 @@ gtk_statusbar_class_init (GtkStatusbarClass *class)
   statusbar_signals[SIGNAL_TEXT_POPPED] =
     gtk_signal_new ("text_popped",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkStatusbarClass, text_popped),
 		    gtk_marshal_NONE__UINT_STRING,
 		    GTK_TYPE_NONE, 2,
 		    GTK_TYPE_UINT,
 		    GTK_TYPE_STRING);
   gtk_object_class_add_signals (object_class, statusbar_signals, SIGNAL_LAST);
-  
-  object_class->destroy = gtk_statusbar_destroy;
-  object_class->finalize = gtk_statusbar_finalize;
-
-  class->messages_mem_chunk = g_mem_chunk_new ("GtkStatusBar messages mem chunk",
-					       sizeof (GtkStatusbarMsg),
-					       sizeof (GtkStatusbarMsg) * 64,
-					       G_ALLOC_AND_FREE);
-
-  class->text_pushed = gtk_statusbar_update;
-  class->text_popped = gtk_statusbar_update;
 }
 
 static void
@@ -206,7 +204,7 @@ gtk_statusbar_push (GtkStatusbar *statusbar,
   g_return_val_if_fail (text != NULL, 0);
   g_return_val_if_fail (context_id > 0, 0);
 
-  class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
+  class = GTK_STATUSBAR_GET_CLASS (statusbar);
   msg = g_chunk_new (GtkStatusbarMsg, class->messages_mem_chunk);
   msg->text = g_strdup (text);
   msg->context_id = context_id;
@@ -244,7 +242,7 @@ gtk_statusbar_pop (GtkStatusbar *statusbar,
 	    {
 	      GtkStatusbarClass *class;
 
-	      class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
+	      class = GTK_STATUSBAR_GET_CLASS (statusbar);
 
 	      statusbar->messages = g_slist_remove_link (statusbar->messages,
 							 list);
@@ -298,7 +296,7 @@ gtk_statusbar_remove (GtkStatusbar *statusbar,
 	    {
 	      GtkStatusbarClass *class;
 	      
-	      class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
+	      class = GTK_STATUSBAR_GET_CLASS (statusbar);
 	      statusbar->messages = g_slist_remove_link (statusbar->messages, list);
 	      g_free (msg->text);
 	      g_mem_chunk_free (class->messages_mem_chunk, msg);
@@ -321,7 +319,7 @@ gtk_statusbar_destroy (GtkObject *object)
   g_return_if_fail (GTK_IS_STATUSBAR (object));
 
   statusbar = GTK_STATUSBAR (object);
-  class = GTK_STATUSBAR_CLASS (GTK_OBJECT (statusbar)->klass);
+  class = GTK_STATUSBAR_GET_CLASS (statusbar);
 
   for (list = statusbar->messages; list; list = list->next)
     {
@@ -341,16 +339,3 @@ gtk_statusbar_destroy (GtkObject *object)
 
   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
-
-static void
-gtk_statusbar_finalize (GtkObject *object)
-{
-  GtkStatusbar *statusbar;
-
-  g_return_if_fail (object != NULL);
-  g_return_if_fail (GTK_IS_STATUSBAR (object));
-
-  statusbar = GTK_STATUSBAR (object);
-
-  GTK_OBJECT_CLASS (parent_class)->finalize (object);
-}
diff --git a/gtk/gtktable.c b/gtk/gtktable.c
index e484479c8..c22427637 100644
--- a/gtk/gtktable.c
+++ b/gtk/gtktable.c
@@ -52,7 +52,7 @@ enum
 
 static void gtk_table_class_init    (GtkTableClass  *klass);
 static void gtk_table_init	    (GtkTable	    *table);
-static void gtk_table_finalize	    (GtkObject	    *object);
+static void gtk_table_finalize	    (GObject	    *object);
 static void gtk_table_map	    (GtkWidget	    *widget);
 static void gtk_table_unmap	    (GtkWidget	    *widget);
 static void gtk_table_draw	    (GtkWidget	    *widget,
@@ -129,6 +129,7 @@ gtk_table_get_type (void)
 static void
 gtk_table_class_init (GtkTableClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;
@@ -138,24 +139,11 @@ gtk_table_class_init (GtkTableClass *class)
   container_class = (GtkContainerClass*) class;
   
   parent_class = gtk_type_class (gtk_container_get_type ());
-  
-  gtk_object_add_arg_type ("GtkTable::n_rows", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_N_ROWS);
-  gtk_object_add_arg_type ("GtkTable::n_columns", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_N_COLUMNS);
-  gtk_object_add_arg_type ("GtkTable::row_spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_ROW_SPACING);
-  gtk_object_add_arg_type ("GtkTable::column_spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_COLUMN_SPACING);
-  gtk_object_add_arg_type ("GtkTable::homogeneous", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HOMOGENEOUS);
-  gtk_container_add_child_arg_type ("GtkTable::left_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_LEFT_ATTACH);
-  gtk_container_add_child_arg_type ("GtkTable::right_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_RIGHT_ATTACH);
-  gtk_container_add_child_arg_type ("GtkTable::top_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_TOP_ATTACH);
-  gtk_container_add_child_arg_type ("GtkTable::bottom_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_BOTTOM_ATTACH);
-  gtk_container_add_child_arg_type ("GtkTable::x_options", GTK_TYPE_ATTACH_OPTIONS, GTK_ARG_READWRITE, CHILD_ARG_X_OPTIONS);
-  gtk_container_add_child_arg_type ("GtkTable::y_options", GTK_TYPE_ATTACH_OPTIONS, GTK_ARG_READWRITE, CHILD_ARG_Y_OPTIONS);
-  gtk_container_add_child_arg_type ("GtkTable::x_padding", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_X_PADDING);
-  gtk_container_add_child_arg_type ("GtkTable::y_padding", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_Y_PADDING);
+
+  gobject_class->finalize = gtk_table_finalize;
 
   object_class->get_arg = gtk_table_get_arg;
   object_class->set_arg = gtk_table_set_arg;
-  object_class->finalize = gtk_table_finalize;
   
   widget_class->map = gtk_table_map;
   widget_class->unmap = gtk_table_unmap;
@@ -170,6 +158,20 @@ gtk_table_class_init (GtkTableClass *class)
   container_class->child_type = gtk_table_child_type;
   container_class->set_child_arg = gtk_table_set_child_arg;
   container_class->get_child_arg = gtk_table_get_child_arg;
+  
+  gtk_object_add_arg_type ("GtkTable::n_rows", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_N_ROWS);
+  gtk_object_add_arg_type ("GtkTable::n_columns", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_N_COLUMNS);
+  gtk_object_add_arg_type ("GtkTable::row_spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_ROW_SPACING);
+  gtk_object_add_arg_type ("GtkTable::column_spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_COLUMN_SPACING);
+  gtk_object_add_arg_type ("GtkTable::homogeneous", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HOMOGENEOUS);
+  gtk_container_add_child_arg_type ("GtkTable::left_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_LEFT_ATTACH);
+  gtk_container_add_child_arg_type ("GtkTable::right_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_RIGHT_ATTACH);
+  gtk_container_add_child_arg_type ("GtkTable::top_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_TOP_ATTACH);
+  gtk_container_add_child_arg_type ("GtkTable::bottom_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_BOTTOM_ATTACH);
+  gtk_container_add_child_arg_type ("GtkTable::x_options", GTK_TYPE_ATTACH_OPTIONS, GTK_ARG_READWRITE, CHILD_ARG_X_OPTIONS);
+  gtk_container_add_child_arg_type ("GtkTable::y_options", GTK_TYPE_ATTACH_OPTIONS, GTK_ARG_READWRITE, CHILD_ARG_Y_OPTIONS);
+  gtk_container_add_child_arg_type ("GtkTable::x_padding", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_X_PADDING);
+  gtk_container_add_child_arg_type ("GtkTable::y_padding", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_Y_PADDING);
 }
 
 static GtkType
@@ -655,11 +657,10 @@ gtk_table_set_homogeneous (GtkTable *table,
 }
 
 static void
-gtk_table_finalize (GtkObject *object)
+gtk_table_finalize (GObject *object)
 {
   GtkTable *table;
   
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_TABLE (object));
   
   table = GTK_TABLE (object);
@@ -667,7 +668,7 @@ gtk_table_finalize (GtkObject *object)
   g_free (table->rows);
   g_free (table->cols);
   
-  (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
diff --git a/gtk/gtktext.c b/gtk/gtktext.c
index 1da7b514d..3b6bfd2ae 100644
--- a/gtk/gtktext.c
+++ b/gtk/gtktext.c
@@ -202,7 +202,7 @@ static void  gtk_text_get_arg        (GtkObject      *object,
 				      guint           arg_id);
 static void  gtk_text_init           (GtkText        *text);
 static void  gtk_text_destroy        (GtkObject      *object);
-static void  gtk_text_finalize       (GtkObject      *object);
+static void  gtk_text_finalize       (GObject        *object);
 static void  gtk_text_realize        (GtkWidget      *widget);
 static void  gtk_text_unrealize      (GtkWidget      *widget);
 static void  gtk_text_style_set	     (GtkWidget      *widget,
@@ -534,6 +534,7 @@ gtk_text_get_type (void)
 static void
 gtk_text_class_init (GtkTextClass *class)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkEditableClass *editable_class;
@@ -543,27 +544,11 @@ gtk_text_class_init (GtkTextClass *class)
   editable_class = (GtkEditableClass*) class;
   parent_class = gtk_type_class (GTK_TYPE_EDITABLE);
 
-  gtk_object_add_arg_type ("GtkText::hadjustment",
-			   GTK_TYPE_ADJUSTMENT,
-			   GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
-			   ARG_HADJUSTMENT);
-  gtk_object_add_arg_type ("GtkText::vadjustment",
-			   GTK_TYPE_ADJUSTMENT,
-			   GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
-			   ARG_VADJUSTMENT);
-  gtk_object_add_arg_type ("GtkText::line_wrap",
-			   GTK_TYPE_BOOL,
-			   GTK_ARG_READWRITE,
-			   ARG_LINE_WRAP);
-  gtk_object_add_arg_type ("GtkText::word_wrap",
-			   GTK_TYPE_BOOL,
-			   GTK_ARG_READWRITE,
-			   ARG_WORD_WRAP);
+  gobject_class->finalize = gtk_text_finalize;
 
   object_class->set_arg = gtk_text_set_arg;
   object_class->get_arg = gtk_text_get_arg;
   object_class->destroy = gtk_text_destroy;
-  object_class->finalize = gtk_text_finalize;
   
   widget_class->realize = gtk_text_realize;
   widget_class->unrealize = gtk_text_unrealize;
@@ -580,14 +565,6 @@ gtk_text_class_init (GtkTextClass *class)
   widget_class->key_press_event = gtk_text_key_press;
   widget_class->focus_in_event = gtk_text_focus_in;
   widget_class->focus_out_event = gtk_text_focus_out;
-  
-  widget_class->set_scroll_adjustments_signal =
-    gtk_signal_new ("set_scroll_adjustments",
-		    GTK_RUN_LAST,
-		    object_class->type,
-		    GTK_SIGNAL_OFFSET (GtkTextClass, set_scroll_adjustments),
-		    gtk_marshal_NONE__POINTER_POINTER,
-		    GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 
   editable_class->set_editable = gtk_text_real_set_editable;
   editable_class->insert_text = gtk_text_insert_text;
@@ -609,6 +586,31 @@ gtk_text_class_init (GtkTextClass *class)
   editable_class->set_position = gtk_text_set_position;
 
   class->set_scroll_adjustments = gtk_text_set_adjustments;
+
+  gtk_object_add_arg_type ("GtkText::hadjustment",
+			   GTK_TYPE_ADJUSTMENT,
+			   GTK_ARG_READWRITE,
+			   ARG_HADJUSTMENT);
+  gtk_object_add_arg_type ("GtkText::vadjustment",
+			   GTK_TYPE_ADJUSTMENT,
+			   GTK_ARG_READWRITE,
+			   ARG_VADJUSTMENT);
+  gtk_object_add_arg_type ("GtkText::line_wrap",
+			   GTK_TYPE_BOOL,
+			   GTK_ARG_READWRITE,
+			   ARG_LINE_WRAP);
+  gtk_object_add_arg_type ("GtkText::word_wrap",
+			   GTK_TYPE_BOOL,
+			   GTK_ARG_READWRITE,
+			   ARG_WORD_WRAP);
+  
+  widget_class->set_scroll_adjustments_signal =
+    gtk_signal_new ("set_scroll_adjustments",
+		    GTK_RUN_LAST,
+		    GTK_CLASS_TYPE (object_class),
+		    GTK_SIGNAL_OFFSET (GtkTextClass, set_scroll_adjustments),
+		    gtk_marshal_NONE__POINTER_POINTER,
+		    GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 }
 
 static void
@@ -721,6 +723,7 @@ gtk_text_init (GtkText *text)
   
   GTK_EDITABLE (text)->editable = FALSE;
   
+  gtk_text_set_adjustments (text, NULL, NULL);
   gtk_editable_set_position (GTK_EDITABLE (text), 0);
 }
 
@@ -1200,13 +1203,22 @@ gtk_text_destroy (GtkObject *object)
 {
   GtkText *text;
   
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_TEXT (object));
   
-  text = (GtkText*) object;
+  text = GTK_TEXT (object);
 
-  gtk_signal_disconnect_by_data (GTK_OBJECT (text->hadj), text);
-  gtk_signal_disconnect_by_data (GTK_OBJECT (text->vadj), text);
+  if (text->hadj)
+    {
+      gtk_signal_disconnect_by_data (GTK_OBJECT (text->hadj), text);
+      gtk_object_unref (GTK_OBJECT (text->hadj));
+      text->hadj = NULL;
+    }
+  if (text->vadj)
+    {
+      gtk_signal_disconnect_by_data (GTK_OBJECT (text->vadj), text);
+      gtk_object_unref (GTK_OBJECT (text->vadj));
+      text->vadj = NULL;
+    }
 
   if (text->timer)
     {
@@ -1218,18 +1230,14 @@ gtk_text_destroy (GtkObject *object)
 }
 
 static void
-gtk_text_finalize (GtkObject *object)
+gtk_text_finalize (GObject *object)
 {
   GtkText *text;
   GList *tmp_list;
   
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_TEXT (object));
   
-  text = (GtkText *)object;
-  
-  gtk_object_unref (GTK_OBJECT (text->hadj));
-  gtk_object_unref (GTK_OBJECT (text->vadj));
+  text = GTK_TEXT (object);
 
   /* Clean up the internal structures */
   if (text->use_wchar)
@@ -1262,7 +1270,7 @@ gtk_text_finalize (GtkObject *object)
   
   g_list_free (text->tab_stops);
   
-  GTK_OBJECT_CLASS(parent_class)->finalize (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 static void
diff --git a/gtk/gtktipsquery.c b/gtk/gtktipsquery.c
index aed085d9b..2468e9a78 100644
--- a/gtk/gtktipsquery.c
+++ b/gtk/gtktipsquery.c
@@ -125,21 +125,21 @@ gtk_tips_query_class_init (GtkTipsQueryClass *class)
   tips_query_signals[SIGNAL_START_QUERY] =
     gtk_signal_new ("start_query",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkTipsQueryClass, start_query),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   tips_query_signals[SIGNAL_STOP_QUERY] =
     gtk_signal_new ("stop_query",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkTipsQueryClass, stop_query),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   tips_query_signals[SIGNAL_WIDGET_ENTERED] =
     gtk_signal_new ("widget_entered",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkTipsQueryClass, widget_entered),
 		    gtk_marshal_NONE__POINTER_STRING_STRING,
 		    GTK_TYPE_NONE, 3,
@@ -149,7 +149,7 @@ gtk_tips_query_class_init (GtkTipsQueryClass *class)
   tips_query_signals[SIGNAL_WIDGET_SELECTED] =
     gtk_signal_new ("widget_selected",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkTipsQueryClass, widget_selected),
 		    gtk_marshal_BOOL__POINTER_STRING_STRING_POINTER,
 		    GTK_TYPE_BOOL, 4,
diff --git a/gtk/gtktogglebutton.c b/gtk/gtktogglebutton.c
index 4c4c8431e..788ac6700 100644
--- a/gtk/gtktogglebutton.c
+++ b/gtk/gtktogglebutton.c
@@ -122,7 +122,7 @@ gtk_toggle_button_class_init (GtkToggleButtonClass *class)
   toggle_button_signals[TOGGLED] =
     gtk_signal_new ("toggled",
                     GTK_RUN_FIRST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkToggleButtonClass, toggled),
                     gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
diff --git a/gtk/gtktoolbar.c b/gtk/gtktoolbar.c
index f66f18163..9aa8d7d17 100644
--- a/gtk/gtktoolbar.c
+++ b/gtk/gtktoolbar.c
@@ -143,7 +143,7 @@ gtk_toolbar_class_init (GtkToolbarClass *class)
   toolbar_signals[ORIENTATION_CHANGED] =
     gtk_signal_new ("orientation_changed",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkToolbarClass, orientation_changed),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1,
@@ -151,7 +151,7 @@ gtk_toolbar_class_init (GtkToolbarClass *class)
   toolbar_signals[STYLE_CHANGED] =
     gtk_signal_new ("style_changed",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkToolbarClass, style_changed),
 		    gtk_marshal_NONE__INT,
 		    GTK_TYPE_NONE, 1,
@@ -290,8 +290,11 @@ gtk_toolbar_destroy (GtkObject *object)
 
   toolbar = GTK_TOOLBAR (object);
 
-  gtk_object_unref (GTK_OBJECT (toolbar->tooltips));
-  toolbar->tooltips = NULL;
+  if (toolbar->tooltips)
+    {
+      gtk_object_unref (GTK_OBJECT (toolbar->tooltips));
+      toolbar->tooltips = NULL;
+    }
 
   for (children = toolbar->children; children; children = children->next)
     {
@@ -309,12 +312,10 @@ gtk_toolbar_destroy (GtkObject *object)
 
       g_free (child);
     }
-
   g_list_free (toolbar->children);
   toolbar->children = NULL;
   
-  if (GTK_OBJECT_CLASS (parent_class)->destroy)
-    (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 static void
diff --git a/gtk/gtktree.c b/gtk/gtktree.c
index b3765f561..40c9fd79e 100644
--- a/gtk/gtktree.c
+++ b/gtk/gtktree.c
@@ -115,14 +115,14 @@ gtk_tree_class_init (GtkTreeClass *class)
   tree_signals[SELECTION_CHANGED] =
     gtk_signal_new ("selection_changed",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkTreeClass, selection_changed),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   tree_signals[SELECT_CHILD] =
     gtk_signal_new ("select_child",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkTreeClass, select_child),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -130,7 +130,7 @@ gtk_tree_class_init (GtkTreeClass *class)
   tree_signals[UNSELECT_CHILD] =
     gtk_signal_new ("unselect_child",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkTreeClass, unselect_child),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
diff --git a/gtk/gtktreeitem.c b/gtk/gtktreeitem.c
index e174d6fb1..63e2d7720 100644
--- a/gtk/gtktreeitem.c
+++ b/gtk/gtktreeitem.c
@@ -145,14 +145,14 @@ gtk_tree_item_class_init (GtkTreeItemClass *class)
   tree_item_signals[EXPAND_TREE] =
     gtk_signal_new ("expand",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkTreeItemClass, expand),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   tree_item_signals[COLLAPSE_TREE] =
     gtk_signal_new ("collapse",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkTreeItemClass, collapse),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
diff --git a/gtk/gtktypeutils.c b/gtk/gtktypeutils.c
index a2c15e6aa..b4cb223a3 100644
--- a/gtk/gtktypeutils.c
+++ b/gtk/gtktypeutils.c
@@ -18,984 +18,244 @@
  */
 
 /*
- * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  * file for a list of people on the GTK+ Team.  See the ChangeLog
  * files for a list of changes.  These files are distributed with
  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  */
 
-#include <string.h>
 #include "gtktypeutils.h"
+#include "gtkobject.h"
 
 
-#define	TYPE_NODES_BLOCK_SIZE	(35)  /* needs to be > GTK_TYPE_FUNDAMENTAL_MAX */
-
-typedef struct _GtkTypeNode GtkTypeNode;
-
-struct _GtkTypeNode
+/* --- functions --- */
+GtkType
+gtk_type_unique (GtkType            parent_type,
+		 const GtkTypeInfo *gtkinfo)
 {
-  GtkType type;
-  GtkTypeInfo type_info;
-  guint n_supers : 24;
-  guint chunk_alloc_locked : 1;
-  GtkType *supers;
-  GtkType parent_type;
-  gpointer klass;
-  GList *children_types;
-  GMemChunk *mem_chunk;
-};
-
-#define	LOOKUP_TYPE_NODE(node_var, type)	{ \
-    GtkTypeNode *__node = NULL; \
-    GtkType sqn = GTK_TYPE_SEQNO (type); \
-    if (sqn > 0) \
-      { \
-	sqn--; \
-	if (sqn < GTK_TYPE_FUNDAMENTAL_MAX) \
-	  { \
-	    if (sqn < n_ftype_nodes) \
-	      __node = type_nodes + sqn; \
-	  } \
-	else if (sqn < n_type_nodes) \
-	  __node = type_nodes + sqn; \
-      } \
-    node_var = __node; \
-}
-
-static void  gtk_type_class_init		(GtkType      node_type);
-static void  gtk_type_init_builtin_types	(void);
+  GTypeInfo tinfo = { 0, };
 
-static GtkTypeNode *type_nodes = NULL;
-static guint	    n_type_nodes = 0;
-static guint	    n_ftype_nodes = 0;
-static GHashTable  *type_name_2_type_ht = NULL;
+  g_return_val_if_fail (GTK_TYPE_IS_OBJECT (parent_type), 0);
+  g_return_val_if_fail (gtkinfo != NULL, 0);
+  g_return_val_if_fail (gtkinfo->type_name != NULL, 0);
+  g_return_val_if_fail (g_type_from_name (gtkinfo->type_name) == 0, 0);
 
+  tinfo.class_size = gtkinfo->class_size;
+  tinfo.base_init = gtkinfo->base_class_init_func;
+  tinfo.base_finalize = NULL;
+  tinfo.class_init = (GClassInitFunc) gtkinfo->class_init_func;
+  tinfo.class_finalize = NULL;
+  tinfo.class_data = NULL;
+  tinfo.instance_size = gtkinfo->object_size;
+  tinfo.n_preallocs = 0;
+  tinfo.instance_init = gtkinfo->object_init_func;
 
-static GtkTypeNode*
-gtk_type_node_next_and_invalidate (GtkType parent_type)
-{
-  static guint n_free_type_nodes = 0;
-  GtkTypeNode *node;
-  
-  /* don't keep *any* GtkTypeNode pointers across invokation of this function!!!
-   */
-  
-  if (n_free_type_nodes == 0)
-    {
-      guint i;
-      guint size;
-      
-      /* nearest pow
-       */
-      size = n_type_nodes + TYPE_NODES_BLOCK_SIZE;
-      size *= sizeof (GtkTypeNode);
-      i = 1;
-      while (i < size)
-	i <<= 1;
-      size = i;
-      
-      type_nodes = g_realloc (type_nodes, size);
-      
-      n_free_type_nodes = size / sizeof (GtkTypeNode) - n_type_nodes;
-      
-      memset (type_nodes + n_type_nodes, 0, n_free_type_nodes * sizeof (GtkTypeNode));
-      if (!n_type_nodes)
-	{
-	  n_type_nodes = GTK_TYPE_FUNDAMENTAL_MAX;
-	  n_free_type_nodes -= GTK_TYPE_FUNDAMENTAL_MAX;
-	}
-    }
-
-  if (!parent_type)
-    {
-      g_assert (n_ftype_nodes < GTK_TYPE_FUNDAMENTAL_MAX); /* paranoid */
-
-      node = type_nodes + n_ftype_nodes;
-      n_ftype_nodes++;
-      node->type = n_ftype_nodes;
-    }
-  else
-    {
-      node = type_nodes + n_type_nodes;
-      n_type_nodes++;
-      n_free_type_nodes--;
-      node->type = GTK_TYPE_MAKE (parent_type, n_type_nodes);
-    }
-  
-  return node;
-}
-
-void
-gtk_type_init (void)
-{
-  if (n_type_nodes == 0)
-    {
-      g_assert (sizeof (GtkType) >= 4);
-      g_assert (TYPE_NODES_BLOCK_SIZE > GTK_TYPE_FUNDAMENTAL_MAX);
-      
-      type_name_2_type_ht = g_hash_table_new (g_str_hash, g_str_equal);
-      
-      gtk_type_init_builtin_types ();
-    }
+  return g_type_register_static (parent_type, gtkinfo->type_name, &tinfo);
 }
 
-void
-gtk_type_set_chunk_alloc (GtkType      type,
-			  guint	       n_chunks)
-{
-  GtkTypeNode *node;
-  
-  LOOKUP_TYPE_NODE (node, type);
-  g_return_if_fail (node != NULL);
-  g_return_if_fail (node->chunk_alloc_locked == FALSE);
-  
-  if (node->mem_chunk)
-    {
-      g_mem_chunk_destroy (node->mem_chunk);
-      node->mem_chunk = NULL;
-    }
-  
-  if (n_chunks)
-    node->mem_chunk = g_mem_chunk_new (node->type_info.type_name,
-				       node->type_info.object_size,
-				       node->type_info.object_size * n_chunks,
-				       G_ALLOC_AND_FREE);
-}
-
-static GtkType
-gtk_type_create (GtkType      parent_type,
-		 gchar	      *type_name,
-		 const GtkTypeInfo *type_info)
+gpointer
+gtk_type_class (GtkType type)
 {
-  GtkTypeNode *new_node;
-  GtkTypeNode *parent;
-  guint i;
-  
-  if (g_hash_table_lookup (type_name_2_type_ht, type_name))
-    {
-      g_warning ("gtk_type_create(): type `%s' already exists.", type_name);
-      return 0;
-    }
-  
-  if (parent_type)
-    {
-      GtkTypeNode *tmp_node;
-      
-      LOOKUP_TYPE_NODE (tmp_node, parent_type);
-      if (!tmp_node)
-	{
-	  g_warning ("gtk_type_create(): unknown parent type `%u'.", parent_type);
-	  return 0;
-	}
-    }
-  
-  /* relookup pointers afterwards.
+  static GQuark quark_static_class = 0;
+  gpointer class;
+
+  if (!G_TYPE_IS_ENUM (type) && !G_TYPE_IS_FLAGS (type))
+    g_return_val_if_fail (GTK_TYPE_IS_OBJECT (type), NULL);
+
+  /* ok, this is a bit ugly, GLib reference counts classes,
+   * and gtk_type_class() used to always return static classes.
+   * while we coud be faster with just peeking the glib class
+   * for the normal code path, we can't be sure that that
+   * class stays around (someone else might be holding the
+   * reference count and is going to drop it later). so to
+   * ensure that Gtk actually holds a static reference count
+   * on the class, we use GType qdata to store referenced
+   * classes, and only return those.
    */
-  new_node = gtk_type_node_next_and_invalidate (parent_type);
-  
-  if (parent_type)
-    {
-      g_assert (GTK_TYPE_SEQNO (new_node->type) > GTK_TYPE_FUNDAMENTAL_MAX);
-      LOOKUP_TYPE_NODE (parent, parent_type);
-    }
-  else
-    {
-      g_assert (new_node->type <= GTK_TYPE_FUNDAMENTAL_MAX);
-      parent = NULL;
-    }
-  
-  new_node->type_info = *type_info;
-  new_node->type_info.type_name = type_name;
-  /* new_node->type_info.reserved_1 = NULL; */
-  new_node->type_info.reserved_2 = NULL;
-  new_node->n_supers = parent ? parent->n_supers + 1 : 0;
-  new_node->chunk_alloc_locked = FALSE;
-  new_node->supers = g_new0 (GtkType, new_node->n_supers + 1);
-  new_node->parent_type = parent_type;
-  new_node->klass = NULL;
-  new_node->children_types = NULL;
-  new_node->mem_chunk = NULL;
-  
-  if (parent)
-    parent->children_types = g_list_append (parent->children_types, GUINT_TO_POINTER (new_node->type));
-  
-  parent = new_node;
-  for (i = 0; i < new_node->n_supers + 1; i++)
-    {
-      new_node->supers[i] = parent->type;
-      LOOKUP_TYPE_NODE (parent, parent->parent_type);
-    }
-  
-  g_hash_table_insert (type_name_2_type_ht, new_node->type_info.type_name, GUINT_TO_POINTER (new_node->type));
-  
-  return new_node->type;
-}
 
-GtkType
-gtk_type_unique (GtkType      parent_type,
-		 const GtkTypeInfo *type_info)
-{
-  GtkType new_type;
-  gchar *type_name;
-  
-  g_return_val_if_fail (type_info != NULL, 0);
-  g_return_val_if_fail (type_info->type_name != NULL, 0);
-  
-  if (!parent_type && n_ftype_nodes >= GTK_TYPE_FUNDAMENTAL_MAX)
+  class = g_type_get_qdata (type, quark_static_class);
+  if (!class)
     {
-      g_warning ("gtk_type_unique(): maximum amount of fundamental types reached, "
-		 "try increasing GTK_TYPE_FUNDAMENTAL_MAX");
-      return 0;
-    }
-
-  type_name = g_strdup (type_info->type_name);
-  
-  /* relookup pointers afterwards.
-   */
-  new_type = gtk_type_create (parent_type, type_name, type_info);
-  
-  if (!new_type)
-    g_free (type_name);
+      if (!quark_static_class)
+	quark_static_class = g_quark_from_static_string ("GtkStaticTypeClass");
 
-  return new_type;
-}
-
-gchar*
-gtk_type_name (GtkType type)
-{
-  GtkTypeNode *node;
-  
-  LOOKUP_TYPE_NODE (node, type);
-  
-  if (node)
-    return node->type_info.type_name;
-  
-  return NULL;
-}
-
-GtkType
-gtk_type_from_name (const gchar *name)
-{
-  if (type_name_2_type_ht)
-    {
-      GtkType type;
-      
-      type = GPOINTER_TO_UINT (g_hash_table_lookup (type_name_2_type_ht, (gpointer) name));
-      
-      return type;
-    }
-  
-  return 0;
-}
-
-GtkType
-gtk_type_parent (GtkType type)
-{
-  GtkTypeNode *node;
-  
-  LOOKUP_TYPE_NODE (node, type);
-  if (node)
-    return node->parent_type;
-  
-  return 0;
-}
-
-gpointer
-gtk_type_parent_class (GtkType type)
-{
-  GtkTypeNode *node;
-  
-  LOOKUP_TYPE_NODE (node, type);
-  g_return_val_if_fail (node != NULL, NULL);
-  
-  if (node)
-    {
-      LOOKUP_TYPE_NODE (node, node->parent_type);
-      
-      if (node)
-	{
-	  if (!node->klass)
-	    {
-	      type = node->type;
-	      gtk_type_class_init (type);
-	      LOOKUP_TYPE_NODE (node, type);
-	    }
-	  
-	  return node->klass;
-	}
+      class = g_type_class_ref (type);
+      g_assert (class != NULL);
+      g_type_set_qdata (type, quark_static_class, class);
     }
-  
-  return NULL;
-}
 
-gpointer
-gtk_type_class (GtkType type)
-{
-  GtkTypeNode *node;
-  
-  LOOKUP_TYPE_NODE (node, type);
-  g_return_val_if_fail (node != NULL, NULL);
-  
-  if (!node->klass)
-    {
-      type = node->type;
-      gtk_type_class_init (type);
-      LOOKUP_TYPE_NODE (node, type);
-    }
-  
-  return node->klass;
+  return class;
 }
 
 gpointer
 gtk_type_new (GtkType type)
 {
-  GtkTypeNode *node;
-  GtkTypeObject *tobject;
-  gpointer klass;
-  
-  LOOKUP_TYPE_NODE (node, type);
-  g_return_val_if_fail (node != NULL, NULL);
-  
-  klass = node->klass;
-  if (!klass)
-    {
-      klass = gtk_type_class (type);
-      LOOKUP_TYPE_NODE (node, type);
-    }
-  node->chunk_alloc_locked = TRUE;
-
-  if (node->mem_chunk)
-    tobject = g_mem_chunk_alloc0 (node->mem_chunk);
-  else
-    tobject = g_malloc0 (node->type_info.object_size);
-  
-  /* we need to call the base classes' object_init_func for derived
-   * objects with the object's ->klass field still pointing to the
-   * corresponding base class, otherwise overridden class functions
-   * could get called with partly-initialized objects. the real object
-   * class is passed as second argment to the initializers.
-   */
-  if (node->n_supers)
-    {
-      guint i;
-      GtkType *supers;
-      GtkTypeNode *pnode;
+  gpointer object;
 
-      supers = node->supers;
-      for (i = node->n_supers; i > 0; i--)
-	{
-	  LOOKUP_TYPE_NODE (pnode, supers[i]);
-	  if (pnode->type_info.object_init_func)
-	    {
-	      tobject->klass = pnode->klass;
-	      pnode->type_info.object_init_func (tobject, klass);
-	    }
-	}
-      LOOKUP_TYPE_NODE (node, type);
-    }
-  tobject->klass = klass;
-  if (node->type_info.object_init_func)
-    {
-      node->type_info.object_init_func (tobject, klass);
-      tobject->klass = klass;
-    }
-  
-  return tobject;
-}
+  g_return_val_if_fail (GTK_TYPE_IS_OBJECT (type), NULL);
 
-void
-gtk_type_free (GtkType	    type,
-	       gpointer	    mem)
-{
-  GtkTypeNode *node;
-  
-  g_return_if_fail (mem != NULL);
-  LOOKUP_TYPE_NODE (node, type);
-  g_return_if_fail (node != NULL);
-  
-  if (node->mem_chunk)
-    g_mem_chunk_free (node->mem_chunk, mem);
-  else
-    g_free (mem);
-}
+  object = g_type_create_instance (type);
 
-GList*
-gtk_type_children_types (GtkType type)
-{
-  GtkTypeNode *node;
-  
-  LOOKUP_TYPE_NODE (node, type);
-  if (node)
-    return node->children_types;
-  
-  return NULL;
+  return object;
 }
 
-void
-gtk_type_describe_heritage (GtkType type)
-{
-  GtkTypeNode *node;
-  gchar *is_a = "";
-  
-  LOOKUP_TYPE_NODE (node, type);
-  
-  while (node)
-    {
-      if (node->type_info.type_name)
-	g_message ("%s%s",
-		   is_a,
-		   node->type_info.type_name);
-      else
-	g_message ("%s<unnamed type>",
-		   is_a);
-      is_a = "is a ";
-      
-      LOOKUP_TYPE_NODE (node, node->parent_type);
-    }
-}
+/* includes for various places
+ * with enum definitions
+ */
+#include "makeenums.h"
+/* type variable declarations
+ */
+#include "gtktypebuiltins_vars.c"
+GType GTK_TYPE_IDENTIFIER = 0;
+#include "gtktypebuiltins_evals.c"	  /* enum value definition arrays */
 
 void
-gtk_type_describe_tree (GtkType	 type,
-			gboolean show_size)
+gtk_type_init (void)
 {
-  GtkTypeNode *node;
-  
-  LOOKUP_TYPE_NODE (node, type);
-  
-  if (node)
-    {
-      static gint indent = 0;
-      GList *list;
-      guint old_indent;
+  static gboolean initialized = FALSE;
+  
+  if (!initialized)
+    {
+      static const struct {
+	GtkType type_id;
+	gchar *name;
+      } fundamental_info[] = {
+	{ GTK_TYPE_CHAR,	"gchar" },
+	{ GTK_TYPE_UCHAR,	"guchar" },
+	{ GTK_TYPE_BOOL,	"gboolean" },
+	{ GTK_TYPE_INT,		"gint" },
+	{ GTK_TYPE_UINT,	"guint" },
+	{ GTK_TYPE_LONG,	"glong" },
+	{ GTK_TYPE_ULONG,	"gulong" },
+	{ GTK_TYPE_FLOAT,	"gfloat" },
+	{ GTK_TYPE_DOUBLE,	"gdouble" },
+	{ GTK_TYPE_POINTER,	"gpointer" },
+	{ GTK_TYPE_SIGNAL,	"GtkSignal" },
+      };
+      static struct {
+	gchar              *type_name;
+	GtkType            *type_id;
+	GtkType             parent;
+	const GtkEnumValue *values;
+      } builtin_info[GTK_TYPE_N_BUILTINS + 1] = {
+#include "gtktypebuiltins_ids.c"	/* type entries */
+	{ NULL }
+      };
+      GTypeFundamentalInfo finfo = { 0, };
+      GTypeInfo tinfo = { 0, };
+      GtkType type_id;
       guint i;
-      GString *gstring;
 
-      gstring = g_string_new ("");
-      
-      for (i = 0; i < indent; i++)
-	g_string_append_c (gstring, ' ');
-      
-      if (node->type_info.type_name)
-	g_string_append (gstring, node->type_info.type_name);
-      else
-	g_string_append (gstring, "<unnamed type>");
-      
-      if (show_size)
-	g_string_sprintfa (gstring, " (%d bytes)", node->type_info.object_size);
+      initialized = TRUE;
 
-      g_message ("%s", gstring->str);
-      g_string_free (gstring, TRUE);
-      
-      old_indent = indent;
-      indent += 4;
-      
-      for (list = node->children_types; list; list = list->next)
-	gtk_type_describe_tree (GPOINTER_TO_UINT (list->data), show_size);
+      /* initialize GLib type system
+       */
+      g_type_init ();
       
-      indent = old_indent;
-    }
-}
+      /* GTK_TYPE_OBJECT
+       */
+      gtk_object_get_type ();
 
-gboolean
-gtk_type_is_a (GtkType type,
-	       GtkType is_a_type)
-{
-  if (type == is_a_type)
-    return TRUE;
-  else
-    {
-      GtkTypeNode *node;
-      
-      LOOKUP_TYPE_NODE (node, type);
-      if (node)
+      /* compatibility fundamentals
+       */
+      for (i = 0; i < sizeof (fundamental_info) / sizeof (fundamental_info[0]); i++)
 	{
-	  GtkTypeNode *a_node;
-	  
-	  LOOKUP_TYPE_NODE (a_node, is_a_type);
-	  if (a_node)
-	    {
-	      if (a_node->n_supers <= node->n_supers)
-		return node->supers[node->n_supers - a_node->n_supers] == is_a_type;
-	    }
+	  type_id = g_type_register_fundamental (fundamental_info[i].type_id,
+						 fundamental_info[i].name,
+						 &finfo,
+						 &tinfo);
+	  g_assert (type_id == fundamental_info[i].type_id);
 	}
-    }
-  
-  return FALSE;
-}
 
-static void
-gtk_type_class_init (GtkType type)
-{
-  GtkTypeNode *node;
+      /* GTK_TYPE_STRING & GTK_TYPE_IDENTIFIER
+       */
+      finfo.type_flags = G_TYPE_FLAG_DERIVABLE;
+      type_id = g_type_register_fundamental (GTK_TYPE_STRING, "GtkString", &finfo, &tinfo);
+      g_assert (type_id == GTK_TYPE_STRING);
+      GTK_TYPE_IDENTIFIER = g_type_register_static (GTK_TYPE_STRING, "GtkIdentifier", &tinfo);
 
-  /* we need to relookup nodes everytime we called an external function */
-  LOOKUP_TYPE_NODE (node, type);
-  
-  if (!node->klass && node->type_info.class_size)
-    {
-      GtkTypeClass *type_class;
-      GtkTypeNode *base_node;
-      GSList *slist;
-      
-      if (node->type_info.class_size < sizeof (GtkTypeClass))
-	g_warning ("The `%s' class is too small to inherit from GtkTypeClass",
-		   node->type_info.type_name);
-      
-      node->klass = g_malloc0 (node->type_info.class_size);
-      
-      if (node->parent_type)
-	{
-	  GtkTypeNode *parent;
-	  
-	  LOOKUP_TYPE_NODE (parent, node->parent_type);
-	  
-	  if (node->type_info.class_size < parent->type_info.class_size)
-	    g_warning ("The `%s' class is smaller than its parent class `%s'",
-		       node->type_info.type_name,
-		       parent->type_info.type_name);
-	  
-	  if (!parent->klass)
-	    {
-	      gtk_type_class_init (parent->type);
-	      LOOKUP_TYPE_NODE (node, type);
-	      LOOKUP_TYPE_NODE (parent, node->parent_type);
-	    }
-	  
-	  if (parent->klass)
-	    memcpy (node->klass, parent->klass, parent->type_info.class_size);
-	}
-      
-      type_class = node->klass;
-      type_class->type = node->type;
-      
-      /* stack all base class initialization functions, so we
-       * call them in ascending order.
+      /* GTK_TYPE_BOXED
        */
-      base_node = node;
-      slist = NULL;
-      while (base_node)
-	{
-	  if (base_node->type_info.base_class_init_func)
-	    slist = g_slist_prepend (slist, base_node->type_info.base_class_init_func);
-	  LOOKUP_TYPE_NODE (base_node, base_node->parent_type);
-	}
-      if (slist)
+      finfo.type_flags = G_TYPE_FLAG_DERIVABLE;
+      type_id = g_type_register_fundamental (GTK_TYPE_BOXED, "GtkBoxed", &finfo, &tinfo);
+      g_assert (type_id == GTK_TYPE_BOXED);
+
+      /* enums and flags
+       */
+      for (i = 0; i < GTK_TYPE_N_BUILTINS; i++)
 	{
-	  GSList *walk;
-	  
-	  for (walk = slist; walk; walk = walk->next)
-	    {
-	      GtkClassInitFunc base_class_init;
-	      
-	      base_class_init = walk->data;
-	      base_class_init (node->klass);
-	      LOOKUP_TYPE_NODE (node, type);
-	    }
-	  g_slist_free (slist);
+	  GtkType type_id = 0;
+
+	  if (builtin_info[i].parent == G_TYPE_ENUM)
+	    type_id = g_enum_register_static (builtin_info[i].type_name, builtin_info[i].values);
+	  else if (builtin_info[i].parent == G_TYPE_FLAGS)
+	    type_id = g_flags_register_static (builtin_info[i].type_name, builtin_info[i].values);
+	  else if (builtin_info[i].parent == GTK_TYPE_BOXED)
+	    type_id = g_type_register_static (GTK_TYPE_BOXED, builtin_info[i].type_name, &tinfo);
+	  else
+	    g_assert_not_reached ();
+
+	  *builtin_info[i].type_id = type_id;
 	}
-      
-      if (node->type_info.class_init_func)
-	node->type_info.class_init_func (node->klass);
-    }
-}
-
-static inline gchar*
-gtk_type_descriptive_name (GtkType type)
-{
-  gchar *name;
-
-  name = gtk_type_name (type);
-  if (!name)
-    name = "(unknown)";
-
-  return name;
-}
-
-GtkTypeObject*
-gtk_type_check_object_cast (GtkTypeObject  *type_object,
-			    GtkType         cast_type)
-{
-  if (!type_object)
-    {
-      g_warning ("invalid cast from (NULL) pointer to `%s'",
-		 gtk_type_descriptive_name (cast_type));
-      return type_object;
     }
-  if (!type_object->klass)
-    {
-      g_warning ("invalid unclassed pointer in cast to `%s'",
-		 gtk_type_descriptive_name (cast_type));
-      return type_object;
-    }
-  /* currently, GTK_TYPE_OBJECT is the lowest fundamental type
-   * dominator for types that introduce classes.
-   */
-  if (type_object->klass->type < GTK_TYPE_OBJECT)
-    {
-      g_warning ("invalid class type `%s' in cast to `%s'",
-		 gtk_type_descriptive_name (type_object->klass->type),
-		 gtk_type_descriptive_name (cast_type));
-      return type_object;
-    }
-  if (!gtk_type_is_a (type_object->klass->type, cast_type))
-    {
-      g_warning ("invalid cast from `%s' to `%s'",
-		 gtk_type_descriptive_name (type_object->klass->type),
-		 gtk_type_descriptive_name (cast_type));
-      return type_object;
-    }
-
-  return type_object;
-}
-
-GtkTypeClass*
-gtk_type_check_class_cast (GtkTypeClass   *klass,
-			   GtkType         cast_type)
-{
-  if (!klass)
-    {
-      g_warning ("invalid class cast from (NULL) pointer to `%s'",
-		 gtk_type_descriptive_name (cast_type));
-      return klass;
-    }
-  /* currently, GTK_TYPE_OBJECT is the lowest fundamental type
-   * dominator for types that introduce classes.
-   */
-  if (klass->type < GTK_TYPE_OBJECT)
-    {
-      g_warning ("invalid class type `%s' in class cast to `%s'",
-		 gtk_type_descriptive_name (klass->type),
-		 gtk_type_descriptive_name (cast_type));
-      return klass;
-    }
-  if (!gtk_type_is_a (klass->type, cast_type))
-    {
-      g_warning ("invalid class cast from `%s' to `%s'",
-		 gtk_type_descriptive_name (klass->type),
-		 gtk_type_descriptive_name (cast_type));
-      return klass;
-    }
-
-  return klass;
 }
 
 GtkEnumValue*
-gtk_type_enum_get_values (GtkType      enum_type)
-{
-  if (GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_ENUM ||
-      GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_FLAGS)
-    {
-      GtkTypeNode *node;
-      
-      LOOKUP_TYPE_NODE (node, enum_type);
-      if (node)
-	return (GtkEnumValue*) node->type_info.reserved_1;
-    }
-  
-  g_warning ("gtk_type_enum_get_values(): type `%s' is not derived from `GtkEnum' or `GtkFlags'",
-	     gtk_type_name (enum_type));
-  
-  return NULL;
-}
-
-GtkFlagValue*
-gtk_type_flags_get_values (GtkType	  flags_type)
+gtk_type_enum_get_values (GtkType enum_type)
 {
-  return gtk_type_enum_get_values (flags_type);
-}
+  GEnumClass *class;
 
-GtkEnumValue*
-gtk_type_enum_find_value (GtkType        enum_type,
-			  const gchar    *value_name)
-{
-  g_return_val_if_fail (value_name != NULL, NULL);
+  g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
   
-  if (GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_ENUM ||
-      GTK_FUNDAMENTAL_TYPE (enum_type) == GTK_TYPE_FLAGS)
-    {
-      GtkEnumValue *vals;
-
-      vals = gtk_type_enum_get_values (enum_type);
-      if (vals)
-	while (vals->value_name)
-	  {
-	    if (strcmp (vals->value_name, value_name) == 0 ||
-		strcmp (vals->value_nick, value_name) == 0)
-	      return vals;
-	    vals++;
-	  }
-    }
-  else
-    g_warning ("gtk_type_enum_find_value(): type `%s' is not derived from `GtkEnum' or `GtkFlags'",
-	       gtk_type_name (enum_type));
+  class = gtk_type_class (enum_type);
   
-  return NULL;
+  return class->values;
 }
 
 GtkFlagValue*
-gtk_type_flags_find_value (GtkType         flag_type,
-			   const gchar    *value_name)
-{
-  g_return_val_if_fail (value_name != NULL, NULL);
-
-  return gtk_type_enum_find_value (flag_type, value_name);
-}
-
-typedef struct _GtkTypeVarargType GtkTypeVarargType;
-struct _GtkTypeVarargType
+gtk_type_flags_get_values (GtkType flags_type)
 {
-  GtkType foreign_type;
-  GtkType varargs_type;
-};
-
-static GtkTypeVarargType *vararg_types = NULL;
-static guint              n_vararg_types = 0;
+  GFlagsClass *class;
 
-void
-gtk_type_set_varargs_type (GtkType        foreign_type,
-			   GtkType        varargs_type)
-{
-  g_return_if_fail (foreign_type == GTK_FUNDAMENTAL_TYPE (foreign_type));
-  g_return_if_fail (foreign_type > GTK_TYPE_FUNDAMENTAL_LAST);
-
-  if (!((varargs_type >= GTK_TYPE_STRUCTURED_FIRST &&
-	 varargs_type <= GTK_TYPE_STRUCTURED_LAST) ||
-	(varargs_type >= GTK_TYPE_FLAT_FIRST &&
-	 varargs_type <= GTK_TYPE_FLAT_LAST) ||
-	varargs_type == GTK_TYPE_NONE))
-    {
-      g_warning ("invalid varargs type `%s' for fundamental type `%s'",
-		 gtk_type_name (varargs_type),
-		 gtk_type_name (foreign_type));
-      return;
-    }
-  if (gtk_type_get_varargs_type (foreign_type))
-    {
-      g_warning ("varargs type is already registered for fundamental type `%s'",
-		 gtk_type_name (foreign_type));
-      return;
-    }
+  g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), NULL);
 
-  n_vararg_types++;
-  vararg_types = g_realloc (vararg_types, sizeof (GtkTypeVarargType) * n_vararg_types);
+  class = gtk_type_class (flags_type);
 
-  vararg_types[n_vararg_types - 1].foreign_type = foreign_type;
-  vararg_types[n_vararg_types - 1].varargs_type = varargs_type;
+  return class->values;
 }
 
-GtkType
-gtk_type_get_varargs_type (GtkType foreign_type)
+GtkEnumValue*
+gtk_type_enum_find_value (GtkType      enum_type,
+			  const gchar *value_name)
 {
-  GtkType type;
-  guint i;
-
-  type = GTK_FUNDAMENTAL_TYPE (foreign_type);
-  if (type <= GTK_TYPE_FUNDAMENTAL_LAST)
-    return type;
-
-  for (i = 0; i < n_vararg_types; i++)
-    if (vararg_types[i].foreign_type == type)
-      return vararg_types[i].varargs_type;
+  GtkEnumValue *value;
+  GEnumClass *class;
 
-  return 0;
-}
-
-static inline GtkType
-gtk_type_register_intern (gchar	             *name,
-			  GtkType  	      parent,
-			  const GtkEnumValue *values)
-{
-  GtkType type_id;
-  GtkTypeInfo info;
-  
-  info.type_name = name;
-  info.object_size = 0;
-  info.class_size = 0;
-  info.class_init_func = NULL;
-  info.object_init_func = NULL;
-  info.reserved_1 = (gpointer) values;
-  info.reserved_2 = NULL;
-  
-  /* relookup pointers afterwards.
-   */
-  type_id = gtk_type_create (parent, name, &info);
-  
-  if (type_id && values)
-    {
-      guint i;
-      
-      /* check for proper type consistency and NULL termination
-       * of value array
-       */
-      g_assert (GTK_FUNDAMENTAL_TYPE (type_id) == GTK_TYPE_ENUM ||
-		GTK_FUNDAMENTAL_TYPE (type_id) == GTK_TYPE_FLAGS);
-      
-      i = 0;
-      while (values[i].value_name)
-	i++;
-      
-      g_assert (values[i].value_name == NULL && values[i].value_nick == NULL);
-    }
-  
-  return type_id;
-}
+  g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
+  g_return_val_if_fail (value_name != NULL, NULL);
 
-GtkType
-gtk_type_register_enum (const gchar    *type_name,
-			GtkEnumValue   *values)
-{
-  GtkType type_id;
-  gchar *name;
-  
-  g_return_val_if_fail (type_name != NULL, 0);
-  
-  name = g_strdup (type_name);
-  
-  /* relookup pointers afterwards.
-   */
-  type_id = gtk_type_register_intern (name, GTK_TYPE_ENUM, values);
-  
-  if (!type_id)
-    g_free (name);
-  
-  return type_id;
-}
+  class = gtk_type_class (enum_type);
+  value = g_enum_get_value_by_name (class, value_name);
+  if (!value)
+    value = g_enum_get_value_by_nick (class, value_name);
 
-GtkType
-gtk_type_register_flags (const gchar	*type_name,
-			 GtkFlagValue	*values)
-{
-  GtkType type_id;
-  gchar *name;
-  
-  g_return_val_if_fail (type_name != NULL, 0);
-  
-  name = g_strdup (type_name);
-  
-  /* relookup pointers afterwards.
-   */
-  type_id = gtk_type_register_intern (name, GTK_TYPE_FLAGS, values);
-  
-  if (!type_id)
-    g_free (name);
-  
-  return type_id;
+  return value;
 }
 
-GtkTypeQuery*
-gtk_type_query (GtkType type)
+GtkFlagValue*
+gtk_type_flags_find_value (GtkType      flags_type,
+			   const gchar *value_name)
 {
-  GtkTypeNode *node;
-  
-  LOOKUP_TYPE_NODE (node, type);
-  if (node)
-    {
-      GtkTypeQuery *query;
-
-      query = g_new0 (GtkTypeQuery, 1);
-      query->type = type;
-      query->type_name = node->type_info.type_name;
-      query->object_size = node->type_info.object_size;
-      query->class_size = node->type_info.class_size;
-
-      return query;
-    }
-  
-  return NULL;
-}
-
-extern void gtk_object_init_type (void);
+  GtkFlagValue *value;
+  GFlagsClass *class;
 
-#include "makeenums.h"			/* include for various places
-					 * with enum definitions
-					 */
-#include "gtktypebuiltins_vars.c"	/* type variable declarations
-					 */
-#include "gtktypebuiltins_evals.c"	/* enum value definition arrays
-					 */
+  g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), NULL);
+  g_return_val_if_fail (value_name != NULL, NULL);
 
-static void
-gtk_type_init_builtin_types (void)
-{
-  /* GTK_TYPE_INVALID has typeid 0.  The first type id returned by
-   * gtk_type_unique is 1, which is GTK_TYPE_NONE.  And so on.
-   */
-  
-  static const struct {
-    GtkType type_id;
-    gchar *name;
-  } fundamental_info[] = {
-    { GTK_TYPE_NONE,		"void" },
-    { GTK_TYPE_CHAR,		"gchar" },
-    { GTK_TYPE_UCHAR,		"guchar" },
-    { GTK_TYPE_BOOL,		"gboolean" },
-    { GTK_TYPE_INT,		"gint" },
-    { GTK_TYPE_UINT,		"guint" },
-    { GTK_TYPE_LONG,		"glong" },
-    { GTK_TYPE_ULONG,		"gulong" },
-    { GTK_TYPE_FLOAT,		"gfloat" },
-    { GTK_TYPE_DOUBLE,		"gdouble" },
-    { GTK_TYPE_STRING,		"GtkString" },
-    { GTK_TYPE_ENUM,		"GtkEnum" },
-    { GTK_TYPE_FLAGS,		"GtkFlags" },
-    { GTK_TYPE_BOXED,		"GtkBoxed" },
-    { GTK_TYPE_POINTER,		"gpointer" },
-    
-    { GTK_TYPE_SIGNAL,		"GtkSignal" },
-    { GTK_TYPE_ARGS,		"GtkArgs" },
-    { GTK_TYPE_CALLBACK,	"GtkCallback" },
-    { GTK_TYPE_C_CALLBACK,	"GtkCCallback" },
-    { GTK_TYPE_FOREIGN,		"GtkForeign" },
-  };
-  static struct {
-    gchar *type_name;
-    GtkType *type_id;
-    GtkType parent;
-    const GtkEnumValue *values;
-  } builtin_info[GTK_TYPE_NUM_BUILTINS + 1] = {
-#include "gtktypebuiltins_ids.c"	/* type entries */
-    { NULL }
-  };
-  guint i;
-  
-  for (i = 0; i < sizeof (fundamental_info) / sizeof (fundamental_info[0]); i++)
-    {
-      GtkType type_id;
-      
-      /* relookup pointers afterwards.
-       */
-      type_id = gtk_type_register_intern (fundamental_info[i].name, 0, NULL);
-      
-      g_assert (type_id == fundamental_info[i].type_id);
-    }
-  
-  gtk_object_init_type ();
-  
-  for (i = 0; i < GTK_TYPE_NUM_BUILTINS; i++)
-    {
-      GtkType type_id;
-      
-      g_assert (builtin_info[i].type_name != NULL);
-      
-      /* relookup pointers afterwards.
-       */
-      type_id = gtk_type_register_intern (builtin_info[i].type_name,
-					  builtin_info[i].parent,
-					  builtin_info[i].values);
-      
-      g_assert (GTK_TYPE_SEQNO (type_id) > GTK_TYPE_FUNDAMENTAL_MAX);
-      
-      (*builtin_info[i].type_id) = type_id;
-    }
-}
+  class = gtk_type_class (flags_type);
+  value = g_flags_get_value_by_name (class, value_name);
+  if (!value)
+    value = g_flags_get_value_by_nick (class, value_name);
 
-GtkType
-gtk_identifier_get_type (void)
-{
-  static GtkType identifier_type = 0;
-  
-  if (!identifier_type)
-    identifier_type = gtk_type_register_intern ("GtkIdentifier", GTK_TYPE_STRING, NULL);
-  
-  return identifier_type;
+  return value;
 }
diff --git a/gtk/gtktypeutils.h b/gtk/gtktypeutils.h
index ee5d50b05..30f1bc0e8 100644
--- a/gtk/gtktypeutils.h
+++ b/gtk/gtktypeutils.h
@@ -18,7 +18,7 @@
  */
 
 /*
- * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
+ * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  * file for a list of people on the GTK+ Team.  See the ChangeLog
  * files for a list of changes.  These files are distributed with
  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
@@ -28,7 +28,7 @@
 #define __GTK_TYPE_UTILS_H__
 
 
-#include <glib.h>
+#include <glib-object.h>
 
 
 #ifdef __cplusplus
@@ -37,168 +37,91 @@ extern "C" {
 
 
 /* Fundamental Types
+ * many of these are just aliases for GLib types to maintain
+ * compatibility
  */
-typedef enum
+typedef enum	/*< skip >*/
 {
-  GTK_TYPE_INVALID,
-  GTK_TYPE_NONE,
-  
-  /* flat types */
-  GTK_TYPE_CHAR,
-  GTK_TYPE_UCHAR,
-  GTK_TYPE_BOOL,
-  GTK_TYPE_INT,
-  GTK_TYPE_UINT,
-  GTK_TYPE_LONG,
-  GTK_TYPE_ULONG,
-  GTK_TYPE_FLOAT,
-  GTK_TYPE_DOUBLE,
-  GTK_TYPE_STRING,
-  GTK_TYPE_ENUM,
-  GTK_TYPE_FLAGS,
-  GTK_TYPE_BOXED,
-  GTK_TYPE_POINTER,
-  
-  /* structured types */
-  GTK_TYPE_SIGNAL,
-  GTK_TYPE_ARGS,
-  GTK_TYPE_CALLBACK,
-  GTK_TYPE_C_CALLBACK,
-  GTK_TYPE_FOREIGN,
-  
-  /* base type node of the object system */
-  GTK_TYPE_OBJECT
+  GTK_TYPE_INVALID	= G_TYPE_INVALID,
+  GTK_TYPE_NONE		= G_TYPE_NONE,
+  GTK_TYPE_ENUM		= G_TYPE_ENUM,
+  GTK_TYPE_FLAGS	= G_TYPE_FLAGS,
+
+  /* GtkArg types */
+  GTK_TYPE_CHAR		= G_TYPE_GTK_CHAR,
+  GTK_TYPE_UCHAR	= G_TYPE_GTK_UCHAR,
+  GTK_TYPE_BOOL		= G_TYPE_GTK_BOOL,
+  GTK_TYPE_INT		= G_TYPE_GTK_INT,
+  GTK_TYPE_UINT		= G_TYPE_GTK_UINT,
+  GTK_TYPE_LONG		= G_TYPE_GTK_LONG,
+  GTK_TYPE_ULONG	= G_TYPE_GTK_ULONG,
+  GTK_TYPE_FLOAT	= G_TYPE_GTK_FLOAT,
+  GTK_TYPE_DOUBLE	= G_TYPE_GTK_DOUBLE,
+  GTK_TYPE_STRING	= G_TYPE_GTK_STRING,
+  GTK_TYPE_BOXED	= G_TYPE_GTK_BOXED,
+  GTK_TYPE_POINTER	= G_TYPE_GTK_POINTER,
+  GTK_TYPE_SIGNAL	= G_TYPE_GTK_SIGNAL
 } GtkFundamentalType;
 
-/* bounds definitions for type sets, these are provided to distinct
- * between fundamental types with if() statements, and to build
- * up foreign fundamentals
- */
-#define	GTK_TYPE_FLAT_FIRST		GTK_TYPE_CHAR
-#define	GTK_TYPE_FLAT_LAST		GTK_TYPE_POINTER
-#define	GTK_TYPE_STRUCTURED_FIRST	GTK_TYPE_SIGNAL
-#define	GTK_TYPE_STRUCTURED_LAST	GTK_TYPE_FOREIGN
-#define	GTK_TYPE_FUNDAMENTAL_LAST	GTK_TYPE_OBJECT
-#define	GTK_TYPE_FUNDAMENTAL_MAX	(32)
 
+/* --- type macros --- */
+#define GTK_CLASS_NAME(class)		(g_type_name (G_TYPE_FROM_CLASS (class)))
+#define GTK_CLASS_TYPE(class)		(G_TYPE_FROM_CLASS (class))
+#define GTK_TYPE_IS_OBJECT(type)	(g_type_is_a ((type), GTK_TYPE_OBJECT))
 
-/* retrive a structure offset */
-#ifdef offsetof
-#define GTK_STRUCT_OFFSET(struct, field)        ((gint) offsetof (struct, field))
-#else /* !offsetof */
-#define GTK_STRUCT_OFFSET(struct, field)        ((gint) ((gchar*) &((struct*) 0)->field))
-#endif /* !offsetof */
 
-
-/* The debugging versions of the casting macros make sure the cast is "ok"
- *  before proceeding, but they are definately slower than their less
- *  careful counterparts as they involve extra ``is a'' checks.
- */
-#ifdef GTK_NO_CHECK_CASTS
-#  define GTK_CHECK_CAST(tobj, cast_type, cast)       ((cast*) (tobj))
-#  define GTK_CHECK_CLASS_CAST(tclass,cast_type,cast) ((cast*) (tclass))
-#else /* !GTK_NO_CHECK_CASTS */
-#  define GTK_CHECK_CAST(tobj, cast_type, cast) \
-      ((cast*) gtk_type_check_object_cast ((GtkTypeObject*) (tobj), (cast_type)))
-#  define GTK_CHECK_CLASS_CAST(tclass,cast_type,cast) \
-      ((cast*) gtk_type_check_class_cast ((GtkTypeClass*) (tclass), (cast_type)))
-#endif /* GTK_NO_CHECK_CASTS */
-#define GTK_CHECK_GET_CLASS(obj,type,klass)   ((klass*) (((GtkTypeObject*) (obj))->klass))
-
-/* Determines whether `type_object' and `type_class' are a type of `otype'.
+/* outdated macros that really shouldn't e used anymore,
+ * use the GLib type system instead
  */
-#define GTK_CHECK_TYPE(type_object, otype)       ( \
-  ((GtkTypeObject*) (type_object)) != NULL && \
-  GTK_CHECK_CLASS_TYPE (((GtkTypeObject*) (type_object))->klass, (otype)) \
-)
-#define GTK_CHECK_CLASS_TYPE(type_class, otype)  ( \
-  ((GtkTypeClass*) (type_class)) != NULL && \
-  gtk_type_is_a (((GtkTypeClass*) (type_class))->type, (otype)) \
-)
-
-
-
-
-/* A GtkType holds a unique type id
- */
-typedef guint GtkType;
-
-typedef struct _GtkTypeObject	GtkTypeObject;
-typedef struct _GtkTypeClass	GtkTypeClass;
+#ifndef	GTK_DISABLE_COMPAT_H
+#define	GTK_TYPE_FUNDAMENTAL_LAST        (G_TYPE_LAST_RESERVED_FUNDAMENTAL - 1)
+#define	GTK_TYPE_FUNDAMENTAL_MAX         (G_TYPE_FUNDAMENTAL_MAX)
+#endif /* GTK_DISABLE_COMPAT_H */
+
+/* glib macro wrappers (compatibility) */
+#define GTK_STRUCT_OFFSET	G_STRUCT_OFFSET
+#define	GTK_CHECK_CAST		G_TYPE_CHECK_INSTANCE_CAST
+#define	GTK_CHECK_CLASS_CAST	G_TYPE_CHECK_CLASS_CAST
+#define GTK_CHECK_GET_CLASS	G_TYPE_INSTANCE_GET_CLASS
+#define	GTK_CHECK_TYPE		G_TYPE_CHECK_INSTANCE_TYPE
+#define	GTK_CHECK_CLASS_TYPE	G_TYPE_CHECK_CLASS_TYPE
+#define	GTK_FUNDAMENTAL_TYPE	G_TYPE_FUNDAMENTAL
+
+/* glib type wrappers (compatibility) */
+typedef GType			GtkType;
+typedef GTypeInstance		GtkTypeObject;
+typedef GTypeClass		GtkTypeClass;
+typedef GBaseInitFunc		GtkClassInitFunc;
+typedef GInstanceInitFunc	GtkObjectInitFunc;
 
 
 /* Builtin Types
  */
 #include <gtk/gtktypebuiltins.h>
 
-#define		GTK_TYPE_IDENTIFIER		(gtk_identifier_get_type ())
-GtkType		gtk_identifier_get_type		(void);
 
-/* Macros
- */
-#define GTK_TYPE_MAKE(parent_t, seqno)	(((seqno) << 8) | GTK_FUNDAMENTAL_TYPE (parent_t))
-#define GTK_FUNDAMENTAL_TYPE(type)	((GtkFundamentalType) ((type) & 0xFF))
-#define GTK_TYPE_SEQNO(type)		((type) > 0xFF ? (type) >> 8 : (type))
-
-typedef struct _GtkArg	       GtkArg;
-typedef struct _GtkObject      GtkObject;   /* forward declaration of object type */
-typedef struct _GtkTypeInfo    GtkTypeInfo;
-typedef struct _GtkTypeQuery   GtkTypeQuery;
-typedef struct _GtkEnumValue   GtkEnumValue;
-typedef struct _GtkEnumValue   GtkFlagValue;
-
-
-#define GTK_SIGNAL_FUNC(f)  ((GtkSignalFunc) f)
-
-typedef void (*GtkClassInitFunc)   (gpointer   klass);
-typedef void (*GtkObjectInitFunc)  (gpointer   object,
-				    gpointer   klass);
-typedef void (*GtkSignalFunc)      ();
-typedef gint (*GtkFunction)	   (gpointer   data);
-typedef void (*GtkDestroyNotify)   (gpointer   data);
-typedef void (*GtkCallbackMarshal) (GtkObject *object,
-				    gpointer   data,
-				    guint      n_args,
-				    GtkArg    *args);
-typedef void (*GtkSignalMarshaller) (GtkObject      *object,
-				     GtkSignalFunc   func,
-				     gpointer        func_data,
-				     GtkArg         *args);
-
-/* deprecated */
-typedef void (*GtkArgGetFunc)	   (GtkObject*, GtkArg*, guint);
-typedef void (*GtkArgSetFunc)	   (GtkObject*, GtkArg*, guint);
-
-
-/* A GtkTypeObject defines the minimum structure requirements
- * for type instances. Type instances returned from gtk_type_new ()
- * and initialized through a GtkObjectInitFunc need to directly inherit
- * from this structure or at least copy its fields one by one.
+/* --- typedefs --- */
+/* here we come with some necessary forward declarations for structures and
+ * provide some fundamental function signatures
  */
-struct _GtkTypeObject
-{
-  /* A pointer to the objects class. This will actually point to
-   *  the derived objects class struct (which will be derived from
-   *  GtkTypeClass).
-   */
-  GtkTypeClass	*klass;
-};
-
-
-/* A GtkTypeClass defines the minimum structure requirements for
- * a types class. Classes returned from gtk_type_class () and
- * initialized through a GtkClassInitFunc need to directly inherit
- * from this structure or at least copy its fields one by one.
- */
-struct _GtkTypeClass
-{
-  /* The type identifier for the objects class. There is
-   *  one unique identifier per class.
-   */
-  GtkType type;
-};
-
-
+typedef struct _GtkArg	       	     GtkArg;
+typedef struct _GtkObject   	     GtkObject; /* object forward declaration */
+typedef struct _GtkTypeInfo 	     GtkTypeInfo;
+typedef gint (*GtkFunction)	    (gpointer      data);
+typedef void (*GtkDestroyNotify)    (gpointer      data);
+typedef void (*GtkCallbackMarshal)  (GtkObject    *object,
+				     gpointer      data,
+				     guint         n_args,
+				     GtkArg       *args);
+typedef void (*GtkSignalFunc)       ();
+typedef void (*GtkSignalMarshaller) (GtkObject    *object,
+				     GtkSignalFunc func,
+				     gpointer      func_data,
+				     GtkArg       *args);
+#define GTK_SIGNAL_FUNC(f)	    ((GtkSignalFunc) (f))
+
+
+/* GtkArg, used to hold differently typed values */
 struct _GtkArg
 {
   GtkType type;
@@ -222,31 +145,14 @@ struct _GtkArg
     gfloat float_data;
     gdouble double_data;
     gchar *string_data;
-    gpointer pointer_data;
     GtkObject *object_data;
+    gpointer pointer_data;
     
     /* structured values */
     struct {
       GtkSignalFunc f;
       gpointer d;
     } signal_data;
-    struct {
-      gint n_args;
-      GtkArg *args;
-    } args_data;
-    struct {
-      GtkCallbackMarshal marshal;
-      gpointer data;
-      GtkDestroyNotify notify;
-    } callback_data;
-    struct {
-      GtkFunction func;
-      gpointer func_data;
-    } c_callback_data;
-    struct {
-      gpointer data;
-      GtkDestroyNotify notify;
-    } foreign_data;
   } d;
 };
 
@@ -254,8 +160,6 @@ struct _GtkArg
  * to allow the usage of these macros in combination with the
  * adress operator, e.g. &GTK_VALUE_CHAR (*arg)
  */
-
-/* flat values */
 #define GTK_VALUE_CHAR(a)	((a).d.char_data)
 #define GTK_VALUE_UCHAR(a)	((a).d.uchar_data)
 #define GTK_VALUE_BOOL(a)	((a).d.bool_data)
@@ -269,22 +173,14 @@ struct _GtkArg
 #define GTK_VALUE_ENUM(a)	((a).d.int_data)
 #define GTK_VALUE_FLAGS(a)	((a).d.uint_data)
 #define GTK_VALUE_BOXED(a)	((a).d.pointer_data)
-#define GTK_VALUE_POINTER(a)	((a).d.pointer_data)
 #define GTK_VALUE_OBJECT(a)	((a).d.object_data)
-
-/* structured values */
+#define GTK_VALUE_POINTER(a)	((a).d.pointer_data)
 #define GTK_VALUE_SIGNAL(a)	((a).d.signal_data)
-#define GTK_VALUE_ARGS(a)	((a).d.args_data)
-#define GTK_VALUE_CALLBACK(a)	((a).d.callback_data)
-#define GTK_VALUE_C_CALLBACK(a) ((a).d.c_callback_data)
-#define GTK_VALUE_FOREIGN(a)	((a).d.foreign_data)
 
 /* return location macros, these all narow down to
  * pointer types, because return values need to be
  * passed by reference
  */
-
-/* flat values */
 #define GTK_RETLOC_CHAR(a)	((gchar*)	(a).d.pointer_data)
 #define GTK_RETLOC_UCHAR(a)	((guchar*)	(a).d.pointer_data)
 #define GTK_RETLOC_BOOL(a)	((gboolean*)	(a).d.pointer_data)
@@ -298,9 +194,14 @@ struct _GtkArg
 #define GTK_RETLOC_ENUM(a)	((gint*)	(a).d.pointer_data)
 #define GTK_RETLOC_FLAGS(a)	((guint*)	(a).d.pointer_data)
 #define GTK_RETLOC_BOXED(a)	((gpointer*)	(a).d.pointer_data)
-#define GTK_RETLOC_POINTER(a)	((gpointer*)	(a).d.pointer_data)
 #define GTK_RETLOC_OBJECT(a)	((GtkObject**)	(a).d.pointer_data)
+#define GTK_RETLOC_POINTER(a)	((gpointer*)	(a).d.pointer_data)
+/* GTK_RETLOC_SIGNAL() - no such thing */
 
+/* type registration, it is recommended to use
+ * g_type_register_static() or
+ * g_type_register_dynamic() instead
+ */
 struct _GtkTypeInfo
 {
   gchar			*type_name;
@@ -312,66 +213,37 @@ struct _GtkTypeInfo
   gpointer		 reserved_2;
   GtkClassInitFunc	 base_class_init_func;
 };
+GtkType		gtk_type_unique	(GtkType	   parent_type,
+				 const GtkTypeInfo *gtkinfo);
+gpointer	gtk_type_class	(GtkType	 type);
+gpointer	gtk_type_new	(GtkType	 type);
 
-struct _GtkTypeQuery
-{
-  GtkType		 type;
-  const gchar		*type_name;
-  guint			 object_size;
-  guint			 class_size;
-};
 
-struct _GtkEnumValue
-{
-  guint	 value;
-  gchar	*value_name;
-  gchar *value_nick;
-};
+/* --- initialize the type system --- */
+void		gtk_type_init	(void);
+
 
+/* --- compatibility defines --- */
+#define	gtk_type_name			 g_type_name
+#define	gtk_type_from_name		 g_type_from_name
+#define	gtk_type_parent			 g_type_parent
+#define	gtk_type_is_a			 g_type_is_a
 
-void		gtk_type_init			(void);
-GtkType		gtk_type_unique			(GtkType	   parent_type,
-						 const GtkTypeInfo *type_info);
-void		gtk_type_set_chunk_alloc	(GtkType	 type,
-						 guint		 n_chunks);
-gchar*		gtk_type_name			(GtkType	 type);
-GtkType		gtk_type_from_name		(const gchar	*name);
-GtkType		gtk_type_parent			(GtkType	 type);
-gpointer	gtk_type_class			(GtkType	 type);
-gpointer	gtk_type_parent_class		(GtkType	 type);
-GList*		gtk_type_children_types		(GtkType	 type);
-gpointer	gtk_type_new			(GtkType	 type);
-void		gtk_type_free			(GtkType	 type,
-						 gpointer	 mem);
-void		gtk_type_describe_heritage	(GtkType	 type);
-void		gtk_type_describe_tree		(GtkType	 type,
-						 gboolean	 show_size);
-gboolean	gtk_type_is_a			(GtkType	 type,
-						 GtkType	 is_a_type);
-GtkTypeObject*	gtk_type_check_object_cast	(GtkTypeObject	*type_object,
-						 GtkType         cast_type);
-GtkTypeClass*	gtk_type_check_class_cast	(GtkTypeClass	*klass,
-						 GtkType         cast_type);
-GtkType		gtk_type_register_enum		(const gchar	*type_name,
-						 GtkEnumValue	*values);
-GtkType		gtk_type_register_flags		(const gchar	*type_name,
-						 GtkFlagValue	*values);
+
+/* enum/flags compatibility functions, we strongly
+ * recommend to use the glib enum/flags classes directly
+ */
+typedef GEnumValue  GtkEnumValue;
+typedef GFlagsValue GtkFlagValue;
 GtkEnumValue*	gtk_type_enum_get_values	(GtkType	 enum_type);
 GtkFlagValue*	gtk_type_flags_get_values	(GtkType	 flags_type);
 GtkEnumValue*	gtk_type_enum_find_value	(GtkType	 enum_type,
 						 const gchar	*value_name);
-GtkFlagValue*	gtk_type_flags_find_value	(GtkType	 flag_type,
+GtkFlagValue*	gtk_type_flags_find_value	(GtkType	 flags_type,
 						 const gchar	*value_name);
-/* set the argument collector alias for foreign fundamentals */
-void		gtk_type_set_varargs_type	(GtkType	foreign_type,
-						 GtkType	varargs_type);
-GtkType		gtk_type_get_varargs_type	(GtkType	foreign_type);
-/* Report internal information about a type. The caller has the
- * responsibility to invoke a subsequent g_free (returned_data); but
- * must not modify data pointed to by the members of GtkTypeQuery
- */
-GtkTypeQuery*	gtk_type_query			(GtkType	type);
 
+/* urg */
+extern GType GTK_TYPE_IDENTIFIER;
 
 
 #ifdef __cplusplus
diff --git a/gtk/gtkviewport.c b/gtk/gtkviewport.c
index f602e9224..481f59425 100644
--- a/gtk/gtkviewport.c
+++ b/gtk/gtkviewport.c
@@ -38,7 +38,6 @@ enum {
 static void gtk_viewport_class_init               (GtkViewportClass *klass);
 static void gtk_viewport_init                     (GtkViewport      *viewport);
 static void gtk_viewport_destroy                  (GtkObject        *object);
-static void gtk_viewport_finalize                 (GtkObject        *object);
 static void gtk_viewport_set_arg		  (GtkObject        *object,
 						   GtkArg           *arg,
 						   guint             arg_id);
@@ -110,23 +109,9 @@ gtk_viewport_class_init (GtkViewportClass *class)
   container_class = (GtkContainerClass*) class;
   parent_class = (GtkBinClass*) gtk_type_class (GTK_TYPE_BIN);
 
-  gtk_object_add_arg_type ("GtkViewport::hadjustment",
-			   GTK_TYPE_ADJUSTMENT,
-			   GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
-			   ARG_HADJUSTMENT);
-  gtk_object_add_arg_type ("GtkViewport::vadjustment",
-			   GTK_TYPE_ADJUSTMENT,
-			   GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
-			   ARG_VADJUSTMENT);
-  gtk_object_add_arg_type ("GtkViewport::shadow_type",
-			   GTK_TYPE_SHADOW_TYPE,
-			   GTK_ARG_READWRITE,
-			   ARG_SHADOW_TYPE);
-
   object_class->set_arg = gtk_viewport_set_arg;
   object_class->get_arg = gtk_viewport_get_arg;
   object_class->destroy = gtk_viewport_destroy;
-  object_class->finalize = gtk_viewport_finalize;
   
   widget_class->map = gtk_viewport_map;
   widget_class->unmap = gtk_viewport_unmap;
@@ -137,18 +122,31 @@ gtk_viewport_class_init (GtkViewportClass *class)
   widget_class->size_request = gtk_viewport_size_request;
   widget_class->size_allocate = gtk_viewport_size_allocate;
   widget_class->style_set = gtk_viewport_style_set;
+  
+  container_class->add = gtk_viewport_add;
+
+  class->set_scroll_adjustments = gtk_viewport_set_scroll_adjustments;
+
+  gtk_object_add_arg_type ("GtkViewport::hadjustment",
+			   GTK_TYPE_ADJUSTMENT,
+			   GTK_ARG_READWRITE,
+			   ARG_HADJUSTMENT);
+  gtk_object_add_arg_type ("GtkViewport::vadjustment",
+			   GTK_TYPE_ADJUSTMENT,
+			   GTK_ARG_READWRITE,
+			   ARG_VADJUSTMENT);
+  gtk_object_add_arg_type ("GtkViewport::shadow_type",
+			   GTK_TYPE_SHADOW_TYPE,
+			   GTK_ARG_READWRITE,
+			   ARG_SHADOW_TYPE);
 
   widget_class->set_scroll_adjustments_signal =
     gtk_signal_new ("set_scroll_adjustments",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkViewportClass, set_scroll_adjustments),
 		    gtk_marshal_NONE__POINTER_POINTER,
 		    GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
-  
-  container_class->add = gtk_viewport_add;
-
-  class->set_scroll_adjustments = gtk_viewport_set_scroll_adjustments;
 }
 
 static void
@@ -236,24 +234,19 @@ gtk_viewport_destroy (GtkObject *object)
   GtkViewport *viewport = GTK_VIEWPORT (object);
 
   if (viewport->hadjustment)
-    gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->hadjustment),
-				   viewport);
+    {
+      gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->hadjustment), viewport);
+      gtk_object_unref (GTK_OBJECT (viewport->hadjustment));
+      viewport->hadjustment = NULL;
+    }
   if (viewport->vadjustment)
-    gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->vadjustment),
-				   viewport);
-
-  GTK_OBJECT_CLASS(parent_class)->destroy (object);
-}
-
-static void
-gtk_viewport_finalize (GtkObject *object)
-{
-  GtkViewport *viewport = GTK_VIEWPORT (object);
-
-  gtk_object_unref (GTK_OBJECT (viewport->hadjustment));
-  gtk_object_unref (GTK_OBJECT (viewport->vadjustment));
+    {
+      gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->vadjustment), viewport);
+      gtk_object_unref (GTK_OBJECT (viewport->vadjustment));
+      viewport->vadjustment = NULL;
+    }
 
-  GTK_OBJECT_CLASS(parent_class)->finalize (object);
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 GtkAdjustment*
@@ -262,6 +255,9 @@ gtk_viewport_get_hadjustment (GtkViewport *viewport)
   g_return_val_if_fail (viewport != NULL, NULL);
   g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), NULL);
 
+  if (!viewport->hadjustment)
+    gtk_viewport_set_hadjustment (viewport, NULL);
+
   return viewport->hadjustment;
 }
 
@@ -271,6 +267,9 @@ gtk_viewport_get_vadjustment (GtkViewport *viewport)
   g_return_val_if_fail (viewport != NULL, NULL);
   g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), NULL);
 
+  if (!viewport->vadjustment)
+    gtk_viewport_set_vadjustment (viewport, NULL);
+
   return viewport->vadjustment;
 }
 
@@ -285,9 +284,9 @@ gtk_viewport_set_hadjustment (GtkViewport   *viewport,
 
   if (viewport->hadjustment && viewport->hadjustment != adjustment)
     {
-      gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->hadjustment),
-				     (gpointer) viewport);
+      gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->hadjustment), viewport);
       gtk_object_unref (GTK_OBJECT (viewport->hadjustment));
+      viewport->hadjustment = NULL;
     }
 
   if (!adjustment)
@@ -322,9 +321,9 @@ gtk_viewport_set_vadjustment (GtkViewport   *viewport,
 
   if (viewport->vadjustment && viewport->vadjustment != adjustment)
     {
-      gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->vadjustment),
-				     (gpointer) viewport);
+      gtk_signal_disconnect_by_data (GTK_OBJECT (viewport->vadjustment), viewport);
       gtk_object_unref (GTK_OBJECT (viewport->vadjustment));
+      viewport->vadjustment = NULL;
     }
 
   if (!adjustment)
@@ -686,6 +685,12 @@ gtk_viewport_size_allocate (GtkWidget     *widget,
   viewport = GTK_VIEWPORT (widget);
   bin = GTK_BIN (widget);
 
+  /* demand creation */
+  if (!viewport->hadjustment)
+    gtk_viewport_set_hadjustment (viewport, NULL);
+  if (!viewport->vadjustment)
+    gtk_viewport_set_hadjustment (viewport, NULL);
+
   border_width = GTK_CONTAINER (widget)->border_width;
 
   child_allocation.x = 0;
diff --git a/gtk/gtkvscale.c b/gtk/gtkvscale.c
index a27e0ae4b..003760cba 100644
--- a/gtk/gtkvscale.c
+++ b/gtk/gtkvscale.c
@@ -30,8 +30,8 @@
 #include "gdk/gdkkeysyms.h"
 
 
-#define SCALE_CLASS(w)  GTK_SCALE_CLASS (GTK_OBJECT (w)->klass)
-#define RANGE_CLASS(w)  GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+#define SCALE_CLASS(w)  GTK_SCALE_GET_CLASS (w)
+#define RANGE_CLASS(w)  GTK_RANGE_GET_CLASS (w)
 
 enum {
   ARG_0,
@@ -111,7 +111,7 @@ gtk_vscale_class_init (GtkVScaleClass *class)
   
   gtk_object_add_arg_type ("GtkVScale::adjustment",
                            GTK_TYPE_ADJUSTMENT,
-                           GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+                           GTK_ARG_READWRITE,
                            ARG_ADJUSTMENT);
   
   object_class->set_arg = gtk_vscale_set_arg;
diff --git a/gtk/gtkvscrollbar.c b/gtk/gtkvscrollbar.c
index 082fb746b..833f003a6 100644
--- a/gtk/gtkvscrollbar.c
+++ b/gtk/gtkvscrollbar.c
@@ -31,7 +31,7 @@
 
 #define EPSILON 0.01
 
-#define RANGE_CLASS(w)  GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
+#define RANGE_CLASS(w)  GTK_RANGE_GET_CLASS (w)
 
 enum {
   ARG_0,
@@ -97,7 +97,7 @@ gtk_vscrollbar_class_init (GtkVScrollbarClass *class)
   
   gtk_object_add_arg_type ("GtkVScrollbar::adjustment",
                            GTK_TYPE_ADJUSTMENT,
-                           GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+                           GTK_ARG_READWRITE,
                            ARG_ADJUSTMENT);
   
   object_class->set_arg = gtk_vscrollbar_set_arg;
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index 62127f727..c09e605e5 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -39,7 +39,7 @@
 #include "gdk/gdkprivate.h" /* Used in gtk_reset_shapes_recurse to avoid copy */
 
 
-#define WIDGET_CLASS(w)	 GTK_WIDGET_CLASS (GTK_OBJECT (w)->klass)
+#define WIDGET_CLASS(w)	 GTK_WIDGET_GET_CLASS (w)
 #define	INIT_PATH_SIZE	(512)
 
 
@@ -141,9 +141,9 @@ static void gtk_widget_set_arg			 (GtkObject         *object,
 static void gtk_widget_get_arg			 (GtkObject         *object,
 						  GtkArg	    *arg,
 						  guint		     arg_id);
-static void gtk_widget_shutdown			 (GtkObject	    *object);
+static void gtk_widget_shutdown			 (GObject	    *object);
 static void gtk_widget_real_destroy		 (GtkObject	    *object);
-static void gtk_widget_finalize			 (GtkObject	    *object);
+static void gtk_widget_finalize			 (GObject	    *object);
 static void gtk_widget_real_show		 (GtkWidget	    *widget);
 static void gtk_widget_real_hide		 (GtkWidget	    *widget);
 static void gtk_widget_real_map			 (GtkWidget	    *widget);
@@ -183,7 +183,7 @@ static gboolean gtk_widget_is_offscreen           (GtkWidget     *widget);
 static GtkWidgetAuxInfo* gtk_widget_aux_info_new     (void);
 static void		 gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info);
 
-static GtkObjectClass *parent_class = NULL;
+static gpointer parent_class = NULL;
 static guint widget_signals[LAST_SIGNAL] = { 0 };
 
 static GMemChunk *aux_info_mem_chunk = NULL;
@@ -241,7 +241,7 @@ gtk_widget_get_type (void)
 	(GtkClassInitFunc) NULL,
       };
       
-      widget_type = gtk_type_unique (gtk_object_get_type (), &widget_info);
+      widget_type = gtk_type_unique (GTK_TYPE_OBJECT, &widget_info);
     }
   
   return widget_type;
@@ -265,11 +265,72 @@ gtk_widget_debug_msg (GtkWidget          *widget,
 static void
 gtk_widget_class_init (GtkWidgetClass *klass)
 {
-  GtkObjectClass *object_class;
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
   
-  object_class = (GtkObjectClass*) klass;
+  parent_class = gtk_type_class (GTK_TYPE_OBJECT);
+
+  gobject_class->shutdown = gtk_widget_shutdown;
+  gobject_class->finalize = gtk_widget_finalize;
+
+  object_class->set_arg = gtk_widget_set_arg;
+  object_class->get_arg = gtk_widget_get_arg;
+  object_class->destroy = gtk_widget_real_destroy;
   
-  parent_class = gtk_type_class (gtk_object_get_type ());
+  klass->activate_signal = 0;
+  klass->set_scroll_adjustments_signal = 0;
+  klass->show = gtk_widget_real_show;
+  klass->show_all = gtk_widget_show;
+  klass->hide = gtk_widget_real_hide;
+  klass->hide_all = gtk_widget_hide;
+  klass->map = gtk_widget_real_map;
+  klass->unmap = gtk_widget_real_unmap;
+  klass->realize = gtk_widget_real_realize;
+  klass->unrealize = gtk_widget_real_unrealize;
+  klass->draw = gtk_widget_real_draw;
+  klass->draw_focus = NULL;
+  klass->size_request = gtk_widget_real_size_request;
+  klass->size_allocate = gtk_widget_real_size_allocate;
+  klass->state_changed = NULL;
+  klass->parent_set = NULL;
+  klass->style_set = gtk_widget_style_set;
+  klass->add_accelerator = (void*) gtk_accel_group_handle_add;
+  klass->remove_accelerator = (void*) gtk_accel_group_handle_remove;
+  klass->grab_focus = gtk_widget_real_grab_focus;
+  klass->event = NULL;
+  klass->button_press_event = NULL;
+  klass->button_release_event = NULL;
+  klass->motion_notify_event = NULL;
+  klass->delete_event = NULL;
+  klass->destroy_event = NULL;
+  klass->expose_event = NULL;
+  klass->key_press_event = gtk_widget_real_key_press_event;
+  klass->key_release_event = gtk_widget_real_key_release_event;
+  klass->enter_notify_event = NULL;
+  klass->leave_notify_event = NULL;
+  klass->configure_event = NULL;
+  klass->focus_in_event = NULL;
+  klass->focus_out_event = NULL;
+  klass->map_event = NULL;
+  klass->unmap_event = NULL;
+  klass->property_notify_event = gtk_selection_property_notify;
+  klass->selection_clear_event = gtk_selection_clear;
+  klass->selection_request_event = gtk_selection_request;
+  klass->selection_notify_event = gtk_selection_notify;
+  klass->selection_received = NULL;
+  klass->proximity_in_event = NULL;
+  klass->proximity_out_event = NULL;
+  klass->drag_begin = NULL;
+  klass->drag_end = NULL;
+  klass->drag_data_delete = NULL;
+  klass->drag_leave = NULL;
+  klass->drag_motion = NULL;
+  klass->drag_drop = NULL;
+  klass->drag_data_received = NULL;
+
+  klass->no_expose_event = NULL;
+
+  klass->debug_msg = gtk_widget_debug_msg;
   
   gtk_object_add_arg_type ("GtkWidget::name", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_NAME);
   gtk_object_add_arg_type ("GtkWidget::parent", GTK_TYPE_CONTAINER, GTK_ARG_READWRITE, ARG_PARENT);
@@ -293,49 +354,49 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[SHOW] =
     gtk_signal_new ("show",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, show),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   widget_signals[HIDE] =
     gtk_signal_new ("hide",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, hide),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   widget_signals[MAP] =
     gtk_signal_new ("map",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, map),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   widget_signals[UNMAP] =
     gtk_signal_new ("unmap",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   widget_signals[REALIZE] =
     gtk_signal_new ("realize",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, realize),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   widget_signals[UNREALIZE] =
     gtk_signal_new ("unrealize",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, unrealize),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   widget_signals[DRAW] =
     gtk_signal_new ("draw",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, draw),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -343,21 +404,21 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DRAW_FOCUS] =
     gtk_signal_new ("draw_focus",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_focus),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   widget_signals[DRAW_DEFAULT] =
     gtk_signal_new ("draw_default",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, draw_default),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   widget_signals[SIZE_REQUEST] =
     gtk_signal_new ("size_request",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, size_request),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -365,7 +426,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[SIZE_ALLOCATE] =
     gtk_signal_new ("size_allocate",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, size_allocate),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -373,7 +434,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[STATE_CHANGED] =
     gtk_signal_new ("state_changed",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, state_changed),
 		    gtk_marshal_NONE__UINT,
 		    GTK_TYPE_NONE, 1,
@@ -381,7 +442,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[PARENT_SET] =
     gtk_signal_new ("parent_set",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, parent_set),
 		    gtk_marshal_NONE__OBJECT,
 		    GTK_TYPE_NONE, 1,
@@ -389,28 +450,28 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[STYLE_SET] =
     gtk_signal_new ("style_set",
 		    GTK_RUN_FIRST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, style_set),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
 		    GTK_TYPE_STYLE);
   widget_signals[ADD_ACCELERATOR] =
-    gtk_accel_group_create_add (object_class->type, GTK_RUN_LAST,
+    gtk_accel_group_create_add (GTK_CLASS_TYPE (object_class), GTK_RUN_LAST,
 				GTK_SIGNAL_OFFSET (GtkWidgetClass, add_accelerator));
   widget_signals[REMOVE_ACCELERATOR] =
-    gtk_accel_group_create_remove (object_class->type, GTK_RUN_LAST,
+    gtk_accel_group_create_remove (GTK_CLASS_TYPE (object_class), GTK_RUN_LAST,
 				   GTK_SIGNAL_OFFSET (GtkWidgetClass, remove_accelerator));
   widget_signals[GRAB_FOCUS] =
     gtk_signal_new ("grab_focus",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, grab_focus),
 		    gtk_marshal_NONE__NONE,
 		    GTK_TYPE_NONE, 0);
   widget_signals[EVENT] =
     gtk_signal_new ("event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -418,7 +479,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[BUTTON_PRESS_EVENT] =
     gtk_signal_new ("button_press_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, button_press_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -426,7 +487,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[BUTTON_RELEASE_EVENT] =
     gtk_signal_new ("button_release_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, button_release_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -434,7 +495,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[SCROLL_EVENT] =
     gtk_signal_new ("scroll_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, scroll_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -442,7 +503,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[MOTION_NOTIFY_EVENT] =
     gtk_signal_new ("motion_notify_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, motion_notify_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -450,7 +511,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DELETE_EVENT] =
     gtk_signal_new ("delete_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, delete_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -458,7 +519,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DESTROY_EVENT] =
     gtk_signal_new ("destroy_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, destroy_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -466,7 +527,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[EXPOSE_EVENT] =
     gtk_signal_new ("expose_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, expose_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -474,7 +535,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[KEY_PRESS_EVENT] =
     gtk_signal_new ("key_press_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, key_press_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -482,7 +543,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[KEY_RELEASE_EVENT] =
     gtk_signal_new ("key_release_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, key_release_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -490,7 +551,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[ENTER_NOTIFY_EVENT] =
     gtk_signal_new ("enter_notify_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, enter_notify_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -498,7 +559,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[LEAVE_NOTIFY_EVENT] =
     gtk_signal_new ("leave_notify_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, leave_notify_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -506,7 +567,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[CONFIGURE_EVENT] =
     gtk_signal_new ("configure_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, configure_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -514,7 +575,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[FOCUS_IN_EVENT] =
     gtk_signal_new ("focus_in_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_in_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -522,7 +583,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[FOCUS_OUT_EVENT] =
     gtk_signal_new ("focus_out_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, focus_out_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -530,7 +591,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[MAP_EVENT] =
     gtk_signal_new ("map_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, map_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -538,7 +599,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[UNMAP_EVENT] =
     gtk_signal_new ("unmap_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, unmap_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -546,7 +607,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[PROPERTY_NOTIFY_EVENT] =
     gtk_signal_new ("property_notify_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, property_notify_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -554,7 +615,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[SELECTION_CLEAR_EVENT] =
     gtk_signal_new ("selection_clear_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_clear_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -562,7 +623,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[SELECTION_REQUEST_EVENT] =
     gtk_signal_new ("selection_request_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_request_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -570,7 +631,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[SELECTION_NOTIFY_EVENT] =
     gtk_signal_new ("selection_notify_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_notify_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -578,7 +639,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[SELECTION_RECEIVED] =
     gtk_signal_new ("selection_received",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_received),
 		    gtk_marshal_NONE__POINTER_UINT,
 		    GTK_TYPE_NONE, 2,
@@ -587,7 +648,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[SELECTION_GET] =
     gtk_signal_new ("selection_get",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, selection_get),
 		    gtk_marshal_NONE__POINTER_UINT_UINT,
 		    GTK_TYPE_NONE, 3,
@@ -597,7 +658,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[PROXIMITY_IN_EVENT] =
     gtk_signal_new ("proximity_in_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_in_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -605,7 +666,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[PROXIMITY_OUT_EVENT] =
     gtk_signal_new ("proximity_out_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, proximity_out_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -613,7 +674,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DRAG_LEAVE] =
     gtk_signal_new ("drag_leave",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_leave),
 		    gtk_marshal_NONE__POINTER_UINT,
 		    GTK_TYPE_NONE, 2,
@@ -622,7 +683,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DRAG_BEGIN] =
     gtk_signal_new ("drag_begin",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_begin),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -630,7 +691,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DRAG_END] =
     gtk_signal_new ("drag_end",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_end),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -638,7 +699,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DRAG_DATA_DELETE] =
     gtk_signal_new ("drag_data_delete",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_delete),
 		    gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -646,7 +707,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DRAG_MOTION] =
     gtk_signal_new ("drag_motion",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_motion),
 		    gtk_marshal_BOOL__POINTER_INT_INT_UINT,
 		    GTK_TYPE_BOOL, 4,
@@ -657,7 +718,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DRAG_DROP] =
     gtk_signal_new ("drag_drop",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_drop),
 		    gtk_marshal_BOOL__POINTER_INT_INT_UINT,
 		    GTK_TYPE_BOOL, 4,
@@ -668,7 +729,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DRAG_DATA_GET] =
     gtk_signal_new ("drag_data_get",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_get),
 		    gtk_marshal_NONE__POINTER_POINTER_UINT_UINT,
 		    GTK_TYPE_NONE, 4,
@@ -679,7 +740,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DRAG_DATA_RECEIVED] =
     gtk_signal_new ("drag_data_received",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, drag_data_received),
 		    gtk_marshal_NONE__POINTER_INT_INT_POINTER_UINT_UINT,
 		    GTK_TYPE_NONE, 6,
@@ -692,7 +753,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[VISIBILITY_NOTIFY_EVENT] =
     gtk_signal_new ("visibility_notify_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, visibility_notify_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -700,7 +761,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[CLIENT_EVENT] =
     gtk_signal_new ("client_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, client_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -708,7 +769,7 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[NO_EXPOSE_EVENT] =
     gtk_signal_new ("no_expose_event",
 		    GTK_RUN_LAST,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, no_expose_event),
 		    gtk_marshal_BOOL__POINTER,
 		    GTK_TYPE_BOOL, 1,
@@ -716,74 +777,13 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   widget_signals[DEBUG_MSG] =
     gtk_signal_new ("debug_msg",
 		    GTK_RUN_LAST | GTK_RUN_ACTION,
-		    object_class->type,
+		    GTK_CLASS_TYPE (object_class),
 		    GTK_SIGNAL_OFFSET (GtkWidgetClass, debug_msg),
 		    gtk_marshal_NONE__STRING,
 		    GTK_TYPE_NONE, 1,
 		    GTK_TYPE_STRING);
 
   gtk_object_class_add_signals (object_class, widget_signals, LAST_SIGNAL);
-
-  object_class->set_arg = gtk_widget_set_arg;
-  object_class->get_arg = gtk_widget_get_arg;
-  object_class->shutdown = gtk_widget_shutdown;
-  object_class->destroy = gtk_widget_real_destroy;
-  object_class->finalize = gtk_widget_finalize;
-  
-  klass->activate_signal = 0;
-  klass->set_scroll_adjustments_signal = 0;
-  klass->show = gtk_widget_real_show;
-  klass->show_all = gtk_widget_show;
-  klass->hide = gtk_widget_real_hide;
-  klass->hide_all = gtk_widget_hide;
-  klass->map = gtk_widget_real_map;
-  klass->unmap = gtk_widget_real_unmap;
-  klass->realize = gtk_widget_real_realize;
-  klass->unrealize = gtk_widget_real_unrealize;
-  klass->draw = gtk_widget_real_draw;
-  klass->draw_focus = NULL;
-  klass->size_request = gtk_widget_real_size_request;
-  klass->size_allocate = gtk_widget_real_size_allocate;
-  klass->state_changed = NULL;
-  klass->parent_set = NULL;
-  klass->style_set = gtk_widget_style_set;
-  klass->add_accelerator = (void*) gtk_accel_group_handle_add;
-  klass->remove_accelerator = (void*) gtk_accel_group_handle_remove;
-  klass->grab_focus = gtk_widget_real_grab_focus;
-  klass->event = NULL;
-  klass->button_press_event = NULL;
-  klass->button_release_event = NULL;
-  klass->motion_notify_event = NULL;
-  klass->delete_event = NULL;
-  klass->destroy_event = NULL;
-  klass->expose_event = NULL;
-  klass->key_press_event = gtk_widget_real_key_press_event;
-  klass->key_release_event = gtk_widget_real_key_release_event;
-  klass->enter_notify_event = NULL;
-  klass->leave_notify_event = NULL;
-  klass->configure_event = NULL;
-  klass->focus_in_event = NULL;
-  klass->focus_out_event = NULL;
-  klass->map_event = NULL;
-  klass->unmap_event = NULL;
-  klass->property_notify_event = gtk_selection_property_notify;
-  klass->selection_clear_event = gtk_selection_clear;
-  klass->selection_request_event = gtk_selection_request;
-  klass->selection_notify_event = gtk_selection_notify;
-  klass->selection_received = NULL;
-  klass->proximity_in_event = NULL;
-  klass->proximity_out_event = NULL;
-  klass->drag_begin = NULL;
-  klass->drag_end = NULL;
-  klass->drag_data_delete = NULL;
-  klass->drag_leave = NULL;
-  klass->drag_motion = NULL;
-  klass->drag_drop = NULL;
-  klass->drag_data_received = NULL;
-
-  klass->no_expose_event = NULL;
-
-  klass->debug_msg = gtk_widget_debug_msg;
 }
 
 static void
@@ -1553,7 +1553,7 @@ gtk_widget_show_all (GtkWidget *widget)
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_WIDGET (widget));
 
-  class = GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass);
+  class = GTK_WIDGET_GET_CLASS (widget);
 
   if (class->show_all)
     class->show_all (widget);
@@ -1567,7 +1567,7 @@ gtk_widget_hide_all (GtkWidget *widget)
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_WIDGET (widget));
 
-  class = GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass);
+  class = GTK_WIDGET_GET_CLASS (widget);
 
   if (class->hide_all)
     class->hide_all (widget);
@@ -2691,7 +2691,7 @@ gtk_widget_grab_default (GtkWidget *widget)
   g_return_if_fail (GTK_IS_WIDGET (widget));
   g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (widget));
   
-  window_type = gtk_window_get_type ();
+  window_type = GTK_TYPE_WINDOW;
   window = widget->parent;
   
   while (window && !gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
@@ -3888,13 +3888,9 @@ gtk_widget_get_default_visual (void)
 }
 
 static void
-gtk_widget_shutdown (GtkObject *object)
+gtk_widget_shutdown (GObject *object)
 {
-  GtkWidget *widget;
-  
-  /* gtk_object_destroy() will already hold a refcount on object
-   */
-  widget = GTK_WIDGET (object);
+  GtkWidget *widget = GTK_WIDGET (object);
 
   if (widget->parent)
     gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
@@ -3903,7 +3899,7 @@ gtk_widget_shutdown (GtkObject *object)
   if (GTK_WIDGET_REALIZED (widget))
     gtk_widget_unrealize (widget);
   
-  parent_class->shutdown (object);
+  G_OBJECT_CLASS (parent_class)->shutdown (object);
 }
 
 static void
@@ -3927,21 +3923,34 @@ gtk_widget_real_destroy (GtkObject *object)
     }
 
   gtk_style_unref (widget->style);
-  widget->style = NULL;
+  widget->style = gtk_widget_peek_style ();
+  gtk_style_ref (widget->style);
 
-  parent_class->destroy (object);
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 static void
-gtk_widget_finalize (GtkObject *object)
+gtk_widget_finalize (GObject *object)
 {
-  GtkWidget *widget;
+  GtkWidget *widget = GTK_WIDGET (object);
   GtkWidgetAuxInfo *aux_info;
   gint *events;
   GdkExtensionMode *mode;
+  GtkStyle *saved_style;
   
-  widget = GTK_WIDGET (object);
-  
+  gtk_grab_remove (widget);
+  gtk_selection_remove_all (widget);
+
+  saved_style = gtk_object_get_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id);
+  if (saved_style)
+    {
+      gtk_style_unref (saved_style);
+      gtk_object_remove_data_by_id (GTK_OBJECT (widget), saved_default_style_key_id);
+    }
+
+  gtk_style_unref (widget->style);
+  widget->style = NULL;
+
   if (widget->name)
     g_free (widget->name);
   
@@ -3957,7 +3966,7 @@ gtk_widget_finalize (GtkObject *object)
   if (mode)
     g_free (mode);
 
-  parent_class->finalize (object);
+  G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 /*****************************************
@@ -4194,7 +4203,7 @@ gtk_widget_propagate_state (GtkWidget           *widget,
     {
       GtkWidget *window;
 
-      window = gtk_widget_get_ancestor (widget, gtk_window_get_type ());
+      window = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
       if (window)
 	gtk_window_set_focus (GTK_WINDOW (window), NULL);
     }
@@ -4375,22 +4384,20 @@ gtk_widget_reset_shapes (GtkWidget *widget)
     gtk_reset_shapes_recurse (widget, widget->window);
 }
 
-void
+GtkWidget*
 gtk_widget_ref (GtkWidget *widget)
 {
-  g_return_if_fail (widget != NULL);
-  g_return_if_fail (GTK_IS_WIDGET (widget));
+  g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
 
-  gtk_object_ref ((GtkObject*) widget);
+  return (GtkWidget*) g_object_ref ((GObject*) widget);
 }
 
 void
 gtk_widget_unref (GtkWidget *widget)
 {
-  g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_WIDGET (widget));
 
-  gtk_object_unref ((GtkObject*) widget);
+  g_object_unref ((GObject*) widget);
 }
 
 void
diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h
index 66568b422..2b2579ddb 100644
--- a/gtk/gtkwidget.h
+++ b/gtk/gtkwidget.h
@@ -409,7 +409,7 @@ GtkWidget* gtk_widget_new		  (GtkType		type,
 GtkWidget* gtk_widget_newv		  (GtkType		type,
 					   guint		nargs,
 					   GtkArg	       *args);
-void	   gtk_widget_ref		  (GtkWidget	       *widget);
+GtkWidget* gtk_widget_ref		  (GtkWidget	       *widget);
 void	   gtk_widget_unref		  (GtkWidget	       *widget);
 void	   gtk_widget_destroy		  (GtkWidget	       *widget);
 void	   gtk_widget_destroyed		  (GtkWidget	       *widget,
diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c
index b73814229..2cfc579cc 100644
--- a/gtk/gtkwindow.c
+++ b/gtk/gtkwindow.c
@@ -93,9 +93,9 @@ static void gtk_window_set_arg            (GtkObject         *object,
 static void gtk_window_get_arg            (GtkObject         *object,
 					   GtkArg            *arg,
 					   guint	      arg_id);
-static void gtk_window_shutdown           (GtkObject         *object);
+static void gtk_window_shutdown           (GObject           *object);
 static void gtk_window_destroy            (GtkObject         *object);
-static void gtk_window_finalize           (GtkObject         *object);
+static void gtk_window_finalize           (GObject           *object);
 static void gtk_window_show               (GtkWidget         *widget);
 static void gtk_window_hide               (GtkWidget         *widget);
 static void gtk_window_map                (GtkWidget         *widget);
@@ -167,8 +167,9 @@ static GtkWindowGeometryInfo* gtk_window_get_geometry_info (GtkWindow *window,
 							    gboolean   create);
 static void gtk_window_geometry_destroy  (GtkWindowGeometryInfo *info);
 
+static GSList      *toplevel_list = NULL;
 static GtkBinClass *parent_class = NULL;
-static guint window_signals[LAST_SIGNAL] = { 0 };
+static guint        window_signals[LAST_SIGNAL] = { 0 };
 
 
 GtkType
@@ -199,6 +200,7 @@ gtk_window_get_type (void)
 static void
 gtk_window_class_init (GtkWindowClass *klass)
 {
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;
@@ -209,6 +211,9 @@ gtk_window_class_init (GtkWindowClass *klass)
 
   parent_class = gtk_type_class (gtk_bin_get_type ());
 
+  gobject_class->shutdown = gtk_window_shutdown;
+  gobject_class->finalize = gtk_window_finalize;
+
   gtk_object_add_arg_type ("GtkWindow::type", GTK_TYPE_WINDOW_TYPE, GTK_ARG_READWRITE, ARG_TYPE);
   gtk_object_add_arg_type ("GtkWindow::title", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_TITLE);
   gtk_object_add_arg_type ("GtkWindow::auto_shrink", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_AUTO_SHRINK);
@@ -222,7 +227,7 @@ gtk_window_class_init (GtkWindowClass *klass)
   window_signals[SET_FOCUS] =
     gtk_signal_new ("set_focus",
                     GTK_RUN_LAST,
-                    object_class->type,
+                    GTK_CLASS_TYPE (object_class),
                     GTK_SIGNAL_OFFSET (GtkWindowClass, set_focus),
                     gtk_marshal_NONE__POINTER,
 		    GTK_TYPE_NONE, 1,
@@ -232,9 +237,7 @@ gtk_window_class_init (GtkWindowClass *klass)
 
   object_class->set_arg = gtk_window_set_arg;
   object_class->get_arg = gtk_window_get_arg;
-  object_class->shutdown = gtk_window_shutdown;
   object_class->destroy = gtk_window_destroy;
-  object_class->finalize = gtk_window_finalize;
 
   widget_class->show = gtk_window_show;
   widget_class->hide = gtk_window_hide;
@@ -282,8 +285,11 @@ gtk_window_init (GtkWindow *window)
   window->position = GTK_WIN_POS_NONE;
   window->use_uposition = TRUE;
   window->modal = FALSE;
-  
-  gtk_container_register_toplevel (GTK_CONTAINER (window));
+
+  gtk_widget_ref (GTK_WIDGET (window));
+  gtk_object_sink (GTK_OBJECT (window));
+  window->has_user_ref_count = TRUE;
+  toplevel_list = g_slist_prepend (toplevel_list, window);
 }
 
 static void
@@ -572,6 +578,18 @@ gtk_window_set_modal (GtkWindow *window,
     gtk_grab_remove (GTK_WIDGET (window));
 }
 
+GList*
+gtk_window_list_toplevels (void)
+{
+  GList *list = NULL;
+  GSList *slist;
+
+  for (slist = toplevel_list; slist; slist = slist->next)
+    list = g_list_prepend (list, gtk_widget_ref (slist->data));
+
+  return list;
+}
+
 void
 gtk_window_add_embedded_xid (GtkWindow *window, guint xid)
 {
@@ -649,11 +667,10 @@ gtk_window_reposition (GtkWindow *window,
 }
 
 static void
-gtk_window_shutdown (GtkObject *object)
+gtk_window_shutdown (GObject *object)
 {
   GtkWindow *window;
 
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_WINDOW (object));
 
   window = GTK_WINDOW (object);
@@ -661,7 +678,7 @@ gtk_window_shutdown (GtkObject *object)
   gtk_window_set_focus (window, NULL);
   gtk_window_set_default (window, NULL);
 
-  GTK_OBJECT_CLASS (parent_class)->shutdown (object);
+  G_OBJECT_CLASS (parent_class)->shutdown (object);
 }
 
 static void
@@ -831,33 +848,38 @@ gtk_window_destroy (GtkObject *object)
 {
   GtkWindow *window;
   
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_WINDOW (object));
 
   window = GTK_WINDOW (object);
-  
-  gtk_container_unregister_toplevel (GTK_CONTAINER (object));
 
   if (window->transient_parent)
     gtk_window_unset_transient_for (window);
 
+  if (window->has_user_ref_count)
+    {
+      window->has_user_ref_count = FALSE;
+      gtk_widget_unref (GTK_WIDGET (window));
+    }
+
   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 static void
-gtk_window_finalize (GtkObject *object)
+gtk_window_finalize (GObject *object)
 {
   GtkWindow *window;
 
-  g_return_if_fail (object != NULL);
   g_return_if_fail (GTK_IS_WINDOW (object));
 
   window = GTK_WINDOW (object);
+
+  toplevel_list = g_slist_remove (toplevel_list, window);
+
   g_free (window->title);
   g_free (window->wmclass_name);
   g_free (window->wmclass_class);
 
-  GTK_OBJECT_CLASS(parent_class)->finalize (object);
+  G_OBJECT_CLASS(parent_class)->finalize (object);
 }
 
 static void
@@ -1406,14 +1428,14 @@ gtk_window_read_rcfiles (GtkWidget *widget,
        * then, the RC file will up to date, so we have to tell
        * them now.
        */
-      GList *toplevels;
-      
-      toplevels = gtk_container_get_toplevels();
-      while (toplevels)
+      GList *list, *toplevels = gtk_window_list_toplevels ();
+
+      for (list = toplevels; list; list = list->next)
 	{
-	  gtk_widget_reset_rc_styles (toplevels->data);
-	  toplevels = toplevels->next;
+	  gtk_widget_reset_rc_styles (list->data);
+	  gtk_widget_unref (list->data);
 	}
+      g_list_free (toplevels);
     }
 }
 
diff --git a/gtk/gtkwindow.h b/gtk/gtkwindow.h
index 1bf69438f..219f4497d 100644
--- a/gtk/gtkwindow.h
+++ b/gtk/gtkwindow.h
@@ -64,6 +64,7 @@ struct _GtkWindow
   GtkWindow *transient_parent;
 
   gushort resize_count;
+  guint has_user_ref_count : 1;
   guint allow_shrink : 1;
   guint allow_grow : 1;
   guint auto_shrink : 1;
@@ -126,6 +127,8 @@ void       gtk_window_set_default_size         (GtkWindow           *window,
 /* If window is set modal, input will be grabbed when show and released when hide */
 void       gtk_window_set_modal                (GtkWindow           *window,
                                                 gboolean             modal);
+GList*	   gtk_window_list_toplevels	       (void);
+
 
 /* --- internal functions --- */
 void       gtk_window_set_focus                (GtkWindow           *window,
diff --git a/gtk/maketypes.awk b/gtk/maketypes.awk
index 33faec794..0c82cf3a2 100644
--- a/gtk/maketypes.awk
+++ b/gtk/maketypes.awk
@@ -124,5 +124,5 @@ function generate (generate_1)
 
 END {
   if (gen_macros)
-    printf("\n#define\tGTK_TYPE_NUM_BUILTINS\t(%u)\n", type_counter);
+    printf("\n#define\tGTK_TYPE_N_BUILTINS\t(%u)\n", type_counter);
 }
diff --git a/gtk/testdnd.c b/gtk/testdnd.c
index f258c1b97..203272996 100644
--- a/gtk/testdnd.c
+++ b/gtk/testdnd.c
@@ -311,9 +311,9 @@ target_drag_motion	   (GtkWidget	       *widget,
     }
 
   source_widget = gtk_drag_get_source_widget (context);
-  g_print("motion, source %s\n", source_widget ?
-	    gtk_type_name (GTK_OBJECT (source_widget)->klass->type) :
-	    "unknown");
+  g_print ("motion, source %s\n", source_widget ?
+	   GTK_OBJECT_TYPE_NAME (source_widget) :
+	   "NULL");
 
   gdk_drag_status (context, context->suggested_action, time);
   return TRUE;
diff --git a/gtk/testgtk.c b/gtk/testgtk.c
index 7a431e9d9..56dc6cb13 100644
--- a/gtk/testgtk.c
+++ b/gtk/testgtk.c
@@ -3290,7 +3290,7 @@ set_cursor (GtkWidget *spinner,
   guint c;
   GdkCursor *cursor;
   GtkWidget *label;
-  GtkFlagValue *vals;
+  GtkEnumValue *vals;
 
   c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
   c &= 0xfe;
@@ -5660,13 +5660,11 @@ create_rulers (void)
       gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
       gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
 
-      gtk_signal_connect_object (
-        GTK_OBJECT (window), 
-	"motion_notify_event",
-	GTK_SIGNAL_FUNC(
-          GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
-	GTK_OBJECT (ruler));
-
+      gtk_signal_connect_object (GTK_OBJECT (window), 
+				 "motion_notify_event",
+				 GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+				 GTK_OBJECT (ruler));
+      
       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
 			GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
       gtk_widget_show (ruler);
@@ -5675,12 +5673,11 @@ create_rulers (void)
       ruler = gtk_vruler_new ();
       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
 
-      gtk_signal_connect_object (
-        GTK_OBJECT (window), 
-	"motion_notify_event",
-	GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
-	GTK_OBJECT (ruler));
-
+      gtk_signal_connect_object (GTK_OBJECT (window), 
+				 "motion_notify_event",
+				 GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+				 GTK_OBJECT (ruler));
+      
       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
 			GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
       gtk_widget_show (ruler);
diff --git a/tests/testdnd.c b/tests/testdnd.c
index f258c1b97..203272996 100644
--- a/tests/testdnd.c
+++ b/tests/testdnd.c
@@ -311,9 +311,9 @@ target_drag_motion	   (GtkWidget	       *widget,
     }
 
   source_widget = gtk_drag_get_source_widget (context);
-  g_print("motion, source %s\n", source_widget ?
-	    gtk_type_name (GTK_OBJECT (source_widget)->klass->type) :
-	    "unknown");
+  g_print ("motion, source %s\n", source_widget ?
+	   GTK_OBJECT_TYPE_NAME (source_widget) :
+	   "NULL");
 
   gdk_drag_status (context, context->suggested_action, time);
   return TRUE;
diff --git a/tests/testgtk.c b/tests/testgtk.c
index 7a431e9d9..56dc6cb13 100644
--- a/tests/testgtk.c
+++ b/tests/testgtk.c
@@ -3290,7 +3290,7 @@ set_cursor (GtkWidget *spinner,
   guint c;
   GdkCursor *cursor;
   GtkWidget *label;
-  GtkFlagValue *vals;
+  GtkEnumValue *vals;
 
   c = CLAMP (gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spinner)), 0, 152);
   c &= 0xfe;
@@ -5660,13 +5660,11 @@ create_rulers (void)
       gtk_ruler_set_metric (GTK_RULER (ruler), GTK_CENTIMETERS);
       gtk_ruler_set_range (GTK_RULER (ruler), 100, 0, 0, 20);
 
-      gtk_signal_connect_object (
-        GTK_OBJECT (window), 
-	"motion_notify_event",
-	GTK_SIGNAL_FUNC(
-          GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
-	GTK_OBJECT (ruler));
-
+      gtk_signal_connect_object (GTK_OBJECT (window), 
+				 "motion_notify_event",
+				 GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+				 GTK_OBJECT (ruler));
+      
       gtk_table_attach (GTK_TABLE (table), ruler, 1, 2, 0, 1,
 			GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
       gtk_widget_show (ruler);
@@ -5675,12 +5673,11 @@ create_rulers (void)
       ruler = gtk_vruler_new ();
       gtk_ruler_set_range (GTK_RULER (ruler), 5, 15, 0, 20);
 
-      gtk_signal_connect_object (
-        GTK_OBJECT (window), 
-	"motion_notify_event",
-	GTK_SIGNAL_FUNC (GTK_WIDGET_CLASS (GTK_OBJECT (ruler)->klass)->motion_notify_event),
-	GTK_OBJECT (ruler));
-
+      gtk_signal_connect_object (GTK_OBJECT (window), 
+				 "motion_notify_event",
+				 GTK_SIGNAL_FUNC (GTK_WIDGET_GET_CLASS (ruler)->motion_notify_event),
+				 GTK_OBJECT (ruler));
+      
       gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 2,
 			GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
       gtk_widget_show (ruler);