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 * gtk-boxed.defs: s/GkWidget/GtkWidget/ +Wed Jun 24 07:47:29 1998 Tim Janik + + * 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 + + * 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 + + * 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 * 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 * gtk-boxed.defs: s/GkWidget/GtkWidget/ +Wed Jun 24 07:47:29 1998 Tim Janik + + * 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 + + * 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 + + * 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 * 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 * gtk-boxed.defs: s/GkWidget/GtkWidget/ +Wed Jun 24 07:47:29 1998 Tim Janik + + * 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 + + * 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 + + * 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 * 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 * gtk-boxed.defs: s/GkWidget/GtkWidget/ +Wed Jun 24 07:47:29 1998 Tim Janik + + * 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 + + * 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 + + * 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 * 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 * gtk-boxed.defs: s/GkWidget/GtkWidget/ +Wed Jun 24 07:47:29 1998 Tim Janik + + * 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 + + * 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 + + * 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 * 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 * gtk-boxed.defs: s/GkWidget/GtkWidget/ +Wed Jun 24 07:47:29 1998 Tim Janik + + * 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 + + * 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 + + * 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 * 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 * gtk-boxed.defs: s/GkWidget/GtkWidget/ +Wed Jun 24 07:47:29 1998 Tim Janik + + * 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 + + * 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 + + * 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 * 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 @@ -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), + >K_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), + >K_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", >K_TYPE_SPIN_BUTTON_UPDATE_POLICY, GTK_TYPE_ENUM, _gtk_spin_button_update_policy_values }, + { "GtkSpinType", >K_TYPE_SPIN_TYPE, + GTK_TYPE_ENUM, _gtk_spin_type_values }, { "GtkToolbarChildType", >K_TYPE_TOOLBAR_CHILD_TYPE, GTK_TYPE_ENUM, _gtk_toolbar_child_type_values }, { "GtkTreeViewMode", >K_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 @@ -632,25 +630,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 (parent == widget) + if (!GTK_CONTAINER (toplevel)->resize_widgets) { - GTK_PRIVATE_UNSET_FLAG (child, GTK_RESIZE_NEEDED); - - if (prev_list) - prev_list->next = tmp_list; - else - GTK_CONTAINER (toplevel)->resize_widgets = tmp_list; - - tmp->next = NULL; - - g_slist_free_1 (tmp); + toplevel = toplevel->parent; + continue; } - else - prev_list = tmp; + + prev = NULL; + slist = GTK_CONTAINER (toplevel)->resize_widgets; + while (slist) + { + GtkWidget *child; + GtkWidget *parent; + GSList *last; + + 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 + prev = last; + } + + 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; + g_return_if_fail (GTK_IS_WIDGET (widget)); - resize_widget = gtk_widget_get_resize_container (widget); + if (GTK_IS_RESIZE_CONTAINER (widget)) + gtk_container_clear_resize_widgets (GTK_CONTAINER (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; - - 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)); } @@ -446,6 +449,22 @@ gtk_window_marshal_signal_2 (GtkObject *object, (* rfunc) (object, GTK_VALUE_POINTER (args[0]), func_data); } +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) { @@ -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",