new function gtk_container_child_arg_set, similar to

Wed Jun 24 14:14:32 1998  Tim Janik  <timj@gtk.org>

        * gtk/gtkcontainer.c: new function gtk_container_child_arg_set, similar
        to gtk_container_child_arg_setv, but takes a variable argument list.
        new function gtk_container_get_child_arg_type, which is needed by
        gtk_object_collect_args.

        * gtk/gtkobject.c: changed prototype for gtk_object_collect_args, to
        take a function pointer to figure the argument type.
        adapted callers to pass gtk_object_get_arg_type.
        * gtk/gtkwidget.c: adapted gtk_object_collect_args callers to pass
        gtk_object_get_arg_type..

        * gtk/gtkpacker.h:
        * gtk/gtkpacker.c:
        (gtk_packer_reorder_child): new function to change the packing order
        of a child.
        (gtk_packer_size_request):
        (gtk_packer_size_allocate): take container->border_width into acount.

        * gtk/gtkpacker.c: implemented widget arguments:
        "GtkPacker::spacing", "GtkPacker::border_width", "GtkPacker::pad_x",
        "GtkPacker::pad_y", "GtkPacker::ipad_x", "GtkPacker::ipad_y".
        implemented child arguments:
        "GtkPacker::side", "GtkPacker::anchor", "GtkPacker::expand",
        "GtkPacker::fill_x", "GtkPacker::fill_y", "GtkPacker::use_default",
        "GtkPacker::border_width", "GtkPacker::pad_x", "GtkPacker::pad_y",
        "GtkPacker::ipad_x", "GtkPacker::ipad_y", "GtkPacker::position".

        * gtk/gtkmisc.c (gtk_misc_set_arg): for padding args, set the padding,
        not the alignment.

        * gtk/gtkeventbox.h:
        * gtk/gtkeventbox.c: GtkType and macro fixups.

        * gtk/testgtk.c (entry_toggle_sensitive): new function to toggle
        sensitivity of an entry.

        * gtk/gtkstyle.c (gtk_style_new): support normal grey as default color
        for insensitive base.

        * gtk/gtkentry.c (gtk_entry_realize): set the window backgrounds
        widget state dependent.
        (gtk_entry_style_set): likewise.
        (gtk_entry_state_changed): set background color on state changes.
        (gtk_entry_draw_text): for non selected text, use state dependent
        colors.

        * gtk/gtktogglebutton.c: support for widget arguments
        "GtkToggleButton::active" and "GtkToggleButton::draw_indicator".

14 files changed, 665 insertions, 90 deletions

diff --git a/gtk/gtkcontainer.c b/gtk/gtkcontainer.c
index ac4a713478..fc9bb9dfd4 100644
--- a/gtk/gtkcontainer.c
+++ b/gtk/gtkcontainer.c
@@ -40,8 +40,8 @@ enum {
   ARG_CHILD
 };
 
-typedef struct _GtkLArgInfo	GtkLArgInfo;
-struct _GtkLArgInfo
+typedef struct _GtkChildArgInfo	GtkChildArgInfo;
+struct _GtkChildArgInfo
 {
   gchar *name;
   GtkType type;
@@ -116,13 +116,14 @@ static void gtk_container_show_all          (GtkWidget         *widget);
 static void gtk_container_hide_all          (GtkWidget         *widget);
 
 GtkArg*     gtk_object_collect_args	    (guint   *n_args,
+					     GtkType (*) (const gchar*),
 					     va_list  args1,
 					     va_list  args2);
 
 
 
 static guint container_signals[LAST_SIGNAL] = { 0 };
-static GHashTable *arg_info_ht = NULL;
+static GHashTable *child_arg_info_ht = NULL;
 
 static GtkWidgetClass *parent_class = NULL;
 
@@ -310,7 +311,7 @@ gtk_container_add_child_arg_type (const gchar       *arg_name,
 				  guint              arg_flags,
 				  guint              arg_id)
 {
-  GtkLArgInfo *info;
+  GtkChildArgInfo *info;
   gchar class_part[1024];
   gchar *arg_part;
   GtkType class_type;
@@ -340,7 +341,7 @@ gtk_container_add_child_arg_type (const gchar       *arg_name,
       return;
     }
 
-  info = g_new (GtkLArgInfo, 1);
+  info = g_new (GtkChildArgInfo, 1);
   info->name = g_strdup (arg_name);
   info->type = arg_type;
   info->class_type = class_type;
@@ -348,25 +349,25 @@ gtk_container_add_child_arg_type (const gchar       *arg_name,
   info->arg_id = arg_id;
   info->seq_id = ++((GtkContainerClass*) gtk_type_class (class_type))->n_child_args;
 
-  if (!arg_info_ht)
-    arg_info_ht = g_hash_table_new (g_str_hash, g_str_equal);
+  if (!child_arg_info_ht)
+    child_arg_info_ht = g_hash_table_new (g_str_hash, g_str_equal);
 
-  g_hash_table_insert (arg_info_ht, info->name, info);
+  g_hash_table_insert (child_arg_info_ht, info->name, info);
 }
 
 typedef struct
 {
   GList *arg_list;
   GtkType class_type;
-} GtkQueryLArgData;
+} GtkQueryChildArgData;
 
 static void
-gtk_query_larg_foreach (gpointer key,
-			gpointer value,
-			gpointer user_data)
+gtk_query_child_arg_foreach (gpointer key,
+			     gpointer value,
+			     gpointer user_data)
 {
-  register GtkLArgInfo *info;
-  register GtkQueryLArgData *data;
+  register GtkChildArgInfo *info;
+  register GtkQueryChildArgData *data;
 
   info = value;
   data = user_data;
@@ -375,13 +376,55 @@ gtk_query_larg_foreach (gpointer key,
     data->arg_list = g_list_prepend (data->arg_list, info);
 }
 
+GtkType
+gtk_container_get_child_arg_type (const gchar *arg_name)
+{
+  GtkChildArgInfo *info;
+  gchar buffer[128];
+  gchar *t;
+
+  g_return_val_if_fail (arg_name != NULL, 0);
+
+  if (!child_arg_info_ht)
+    return GTK_TYPE_INVALID;
+
+  if (!arg_name || strlen (arg_name) > 120)
+    {
+      /* security audit
+       */
+      g_warning ("gtk_container_get_child_arg_type(): argument `arg_name' exceeds maximum size.");
+      return GTK_TYPE_INVALID;
+    }
+
+  t = strchr (arg_name, ':');
+  if (!t || (t[0] != ':') || (t[1] != ':'))
+    {
+      g_warning ("gtk_container_get_child_arg_type(): invalid arg name: \"%s\"\n", arg_name);
+      return GTK_TYPE_INVALID;
+    }
+
+  t = strchr (t + 2, ':');
+  if (t)
+    {
+      strncpy (buffer, arg_name, (long) (t - arg_name));
+      buffer[(long) (t - arg_name)] = '\0';
+      arg_name = buffer;
+    }
+
+  info = g_hash_table_lookup (child_arg_info_ht, arg_name);
+  if (info)
+    return info->type;
+
+  return GTK_TYPE_INVALID;
+}
+
 GtkArg*
 gtk_container_query_child_args (GtkType	           class_type,
 				guint32          **arg_flags,
 				guint             *n_args)
 {
   GtkArg *args;
-  GtkQueryLArgData query_data;
+  GtkQueryChildArgData query_data;
 
   if (arg_flags)
     *arg_flags = NULL;
@@ -389,7 +432,7 @@ gtk_container_query_child_args (GtkType	           class_type,
   *n_args = 0;
   g_return_val_if_fail (gtk_type_is_a (class_type, GTK_TYPE_CONTAINER), NULL);
 
-  if (!arg_info_ht)
+  if (!child_arg_info_ht)
     return NULL;
 
   /* make sure the types class has been initialized, because
@@ -399,7 +442,7 @@ gtk_container_query_child_args (GtkType	           class_type,
 
   query_data.arg_list = NULL;
   query_data.class_type = class_type;
-  g_hash_table_foreach (arg_info_ht, gtk_query_larg_foreach, &query_data);
+  g_hash_table_foreach (child_arg_info_ht, gtk_query_child_arg_foreach, &query_data);
 
   if (query_data.arg_list)
     {
@@ -422,7 +465,7 @@ gtk_container_query_child_args (GtkType	           class_type,
 
       do
 	{
-	  GtkLArgInfo *info;
+	  GtkChildArgInfo *info;
 
 	  info = list->data;
 	  list = list->prev;
@@ -457,12 +500,12 @@ gtk_container_child_arg_getv (GtkContainer      *container,
   g_return_if_fail (child != NULL);
   g_return_if_fail (GTK_IS_WIDGET (child));
 
-  if (!arg_info_ht)
+  if (!child_arg_info_ht)
     return;
 
   for (i = 0; i < n_args; i++)
     {
-      GtkLArgInfo *info;
+      GtkChildArgInfo *info;
       gchar *lookup_name;
       gchar *d;
 
@@ -477,7 +520,7 @@ gtk_container_child_arg_getv (GtkContainer      *container,
 	  if (d)
 	    *d = 0;
 
-	  info = g_hash_table_lookup (arg_info_ht, lookup_name);
+	  info = g_hash_table_lookup (child_arg_info_ht, lookup_name);
 	}
       else
 	info = NULL;
@@ -515,6 +558,33 @@ gtk_container_child_arg_getv (GtkContainer      *container,
 }
 
 void
+gtk_container_child_arg_set (GtkContainer      *container,
+			     GtkWidget         *child,
+			     ...)
+{
+  GtkArg *args;
+  guint n_args;
+  va_list args1;
+  va_list args2;
+  
+  g_return_if_fail (container != NULL);
+  g_return_if_fail (GTK_IS_CONTAINER (container));
+  g_return_if_fail (child != NULL);
+  g_return_if_fail (GTK_IS_WIDGET (child));
+  g_return_if_fail (child->parent != NULL);
+
+  va_start (args1, child);
+  va_start (args2, child);
+  
+  args = gtk_object_collect_args (&n_args, gtk_container_get_child_arg_type, args1, args2);
+  gtk_container_child_arg_setv (container, child, n_args, args);
+  g_free (args);
+  
+  va_end (args1);
+  va_end (args2);
+}
+
+void
 gtk_container_child_arg_setv (GtkContainer      *container,
 			      GtkWidget         *child,
 			      guint              n_args,
@@ -527,12 +597,12 @@ gtk_container_child_arg_setv (GtkContainer      *container,
   g_return_if_fail (child != NULL);
   g_return_if_fail (GTK_IS_WIDGET (child));
 
-  if (!arg_info_ht)
+  if (!child_arg_info_ht)
     return;
 
   for (i = 0; i < n_args; i++)
     {
-      GtkLArgInfo *info;
+      GtkChildArgInfo *info;
       gchar *lookup_name;
       gchar *d;
       gboolean arg_ok;
@@ -545,7 +615,7 @@ gtk_container_child_arg_setv (GtkContainer      *container,
 	  if (d)
 	    *d = 0;
 
-	  info = g_hash_table_lookup (arg_info_ht, lookup_name);
+	  info = g_hash_table_lookup (child_arg_info_ht, lookup_name);
 	}
       else
 	info = NULL;
@@ -612,7 +682,7 @@ gtk_container_add_with_args (GtkContainer      *container,
       va_start (args1, widget);
       va_start (args2, widget);
 
-      args = gtk_object_collect_args (&n_args, args1, args2);
+      args = gtk_object_collect_args (&n_args, gtk_container_get_child_arg_type, args1, args2);
       gtk_container_child_arg_setv (container, widget, n_args, args);
       g_free (args);
 
diff --git a/gtk/gtkcontainer.h b/gtk/gtkcontainer.h
index ba1d3d3273..f314884655 100644
--- a/gtk/gtkcontainer.h
+++ b/gtk/gtkcontainer.h
@@ -138,10 +138,11 @@ void    gtk_container_add_child_arg_type   (const gchar      *arg_name,
 					    GtkType           arg_type,
 					    guint             arg_flags,
 					    guint             arg_id);
-
+GtkType gtk_container_get_child_arg_type   (const gchar      *arg_name);
+     
 /* Allocate a GtkArg array of size nargs that hold the
  * names and types of the args that can be used with
- * gtk_container_child_arg_get/gtk_container_child_arg_set.
+ * gtk_container_child_arg_getv/gtk_container_child_arg_setv.
  * if (arg_flags!=NULL),
  * (*arg_flags) will be set to point to a newly allocated
  * guint array that holds the flags of the args.
@@ -178,7 +179,10 @@ void    gtk_container_add_with_argv	   (GtkContainer      *container,
 					    GtkWidget	      *widget,
 					    guint	       n_args,
 					    GtkArg	      *args);
-
+void	gtk_container_child_arg_set	   (GtkContainer      *container,
+					    GtkWidget         *child,
+					    ...);
+     
 
 /* Non-public methods */
 void	gtk_container_queue_resize	   (GtkContainer *container);
diff --git a/gtk/gtkentry.c b/gtk/gtkentry.c
index 97399a1e5d..e80d8c157b 100644
--- a/gtk/gtkentry.c
+++ b/gtk/gtkentry.c
@@ -68,6 +68,8 @@ static void gtk_entry_draw_cursor_on_drawable
 					   GdkDrawable       *drawable);
 static void gtk_entry_style_set	          (GtkWidget         *widget,
 					   GtkStyle          *previous_style);
+static void gtk_entry_state_changed	  (GtkWidget         *widget,
+					   GtkStateType       previous_state);
 static void gtk_entry_queue_draw          (GtkEntry          *entry);
 static gint gtk_entry_timer               (gpointer           data);
 static gint gtk_entry_position            (GtkEntry          *entry,
@@ -250,7 +252,8 @@ gtk_entry_class_init (GtkEntryClass *class)
   widget_class->key_press_event = gtk_entry_key_press;
   widget_class->focus_in_event = gtk_entry_focus_in;
   widget_class->focus_out_event = gtk_entry_focus_out;
-  widget_class->style_set    = gtk_entry_style_set;
+  widget_class->style_set = gtk_entry_style_set;
+  widget_class->state_changed = gtk_entry_state_changed;
 
   editable_class->insert_text = gtk_entry_insert_text;
   editable_class->delete_text = gtk_entry_delete_text;
@@ -508,8 +511,8 @@ gtk_entry_realize (GtkWidget *widget)
 
   widget->style = gtk_style_attach (widget->style, widget->window);
 
-  gdk_window_set_background (widget->window, &widget->style->base[GTK_STATE_NORMAL]);
-  gdk_window_set_background (entry->text_area, &widget->style->base[GTK_STATE_NORMAL]);
+  gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+  gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
 
 #ifdef USE_XIM
   if (gdk_im_ready ())
@@ -635,7 +638,7 @@ gtk_entry_draw_focus (GtkWidget *widget)
       else
 	{
 	  gdk_draw_rectangle (widget->window, 
-			      widget->style->base_gc[GTK_WIDGET_STATE(widget)],
+			      widget->style->base_gc[GTK_WIDGET_STATE (widget)],
 			      FALSE, x + 2, y + 2, width - 5, height - 5);
 	}
 
@@ -1284,7 +1287,7 @@ gtk_entry_draw_text (GtkEntry *entry)
       
       if (selection_start_pos > start_pos)
 	gdk_draw_text (drawable, widget->style->font,
-		       widget->style->fg_gc[GTK_STATE_NORMAL],
+		       widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
 		       start_xoffset, y,
 		       toprint,
 		       selection_start_pos - start_pos);
@@ -1310,7 +1313,7 @@ gtk_entry_draw_text (GtkEntry *entry)
       
       if (selection_end_pos < end_pos)
 	gdk_draw_text (drawable, widget->style->font,
-		       widget->style->fg_gc[GTK_STATE_NORMAL],
+		       widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
 		       selection_end_xoffset, y,
 		       toprint + selection_end_pos - start_pos,
 		       end_pos - selection_end_pos);
@@ -2242,8 +2245,25 @@ gtk_entry_style_set	(GtkWidget      *widget,
       entry->scroll_offset = entry->char_offset[scroll_char];
       gtk_entry_adjust_scroll (entry);
 
-      gdk_window_set_background (widget->window, &widget->style->base[GTK_STATE_NORMAL]);
-      gdk_window_set_background (entry->text_area, &widget->style->base[GTK_STATE_NORMAL]);
+      gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+      gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+    }
+
+  if (GTK_WIDGET_DRAWABLE (widget))
+    gdk_window_clear (widget->window);
+}
+
+static void
+gtk_entry_state_changed (GtkWidget      *widget,
+			 GtkStateType    previous_state)
+{
+  g_return_if_fail (widget != NULL);
+  g_return_if_fail (GTK_IS_ENTRY (widget));
+
+  if (GTK_WIDGET_REALIZED (widget))
+    {
+      gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
+      gdk_window_set_background (GTK_ENTRY (widget)->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
     }
 
   if (GTK_WIDGET_DRAWABLE (widget))
diff --git a/gtk/gtkeventbox.c b/gtk/gtkeventbox.c
index 004bb7fc3b..f33133925a 100644
--- a/gtk/gtkeventbox.c
+++ b/gtk/gtkeventbox.c
@@ -33,10 +33,10 @@ static gint gtk_event_box_expose                   (GtkWidget      *widget,
 						   GdkEventExpose *event);
 
 
-guint
+GtkType
 gtk_event_box_get_type (void)
 {
-  static guint event_box_type = 0;
+  static GtkType event_box_type = 0;
 
   if (!event_box_type)
     {
diff --git a/gtk/gtkeventbox.h b/gtk/gtkeventbox.h
index 222e73da06..f5594039f3 100644
--- a/gtk/gtkeventbox.h
+++ b/gtk/gtkeventbox.h
@@ -8,7 +8,7 @@
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public
@@ -26,15 +26,18 @@
 
 #ifdef __cplusplus
 extern "C" {
+#pragma }
 #endif /* __cplusplus */
 
 
-#define GTK_EVENT_BOX(obj)          GTK_CHECK_CAST (obj, gtk_event_box_get_type (), GtkEventBox)
-#define GTK_EVENT_BOX_CLASS(klass)  GTK_CHECK_CLASS_CAST (klass, gtk_event_box_get_type (), GtkEventBoxClass)
-#define GTK_IS_EVENT_BOX(obj)       GTK_CHECK_TYPE (obj, gtk_event_box_get_type ())
+#define GTK_TYPE_EVENT_BOX		(gtk_event_box_get_type ())
+#define GTK_EVENT_BOX(obj)		(GTK_CHECK_CAST ((obj), GTK_TYPE_EVENT_BOX, GtkEventBox))
+#define GTK_EVENT_BOX_CLASS(klass)	(GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_EVENT_BOX, GtkEventBoxClass))
+#define GTK_IS_EVENT_BOX(obj)		(GTK_CHECK_TYPE ((obj), GTK_TYPE_EVENT_BOX))
+#define GTK_IS_EVENT_BOX_CLASS(klass)	(GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_EVENT_BOX))
 
 
-typedef struct _GtkEventBox       GtkEventBox;
+typedef struct _GtkEventBox	  GtkEventBox;
 typedef struct _GtkEventBoxClass  GtkEventBoxClass;
 
 struct _GtkEventBox
@@ -47,8 +50,8 @@ struct _GtkEventBoxClass
   GtkBinClass parent_class;
 };
 
-guint          gtk_event_box_get_type        (void);
-GtkWidget*     gtk_event_box_new             (void);
+GtkType	       gtk_event_box_get_type	     (void);
+GtkWidget*     gtk_event_box_new	     (void);
 
 #ifdef __cplusplus
 }
diff --git a/gtk/gtkmisc.c b/gtk/gtkmisc.c
index bfe4d2fdcc..148e689db3 100644
--- a/gtk/gtkmisc.c
+++ b/gtk/gtkmisc.c
@@ -103,10 +103,10 @@ gtk_misc_set_arg (GtkMisc        *misc,
       gtk_misc_set_alignment (misc, misc->xalign, GTK_VALUE_DOUBLE (*arg));
       break;
     case ARG_XPAD:
-      gtk_misc_set_alignment (misc, GTK_VALUE_INT (*arg), misc->ypad);
+      gtk_misc_set_padding (misc, GTK_VALUE_INT (*arg), misc->ypad);
       break;
     case ARG_YPAD:
-      gtk_misc_set_alignment (misc, misc->xpad, GTK_VALUE_INT (*arg));
+      gtk_misc_set_padding (misc, misc->xpad, GTK_VALUE_INT (*arg));
       break;
     default:
       break;
diff --git a/gtk/gtkobject.c b/gtk/gtkobject.c
index 159487ac30..827d8186cc 100644
--- a/gtk/gtkobject.c
+++ b/gtk/gtkobject.c
@@ -76,6 +76,7 @@ static void           gtk_object_finalize      (GtkObject      *object);
 static void           gtk_object_notify_weaks  (GtkObject      *object);
 
 GtkArg*               gtk_object_collect_args  (guint   *nargs,
+						GtkType (*) (const gchar*),
 						va_list  args1,
 						va_list  args2);
 
@@ -619,7 +620,7 @@ gtk_object_new (GtkType type,
   va_start (args1, type);
   va_start (args2, type);
 
-  args = gtk_object_collect_args (&nargs, args1, args2);
+  args = gtk_object_collect_args (&nargs, gtk_object_get_arg_type, args1, args2);
   gtk_object_setv (obj, nargs, args);
   g_free (args);
 
@@ -846,7 +847,7 @@ gtk_object_set (GtkObject *object,
   va_start (args1, object);
   va_start (args2, object);
 
-  args = gtk_object_collect_args (&nargs, args1, args2);
+  args = gtk_object_collect_args (&nargs, gtk_object_get_arg_type, args1, args2);
   gtk_object_setv (object, nargs, args);
   g_free (args);
 
@@ -1001,7 +1002,7 @@ GtkType
 gtk_object_get_arg_type (const gchar *arg_name)
 {
   GtkArgInfo *info;
-  gchar buffer[1024];
+  gchar buffer[128];
   gchar *t;
 
   g_return_val_if_fail (arg_name != NULL, 0);
@@ -1009,18 +1010,18 @@ gtk_object_get_arg_type (const gchar *arg_name)
   if (!arg_info_ht)
     return GTK_TYPE_INVALID;
 
-  if (!arg_name || strlen (arg_name) > 1000)
+  if (!arg_name || strlen (arg_name) > 120)
     {
       /* security audit
        */
       g_warning ("gtk_object_get_arg_type(): argument `arg_name' exceeds maximum size.");
-      return 0;
+      return GTK_TYPE_INVALID;
     }
 
   t = strchr (arg_name, ':');
   if (!t || (t[0] != ':') || (t[1] != ':'))
     {
-      g_warning ("invalid arg name: \"%s\"\n", arg_name);
+      g_warning ("gtk_object_get_arg_type(): invalid arg name: \"%s\"\n", arg_name);
       return GTK_TYPE_INVALID;
     }
 
@@ -1032,7 +1033,7 @@ gtk_object_get_arg_type (const gchar *arg_name)
       arg_name = buffer;
     }
 
-  info = g_hash_table_lookup (arg_info_ht, (gpointer) arg_name);
+  info = g_hash_table_lookup (arg_info_ht, arg_name);
   if (info)
     return info->type;
 
@@ -1360,6 +1361,7 @@ gtk_object_check_class_cast (GtkObjectClass *klass,
 
 GtkArg*
 gtk_object_collect_args (guint   *nargs,
+			 GtkType (*get_arg_type) (const gchar*),
 			 va_list  args1,
 			 va_list  args2)
 {
@@ -1381,7 +1383,7 @@ gtk_object_collect_args (guint   *nargs,
 	  continue;
 	}
 
-      type = gtk_object_get_arg_type (name);
+      type = get_arg_type (name);
 
       switch (GTK_FUNDAMENTAL_TYPE (type))
 	{
@@ -1458,7 +1460,7 @@ gtk_object_collect_args (guint   *nargs,
       for (i = 0; i < n; i++)
 	{
 	  args[i].name = va_arg (args2, char *);
-	  args[i].type = gtk_object_get_arg_type (args[i].name);
+	  args[i].type = get_arg_type (args[i].name);
 
 	  switch (GTK_FUNDAMENTAL_TYPE (args[i].type))
 	    {
diff --git a/gtk/gtkpacker.c b/gtk/gtkpacker.c
index 1a3e7b5c98..a48a6f0d2f 100644
--- a/gtk/gtkpacker.c
+++ b/gtk/gtkpacker.c
@@ -89,6 +89,32 @@ terms specified in this license.
 #include "gtkpacker.h"
 
 
+enum {
+  ARG_0,
+  ARG_SPACING,
+  ARG_D_BORDER_WIDTH,
+  ARG_D_PAD_X,
+  ARG_D_PAD_Y,
+  ARG_D_IPAD_X,
+  ARG_D_IPAD_Y
+};
+
+enum {
+  CHILD_ARG_0,
+  CHILD_ARG_SIDE,
+  CHILD_ARG_ANCHOR,
+  CHILD_ARG_EXPAND,
+  CHILD_ARG_FILL_X,
+  CHILD_ARG_FILL_Y,
+  CHILD_ARG_USE_DEFAULT,
+  CHILD_ARG_BORDER_WIDTH,
+  CHILD_ARG_PAD_X,
+  CHILD_ARG_PAD_Y,
+  CHILD_ARG_I_PAD_X,
+  CHILD_ARG_I_PAD_Y,
+  CHILD_ARG_POSITION
+};
+
 static void gtk_packer_class_init    (GtkPackerClass   *klass);
 static void gtk_packer_init          (GtkPacker        *packer);
 static void gtk_packer_map           (GtkWidget        *widget);
@@ -108,8 +134,22 @@ static void gtk_packer_remove        (GtkContainer   *container,
 static void gtk_packer_foreach       (GtkContainer   *container,
                                       GtkCallback     callback,
                                       gpointer        callback_data);
+static void gtk_packer_set_arg	     (GtkObject      *object,
+				      GtkArg         *arg,
+				      guint           arg_id);
+static void gtk_packer_get_arg	     (GtkObject      *object,
+				      GtkArg         *arg,
+				      guint           arg_id);
+static void gtk_packer_get_child_arg (GtkContainer   *container,
+				      GtkWidget      *child,
+				      GtkArg         *arg,
+				      guint           arg_id);
+static void gtk_packer_set_child_arg (GtkContainer   *container,
+				      GtkWidget      *child,
+				      GtkArg         *arg,
+				      guint           arg_id);
 static GtkType gtk_packer_child_type (GtkContainer   *container);
-
+     
 
 static GtkPackerClass *parent_class;
 
@@ -127,11 +167,11 @@ gtk_packer_get_type (void)
         sizeof (GtkPackerClass),
         (GtkClassInitFunc) gtk_packer_class_init,
         (GtkObjectInitFunc) gtk_packer_init,
-        (GtkArgSetFunc) NULL,
-        (GtkArgGetFunc) NULL
+        (GtkArgSetFunc) gtk_packer_set_arg,
+        (GtkArgGetFunc) gtk_packer_get_arg
       };
 
-      packer_type = gtk_type_unique (gtk_container_get_type (), &packer_info);
+      packer_type = gtk_type_unique (GTK_TYPE_CONTAINER, &packer_info);
     }
   
   return packer_type;
@@ -145,8 +185,28 @@ gtk_packer_class_init (GtkPackerClass *klass)
   
   widget_class = (GtkWidgetClass*) klass;
   container_class = (GtkContainerClass*) klass;
-  parent_class = gtk_type_class (gtk_container_get_type ());
+  parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
   
+  gtk_object_add_arg_type ("GtkPacker::spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_SPACING);
+  gtk_object_add_arg_type ("GtkPacker::default_border_width", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_BORDER_WIDTH);
+  gtk_object_add_arg_type ("GtkPacker::default_pad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_PAD_X);
+  gtk_object_add_arg_type ("GtkPacker::default_pad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_PAD_Y);
+  gtk_object_add_arg_type ("GtkPacker::default_ipad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_IPAD_X);
+  gtk_object_add_arg_type ("GtkPacker::default_ipad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_D_IPAD_Y);
+
+  gtk_container_add_child_arg_type ("GtkPacker::side", GTK_TYPE_SIDE_TYPE, GTK_ARG_READWRITE, CHILD_ARG_SIDE);
+  gtk_container_add_child_arg_type ("GtkPacker::anchor", GTK_TYPE_ANCHOR_TYPE, GTK_ARG_READWRITE, CHILD_ARG_ANCHOR);
+  gtk_container_add_child_arg_type ("GtkPacker::expand", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_EXPAND);
+  gtk_container_add_child_arg_type ("GtkPacker::fill_x", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_FILL_X);
+  gtk_container_add_child_arg_type ("GtkPacker::fill_y", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_FILL_Y);
+  gtk_container_add_child_arg_type ("GtkPacker::use_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, CHILD_ARG_USE_DEFAULT);
+  gtk_container_add_child_arg_type ("GtkPacker::border_width", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_BORDER_WIDTH);
+  gtk_container_add_child_arg_type ("GtkPacker::pad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_PAD_X);
+  gtk_container_add_child_arg_type ("GtkPacker::pad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_PAD_Y);
+  gtk_container_add_child_arg_type ("GtkPacker::ipad_x", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_I_PAD_X);
+  gtk_container_add_child_arg_type ("GtkPacker::ipad_y", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_I_PAD_Y);
+  gtk_container_add_child_arg_type ("GtkPacker::position", GTK_TYPE_LONG, GTK_ARG_READWRITE, CHILD_ARG_POSITION);
+
   widget_class->map = gtk_packer_map;
   widget_class->unmap = gtk_packer_unmap;
   widget_class->draw = gtk_packer_draw;
@@ -159,6 +219,85 @@ gtk_packer_class_init (GtkPackerClass *klass)
   container_class->remove = gtk_packer_remove;
   container_class->foreach = gtk_packer_foreach;
   container_class->child_type = gtk_packer_child_type;
+  container_class->get_child_arg = gtk_packer_get_child_arg;
+  container_class->set_child_arg = gtk_packer_set_child_arg;
+}
+
+static void
+gtk_packer_set_arg (GtkObject	 *object,
+		    GtkArg       *arg,
+		    guint         arg_id)
+{
+  GtkPacker *packer;
+
+  packer = GTK_PACKER (object);
+
+  switch (arg_id)
+    {
+    case ARG_SPACING:
+      gtk_packer_set_spacing (packer, GTK_VALUE_UINT (*arg));
+      break;
+    case ARG_D_BORDER_WIDTH:
+      gtk_packer_set_default_border_width (packer, GTK_VALUE_UINT (*arg));
+      break;
+    case ARG_D_PAD_X:
+      gtk_packer_set_default_pad (packer,
+				  GTK_VALUE_UINT (*arg),
+				  packer->default_pad_y);
+      break;
+    case ARG_D_PAD_Y:
+      gtk_packer_set_default_pad (packer,
+				  packer->default_pad_x,
+				  GTK_VALUE_UINT (*arg));
+      break;
+    case ARG_D_IPAD_X:
+      gtk_packer_set_default_ipad (packer,
+				   GTK_VALUE_UINT (*arg),
+				   packer->default_i_pad_y);
+      break;
+    case ARG_D_IPAD_Y:
+      gtk_packer_set_default_ipad (packer,
+				   packer->default_i_pad_x,
+				   GTK_VALUE_UINT (*arg));
+      break;
+    default:
+      break;
+    }
+}
+
+static void
+gtk_packer_get_arg (GtkObject	 *object,
+		    GtkArg       *arg,
+		    guint         arg_id)
+{
+  GtkPacker *packer;
+
+  packer = GTK_PACKER (object);
+
+  switch (arg_id)
+    {
+    case ARG_SPACING:
+      GTK_VALUE_UINT (*arg) = packer->spacing;
+      break;
+    case ARG_D_BORDER_WIDTH:
+      GTK_VALUE_UINT (*arg) = packer->default_border_width;
+      break;
+    case ARG_D_PAD_X:
+      GTK_VALUE_UINT (*arg) = packer->default_pad_x;
+      break;
+    case ARG_D_PAD_Y:
+      GTK_VALUE_UINT (*arg) = packer->default_pad_y;
+      break;
+    case ARG_D_IPAD_X:
+      GTK_VALUE_UINT (*arg) = packer->default_i_pad_x;
+      break;
+    case ARG_D_IPAD_Y:
+      GTK_VALUE_UINT (*arg) = packer->default_i_pad_y;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+    }
 }
 
 static GtkType
@@ -168,6 +307,181 @@ gtk_packer_child_type (GtkContainer   *container)
 }
 
 static void
+gtk_packer_set_child_arg (GtkContainer   *container,
+			  GtkWidget      *child,
+			  GtkArg         *arg,
+			  guint           arg_id)
+{
+  GtkPacker *packer;
+  GtkPackerChild *child_info = NULL;
+  
+  packer = GTK_PACKER (container);
+
+  if (arg_id != CHILD_ARG_POSITION)
+    {
+      GList *list;
+      
+      list = packer->children;
+      while (list)
+	{
+	  child_info = list->data;
+	  if (child_info->widget == child)
+	    break;
+	  
+	  list = list->next;
+	}
+      if (!list)
+	return;
+    }
+
+  switch (arg_id)
+    {
+    case CHILD_ARG_SIDE:
+      child_info->side = GTK_VALUE_ENUM (*arg);
+      break;
+    case CHILD_ARG_ANCHOR:
+      child_info->anchor = GTK_VALUE_ENUM (*arg);
+      break;
+    case CHILD_ARG_EXPAND:
+      if (GTK_VALUE_BOOL (*arg))
+	child_info->options |= GTK_PACK_EXPAND;
+      else
+	child_info->options &= ~GTK_PACK_EXPAND;
+      break;
+    case CHILD_ARG_FILL_X:
+      if (GTK_VALUE_BOOL (*arg))
+	child_info->options |= GTK_FILL_X;
+      else
+	child_info->options &= ~GTK_FILL_X;
+      break;
+    case CHILD_ARG_FILL_Y:
+      if (GTK_VALUE_BOOL (*arg))
+	child_info->options |= GTK_FILL_Y;
+      else
+	child_info->options &= ~GTK_FILL_Y;
+      break;
+    case CHILD_ARG_USE_DEFAULT:
+      child_info->use_default = (GTK_VALUE_BOOL (*arg) != 0);
+      break;
+    case CHILD_ARG_BORDER_WIDTH:
+      if (!child_info->use_default)
+	child_info->border_width = GTK_VALUE_UINT (*arg);
+      break;
+    case CHILD_ARG_PAD_X:
+      if (!child_info->use_default)
+	child_info->pad_x = GTK_VALUE_UINT (*arg);
+      break;
+    case CHILD_ARG_PAD_Y:
+      if (!child_info->use_default)
+	child_info->pad_y = GTK_VALUE_UINT (*arg);
+      break;
+    case CHILD_ARG_I_PAD_X:
+      if (!child_info->use_default)
+	child_info->i_pad_x = GTK_VALUE_UINT (*arg);
+      break;
+    case CHILD_ARG_I_PAD_Y:
+      if (!child_info->use_default)
+	child_info->i_pad_y = GTK_VALUE_UINT (*arg);
+      break;
+    case CHILD_ARG_POSITION:
+      gtk_packer_reorder_child (packer,
+				child,
+				GTK_VALUE_LONG (*arg));
+      break;
+    default:
+      break;
+    }
+
+  if (arg_id != CHILD_ARG_POSITION &&
+      GTK_WIDGET_VISIBLE (packer) &&
+      GTK_WIDGET_VISIBLE (child))
+    gtk_widget_queue_resize (child);
+}
+
+static void
+gtk_packer_get_child_arg (GtkContainer   *container,
+			  GtkWidget      *child,
+			  GtkArg         *arg,
+			  guint           arg_id)
+{
+  GtkPacker *packer;
+  GtkPackerChild *child_info = NULL;
+  GList * list;
+  
+  packer = GTK_PACKER (container);
+
+  if (arg_id != CHILD_ARG_POSITION)
+    {
+      list = packer->children;
+      while (list)
+	{
+	  child_info = list->data;
+	  if (child_info->widget == child)
+	    break;
+	  
+	  list = list->next;
+	}
+      if (!list)
+	{
+	  arg->type = GTK_TYPE_INVALID;
+	  return;
+	}
+    }
+
+  switch (arg_id)
+    {
+    case CHILD_ARG_SIDE:
+      GTK_VALUE_ENUM (*arg) = child_info->side;
+      break;
+    case CHILD_ARG_ANCHOR:
+      GTK_VALUE_ENUM (*arg) = child_info->anchor;
+      break;
+    case CHILD_ARG_EXPAND:
+      GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_PACK_EXPAND) != 0;
+      break;
+    case CHILD_ARG_FILL_X:
+      GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_FILL_X) != 0;
+      break;
+    case CHILD_ARG_FILL_Y:
+      GTK_VALUE_BOOL (*arg) = (child_info->options & GTK_FILL_Y) != 0;
+      break;
+    case CHILD_ARG_USE_DEFAULT:
+      GTK_VALUE_BOOL (*arg) = child_info->use_default;
+      break;
+    case CHILD_ARG_BORDER_WIDTH:
+      GTK_VALUE_UINT (*arg) = child_info->border_width;
+      break;
+    case CHILD_ARG_PAD_X:
+      GTK_VALUE_UINT (*arg) = child_info->pad_x;
+      break;
+    case CHILD_ARG_PAD_Y:
+      GTK_VALUE_UINT (*arg) = child_info->pad_y;
+      break;
+    case CHILD_ARG_I_PAD_X:
+      GTK_VALUE_UINT (*arg) = child_info->i_pad_x;
+      break;
+    case CHILD_ARG_I_PAD_Y:
+      GTK_VALUE_UINT (*arg) = child_info->i_pad_y;
+      break;
+    case CHILD_ARG_POSITION:
+      GTK_VALUE_LONG (*arg) = 0;
+      for (list = packer->children; list; list = list->next)
+	{
+	  child_info = list->data;
+	  if (child_info->widget == child)
+	    break;
+	  GTK_VALUE_LONG (*arg)++;
+	}
+      if (!list)
+	GTK_VALUE_LONG (*arg) = -1;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+    }
+}
+
+static void
 gtk_packer_init (GtkPacker *packer)
 {
   GTK_WIDGET_SET_FLAGS (packer, GTK_NO_WINDOW | GTK_BASIC);
@@ -186,14 +500,14 @@ gtk_packer_set_spacing (GtkPacker *packer,
   if (spacing != packer->spacing) 
     {
       packer->spacing = spacing;
-      gtk_widget_queue_resize(GTK_WIDGET(packer));
+      gtk_widget_queue_resize (GTK_WIDGET (packer));
     }
 };
 
 GtkWidget*
 gtk_packer_new (void)
 {
-  return GTK_WIDGET (gtk_type_new (gtk_packer_get_type ()));
+  return GTK_WIDGET (gtk_type_new (GTK_TYPE_PACKER));
 }
 
 static void
@@ -214,7 +528,7 @@ redo_defaults_children (GtkPacker *packer)
 	  child->pad_y = packer->default_pad_y;
 	  child->i_pad_x = packer->default_i_pad_x;
 	  child->i_pad_y = packer->default_i_pad_y;
-	  gtk_widget_queue_resize(GTK_WIDGET(packer));
+	  gtk_widget_queue_resize (GTK_WIDGET (child->widget));
 	}
       list = g_list_next(list);
     }
@@ -234,9 +548,9 @@ gtk_packer_set_default_border_width (GtkPacker *packer,
     }
 }
 void
-gtk_packer_set_default_pad(GtkPacker *packer,
-			   guint      pad_x,
-			   guint      pad_y)
+gtk_packer_set_default_pad (GtkPacker *packer,
+			    guint      pad_x,
+			    guint      pad_y)
 {
   g_return_if_fail (packer != NULL);
   g_return_if_fail (GTK_IS_PACKER (packer));
@@ -251,9 +565,9 @@ gtk_packer_set_default_pad(GtkPacker *packer,
 }
 
 void
-gtk_packer_set_default_ipad(GtkPacker *packer,
-			    guint      i_pad_x,
-			    guint      i_pad_y)
+gtk_packer_set_default_ipad (GtkPacker *packer,
+			     guint      i_pad_x,
+			     guint      i_pad_y)
 {
   g_return_if_fail (packer != NULL);
   g_return_if_fail (GTK_IS_PACKER (packer));
@@ -425,8 +739,72 @@ gtk_packer_configure (GtkPacker       *packer,
 
 }
 
+void
+gtk_packer_reorder_child (GtkPacker *packer,
+			  GtkWidget *child,
+			  gint       position)
+{
+  GList *list;
+
+  g_return_if_fail (packer != NULL);
+  g_return_if_fail (GTK_IS_PACKER (packer));
+  g_return_if_fail (child != NULL);
+
+  list = packer->children;
+  while (list)
+    {
+      GtkPackerChild *child_info;
+
+      child_info = list->data;
+      if (child_info->widget == child)
+	break;
+
+      list = list->next;
+    }
+
+  if (list && packer->children->next)
+    {
+      GList *tmp_list;
+
+      if (list->next)
+	list->next->prev = list->prev;
+      if (list->prev)
+	list->prev->next = list->next;
+      else
+	packer->children = list->next;
+
+      tmp_list = packer->children;
+      while (position && tmp_list->next)
+	{
+	  position--;
+	  tmp_list = tmp_list->next;
+	}
+
+      if (position)
+	{
+	  tmp_list->next = list;
+	  list->prev = tmp_list;
+	  list->next = NULL;
+	}
+      else
+	{
+	  if (tmp_list->prev)
+	    tmp_list->prev->next = list;
+	  else
+	    packer->children = list;
+	  list->prev = tmp_list->prev;
+	  tmp_list->prev = list;
+	  list->next = tmp_list;
+	}
+
+      if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (packer))
+	gtk_widget_queue_resize (child);
+    }
+}
+
 static void 
-gtk_packer_remove (GtkContainer *container, GtkWidget *widget) 
+gtk_packer_remove (GtkContainer *container,
+		   GtkWidget    *widget) 
 {
   GtkPacker *packer;
   GtkPackerChild *child;
@@ -577,6 +955,7 @@ static void
 gtk_packer_size_request (GtkWidget *widget, GtkRequisition *requisition)
 {
   GtkPacker *packer;
+  GtkContainer *container;
   GtkPackerChild *child;
   GList *children;
   gint nvis_vert_children;
@@ -589,6 +968,8 @@ gtk_packer_size_request (GtkWidget *widget, GtkRequisition *requisition)
   g_return_if_fail (requisition != NULL);
   
   packer = GTK_PACKER (widget);
+  container = GTK_CONTAINER (widget);
+
   requisition->width = 0;
   requisition->height = 0;
   nvis_vert_children = 0;
@@ -631,8 +1012,9 @@ gtk_packer_size_request (GtkWidget *widget, GtkRequisition *requisition)
 
       children = g_list_next(children);
     }
-  requisition->width = MAX (maxWidth, width);
-  requisition->height = MAX (maxHeight, height);
+
+  requisition->width = MAX (maxWidth, width) + 2 * container->border_width;
+  requisition->height = MAX (maxHeight, height) + 2 * container->border_width;
 }
 
 static gint
@@ -720,6 +1102,7 @@ static void
 gtk_packer_size_allocate (GtkWidget *widget, GtkAllocation  *allocation)
 {
   GtkPacker *packer;
+  GtkContainer *container;
   GtkAllocation child_allocation;
   GList *list;
   GtkPackerChild *child;
@@ -733,16 +1116,19 @@ gtk_packer_size_allocate (GtkWidget *widget, GtkAllocation  *allocation)
   g_return_if_fail (GTK_IS_PACKER (widget));
   g_return_if_fail (allocation != NULL);
 
+  packer = GTK_PACKER (widget);
+  container = GTK_CONTAINER (widget);
+
   x = y = 0;
 
   widget->allocation = *allocation;
-  packer = GTK_PACKER(widget);
   
-  cavityX = widget->allocation.x;
-  cavityY = widget->allocation.y;
-  cavityWidth = widget->allocation.width;
-  cavityHeight = widget->allocation.height;
-  list = g_list_first(packer->children);
+  cavityX = widget->allocation.x + container->border_width;
+  cavityY = widget->allocation.y + container->border_width;
+  cavityWidth = widget->allocation.width - 2 * container->border_width;
+  cavityHeight = widget->allocation.height - 2 * container->border_width;
+
+  list = g_list_first (packer->children);
   while (list != NULL)
     {
       child = list->data;
diff --git a/gtk/gtkpacker.h b/gtk/gtkpacker.h
index 26a968a0ad..637ef30452 100644
--- a/gtk/gtkpacker.h
+++ b/gtk/gtkpacker.h
@@ -144,6 +144,9 @@ void       gtk_packer_configure		       (GtkPacker	*packer,
 						guint		 pad_y,
 						guint		 i_pad_x,
 						guint		 i_pad_y);
+void	   gtk_packer_reorder_child	       (GtkPacker	*packer,
+						GtkWidget	*child,
+						gint             position);
 void       gtk_packer_set_spacing	       (GtkPacker	*packer,
 						guint		 spacing);
 void       gtk_packer_set_default_border_width (GtkPacker	*packer,
diff --git a/gtk/gtkradiobutton.c b/gtk/gtkradiobutton.c
index 741c84cf50..b5b6cedd64 100644
--- a/gtk/gtkradiobutton.c
+++ b/gtk/gtkradiobutton.c
@@ -35,10 +35,10 @@ 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,
+static void gtk_radio_button_set_arg	    (GtkObject		  *object,
 					     GtkArg        	  *arg,
 					     guint         	   arg_id);
-static void gtk_radio_button_get_arg	    (GtkRadioButton	  *radio_button,
+static void gtk_radio_button_get_arg	    (GtkObject		  *object,
 					     GtkArg        	  *arg,
 					     guint         	   arg_id);
 
@@ -99,10 +99,14 @@ gtk_radio_button_init (GtkRadioButton *radio_button)
 }
 
 static void
-gtk_radio_button_set_arg (GtkRadioButton *radio_button,
+gtk_radio_button_set_arg (GtkObject	 *object,
 			  GtkArg         *arg,
 			  guint           arg_id)
 {
+  GtkRadioButton *radio_button;
+
+  radio_button = GTK_RADIO_BUTTON (object);
+
   switch (arg_id)
     {
       GSList *slist;
@@ -120,10 +124,14 @@ gtk_radio_button_set_arg (GtkRadioButton *radio_button,
 }
 
 static void
-gtk_radio_button_get_arg (GtkRadioButton *radio_button,
+gtk_radio_button_get_arg (GtkObject      *object,
 			  GtkArg         *arg,
 			  guint           arg_id)
 {
+  GtkRadioButton *radio_button;
+
+  radio_button = GTK_RADIO_BUTTON (object);
+
   switch (arg_id)
     {
     default:
diff --git a/gtk/gtkstyle.c b/gtk/gtkstyle.c
index 62d90302a6..020d323708 100644
--- a/gtk/gtkstyle.c
+++ b/gtk/gtkstyle.c
@@ -229,12 +229,15 @@ gtk_style_new (void)
   style->bg[GTK_STATE_SELECTED] = gtk_default_selected_bg;
   style->bg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
 
-  for (i = 0; i < 5; i++)
+  for (i = 0; i < 4; i++)
     {
       style->text[i] = style->fg[i];
       style->base[i] = style->white;
     }
 
+  style->base[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
+  style->text[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
+
   for (i = 0; i < 5; i++)
     style->bg_pixmap[i] = NULL;
 
diff --git a/gtk/gtktogglebutton.c b/gtk/gtktogglebutton.c
index 23ff9ed07f..bb3df60b3d 100644
--- a/gtk/gtktogglebutton.c
+++ b/gtk/gtktogglebutton.c
@@ -31,6 +31,12 @@ enum {
   LAST_SIGNAL
 };
 
+enum {
+  ARG_0,
+  ARG_ACTIVE,
+  ARG_DRAW_INDICATOR
+};
+
 
 static void gtk_toggle_button_class_init (GtkToggleButtonClass *klass);
 static void gtk_toggle_button_init       (GtkToggleButton      *toggle_button);
@@ -40,7 +46,13 @@ static void gtk_toggle_button_released   (GtkButton            *button);
 static void gtk_toggle_button_clicked    (GtkButton            *button);
 static void gtk_toggle_button_enter      (GtkButton            *button);
 static void gtk_toggle_button_leave      (GtkButton            *button);
-
+static void gtk_toggle_button_set_arg	 (GtkObject	       *object,
+					  GtkArg    	       *arg,
+					  guint      		arg_id);
+static void gtk_toggle_button_get_arg	 (GtkObject	       *object,
+					  GtkArg    	       *arg,
+					  guint      		arg_id);
+     
 
 static guint toggle_button_signals[LAST_SIGNAL] = { 0 };
 
@@ -59,8 +71,8 @@ gtk_toggle_button_get_type (void)
 	sizeof (GtkToggleButtonClass),
 	(GtkClassInitFunc) gtk_toggle_button_class_init,
 	(GtkObjectInitFunc) gtk_toggle_button_init,
-	(GtkArgSetFunc) NULL,
-        (GtkArgGetFunc) NULL,
+	(GtkArgSetFunc) gtk_toggle_button_set_arg,
+        (GtkArgGetFunc) gtk_toggle_button_get_arg,
       };
 
       toggle_button_type = gtk_type_unique (gtk_button_get_type (), &toggle_button_info);
@@ -82,6 +94,9 @@ gtk_toggle_button_class_init (GtkToggleButtonClass *class)
   container_class = (GtkContainerClass*) class;
   button_class = (GtkButtonClass*) class;
 
+  gtk_object_add_arg_type ("GtkToggleButton::active", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_ACTIVE);
+  gtk_object_add_arg_type ("GtkToggleButton::draw_indicator", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DRAW_INDICATOR);
+
   toggle_button_signals[TOGGLED] =
     gtk_signal_new ("toggled",
                     GTK_RUN_FIRST,
@@ -133,6 +148,51 @@ gtk_toggle_button_new_with_label (const gchar *label)
   return toggle_button;
 }
 
+static void
+gtk_toggle_button_set_arg (GtkObject *object,
+			   GtkArg    *arg,
+			   guint      arg_id)
+{
+  GtkToggleButton *tb;
+
+  tb = GTK_TOGGLE_BUTTON (object);
+
+  switch (arg_id)
+    {
+    case ARG_ACTIVE:
+      gtk_toggle_button_set_state (tb, GTK_VALUE_BOOL (*arg));
+      break;
+    case ARG_DRAW_INDICATOR:
+      gtk_toggle_button_set_mode (tb, GTK_VALUE_BOOL (*arg));
+      break;
+    default:
+      break;
+    }
+}
+
+static void
+gtk_toggle_button_get_arg (GtkObject *object,
+			   GtkArg    *arg,
+			   guint      arg_id)
+{
+  GtkToggleButton *tb;
+
+  tb = GTK_TOGGLE_BUTTON (object);
+
+  switch (arg_id)
+    {
+    case ARG_ACTIVE:
+      GTK_VALUE_BOOL (*arg) = tb->active;
+      break;
+    case ARG_DRAW_INDICATOR:
+      GTK_VALUE_BOOL (*arg) = tb->draw_indicator;
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+    }
+}
+
 void
 gtk_toggle_button_set_mode (GtkToggleButton *toggle_button,
 			    gint             draw_indicator)
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index bda325a0c0..1cdf74546d 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -206,6 +206,7 @@ static void gtk_widget_set_style_recurse	 (GtkWidget	*widget,
 						  gpointer	 client_data);
 
 extern GtkArg* gtk_object_collect_args (guint	*nargs,
+					GtkType (*) (const gchar*),
 					va_list	 args1,
 					va_list	 args2);
 
@@ -1006,7 +1007,7 @@ gtk_widget_new (guint type,
   va_start (args1, type);
   va_start (args2, type);
   
-  args = gtk_object_collect_args (&nargs, args1, args2);
+  args = gtk_object_collect_args (&nargs, gtk_object_get_arg_type, args1, args2);
   gtk_object_setv (obj, nargs, args);
   g_free (args);
   
@@ -1090,7 +1091,7 @@ gtk_widget_set (GtkWidget *widget,
   va_start (args1, widget);
   va_start (args2, widget);
   
-  args = gtk_object_collect_args (&nargs, args1, args2);
+  args = gtk_object_collect_args (&nargs, gtk_object_get_arg_type, args1, args2);
   gtk_object_setv (GTK_OBJECT (widget), nargs, args);
   g_free (args);
   
diff --git a/gtk/testgtk.c b/gtk/testgtk.c
index 8e01df8f0f..6545a11533 100644
--- a/gtk/testgtk.c
+++ b/gtk/testgtk.c
@@ -2307,6 +2307,13 @@ entry_toggle_editable (GtkWidget *checkbutton,
 }
 
 static void
+entry_toggle_sensitive (GtkWidget *checkbutton,
+			GtkWidget *entry)
+{
+   gtk_widget_set_sensitive (entry, GTK_TOGGLE_BUTTON(checkbutton)->active);
+}
+
+static void
 entry_toggle_visibility (GtkWidget *checkbutton,
 			GtkWidget *entry)
 {
@@ -2321,6 +2328,7 @@ create_entry (void)
   GtkWidget *box1;
   GtkWidget *box2;
   GtkWidget *editable_check;
+  GtkWidget *sensitive_check;
   GtkWidget *entry, *cb;
   GtkWidget *button;
   GtkWidget *separator;
@@ -2361,7 +2369,7 @@ create_entry (void)
 
       entry = gtk_entry_new ();
       gtk_entry_set_text (GTK_ENTRY (entry), "hello world");
-      gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
+      gtk_editable_select_region (GTK_EDITABLE (entry), 0, 5);
       gtk_box_pack_start (GTK_BOX (box2), entry, TRUE, TRUE, 0);
       gtk_widget_show (entry);
 
@@ -2387,6 +2395,13 @@ create_entry (void)
       gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(editable_check), TRUE);
       gtk_widget_show (editable_check);
 
+      sensitive_check = gtk_check_button_new_with_label("Sensitive");
+      gtk_box_pack_start (GTK_BOX (box2), sensitive_check, FALSE, TRUE, 0);
+      gtk_signal_connect (GTK_OBJECT(sensitive_check), "toggled",
+			  GTK_SIGNAL_FUNC(entry_toggle_sensitive), entry);
+      gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sensitive_check), TRUE);
+      gtk_widget_show (sensitive_check);
+
       separator = gtk_hseparator_new ();
       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
       gtk_widget_show (separator);