added a frame with radio buttons to select the resize_mode for the

Wed Jun 24 07:47:29 1998  Tim Janik  <timj@gtk.org>

        * gtk/testgtk.c (create_idle_test): added a frame with radio buttons
        to select the resize_mode for the idle-labels container.

        * gtk/gtkframe.h:
        * gtk/gtkframe.c: GtkType and macro corrections.

        * gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
        support radio grouping.

Tue Jun 23 08:01:09 1998  Tim Janik  <timj@gtk.org>

        * gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
        unconditionally if resize_mode has changed.

        * gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
        GTK_RESIZE_QUEUE on the scrolled window.
        (gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.

Tue Jun 23 04:20:30 1998  Tim Janik  <timj@gtk.org>

        * gtk/gtkcontainer.h:
        * gtk/gtkcontainer.c:
        (GTK_IS_RESIZE_CONTAINER): new macro to find out if
        a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
        (gtk_container_queue_resize): new function to queue a container for
        a *size* reallocation (doesn't affect its position, and thus its
        parent is left untouched usually).
        (gtk_container_get_resize_container): new function to retrive the next
        most resize container which is not itself queued for a resize.
        (gtk_container_idle_sizer): new function to carefully process the
        container_resize_queue since it can change during invokation of
        gtk_container_check_resize().
        (gtk_container_resize_children): total rework of this function to
        properly handle resize containers. makes a lot of assumptions whitch
        are stated in the comments.

        * gtk/gtkcontainer.c:
        (gtk_container_real_check_resize): only requeue ourselves if we are not
        a resize container.
        (gtk_container_clear_resize_widgets): care for automatic deletion of our
        resize_widgets list on size_allocate through a handler connection.

        * gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
        focus and default widget of a window, so to take the burden from
        gtk_widget_unparent.

        * gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
        to be clever, but actually messed up the resize_children logic and
        caused unneccessary allocations on its whole branch. besides this,
        it messed up the display by not invoking a redraw after the allocation.

        * gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
        that it is the child again that is queued for a resize.
        (gtk_table_attach): likewise.
        (gtk_table_remove): likewise.

25 files changed, 963 insertions, 274 deletions

diff --git a/ChangeLog b/ChangeLog
index afaecc84fd..153476a55a 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -2,6 +2,64 @@ Tue Jun 23 22:21:33 PDT 1998 Manish Singh <yosh@gimp.org>
 
 	* gtk-boxed.defs: s/GkWidget/GtkWidget/
 
+Wed Jun 24 07:47:29 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+	to select the resize_mode for the idle-labels container.
+
+	* gtk/gtkframe.h: 
+	* gtk/gtkframe.c: GtkType and macro corrections.
+
+	* gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ 	support radio grouping.
+
+Tue Jun 23 08:01:09 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+	unconditionally if resize_mode has changed.
+
+	* gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ 	GTK_RESIZE_QUEUE on the scrolled window.
+	(gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.h:
+	* gtk/gtkcontainer.c:
+ 	(GTK_IS_RESIZE_CONTAINER): new macro to find out if
+	a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+	(gtk_container_queue_resize): new function to queue a container for
+	a *size* reallocation (doesn't affect its position, and thus its
+	parent is left untouched usually).
+	(gtk_container_get_resize_container): new function to retrive the next
+	most resize container which is not itself queued for a resize.
+	(gtk_container_idle_sizer): new function to carefully process the
+ 	container_resize_queue since it can change during invokation of
+ 	gtk_container_check_resize().
+	(gtk_container_resize_children): total rework of this function to
+	properly handle resize containers. makes a lot of assumptions whitch
+	are stated in the comments.
+
+	* gtk/gtkcontainer.c:
+ 	(gtk_container_real_check_resize): only requeue ourselves if we are not
+ 	a resize container.
+	(gtk_container_clear_resize_widgets): care for automatic deletion of our
+	resize_widgets list on size_allocate through a handler connection.
+
+	* gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ 	focus and default widget of a window, so to take the burden from
+	gtk_widget_unparent.
+
+	* gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+	to be clever, but actually messed up the resize_children logic and
+	caused unneccessary allocations on its whole branch. besides this,
+	it messed up the display by not invoking a redraw after the allocation.
+
+	* gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ 	that it is the child again that is queued for a resize.
+	(gtk_table_attach): likewise.
+	(gtk_table_remove): likewise.
+
 1998-06-22  Miguel de Icaza  <miguel@nuclecu.unam.mx>
 
 	* gtk/gtkentry.h, gtk/gtkentry.c: Export the
diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0
index afaecc84fd..153476a55a 100644
--- a/ChangeLog.pre-2-0
+++ b/ChangeLog.pre-2-0
@@ -2,6 +2,64 @@ Tue Jun 23 22:21:33 PDT 1998 Manish Singh <yosh@gimp.org>
 
 	* gtk-boxed.defs: s/GkWidget/GtkWidget/
 
+Wed Jun 24 07:47:29 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+	to select the resize_mode for the idle-labels container.
+
+	* gtk/gtkframe.h: 
+	* gtk/gtkframe.c: GtkType and macro corrections.
+
+	* gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ 	support radio grouping.
+
+Tue Jun 23 08:01:09 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+	unconditionally if resize_mode has changed.
+
+	* gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ 	GTK_RESIZE_QUEUE on the scrolled window.
+	(gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.h:
+	* gtk/gtkcontainer.c:
+ 	(GTK_IS_RESIZE_CONTAINER): new macro to find out if
+	a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+	(gtk_container_queue_resize): new function to queue a container for
+	a *size* reallocation (doesn't affect its position, and thus its
+	parent is left untouched usually).
+	(gtk_container_get_resize_container): new function to retrive the next
+	most resize container which is not itself queued for a resize.
+	(gtk_container_idle_sizer): new function to carefully process the
+ 	container_resize_queue since it can change during invokation of
+ 	gtk_container_check_resize().
+	(gtk_container_resize_children): total rework of this function to
+	properly handle resize containers. makes a lot of assumptions whitch
+	are stated in the comments.
+
+	* gtk/gtkcontainer.c:
+ 	(gtk_container_real_check_resize): only requeue ourselves if we are not
+ 	a resize container.
+	(gtk_container_clear_resize_widgets): care for automatic deletion of our
+	resize_widgets list on size_allocate through a handler connection.
+
+	* gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ 	focus and default widget of a window, so to take the burden from
+	gtk_widget_unparent.
+
+	* gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+	to be clever, but actually messed up the resize_children logic and
+	caused unneccessary allocations on its whole branch. besides this,
+	it messed up the display by not invoking a redraw after the allocation.
+
+	* gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ 	that it is the child again that is queued for a resize.
+	(gtk_table_attach): likewise.
+	(gtk_table_remove): likewise.
+
 1998-06-22  Miguel de Icaza  <miguel@nuclecu.unam.mx>
 
 	* gtk/gtkentry.h, gtk/gtkentry.c: Export the
diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10
index afaecc84fd..153476a55a 100644
--- a/ChangeLog.pre-2-10
+++ b/ChangeLog.pre-2-10
@@ -2,6 +2,64 @@ Tue Jun 23 22:21:33 PDT 1998 Manish Singh <yosh@gimp.org>
 
 	* gtk-boxed.defs: s/GkWidget/GtkWidget/
 
+Wed Jun 24 07:47:29 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+	to select the resize_mode for the idle-labels container.
+
+	* gtk/gtkframe.h: 
+	* gtk/gtkframe.c: GtkType and macro corrections.
+
+	* gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ 	support radio grouping.
+
+Tue Jun 23 08:01:09 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+	unconditionally if resize_mode has changed.
+
+	* gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ 	GTK_RESIZE_QUEUE on the scrolled window.
+	(gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.h:
+	* gtk/gtkcontainer.c:
+ 	(GTK_IS_RESIZE_CONTAINER): new macro to find out if
+	a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+	(gtk_container_queue_resize): new function to queue a container for
+	a *size* reallocation (doesn't affect its position, and thus its
+	parent is left untouched usually).
+	(gtk_container_get_resize_container): new function to retrive the next
+	most resize container which is not itself queued for a resize.
+	(gtk_container_idle_sizer): new function to carefully process the
+ 	container_resize_queue since it can change during invokation of
+ 	gtk_container_check_resize().
+	(gtk_container_resize_children): total rework of this function to
+	properly handle resize containers. makes a lot of assumptions whitch
+	are stated in the comments.
+
+	* gtk/gtkcontainer.c:
+ 	(gtk_container_real_check_resize): only requeue ourselves if we are not
+ 	a resize container.
+	(gtk_container_clear_resize_widgets): care for automatic deletion of our
+	resize_widgets list on size_allocate through a handler connection.
+
+	* gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ 	focus and default widget of a window, so to take the burden from
+	gtk_widget_unparent.
+
+	* gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+	to be clever, but actually messed up the resize_children logic and
+	caused unneccessary allocations on its whole branch. besides this,
+	it messed up the display by not invoking a redraw after the allocation.
+
+	* gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ 	that it is the child again that is queued for a resize.
+	(gtk_table_attach): likewise.
+	(gtk_table_remove): likewise.
+
 1998-06-22  Miguel de Icaza  <miguel@nuclecu.unam.mx>
 
 	* gtk/gtkentry.h, gtk/gtkentry.c: Export the
diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2
index afaecc84fd..153476a55a 100644
--- a/ChangeLog.pre-2-2
+++ b/ChangeLog.pre-2-2
@@ -2,6 +2,64 @@ Tue Jun 23 22:21:33 PDT 1998 Manish Singh <yosh@gimp.org>
 
 	* gtk-boxed.defs: s/GkWidget/GtkWidget/
 
+Wed Jun 24 07:47:29 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+	to select the resize_mode for the idle-labels container.
+
+	* gtk/gtkframe.h: 
+	* gtk/gtkframe.c: GtkType and macro corrections.
+
+	* gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ 	support radio grouping.
+
+Tue Jun 23 08:01:09 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+	unconditionally if resize_mode has changed.
+
+	* gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ 	GTK_RESIZE_QUEUE on the scrolled window.
+	(gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.h:
+	* gtk/gtkcontainer.c:
+ 	(GTK_IS_RESIZE_CONTAINER): new macro to find out if
+	a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+	(gtk_container_queue_resize): new function to queue a container for
+	a *size* reallocation (doesn't affect its position, and thus its
+	parent is left untouched usually).
+	(gtk_container_get_resize_container): new function to retrive the next
+	most resize container which is not itself queued for a resize.
+	(gtk_container_idle_sizer): new function to carefully process the
+ 	container_resize_queue since it can change during invokation of
+ 	gtk_container_check_resize().
+	(gtk_container_resize_children): total rework of this function to
+	properly handle resize containers. makes a lot of assumptions whitch
+	are stated in the comments.
+
+	* gtk/gtkcontainer.c:
+ 	(gtk_container_real_check_resize): only requeue ourselves if we are not
+ 	a resize container.
+	(gtk_container_clear_resize_widgets): care for automatic deletion of our
+	resize_widgets list on size_allocate through a handler connection.
+
+	* gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ 	focus and default widget of a window, so to take the burden from
+	gtk_widget_unparent.
+
+	* gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+	to be clever, but actually messed up the resize_children logic and
+	caused unneccessary allocations on its whole branch. besides this,
+	it messed up the display by not invoking a redraw after the allocation.
+
+	* gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ 	that it is the child again that is queued for a resize.
+	(gtk_table_attach): likewise.
+	(gtk_table_remove): likewise.
+
 1998-06-22  Miguel de Icaza  <miguel@nuclecu.unam.mx>
 
 	* gtk/gtkentry.h, gtk/gtkentry.c: Export the
diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4
index afaecc84fd..153476a55a 100644
--- a/ChangeLog.pre-2-4
+++ b/ChangeLog.pre-2-4
@@ -2,6 +2,64 @@ Tue Jun 23 22:21:33 PDT 1998 Manish Singh <yosh@gimp.org>
 
 	* gtk-boxed.defs: s/GkWidget/GtkWidget/
 
+Wed Jun 24 07:47:29 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+	to select the resize_mode for the idle-labels container.
+
+	* gtk/gtkframe.h: 
+	* gtk/gtkframe.c: GtkType and macro corrections.
+
+	* gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ 	support radio grouping.
+
+Tue Jun 23 08:01:09 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+	unconditionally if resize_mode has changed.
+
+	* gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ 	GTK_RESIZE_QUEUE on the scrolled window.
+	(gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.h:
+	* gtk/gtkcontainer.c:
+ 	(GTK_IS_RESIZE_CONTAINER): new macro to find out if
+	a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+	(gtk_container_queue_resize): new function to queue a container for
+	a *size* reallocation (doesn't affect its position, and thus its
+	parent is left untouched usually).
+	(gtk_container_get_resize_container): new function to retrive the next
+	most resize container which is not itself queued for a resize.
+	(gtk_container_idle_sizer): new function to carefully process the
+ 	container_resize_queue since it can change during invokation of
+ 	gtk_container_check_resize().
+	(gtk_container_resize_children): total rework of this function to
+	properly handle resize containers. makes a lot of assumptions whitch
+	are stated in the comments.
+
+	* gtk/gtkcontainer.c:
+ 	(gtk_container_real_check_resize): only requeue ourselves if we are not
+ 	a resize container.
+	(gtk_container_clear_resize_widgets): care for automatic deletion of our
+	resize_widgets list on size_allocate through a handler connection.
+
+	* gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ 	focus and default widget of a window, so to take the burden from
+	gtk_widget_unparent.
+
+	* gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+	to be clever, but actually messed up the resize_children logic and
+	caused unneccessary allocations on its whole branch. besides this,
+	it messed up the display by not invoking a redraw after the allocation.
+
+	* gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ 	that it is the child again that is queued for a resize.
+	(gtk_table_attach): likewise.
+	(gtk_table_remove): likewise.
+
 1998-06-22  Miguel de Icaza  <miguel@nuclecu.unam.mx>
 
 	* gtk/gtkentry.h, gtk/gtkentry.c: Export the
diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6
index afaecc84fd..153476a55a 100644
--- a/ChangeLog.pre-2-6
+++ b/ChangeLog.pre-2-6
@@ -2,6 +2,64 @@ Tue Jun 23 22:21:33 PDT 1998 Manish Singh <yosh@gimp.org>
 
 	* gtk-boxed.defs: s/GkWidget/GtkWidget/
 
+Wed Jun 24 07:47:29 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+	to select the resize_mode for the idle-labels container.
+
+	* gtk/gtkframe.h: 
+	* gtk/gtkframe.c: GtkType and macro corrections.
+
+	* gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ 	support radio grouping.
+
+Tue Jun 23 08:01:09 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+	unconditionally if resize_mode has changed.
+
+	* gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ 	GTK_RESIZE_QUEUE on the scrolled window.
+	(gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.h:
+	* gtk/gtkcontainer.c:
+ 	(GTK_IS_RESIZE_CONTAINER): new macro to find out if
+	a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+	(gtk_container_queue_resize): new function to queue a container for
+	a *size* reallocation (doesn't affect its position, and thus its
+	parent is left untouched usually).
+	(gtk_container_get_resize_container): new function to retrive the next
+	most resize container which is not itself queued for a resize.
+	(gtk_container_idle_sizer): new function to carefully process the
+ 	container_resize_queue since it can change during invokation of
+ 	gtk_container_check_resize().
+	(gtk_container_resize_children): total rework of this function to
+	properly handle resize containers. makes a lot of assumptions whitch
+	are stated in the comments.
+
+	* gtk/gtkcontainer.c:
+ 	(gtk_container_real_check_resize): only requeue ourselves if we are not
+ 	a resize container.
+	(gtk_container_clear_resize_widgets): care for automatic deletion of our
+	resize_widgets list on size_allocate through a handler connection.
+
+	* gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ 	focus and default widget of a window, so to take the burden from
+	gtk_widget_unparent.
+
+	* gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+	to be clever, but actually messed up the resize_children logic and
+	caused unneccessary allocations on its whole branch. besides this,
+	it messed up the display by not invoking a redraw after the allocation.
+
+	* gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ 	that it is the child again that is queued for a resize.
+	(gtk_table_attach): likewise.
+	(gtk_table_remove): likewise.
+
 1998-06-22  Miguel de Icaza  <miguel@nuclecu.unam.mx>
 
 	* gtk/gtkentry.h, gtk/gtkentry.c: Export the
diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8
index afaecc84fd..153476a55a 100644
--- a/ChangeLog.pre-2-8
+++ b/ChangeLog.pre-2-8
@@ -2,6 +2,64 @@ Tue Jun 23 22:21:33 PDT 1998 Manish Singh <yosh@gimp.org>
 
 	* gtk-boxed.defs: s/GkWidget/GtkWidget/
 
+Wed Jun 24 07:47:29 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/testgtk.c (create_idle_test): added a frame with radio buttons
+	to select the resize_mode for the idle-labels container.
+
+	* gtk/gtkframe.h: 
+	* gtk/gtkframe.c: GtkType and macro corrections.
+
+	* gtk/gtkradiobutton.c (gtk_radio_button_set_arg): new function to
+ 	support radio grouping.
+
+Tue Jun 23 08:01:09 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.c (gtk_container_set_resize_mode): queue a resize
+	unconditionally if resize_mode has changed.
+
+	* gtk/gtkscrolledwindow.c (gtk_scrolled_window_init): set
+ 	GTK_RESIZE_QUEUE on the scrolled window.
+	(gtk_scrolled_window_construct): set GTK_RESIZE_PARENT for the vieport.
+
+Tue Jun 23 04:20:30 1998  Tim Janik  <timj@gtk.org>
+
+	* gtk/gtkcontainer.h:
+	* gtk/gtkcontainer.c:
+ 	(GTK_IS_RESIZE_CONTAINER): new macro to find out if
+	a given gtkobject is a container with resize_mode==GTK_RESIZE_PARENT.
+	(gtk_container_queue_resize): new function to queue a container for
+	a *size* reallocation (doesn't affect its position, and thus its
+	parent is left untouched usually).
+	(gtk_container_get_resize_container): new function to retrive the next
+	most resize container which is not itself queued for a resize.
+	(gtk_container_idle_sizer): new function to carefully process the
+ 	container_resize_queue since it can change during invokation of
+ 	gtk_container_check_resize().
+	(gtk_container_resize_children): total rework of this function to
+	properly handle resize containers. makes a lot of assumptions whitch
+	are stated in the comments.
+
+	* gtk/gtkcontainer.c:
+ 	(gtk_container_real_check_resize): only requeue ourselves if we are not
+ 	a resize container.
+	(gtk_container_clear_resize_widgets): care for automatic deletion of our
+	resize_widgets list on size_allocate through a handler connection.
+
+	* gtk/gtkwindow.c (gtk_window_shutdown): new functionm to reset the
+ 	focus and default widget of a window, so to take the burden from
+	gtk_widget_unparent.
+
+	* gtk/gtkviewport.c: removed gtk_viewport_check_resize, which tried
+	to be clever, but actually messed up the resize_children logic and
+	caused unneccessary allocations on its whole branch. besides this,
+	it messed up the display by not invoking a redraw after the allocation.
+
+	* gtk/gtktable.c (gtk_table_set_child_arg): reverted recent change, so
+ 	that it is the child again that is queued for a resize.
+	(gtk_table_attach): likewise.
+	(gtk_table_remove): likewise.
+
 1998-06-22  Miguel de Icaza  <miguel@nuclecu.unam.mx>
 
 	* gtk/gtkentry.h, gtk/gtkentry.c: Export the
diff --git a/gtk/gtk.defs b/gtk/gtk.defs
index 005ff9013e..d3fd5d9590 100644
--- a/gtk/gtk.defs
+++ b/gtk/gtk.defs
@@ -20,6 +20,7 @@
 (define-enum GtkCTreeLineStyle
    (solid GTK_CTREE_LINES_SOLID)
    (dotted GTK_CTREE_LINES_DOTTED)
+   (tabbed GTK_CTREE_LINES_TABBED)
    (none GTK_CTREE_LINES_NONE))
 
 ; enumerations from "./gtkdebug.h"
@@ -283,6 +284,15 @@
    (always GTK_UPDATE_ALWAYS)
    (if-valid GTK_UPDATE_IF_VALID))
 
+(define-enum GtkSpinType
+   (step-forward GTK_SPIN_STEP_FORWARD)
+   (step-backward GTK_SPIN_STEP_BACKWARD)
+   (page-forward GTK_SPIN_PAGE_FORWARD)
+   (page-backward GTK_SPIN_PAGE_BACKWARD)
+   (home GTK_SPIN_HOME)
+   (end GTK_SPIN_END)
+   (user-defined GTK_SPIN_USER_DEFINED))
+
 ; enumerations from "./gtktoolbar.h"
 
 (define-enum GtkToolbarChildType
diff --git a/gtk/gtkbox.c b/gtk/gtkbox.c
index 0804b1d21d..78e85b0e59 100644
--- a/gtk/gtkbox.c
+++ b/gtk/gtkbox.c
@@ -563,7 +563,7 @@ gtk_box_set_child_packing (GtkBox               *box,
 	child_info->pack = GTK_PACK_START;
 
       if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (box))
-	gtk_widget_queue_resize (GTK_WIDGET (box));
+	gtk_widget_queue_resize (child);
     }
 }
 
diff --git a/gtk/gtkcontainer.c b/gtk/gtkcontainer.c
index a92a259190..ac4a713478 100644
--- a/gtk/gtkcontainer.c
+++ b/gtk/gtkcontainer.c
@@ -20,6 +20,7 @@
 #include "gtkcontainer.h"
 #include "gtkprivate.h"
 #include "gtksignal.h"
+#include "gtkmain.h"
 #include <stdarg.h>
 
 
@@ -129,6 +130,7 @@ static const gchar *vadjustment_key = "gtk-vadjustment";
 static guint        vadjustment_key_id = 0;
 static const gchar *hadjustment_key = "gtk-hadjustment";
 static guint        hadjustment_key_id = 0;
+static GSList	   *container_resize_queue = NULL;
 
 GtkType
 gtk_container_get_type (void)
@@ -680,6 +682,11 @@ gtk_container_destroy (GtkObject *object)
 
   container = GTK_CONTAINER (object);
   
+  if (GTK_CONTAINER_RESIZE_PENDING (container))
+    {
+      container_resize_queue = g_slist_remove (container_resize_queue, container);
+      GTK_PRIVATE_UNSET_FLAG (container, GTK_RESIZE_PENDING);
+    }
   gtk_container_clear_resize_widgets (container);
   
   gtk_container_foreach (container,
@@ -809,6 +816,11 @@ gtk_container_clear_resize_widgets (GtkContainer *container)
 
   node = container->resize_widgets;
 
+  if (node)
+    gtk_signal_disconnect_by_func (GTK_OBJECT (container),
+				   GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
+				   NULL);
+
   while (node)
     {
       GtkWidget *widget = node->data;
@@ -837,16 +849,136 @@ gtk_container_set_resize_mode (GtkContainer  *container,
     {
       container->resize_mode = resize_mode;
       
-      if (container->resize_widgets != NULL)
+      if (resize_mode == GTK_RESIZE_IMMEDIATE)
+	gtk_container_check_resize (container);
+      else
 	{
-	  if (resize_mode == GTK_RESIZE_IMMEDIATE)
-	    gtk_container_check_resize (container);
-	  else if (resize_mode == GTK_RESIZE_PARENT)
+	  gtk_container_clear_resize_widgets (container);
+	  gtk_widget_queue_resize (GTK_WIDGET (container));
+	}
+    }
+}
+
+gint    
+gtk_container_need_resize (GtkContainer     *container)
+{
+  gtk_container_check_resize (container);
+  return FALSE;
+}
+
+static GtkContainer*
+gtk_container_get_resize_container (GtkContainer *container)
+{
+  GtkWidget *widget;
+
+  widget = GTK_WIDGET (container);
+
+  while (widget->parent)
+    {
+      widget = widget->parent;
+      if (GTK_IS_RESIZE_CONTAINER (widget) && !GTK_WIDGET_RESIZE_NEEDED (widget))
+	break;
+    }
+
+  return GTK_IS_RESIZE_CONTAINER (widget) ? (GtkContainer*) widget : NULL;
+}
+
+static gboolean
+gtk_container_idle_sizer (gpointer data)
+{
+  /* we may be invoked with a container_resize_queue of NULL, because
+   * queue_resize could have been adding an extra idle function while
+   * the queue still got processed. we better just ignore such case
+   * than trying to explicitely work around them with some extra flags,
+   * sine it doesn't cause any actual harm.
+   */
+  while (container_resize_queue)
+    {
+      GSList *slist;
+      GtkWidget *widget;
+
+      slist = container_resize_queue;
+      container_resize_queue = slist->next;
+      widget = slist->data;
+      g_slist_free_1 (slist);
+
+      GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
+      gtk_container_check_resize (GTK_CONTAINER (widget));
+    }
+  
+  return FALSE;
+}
+
+void
+gtk_container_queue_resize (GtkContainer *container)
+{
+  GtkContainer *resize_container;
+  
+  g_return_if_fail (container != NULL);
+  g_return_if_fail (GTK_IS_CONTAINER (container));
+
+  if (GTK_OBJECT_DESTROYED (container) ||
+      GTK_WIDGET_RESIZE_NEEDED (container))
+    return;
+
+  if (GTK_IS_RESIZE_CONTAINER (container))
+    gtk_container_clear_resize_widgets (container);
+
+  resize_container = gtk_container_get_resize_container (container);
+
+  if (resize_container)
+    {
+      if (GTK_WIDGET_VISIBLE (resize_container))
+	{
+	  switch (resize_container->resize_mode)
 	    {
-	      gtk_container_clear_resize_widgets (container);
-	      gtk_widget_queue_resize (GTK_WIDGET (container));
+	    case GTK_RESIZE_QUEUE:
+	      if (!GTK_CONTAINER_RESIZE_PENDING (resize_container))
+		{
+		  GTK_PRIVATE_SET_FLAG (resize_container, GTK_RESIZE_PENDING);
+		  if (container_resize_queue == NULL)
+		    gtk_idle_add_priority (GTK_PRIORITY_INTERNAL - 1,
+					   gtk_container_idle_sizer,
+					   NULL);
+		  container_resize_queue = g_slist_prepend (container_resize_queue, resize_container);
+		}
+	      
+	      GTK_PRIVATE_SET_FLAG (container, GTK_RESIZE_NEEDED);
+	      if (!resize_container->resize_widgets)
+		gtk_signal_connect (GTK_OBJECT (resize_container),
+				    "size_allocate",
+				    GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
+				    NULL);
+	      resize_container->resize_widgets =
+		g_slist_prepend (resize_container->resize_widgets, container);
+	      break;
+
+	    case GTK_RESIZE_IMMEDIATE:
+	      GTK_PRIVATE_SET_FLAG (container, GTK_RESIZE_NEEDED);
+	      if (!resize_container->resize_widgets)
+		gtk_signal_connect (GTK_OBJECT (resize_container),
+				    "size_allocate",
+				    GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
+				    NULL);
+	      resize_container->resize_widgets =
+		g_slist_prepend (resize_container->resize_widgets, container);
+	      gtk_container_check_resize (resize_container);
+	      break;
+
+	    case GTK_RESIZE_PARENT:
+	      /* Ignore */
+	      break;
 	    }
 	}
+      else
+	{
+	  /* We need to let hidden toplevels know that something
+	   * changed while they where hidden. For other resize containers,
+	   * they will get resized when they are shown.
+	   */
+	  if (GTK_WIDGET_TOPLEVEL (resize_container))
+	    gtk_container_check_resize (resize_container);
+	}
     }
 }
 
@@ -859,30 +991,29 @@ gtk_container_check_resize (GtkContainer *container)
   gtk_signal_emit (GTK_OBJECT (container), container_signals[CHECK_RESIZE]);
 }
 
-gint    
-gtk_container_need_resize (GtkContainer     *container)
-{
-  gtk_container_check_resize (container);
-  return FALSE;
-}
-
 static void
 gtk_container_real_check_resize (GtkContainer *container)
 {
   GtkWidget *widget;
-
+  
   g_return_if_fail (container != NULL);
   g_return_if_fail (GTK_IS_CONTAINER (container));
-
+  
   widget = GTK_WIDGET (container);
-
+  
   gtk_widget_size_request (widget, &widget->requisition);
   
-  if ((widget->requisition.width > widget->allocation.width) ||
-      (widget->requisition.height > widget->allocation.height))
+  if (widget->requisition.width > widget->allocation.width ||
+      widget->requisition.height > widget->allocation.height)
     {
-      gtk_container_clear_resize_widgets (container);
-      gtk_widget_queue_resize (widget);
+      if (GTK_IS_RESIZE_CONTAINER (container))
+	{
+	  gtk_widget_size_allocate (GTK_WIDGET (container),
+				    &GTK_WIDGET (container)->allocation);
+	  gtk_widget_queue_draw (GTK_WIDGET (container));
+	}
+      else
+	gtk_widget_queue_resize (widget);
     }
   else
     {
@@ -905,23 +1036,77 @@ void
 gtk_container_resize_children (GtkContainer *container)
 {
   GtkWidget *widget;
+  GtkWidget *resize_container;
   GSList *resize_widgets;
   GSList *resize_containers;
   GSList *node;
   
+  /* resizing invariants:
+   * toplevels have *always* resize_mode != GTK_RESIZE_PARENT set.
+   * containers with resize_mode==GTK_RESIZE_PARENT have to have resize_widgets
+   * set to NULL.
+   * containers that are flagged RESIZE_NEEDED must have resize_widgets set to
+   * NULL, or are toplevels (thus have ->parent set to NULL).
+   * widgets that are in some container->resize_widgets list must be flagged with
+   * RESIZE_NEEDED.
+   * widgets that have RESIZE_NEEDED set must be referenced in some
+   * GTK_IS_RESIZE_CONTAINER (container)->resize_widgets list.
+   * containers that have an idle sizer pending must be flagged with
+   * RESIZE_PENDING.
+   */
+  
   g_return_if_fail (container != NULL);
   g_return_if_fail (GTK_IS_CONTAINER (container));
 
+  /* we first check out if we actually need to perform a resize,
+   * which is not the case if we got another container queued for
+   * a resize in our anchestry. also we can skip the whole
+   * resize_widgets checks if we are a toplevel and NEED_RESIZE.
+   * this code implies that our allocation is sufficient for our
+   * requisition, since otherwise we would NEED_RESIZE.
+   */
+  resize_container = GTK_WIDGET (container);
+  while (resize_container)
+    {
+      if (GTK_WIDGET_RESIZE_NEEDED (resize_container))
+	break;
+      resize_container = resize_container->parent;
+    }
+  if (resize_container)
+    {
+      /* queue_resize and size_allocate both clear our
+       * resize_widgets list.
+       */
+      if (resize_container->parent)
+	gtk_container_queue_resize (container);
+      else
+	{
+	  gtk_widget_size_allocate (GTK_WIDGET (container),
+				    &GTK_WIDGET (container)->allocation);
+	  gtk_widget_queue_draw (GTK_WIDGET (container));
+	}
+      return;
+    }
+
+  resize_container = GTK_WIDGET (container);
+
+  /* we now walk the anchestry for all resize widgets as long
+   * as they are our children and as long as their allocation
+   * is insufficient, since we don't need to reallocate below that.
+   */
   resize_widgets = container->resize_widgets;
+  if (resize_widgets)
+    gtk_signal_disconnect_by_func (GTK_OBJECT (container),
+				   GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
+				   NULL);
   container->resize_widgets = NULL;
-  
   for (node = resize_widgets; node; node = node->next)
     {
       widget = node->data;
-      
+
       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
-      
-      while (widget && widget->parent &&
+
+      while (widget->parent != resize_container &&
 	     ((widget->allocation.width < widget->requisition.width) ||
 	      (widget->allocation.height < widget->requisition.height)))
 	widget = widget->parent;
@@ -929,41 +1114,39 @@ gtk_container_resize_children (GtkContainer *container)
       GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
       node->data = widget;
     }
-  
+
+  /* for the newly setup resize_widgets list, we now walk each widget's
+   * anchestry to sort those widgets out that have RESIZE_NEEDED parents.
+   * we can safely stop the walk if we are the parent, since we checked
+   * our own anchestry already.
+   */
   resize_containers = NULL;
-  
   for (node = resize_widgets; node; node = node->next)
     {
-      GtkWidget *resize_container;
-      
+      GtkWidget *parent;
+
       widget = node->data;
       
       if (!GTK_WIDGET_RESIZE_NEEDED (widget))
 	continue;
       
-      resize_container = widget->parent;
+      parent = widget->parent;
       
-      if (resize_container)
+      while (parent != resize_container)
 	{
-	  GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
-	  widget = resize_container->parent;
-	  
-	  while (widget)
+	  if (GTK_WIDGET_RESIZE_NEEDED (parent))
 	    {
-	      if (GTK_WIDGET_RESIZE_NEEDED (widget))
-		{
-		  GTK_PRIVATE_UNSET_FLAG (resize_container, GTK_RESIZE_NEEDED);
-		  resize_container = widget;
-		}
-	      widget = widget->parent;
+	      GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
+	      widget = parent;
 	    }
+	  parent = parent->parent;
 	}
-      else
-	resize_container = widget;
       
-      if (!g_slist_find (resize_containers, resize_container))
-	resize_containers = g_slist_prepend (resize_containers,
-					     resize_container);
+      if (!g_slist_find (resize_containers, widget))
+	{
+	  resize_containers = g_slist_prepend (resize_containers, widget);
+	  gtk_widget_ref (widget);
+	}
     }
   g_slist_free (resize_widgets);
   
@@ -974,6 +1157,7 @@ gtk_container_resize_children (GtkContainer *container)
       GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
       gtk_widget_size_allocate (widget, &widget->allocation);
       gtk_widget_queue_draw (widget);
+      gtk_widget_unref (widget);
     }
   g_slist_free (resize_containers);
 }
diff --git a/gtk/gtkcontainer.h b/gtk/gtkcontainer.h
index 72cf24ea5c..ba1d3d3273 100644
--- a/gtk/gtkcontainer.h
+++ b/gtk/gtkcontainer.h
@@ -32,11 +32,13 @@ extern "C" {
 #endif /* __cplusplus */
 
 
-#define GTK_TYPE_CONTAINER	      (gtk_container_get_type ())
-#define GTK_CONTAINER(obj)	      (GTK_CHECK_CAST ((obj), GTK_TYPE_CONTAINER, GtkContainer))
-#define GTK_CONTAINER_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER, GtkContainerClass))
-#define GTK_IS_CONTAINER(obj)	      (GTK_CHECK_TYPE ((obj), GTK_TYPE_CONTAINER))
-#define GTK_IS_CONTAINER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CONTAINER))
+#define GTK_TYPE_CONTAINER	        (gtk_container_get_type ())
+#define GTK_CONTAINER(obj)	        (GTK_CHECK_CAST ((obj), GTK_TYPE_CONTAINER, GtkContainer))
+#define GTK_CONTAINER_CLASS(klass)      (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER, GtkContainerClass))
+#define GTK_IS_CONTAINER(obj)	        (GTK_CHECK_TYPE ((obj), GTK_TYPE_CONTAINER))
+#define GTK_IS_CONTAINER_CLASS(klass)   (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CONTAINER))
+
+#define GTK_IS_RESIZE_CONTAINER(widget) (GTK_IS_CONTAINER (widget) && ((GtkContainer*) (widget))->resize_mode != GTK_RESIZE_PARENT)
 
 
 typedef struct _GtkContainer	   GtkContainer;
@@ -179,8 +181,9 @@ void    gtk_container_add_with_argv	   (GtkContainer      *container,
 
 
 /* Non-public methods */
+void	gtk_container_queue_resize	   (GtkContainer *container);
 void    gtk_container_clear_resize_widgets (GtkContainer *container);
-
+     
 /* Deprecated methods */
 
 /* completely non-functional */
diff --git a/gtk/gtkframe.c b/gtk/gtkframe.c
index c5848e5299..7b1df57ce6 100644
--- a/gtk/gtkframe.c
+++ b/gtk/gtkframe.c
@@ -54,10 +54,10 @@ static void gtk_frame_style_set     (GtkWidget      *widget,
 static GtkBinClass *parent_class = NULL;
 
 
-guint
+GtkType
 gtk_frame_get_type (void)
 {
-  static guint frame_type = 0;
+  static GtkType frame_type = 0;
 
   if (!frame_type)
     {
diff --git a/gtk/gtkframe.h b/gtk/gtkframe.h
index ec2c70c232..4a0b2279a7 100644
--- a/gtk/gtkframe.h
+++ b/gtk/gtkframe.h
@@ -26,12 +26,15 @@
 
 #ifdef __cplusplus
 extern "C" {
+#pragma }
 #endif /* __cplusplus */
 
 
-#define GTK_FRAME(obj)          GTK_CHECK_CAST (obj, gtk_frame_get_type (), GtkFrame)
-#define GTK_FRAME_CLASS(klass)  GTK_CHECK_CLASS_CAST (klass, gtk_frame_get_type (), GtkFrameClass)
-#define GTK_IS_FRAME(obj)       GTK_CHECK_TYPE (obj, gtk_frame_get_type ())
+#define GTK_TYPE_FRAME                  (gtk_frame_get_type ())
+#define GTK_FRAME(obj)                  (GTK_CHECK_CAST ((obj), GTK_TYPE_FRAME, GtkFrame))
+#define GTK_FRAME_CLASS(klass)          (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_FRAME, GtkFrameClass))
+#define GTK_IS_FRAME(obj)               (GTK_CHECK_TYPE ((obj), GTK_TYPE_FRAME))
+#define GTK_IS_FRAME_CLASS(klass)       (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FRAME))
 
 
 typedef struct _GtkFrame       GtkFrame;
@@ -40,7 +43,7 @@ typedef struct _GtkFrameClass  GtkFrameClass;
 struct _GtkFrame
 {
   GtkBin bin;
-
+  
   gchar *label;
   gint16 shadow_type;
   gint16 label_width;
@@ -55,7 +58,7 @@ struct _GtkFrameClass
 };
 
 
-guint      gtk_frame_get_type        (void);
+GtkType    gtk_frame_get_type        (void);
 GtkWidget* gtk_frame_new             (const gchar   *label);
 void       gtk_frame_set_label       (GtkFrame      *frame,
 				      const gchar   *label);
diff --git a/gtk/gtkradiobutton.c b/gtk/gtkradiobutton.c
index 52f4b290ad..741c84cf50 100644
--- a/gtk/gtkradiobutton.c
+++ b/gtk/gtkradiobutton.c
@@ -21,6 +21,11 @@
 #include "gtksignal.h"
 
 
+enum {
+  ARG_0,
+  ARG_GROUP
+};
+
 #define CHECK_BUTTON_CLASS(w)  GTK_CHECK_BUTTON_CLASS (GTK_OBJECT (w)->klass)
 
 
@@ -30,6 +35,12 @@ static void gtk_radio_button_destroy        (GtkObject            *object);
 static void gtk_radio_button_clicked        (GtkButton            *button);
 static void gtk_radio_button_draw_indicator (GtkCheckButton       *check_button,
 					     GdkRectangle         *area);
+static void gtk_radio_button_set_arg	    (GtkRadioButton	  *radio_button,
+					     GtkArg        	  *arg,
+					     guint         	   arg_id);
+static void gtk_radio_button_get_arg	    (GtkRadioButton	  *radio_button,
+					     GtkArg        	  *arg,
+					     guint         	   arg_id);
 
 
 static GtkCheckButtonClass *parent_class = NULL;
@@ -49,8 +60,8 @@ gtk_radio_button_get_type (void)
 	sizeof (GtkRadioButtonClass),
 	(GtkClassInitFunc) gtk_radio_button_class_init,
 	(GtkObjectInitFunc) gtk_radio_button_init,
-	(GtkArgSetFunc) NULL,
-        (GtkArgGetFunc) NULL,
+	(GtkArgSetFunc) gtk_radio_button_set_arg,
+        (GtkArgGetFunc) gtk_radio_button_get_arg,
       };
 
       radio_button_type = gtk_type_unique (gtk_check_button_get_type (), &radio_button_info);
@@ -72,6 +83,8 @@ gtk_radio_button_class_init (GtkRadioButtonClass *class)
 
   parent_class = gtk_type_class (gtk_check_button_get_type ());
 
+  gtk_object_add_arg_type ("GtkRadioButton::group", GTK_TYPE_RADIO_BUTTON, GTK_ARG_WRITABLE, ARG_GROUP);
+
   object_class->destroy = gtk_radio_button_destroy;
 
   button_class->clicked = gtk_radio_button_clicked;
@@ -85,6 +98,40 @@ gtk_radio_button_init (GtkRadioButton *radio_button)
   radio_button->group = g_slist_prepend (NULL, radio_button);
 }
 
+static void
+gtk_radio_button_set_arg (GtkRadioButton *radio_button,
+			  GtkArg         *arg,
+			  guint           arg_id)
+{
+  switch (arg_id)
+    {
+      GSList *slist;
+
+    case ARG_GROUP:
+      if (GTK_VALUE_OBJECT (*arg))
+	slist = gtk_radio_button_group ((GtkRadioButton*) GTK_VALUE_OBJECT (*arg));
+      else
+	slist = NULL;
+      gtk_radio_button_set_group (radio_button, slist);
+      break;
+    default:
+      break;
+    }
+}
+
+static void
+gtk_radio_button_get_arg (GtkRadioButton *radio_button,
+			  GtkArg         *arg,
+			  guint           arg_id)
+{
+  switch (arg_id)
+    {
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+    }
+}
+
 void
 gtk_radio_button_set_group (GtkRadioButton *radio_button,
 			    GSList *group)
diff --git a/gtk/gtkscrolledwindow.c b/gtk/gtkscrolledwindow.c
index d7213fc4ce..b2a5c580ee 100644
--- a/gtk/gtkscrolledwindow.c
+++ b/gtk/gtkscrolledwindow.c
@@ -109,6 +109,8 @@ gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window)
 {
   GTK_WIDGET_SET_FLAGS (scrolled_window, GTK_NO_WINDOW);
 
+  gtk_container_set_resize_mode (GTK_CONTAINER (scrolled_window), GTK_RESIZE_QUEUE);
+
   scrolled_window->hscrollbar = NULL;
   scrolled_window->vscrollbar = NULL;
   scrolled_window->hscrollbar_policy = GTK_POLICY_ALWAYS;
@@ -140,6 +142,7 @@ gtk_scrolled_window_construct (GtkScrolledWindow *scrolled_window,
   scrolled_window->viewport = gtk_viewport_new (hadjustment, vadjustment);
   hadjustment = gtk_viewport_get_hadjustment (GTK_VIEWPORT (scrolled_window->viewport));
   vadjustment = gtk_viewport_get_vadjustment (GTK_VIEWPORT (scrolled_window->viewport));
+  gtk_container_set_resize_mode (GTK_CONTAINER (scrolled_window->viewport), GTK_RESIZE_PARENT);
 
   gtk_signal_connect (GTK_OBJECT (hadjustment), "changed",
 		      (GtkSignalFunc) gtk_scrolled_window_adjustment_changed,
diff --git a/gtk/gtktable.c b/gtk/gtktable.c
index fc80d3816c..3fae345596 100644
--- a/gtk/gtktable.c
+++ b/gtk/gtktable.c
@@ -293,7 +293,7 @@ gtk_table_set_child_arg (GtkContainer   *container,
       break;
     }
   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (table))
-    gtk_widget_queue_resize (GTK_WIDGET (table));
+    gtk_widget_queue_resize (child);
 }
 
 static void
@@ -522,7 +522,7 @@ gtk_table_attach (GtkTable	  *table,
     }
   
   if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (table))
-    gtk_widget_queue_resize (GTK_WIDGET (table));
+    gtk_widget_queue_resize (child);
 }
 
 void
@@ -850,7 +850,7 @@ gtk_table_remove (GtkContainer *container,
 	  g_free (child);
 	  
 	  if (was_visible && GTK_WIDGET_VISIBLE (container))
-	    gtk_widget_queue_resize (GTK_WIDGET (container));
+	    gtk_container_queue_resize (container);
 	  break;
 	}
     }
diff --git a/gtk/gtktypebuiltins.h b/gtk/gtktypebuiltins.h
index 30cb80e071..0c0a21c1e6 100644
--- a/gtk/gtktypebuiltins.h
+++ b/gtk/gtktypebuiltins.h
@@ -44,6 +44,7 @@ extern GtkType GTK_TYPE_SIDE_TYPE;
 extern GtkType GTK_TYPE_ANCHOR_TYPE;
 extern GtkType GTK_TYPE_PRIVATE_FLAGS;
 extern GtkType GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY;
+extern GtkType GTK_TYPE_SPIN_TYPE;
 extern GtkType GTK_TYPE_TOOLBAR_CHILD_TYPE;
 extern GtkType GTK_TYPE_TREE_VIEW_MODE;
 extern GtkType GTK_TYPE_FUNDAMENTAL_TYPE;
@@ -100,4 +101,4 @@ extern GtkType GTK_TYPE_GDK_WINDOW;
 extern GtkType GTK_TYPE_GDK_EVENT;
 extern GtkType GTK_TYPE_GDK_COLOR;
 
-#define	GTK_TYPE_NUM_BUILTINS	(99)
+#define	GTK_TYPE_NUM_BUILTINS	(100)
diff --git a/gtk/gtktypebuiltins_evals.c b/gtk/gtktypebuiltins_evals.c
index 1b1ee639f6..3a231dff1c 100644
--- a/gtk/gtktypebuiltins_evals.c
+++ b/gtk/gtktypebuiltins_evals.c
@@ -17,6 +17,7 @@ static GtkEnumValue _gtk_c_tree_pos_values[] = {
 static GtkEnumValue _gtk_c_tree_line_style_values[] = {
   { GTK_CTREE_LINES_SOLID, "GTK_CTREE_LINES_SOLID", "solid" },
   { GTK_CTREE_LINES_DOTTED, "GTK_CTREE_LINES_DOTTED", "dotted" },
+  { GTK_CTREE_LINES_TABBED, "GTK_CTREE_LINES_TABBED", "tabbed" },
   { GTK_CTREE_LINES_NONE, "GTK_CTREE_LINES_NONE", "none" },
   { 0, NULL, NULL }
 };
@@ -308,6 +309,16 @@ static GtkEnumValue _gtk_spin_button_update_policy_values[] = {
   { GTK_UPDATE_IF_VALID, "GTK_UPDATE_IF_VALID", "if-valid" },
   { 0, NULL, NULL }
 };
+static GtkEnumValue _gtk_spin_type_values[] = {
+  { GTK_SPIN_STEP_FORWARD, "GTK_SPIN_STEP_FORWARD", "step-forward" },
+  { GTK_SPIN_STEP_BACKWARD, "GTK_SPIN_STEP_BACKWARD", "step-backward" },
+  { GTK_SPIN_PAGE_FORWARD, "GTK_SPIN_PAGE_FORWARD", "page-forward" },
+  { GTK_SPIN_PAGE_BACKWARD, "GTK_SPIN_PAGE_BACKWARD", "page-backward" },
+  { GTK_SPIN_HOME, "GTK_SPIN_HOME", "home" },
+  { GTK_SPIN_END, "GTK_SPIN_END", "end" },
+  { GTK_SPIN_USER_DEFINED, "GTK_SPIN_USER_DEFINED", "user-defined" },
+  { 0, NULL, NULL }
+};
 static GtkEnumValue _gtk_toolbar_child_type_values[] = {
   { GTK_TOOLBAR_CHILD_SPACE, "GTK_TOOLBAR_CHILD_SPACE", "space" },
   { GTK_TOOLBAR_CHILD_BUTTON, "GTK_TOOLBAR_CHILD_BUTTON", "button" },
diff --git a/gtk/gtktypebuiltins_ids.c b/gtk/gtktypebuiltins_ids.c
index 5a5680363c..92e71c6642 100644
--- a/gtk/gtktypebuiltins_ids.c
+++ b/gtk/gtktypebuiltins_ids.c
@@ -88,6 +88,8 @@
     GTK_TYPE_FLAGS, _gtk_private_flags_values },
   { "GtkSpinButtonUpdatePolicy", &GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY,
     GTK_TYPE_ENUM, _gtk_spin_button_update_policy_values },
+  { "GtkSpinType", &GTK_TYPE_SPIN_TYPE,
+    GTK_TYPE_ENUM, _gtk_spin_type_values },
   { "GtkToolbarChildType", &GTK_TYPE_TOOLBAR_CHILD_TYPE,
     GTK_TYPE_ENUM, _gtk_toolbar_child_type_values },
   { "GtkTreeViewMode", &GTK_TYPE_TREE_VIEW_MODE,
diff --git a/gtk/gtktypebuiltins_vars.c b/gtk/gtktypebuiltins_vars.c
index a8462b96fa..9544a73b0d 100644
--- a/gtk/gtktypebuiltins_vars.c
+++ b/gtk/gtktypebuiltins_vars.c
@@ -44,6 +44,7 @@ GtkType GTK_TYPE_SIDE_TYPE = 0;
 GtkType GTK_TYPE_ANCHOR_TYPE = 0;
 GtkType GTK_TYPE_PRIVATE_FLAGS = 0;
 GtkType GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY = 0;
+GtkType GTK_TYPE_SPIN_TYPE = 0;
 GtkType GTK_TYPE_TOOLBAR_CHILD_TYPE = 0;
 GtkType GTK_TYPE_TREE_VIEW_MODE = 0;
 GtkType GTK_TYPE_FUNDAMENTAL_TYPE = 0;
diff --git a/gtk/gtkviewport.c b/gtk/gtkviewport.c
index 0d7b4f2d10..614692287e 100644
--- a/gtk/gtkviewport.c
+++ b/gtk/gtkviewport.c
@@ -39,7 +39,6 @@ static void gtk_viewport_size_request             (GtkWidget        *widget,
 						   GtkRequisition   *requisition);
 static void gtk_viewport_size_allocate            (GtkWidget        *widget,
 						   GtkAllocation    *allocation);
-static void gtk_viewport_check_resize              (GtkContainer     *container);
 static void gtk_viewport_adjustment_changed       (GtkAdjustment    *adjustment,
 						   gpointer          data);
 static void gtk_viewport_adjustment_value_changed (GtkAdjustment    *adjustment,
@@ -95,7 +94,6 @@ gtk_viewport_class_init (GtkViewportClass *class)
   widget_class->size_allocate = gtk_viewport_size_allocate;
 
   container_class->add = gtk_viewport_add;
-  container_class->check_resize = gtk_viewport_check_resize;
 }
 
 static void
@@ -633,25 +631,6 @@ gtk_viewport_size_allocate (GtkWidget     *widget,
 }
 
 static void
-gtk_viewport_check_resize (GtkContainer *container)
-{
-  GtkBin *bin;
-
-  g_return_if_fail (container != NULL);
-  g_return_if_fail (GTK_IS_VIEWPORT (container));
-
-  if (GTK_WIDGET_REALIZED (container))
-    {
-      bin = GTK_BIN (container);
-
-      gtk_widget_size_request (bin->child, &bin->child->requisition);
-
-      gtk_widget_size_allocate (GTK_WIDGET (container),
-				&(GTK_WIDGET (container)->allocation));
-    }
-}
-
-static void
 gtk_viewport_adjustment_changed (GtkAdjustment *adjustment,
 				 gpointer       data)
 {
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index 307e7aafb8..bda325a0c0 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -193,7 +193,6 @@ static GdkColormap* gtk_widget_peek_colormap (void);
 static GdkVisual*   gtk_widget_peek_visual   (void);
 static GtkStyle*    gtk_widget_peek_style    (void);
 
-static GtkWidget*   gtk_widget_get_resize_container (GtkWidget *widget);
 static void gtk_widget_reparent_container_child  (GtkWidget     *widget,
 						  gpointer       client_data);
 static void gtk_widget_propagate_state		 (GtkWidget	*widget,
@@ -227,7 +226,6 @@ static GSList *visual_stack = NULL;
 static GSList *style_stack = NULL;
 
 static GSList *gtk_widget_redraw_queue = NULL;
-static GSList *gtk_widget_resize_queue = NULL;
 
 static const gchar *aux_info_key = "gtk-aux-info";
 static guint        aux_info_key_id = 0;
@@ -1131,7 +1129,6 @@ gtk_widget_unparent (GtkWidget *widget)
 {
   GtkWidget *toplevel;
   GtkWidget *old_parent;
-  GSList *tmp_list, *prev_list;
   
   g_return_if_fail (widget != NULL);
   if (widget->parent == NULL)
@@ -1140,7 +1137,9 @@ gtk_widget_unparent (GtkWidget *widget)
   /* keep this function in sync with gtk_menu_detach()
    */
 
-  /* unset focused and default children properly
+  /* unset focused and default children properly, this code
+   * should eventually move into some gtk_window_unparent_branch() or
+   * similar function.
    */
   toplevel = gtk_widget_get_toplevel (widget);
   if (GTK_CONTAINER (widget->parent)->focus_child == widget)
@@ -1173,46 +1172,72 @@ gtk_widget_unparent (GtkWidget *widget)
 	gtk_window_set_default (GTK_WINDOW (toplevel), NULL);
     }
 
-  /* Remove the widget and all its children from toplevel->resize_widgets 
-   */
-
-
-  toplevel = gtk_widget_get_resize_container (widget);
-
-  /* Three ways to make this prettier:
+  if (GTK_IS_RESIZE_CONTAINER (widget))
+    gtk_container_clear_resize_widgets (GTK_CONTAINER (widget));
+  
+  /* Remove the widget and all its children from any ->resize_widgets list
+   * of all the parents in our branch. This code should move into gtkcontainer.c
+   * somwhen, since we mess around with ->resize_widgets, which is
+   * actually not of our business.
+   *
+   * Two ways to make this prettier:
    *   Write a g_slist_conditional_remove (GSList, gboolean (*)(gpointer))
    *   Change resize_widgets to a GList
-   *   Just bite the bullet and use g_slist_remove
    */
-  
-  tmp_list = GTK_CONTAINER (toplevel)->resize_widgets;
-  prev_list = NULL;
-  while (tmp_list)
+  toplevel = widget->parent;
+  while (toplevel)
     {
-      GSList *tmp = tmp_list;
-      GtkWidget *child = (GtkWidget *)tmp->data;
-      GtkWidget *parent = child;
+      GSList *slist;
+      GSList *prev;
 
-      tmp_list = tmp_list->next;
-
-      while (parent && (parent != widget))
-	parent = parent->parent;
+      if (!GTK_CONTAINER (toplevel)->resize_widgets)
+	{
+	  toplevel = toplevel->parent;
+	  continue;
+	}
 
-      if (parent == widget)
+      prev = NULL;
+      slist = GTK_CONTAINER (toplevel)->resize_widgets;
+      while (slist)
 	{
-	  GTK_PRIVATE_UNSET_FLAG (child, GTK_RESIZE_NEEDED);
+	  GtkWidget *child;
+	  GtkWidget *parent;
+	  GSList *last;
 
-	  if (prev_list)
-	    prev_list->next = tmp_list;
+	  last = slist;
+	  slist = last->next;
+	  child = last->data;
+	  
+	  parent = child;
+	  while (parent && (parent != widget))
+	    parent = parent->parent;
+	  
+	  if (parent == widget)
+	    {
+	      GTK_PRIVATE_UNSET_FLAG (child, GTK_RESIZE_NEEDED);
+	      
+	      if (prev)
+		prev->next = slist;
+	      else
+		{
+		  /* it is really messy to have this signal disconnection
+		   * in gtkwidget.c, the resize_widgets invariants should
+		   * all be taken care off by gtkcontainer.c exclusively.
+		   */
+		  if (!slist)
+		    gtk_signal_disconnect_by_func (GTK_OBJECT (toplevel),
+						   GTK_SIGNAL_FUNC (gtk_container_clear_resize_widgets),
+						   NULL);
+		  GTK_CONTAINER (toplevel)->resize_widgets = slist;
+		}
+	      
+	      g_slist_free_1 (last);
+	    }
 	  else
-	    GTK_CONTAINER (toplevel)->resize_widgets = tmp_list;
-
-	  tmp->next = NULL;
-
-	  g_slist_free_1 (tmp);
+	    prev = last;
 	}
-      else
-	prev_list = tmp;
+
+      toplevel = toplevel->parent;
     }
   
   if (widget->window &&
@@ -1417,16 +1442,6 @@ gtk_widget_hide_all (GtkWidget *widget)
   g_return_if_fail (widget != NULL);
   g_assert (widget->parent);
 
-  if (GTK_WIDGET_RESIZE_NEEDED (widget))
-    {
-      GtkWidget *toplevel;
-
-      toplevel = gtk_widget_get_resize_container (widget);
-      GTK_CONTAINER (toplevel)->resize_widgets =
-	g_slist_remove (GTK_CONTAINER (toplevel)->resize_widgets, widget);
-      GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_NEEDED);
-    }
-  
   GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass)->hide_all (widget);
 }
 
@@ -1600,104 +1615,19 @@ gtk_widget_queue_draw (GtkWidget *widget)
     }
 }
 
-/*****************************************
- * gtk_widget_queue_resize:
- *
- *   arguments:
- *
- *   results:
- *****************************************/
-
-static gint
-gtk_widget_idle_sizer (void *data)
-{
-  GSList *slist = gtk_widget_resize_queue;
-  GSList *node = slist;
-  
-  gtk_widget_resize_queue = NULL;
-  
-  while (node)
-    {
-      GtkWidget *widget = node->data;
-      
-      GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
-      gtk_container_check_resize (GTK_CONTAINER (widget));
-      
-      node = node->next;
-    }
-  
-  g_slist_free (slist);
-  
-  return FALSE;
-}
-
-/* The guts here should probably be moved into gtkcontainer.c */
-
 void
 gtk_widget_queue_resize (GtkWidget *widget)
 {
-  GtkWidget *resize_widget;
-  GtkContainer *container;
-  
   g_return_if_fail (widget != NULL);
-  if (GTK_OBJECT_DESTROYED (widget))
-    return;
-
-  resize_widget = gtk_widget_get_resize_container (widget);
+  g_return_if_fail (GTK_IS_WIDGET (widget));
 
-  if (resize_widget)
-    {
-      container = GTK_CONTAINER (resize_widget);
-      
-      if (GTK_WIDGET_VISIBLE (container))
-	{
-	  switch (container->resize_mode)
-	    {
-	    case GTK_RESIZE_QUEUE:
-	      if (!GTK_CONTAINER_RESIZE_PENDING (container))
-		{
-		  GTK_PRIVATE_SET_FLAG (container, GTK_RESIZE_PENDING);
-		  if (gtk_widget_resize_queue == NULL)
-		    gtk_idle_add_priority (GTK_PRIORITY_INTERNAL - 1,
-					   gtk_widget_idle_sizer,
-					   NULL);
-		  gtk_widget_resize_queue = g_slist_prepend (gtk_widget_resize_queue, container);
-		}
-	      
-	      if (!GTK_WIDGET_RESIZE_NEEDED (widget))
-		{
-		  GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
-		  container->resize_widgets =
-		    g_slist_prepend (container->resize_widgets, widget);
-		}
-	      else
-		g_assert (g_slist_find (container->resize_widgets, widget)); /* paranoid */
-	      break;
+  if (GTK_IS_RESIZE_CONTAINER (widget))
+    gtk_container_clear_resize_widgets (GTK_CONTAINER (widget));
 
-	    case GTK_RESIZE_IMMEDIATE:
-	      if (!GTK_WIDGET_RESIZE_NEEDED (widget))
-		{
-		  GTK_PRIVATE_SET_FLAG (widget, GTK_RESIZE_NEEDED);
-		  container->resize_widgets =
-		    g_slist_prepend (container->resize_widgets, widget);
-		  gtk_container_check_resize (container);
-		}
-	      break;
-	    case GTK_RESIZE_PARENT:
-	      /* Ignore */
-	      break;
-	    }
-	}
-      else
-	{
-	  /* We need to let hidden toplevels know that something
-	   * changed while they where hidden. For other resize containers,
-	   * they will get resized when they are shown.
-	   */
-	  if (GTK_WIDGET_TOPLEVEL (container))
-	    gtk_container_check_resize (container);
-	}
-    }
+  if (widget->parent)
+    gtk_container_queue_resize (GTK_CONTAINER (widget->parent));
+  else if (GTK_WIDGET_TOPLEVEL (widget))
+    gtk_container_queue_resize (GTK_CONTAINER (widget));
 }
 
 /*****************************************
@@ -3072,30 +3002,6 @@ gtk_widget_set_extension_events (GtkWidget *widget,
   gtk_object_set_data_by_id (GTK_OBJECT (widget), extension_event_key_id, modep);
 }
 
-
-/*****************************************
- * gtk_widget_get_resize_container:
- *
- *   arguments:
- *
- *   results:
- *****************************************/
-
-static GtkWidget *
-gtk_widget_get_resize_container (GtkWidget *widget)
-{
-  g_return_val_if_fail (widget != NULL, NULL);
-
-  while (widget->parent)
-    {
-      widget = widget->parent;
-      if (GTK_CONTAINER (widget)->resize_mode != GTK_RESIZE_PARENT)
-	break;
-    }
-  
-  return GTK_IS_CONTAINER (widget) ? widget : NULL;
-}
-
 /*****************************************
  * gtk_widget_get_toplevel:
  *
@@ -3600,12 +3506,6 @@ gtk_widget_real_destroy (GtkObject *object)
    */
   widget = GTK_WIDGET (object);
 
-  if (GTK_CONTAINER_RESIZE_PENDING (widget))
-    {
-      gtk_widget_resize_queue = g_slist_remove (gtk_widget_resize_queue, widget);
-      GTK_PRIVATE_UNSET_FLAG (widget, GTK_RESIZE_PENDING);
-    }
-
   gtk_grab_remove (widget);
   gtk_selection_remove_all (widget);
   
@@ -3700,7 +3600,7 @@ gtk_widget_real_hide (GtkWidget *widget)
 	gtk_widget_unmap (widget);
       
       if (widget->parent)
-	gtk_widget_queue_resize (widget);
+	gtk_widget_queue_resize (widget->parent);
     }
 }
 
@@ -3809,20 +3709,20 @@ gtk_widget_real_unrealize (GtkWidget *widget)
     {
       gdk_window_set_user_data (widget->window, NULL);
       gdk_window_destroy (widget->window);
+      widget->window = NULL;
     }
   else
     {
       gdk_window_unref (widget->window);
+      widget->window = NULL;
     }
 
   /* Unrealize afterwards to improve visual effect */
 
   if (GTK_IS_CONTAINER (widget))
     gtk_container_foreach (GTK_CONTAINER (widget),
-			   (GtkCallback)gtk_widget_unrealize,
+			   (GtkCallback) gtk_widget_unrealize,
 			   NULL);
-
-  widget->window = NULL;
 }
 
 /*****************************************
diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c
index 04ab0b14ff..08c66781fb 100644
--- a/gtk/gtkwindow.c
+++ b/gtk/gtkwindow.c
@@ -63,6 +63,7 @@ static void gtk_window_set_arg            (GtkWindow         *window,
 static void gtk_window_get_arg            (GtkWindow         *window,
 					   GtkArg            *arg,
 					   guint	      arg_id);
+static void gtk_window_shutdown           (GtkObject         *object);
 static void gtk_window_destroy            (GtkObject         *object);
 static void gtk_window_finalize           (GtkObject         *object);
 static void gtk_window_show               (GtkWidget         *widget);
@@ -162,6 +163,7 @@ gtk_window_class_init (GtkWindowClass *klass)
 
   gtk_object_class_add_signals (object_class, window_signals, LAST_SIGNAL);
 
+  object_class->shutdown = gtk_window_shutdown;
   object_class->destroy = gtk_window_destroy;
   object_class->finalize = gtk_window_finalize;
 
@@ -193,6 +195,8 @@ gtk_window_init (GtkWindow *window)
   GTK_WIDGET_UNSET_FLAGS (window, GTK_NO_WINDOW);
   GTK_WIDGET_SET_FLAGS (window, GTK_TOPLEVEL);
 
+  gtk_container_set_resize_mode (GTK_CONTAINER (window), GTK_RESIZE_QUEUE);
+
   window->title = NULL;
   window->wmclass_name = g_strdup (gdk_progname);
   window->wmclass_class = g_strdup (gdk_progclass);
@@ -207,7 +211,6 @@ gtk_window_init (GtkWindow *window)
   window->position = GTK_WIN_POS_NONE;
   window->use_uposition = TRUE;
   
-  gtk_container_set_resize_mode (GTK_CONTAINER (window), GTK_RESIZE_QUEUE);
   gtk_container_register_toplevel (GTK_CONTAINER (window));
 }
 
@@ -447,6 +450,22 @@ gtk_window_marshal_signal_2 (GtkObject      *object,
 }
 
 static void
+gtk_window_shutdown (GtkObject *object)
+{
+  GtkWindow *window;
+
+  g_return_if_fail (object != NULL);
+  g_return_if_fail (GTK_IS_WINDOW (object));
+
+  window = GTK_WINDOW (object);
+
+  gtk_window_set_focus (window, NULL);
+  gtk_window_set_default (window, NULL);
+
+  GTK_OBJECT_CLASS (parent_class)->shutdown (object);
+}
+
+static void
 gtk_window_destroy (GtkObject *object)
 {
   g_return_if_fail (object != NULL);
@@ -454,8 +473,7 @@ gtk_window_destroy (GtkObject *object)
 
   gtk_container_unregister_toplevel (GTK_CONTAINER (object));
 
-  if (GTK_OBJECT_CLASS (parent_class)->destroy)
-    (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+  GTK_OBJECT_CLASS (parent_class)->destroy (object);
 }
 
 static void
@@ -1072,7 +1090,6 @@ gtk_window_move_resize (GtkWindow *window)
       allocation.height = widget->requisition.height;
       
       gtk_widget_size_allocate (widget, &allocation);
-      gtk_container_clear_resize_widgets (GTK_CONTAINER (window));
     }
   else
     {
diff --git a/gtk/testgtk.c b/gtk/testgtk.c
index cbbc35a9e5..8e01df8f0f 100644
--- a/gtk/testgtk.c
+++ b/gtk/testgtk.c
@@ -6536,7 +6536,7 @@ create_timeout_test (void)
  */
 static int idle = 0;
 
-gint
+static gint
 idle_test (GtkWidget *label)
 {
   static int count = 0;
@@ -6548,7 +6548,7 @@ idle_test (GtkWidget *label)
   return TRUE;
 }
 
-void
+static void
 start_idle_test (GtkWidget *widget,
 		 GtkWidget *label)
 {
@@ -6558,7 +6558,7 @@ start_idle_test (GtkWidget *widget,
     }
 }
 
-void
+static void
 stop_idle_test (GtkWidget *widget,
 		gpointer   data)
 {
@@ -6569,7 +6569,7 @@ stop_idle_test (GtkWidget *widget,
     }
 }
 
-void
+static void
 destroy_idle_test (GtkWidget  *widget,
 		   GtkWidget **window)
 {
@@ -6578,15 +6578,26 @@ destroy_idle_test (GtkWidget  *widget,
   *window = NULL;
 }
 
-void
+static void
+toggle_idle_container (GtkObject *button,
+		       GtkContainer *container)
+{
+  gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
+}
+
+static void
 create_idle_test (void)
 {
   static GtkWidget *window = NULL;
   GtkWidget *button;
   GtkWidget *label;
+  GtkWidget *container;
 
   if (!window)
     {
+      GtkWidget *frame;
+      GtkWidget *box;
+
       window = gtk_dialog_new ();
 
       gtk_signal_connect (GTK_OBJECT (window), "destroy",
@@ -6598,9 +6609,59 @@ create_idle_test (void)
 
       label = gtk_label_new ("count: 0");
       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
-      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), 
-			  label, TRUE, TRUE, 0);
       gtk_widget_show (label);
+      
+      container =
+	gtk_widget_new (GTK_TYPE_HBOX,
+			"GtkWidget::visible", TRUE,
+			/* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
+			 * "GtkWidget::visible", TRUE,
+			 */
+			 "GtkContainer::child", label,
+			/* NULL), */
+			NULL);
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), 
+			  container, TRUE, TRUE, 0);
+
+      frame =
+	gtk_widget_new (GTK_TYPE_FRAME,
+			"GtkContainer::border_width", 5,
+			"GtkFrame::label", "Label Container",
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", GTK_DIALOG (window)->vbox,
+			NULL);
+      box =
+	gtk_widget_new (GTK_TYPE_VBOX,
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", frame,
+			NULL);
+      button =
+	gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+			"GtkButton::label", "Resize-Parent",
+			"GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
+			"GtkObject::signal::clicked", toggle_idle_container, container,
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", box,
+			NULL);
+      button =
+	gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+			"GtkButton::label", "Resize-Queue",
+			"GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
+			"GtkObject::signal::clicked", toggle_idle_container, container,
+			"GtkRadioButton::group", button,
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", box,
+			NULL);
+      button =
+	gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+			"GtkButton::label", "Resize-Immediate",
+			"GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
+			"GtkObject::signal::clicked", toggle_idle_container, container,
+			"GtkRadioButton::group", button,
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", box,
+			NULL);
+      
 
       button = gtk_button_new_with_label ("close");
       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
diff --git a/tests/testgtk.c b/tests/testgtk.c
index cbbc35a9e5..8e01df8f0f 100644
--- a/tests/testgtk.c
+++ b/tests/testgtk.c
@@ -6536,7 +6536,7 @@ create_timeout_test (void)
  */
 static int idle = 0;
 
-gint
+static gint
 idle_test (GtkWidget *label)
 {
   static int count = 0;
@@ -6548,7 +6548,7 @@ idle_test (GtkWidget *label)
   return TRUE;
 }
 
-void
+static void
 start_idle_test (GtkWidget *widget,
 		 GtkWidget *label)
 {
@@ -6558,7 +6558,7 @@ start_idle_test (GtkWidget *widget,
     }
 }
 
-void
+static void
 stop_idle_test (GtkWidget *widget,
 		gpointer   data)
 {
@@ -6569,7 +6569,7 @@ stop_idle_test (GtkWidget *widget,
     }
 }
 
-void
+static void
 destroy_idle_test (GtkWidget  *widget,
 		   GtkWidget **window)
 {
@@ -6578,15 +6578,26 @@ destroy_idle_test (GtkWidget  *widget,
   *window = NULL;
 }
 
-void
+static void
+toggle_idle_container (GtkObject *button,
+		       GtkContainer *container)
+{
+  gtk_container_set_resize_mode (container, (guint) gtk_object_get_user_data (button));
+}
+
+static void
 create_idle_test (void)
 {
   static GtkWidget *window = NULL;
   GtkWidget *button;
   GtkWidget *label;
+  GtkWidget *container;
 
   if (!window)
     {
+      GtkWidget *frame;
+      GtkWidget *box;
+
       window = gtk_dialog_new ();
 
       gtk_signal_connect (GTK_OBJECT (window), "destroy",
@@ -6598,9 +6609,59 @@ create_idle_test (void)
 
       label = gtk_label_new ("count: 0");
       gtk_misc_set_padding (GTK_MISC (label), 10, 10);
-      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), 
-			  label, TRUE, TRUE, 0);
       gtk_widget_show (label);
+      
+      container =
+	gtk_widget_new (GTK_TYPE_HBOX,
+			"GtkWidget::visible", TRUE,
+			/* "GtkContainer::child", gtk_widget_new (GTK_TYPE_HBOX,
+			 * "GtkWidget::visible", TRUE,
+			 */
+			 "GtkContainer::child", label,
+			/* NULL), */
+			NULL);
+      gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), 
+			  container, TRUE, TRUE, 0);
+
+      frame =
+	gtk_widget_new (GTK_TYPE_FRAME,
+			"GtkContainer::border_width", 5,
+			"GtkFrame::label", "Label Container",
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", GTK_DIALOG (window)->vbox,
+			NULL);
+      box =
+	gtk_widget_new (GTK_TYPE_VBOX,
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", frame,
+			NULL);
+      button =
+	gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+			"GtkButton::label", "Resize-Parent",
+			"GtkObject::user_data", (void*)GTK_RESIZE_PARENT,
+			"GtkObject::signal::clicked", toggle_idle_container, container,
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", box,
+			NULL);
+      button =
+	gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+			"GtkButton::label", "Resize-Queue",
+			"GtkObject::user_data", (void*)GTK_RESIZE_QUEUE,
+			"GtkObject::signal::clicked", toggle_idle_container, container,
+			"GtkRadioButton::group", button,
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", box,
+			NULL);
+      button =
+	gtk_widget_new (GTK_TYPE_RADIO_BUTTON,
+			"GtkButton::label", "Resize-Immediate",
+			"GtkObject::user_data", (void*)GTK_RESIZE_IMMEDIATE,
+			"GtkObject::signal::clicked", toggle_idle_container, container,
+			"GtkRadioButton::group", button,
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", box,
+			NULL);
+      
 
       button = gtk_button_new_with_label ("close");
       gtk_signal_connect_object (GTK_OBJECT (button), "clicked",