propertiy patches



I cleaned up and applied a few property patches from bugzilla.

Here they are for your reading pleasure.

Index: ChangeLog
===================================================================
RCS file: /cvs/gnome/gtk+/ChangeLog,v
retrieving revision 1.1862
diff -u -p -r1.1862 ChangeLog
--- ChangeLog	2001/03/30 03:35:44	1.1862
+++ ChangeLog	2001/03/30 15:38:55
@@ -1,3 +1,24 @@
+2001-03-30  Alexander Larsson  <alexl redhat com>
+
+	* gtk/gtkbutton.c (gtk_button_get_property):
+	* gtk/gtklabel.c:
+	Remove leaks.
+	
+	* gtk/gtkcontainer.c:
+	* gtk/gtkhscale.c:
+	* gtk/gtkhscrollbar.c:
+	* gtk/gtklayout.c:
+	* gtk/gtkmisc.c:
+	* gtk/gtkprogress.c:
+	* gtk/gtkprogressbar.c:
+	* gtk/gtkrange.c:
+	* gtk/gtktable.c:
+	* gtk/gtkviewport.c:
+	* gtk/gtkvscale.c:
+	* gtk/gtkvscrollbar.c:
+	* gtk/gtkwidget.c:
+	Property patches, based on patches from John Margaglione and Lee Mallabone.
+
 Thu Mar 29 21:20:38 2001  Mike Kestner  <mkestner ameritech net>
 
 	* gtk/gtkspinbutton.c : added value_changed signal which proxies for the
Index: gtk/gtkbutton.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkbutton.c,v
retrieving revision 1.57
diff -u -p -r1.57 gtkbutton.c
--- gtk/gtkbutton.c	2001/03/23 23:39:23	1.57
+++ gtk/gtkbutton.c	2001/03/30 15:38:59
@@ -306,12 +306,12 @@ gtk_button_get_property (GObject        
     {
     case PROP_LABEL:
       if (GTK_BIN (button)->child && GTK_IS_LABEL (GTK_BIN (button)->child))
-	 g_value_set_string(value, g_strdup (GTK_LABEL (GTK_BIN (button)->child)->label)); 
+	 g_value_set_string (value, GTK_LABEL (GTK_BIN (button)->child)->label); 
       else
-	 g_value_set_string(value, NULL);
+	 g_value_set_string (value, NULL);
       break;
     case PROP_RELIEF:
-      g_value_set_enum(value, gtk_button_get_relief (button));
+      g_value_set_enum (value, gtk_button_get_relief (button));
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
Index: gtk/gtkcontainer.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkcontainer.c,v
retrieving revision 1.73
diff -u -p -r1.73 gtkcontainer.c
--- gtk/gtkcontainer.c	2001/03/22 20:59:37	1.73
+++ gtk/gtkcontainer.c	2001/03/30 15:39:04
@@ -33,6 +33,7 @@
 #include "gtksignal.h"
 #include "gtkmain.h"
 #include "gtkwindow.h"
+#include "gtkintl.h"
 
 enum {
   ADD,
@@ -44,11 +45,11 @@ enum {
 };
 
 enum {
-  ARG_0,
-  ARG_BORDER_WIDTH,
-  ARG_RESIZE_MODE,
-  ARG_CHILD,
-  ARG_REALLOCATE_REDRAWS
+  PROP_0,
+  PROP_BORDER_WIDTH,
+  PROP_RESIZE_MODE,
+  PROP_CHILD,
+  PROP_REALLOCATE_REDRAWS
 };
 
 typedef struct _GtkChildArgInfo	GtkChildArgInfo;
@@ -66,12 +67,14 @@ static void     gtk_container_base_class
 static void     gtk_container_class_init           (GtkContainerClass *klass);
 static void     gtk_container_init                 (GtkContainer      *container);
 static void     gtk_container_destroy              (GtkObject         *object);
-static void     gtk_container_get_arg              (GtkObject         *object,
-						    GtkArg            *arg,
-						    guint              arg_id);
-static void     gtk_container_set_arg              (GtkObject         *object,
-						    GtkArg            *arg,
-						    guint              arg_id);
+static void     gtk_container_set_property         (GObject         *object,
+						    guint            prop_id,
+						    const GValue    *value,
+						    GParamSpec      *pspec);
+static void     gtk_container_get_property         (GObject         *object,
+						    guint            prop_id,
+						    GValue          *value,
+						    GParamSpec      *pspec);
 static void     gtk_container_add_unimplemented    (GtkContainer      *container,
 						    GtkWidget         *widget);
 static void     gtk_container_remove_unimplemented (GtkContainer      *container,
@@ -154,9 +157,11 @@ gtk_container_base_class_init (GtkContai
 static void
 gtk_container_class_init (GtkContainerClass *class)
 {
+  GObjectClass *gobject_class;
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
 
+  gobject_class = G_OBJECT_CLASS (class);
   object_class = (GtkObjectClass*) class;
   widget_class = (GtkWidgetClass*) class;
 
@@ -168,9 +173,40 @@ gtk_container_class_init (GtkContainerCl
   vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
   hadjustment_key_id = g_quark_from_static_string (hadjustment_key);
   
+  gobject_class->set_property = gtk_container_set_property;
+  gobject_class->get_property = gtk_container_get_property;
 
-  object_class->get_arg = gtk_container_get_arg;
-  object_class->set_arg = gtk_container_set_arg;
+  g_object_class_install_property (gobject_class,
+                                   PROP_RESIZE_MODE,
+                                   g_param_spec_enum ("resize_mode",
+                                                      _("Resize mode"),
+                                                      _("Specify how resize events are handled"),
+                                                      GTK_TYPE_RESIZE_MODE,
+                                                      GTK_RESIZE_PARENT,
+                                                      G_PARAM_READWRITE));
+  g_object_class_install_property (gobject_class,
+                                   PROP_BORDER_WIDTH,
+                                   g_param_spec_uint ("border_width",
+                                                      _("Border width"),
+                                                      _("The width of the empty border outside the containers children."),
+						      0,
+						      G_MAXINT,
+						      0,
+                                                      G_PARAM_READWRITE));
+  g_object_class_install_property (gobject_class,
+                                   PROP_CHILD,
+                                   g_param_spec_object ("child",
+                                                      _("Child"),
+                                                      _("Can be used to add a new child to the container."),
+                                                      GTK_TYPE_WIDGET,
+						      G_PARAM_WRITABLE));
+  g_object_class_install_property (gobject_class,
+                                   PROP_REALLOCATE_REDRAWS,
+                                   g_param_spec_boolean ("reallocate_redraws",
+							 _("Reallocate redraws"),
+							 _("Whether redraws should be reallocated"),
+							 FALSE,
+							 G_PARAM_READWRITE));
   object_class->destroy = gtk_container_destroy;
 
   widget_class->show_all = gtk_container_show_all;
@@ -186,11 +222,6 @@ gtk_container_class_init (GtkContainerCl
   class->child_type = NULL;
   class->composite_name = gtk_container_child_default_composite_name;
 
-  gtk_object_add_arg_type ("GtkContainer::border_width", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_BORDER_WIDTH);
-  gtk_object_add_arg_type ("GtkContainer::resize_mode", GTK_TYPE_RESIZE_MODE, GTK_ARG_READWRITE, ARG_RESIZE_MODE);
-  gtk_object_add_arg_type ("GtkContainer::child", GTK_TYPE_WIDGET, GTK_ARG_WRITABLE, ARG_CHILD);
-  gtk_object_add_arg_type ("GtkContainer::reallocate_redraws", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_REALLOCATE_REDRAWS);
-
   container_signals[ADD] =
     gtk_signal_new ("add",
                     GTK_RUN_FIRST,
@@ -641,55 +672,59 @@ gtk_container_destroy (GtkObject *object
 }
 
 static void
-gtk_container_set_arg (GtkObject    *object,
-		       GtkArg       *arg,
-		       guint	     arg_id)
+gtk_container_set_property (GObject         *object,
+			    guint            prop_id,
+			    const GValue    *value,
+			    GParamSpec      *pspec)
 {
   GtkContainer *container;
 
   container = GTK_CONTAINER (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_BORDER_WIDTH:
-      gtk_container_set_border_width (container, GTK_VALUE_UINT (*arg));
+    case PROP_BORDER_WIDTH:
+      gtk_container_set_border_width (container, g_value_get_uint (value));
       break;
-    case ARG_RESIZE_MODE:
-      gtk_container_set_resize_mode (container, GTK_VALUE_ENUM (*arg));
+    case PROP_RESIZE_MODE:
+      gtk_container_set_resize_mode (container, g_value_get_enum (value));
       break;
-    case ARG_REALLOCATE_REDRAWS:
-      gtk_container_set_reallocate_redraws (container, GTK_VALUE_BOOL (*arg));
+    case PROP_REALLOCATE_REDRAWS:
+      gtk_container_set_reallocate_redraws (container, 
+					    g_value_get_boolean (value));
       break;
-    case ARG_CHILD:
-      gtk_container_add (container, GTK_WIDGET (GTK_VALUE_OBJECT (*arg)));
+    case PROP_CHILD:
+      gtk_container_add (container, GTK_WIDGET (g_value_get_object (value)));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
 static void
-gtk_container_get_arg (GtkObject    *object,
-		       GtkArg       *arg,
-		       guint	     arg_id)
+gtk_container_get_property (GObject         *object,
+			    guint            prop_id,
+			    GValue          *value,
+			    GParamSpec      *pspec)
 {
   GtkContainer *container;
 
   container = GTK_CONTAINER (object);
   
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_BORDER_WIDTH:
-      GTK_VALUE_UINT (*arg) = container->border_width;
+    case PROP_BORDER_WIDTH:
+      g_value_set_uint (value, container->border_width);
       break;
-    case ARG_RESIZE_MODE:
-      GTK_VALUE_ENUM (*arg) = container->resize_mode;
+    case PROP_RESIZE_MODE:
+      g_value_set_enum (value, container->resize_mode);
       break;
-    case ARG_REALLOCATE_REDRAWS:
-      GTK_VALUE_BOOL (*arg) = container->reallocate_redraws;
+    case PROP_REALLOCATE_REDRAWS:
+      g_value_set_boolean (value, container->reallocate_redraws);
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
@@ -718,7 +753,8 @@ gtk_container_set_border_width (GtkConta
   if (container->border_width != border_width)
     {
       container->border_width = border_width;
-
+      g_object_notify (G_OBJECT (container), "border_width");
+      
       if (GTK_WIDGET_REALIZED (container))
 	gtk_widget_queue_resize (GTK_WIDGET (container));
     }
@@ -827,7 +863,10 @@ gtk_container_set_resize_mode (GtkContai
   
   if (GTK_WIDGET_TOPLEVEL (container) &&
       resize_mode == GTK_RESIZE_PARENT)
-    resize_mode = GTK_RESIZE_QUEUE;
+    {
+      resize_mode = GTK_RESIZE_QUEUE;
+      g_object_notify (G_OBJECT (container), "resize_mode");
+    }
   
   if (container->resize_mode != resize_mode)
     {
@@ -840,6 +879,7 @@ gtk_container_set_resize_mode (GtkContai
 	  gtk_container_clear_resize_widgets (container);
 	  gtk_widget_queue_resize (GTK_WIDGET (container));
 	}
+       g_object_notify (G_OBJECT (container), "resize_mode");
     }
 }
 
@@ -853,6 +893,8 @@ gtk_container_set_reallocate_redraws (Gt
   if (needs_redraws != container->reallocate_redraws)
     {
       container->reallocate_redraws = needs_redraws;
+      g_object_notify (G_OBJECT (container), "reallocate_redraws");
+      
       if (container->reallocate_redraws)
 	gtk_widget_queue_draw (GTK_WIDGET (container));
     }
Index: gtk/gtkhscale.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkhscale.c,v
retrieving revision 1.29
diff -u -p -r1.29 gtkhscale.c
--- gtk/gtkhscale.c	2001/03/28 04:01:21	1.29
+++ gtk/gtkhscale.c	2001/03/30 15:39:05
@@ -28,23 +28,26 @@
 #include "gtkhscale.h"
 #include "gtksignal.h"
 #include "gdk/gdkkeysyms.h"
+#include "gtkintl.h"
 
 #define SCALE_CLASS(w)  GTK_SCALE_GET_CLASS (w)
 #define RANGE_CLASS(w)  GTK_RANGE_GET_CLASS (w)
 
 enum {
-  ARG_0,
-  ARG_ADJUSTMENT
+  PROP_0,
+  PROP_ADJUSTMENT
 };
 
 static void     gtk_hscale_class_init       (GtkHScaleClass *klass);
 static void     gtk_hscale_init             (GtkHScale      *hscale);
-static void     gtk_hscale_set_arg          (GtkObject      *object,
-					     GtkArg         *arg,
-					     guint           arg_id);
-static void     gtk_hscale_get_arg          (GtkObject      *object,
-					     GtkArg         *arg,
-					     guint           arg_id);
+static void     gtk_hscale_get_property     (GObject        *object,
+					     guint           prop_id,
+					     GValue          *value,
+					     GParamSpec      *pspec);
+static void     gtk_hscale_set_property     (GObject         *object,
+					     guint            prop_id,
+					     const GValue    *value,
+					     GParamSpec      *pspec);
 static void     gtk_hscale_realize          (GtkWidget      *widget);
 static void     gtk_hscale_size_request     (GtkWidget      *widget,
 					     GtkRequisition *requisition);
@@ -97,24 +100,21 @@ gtk_hscale_get_type (void)
 static void
 gtk_hscale_class_init (GtkHScaleClass *class)
 {
+  GObjectClass *gobject_class;
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkRangeClass *range_class;
   GtkScaleClass *scale_class;
-  
+
+  gobject_class = (GObjectClass*) class;
   object_class = (GtkObjectClass*) class;
   widget_class = (GtkWidgetClass*) class;
   range_class = (GtkRangeClass*) class;
   scale_class = (GtkScaleClass*) class;
-  
-  gtk_object_add_arg_type ("GtkHScale::adjustment",
-                           GTK_TYPE_ADJUSTMENT,
-                           GTK_ARG_READWRITE,
-                           ARG_ADJUSTMENT);
-  
-  object_class->set_arg = gtk_hscale_set_arg;
-  object_class->get_arg = gtk_hscale_get_arg;
-  
+
+  gobject_class->set_property = gtk_hscale_set_property;
+  gobject_class->get_property = gtk_hscale_get_property;   
+ 
   widget_class->realize = gtk_hscale_realize;
   widget_class->size_request = gtk_hscale_size_request;
   widget_class->size_allocate = gtk_hscale_size_allocate;
@@ -127,43 +127,56 @@ gtk_hscale_class_init (GtkHScaleClass *c
   range_class->clear_background = gtk_hscale_clear_background;
   
   scale_class->draw_value = gtk_hscale_draw_value;
+
+  g_object_class_install_property (gobject_class,
+				   PROP_ADJUSTMENT,
+				   g_param_spec_object ("adjustment",
+							_("Adjustment"),
+							_("The GtkAdjustment that determines the values to use for this HScale."),
+							GTK_TYPE_ADJUSTMENT,
+							G_PARAM_READWRITE));
+
 }
 
-static void
-gtk_hscale_set_arg (GtkObject          *object,
-                    GtkArg             *arg,
-                    guint               arg_id)
+static void 
+gtk_hscale_set_property (GObject        *object,
+			 guint           prop_id,
+			 const GValue   *value,
+			 GParamSpec     *pspec)
 {
   GtkHScale *hscale;
   
   hscale = GTK_HSCALE (object);
   
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ADJUSTMENT:
-      gtk_range_set_adjustment (GTK_RANGE (hscale), GTK_VALUE_POINTER (*arg));
+    case PROP_ADJUSTMENT:
+      gtk_range_set_adjustment (GTK_RANGE (hscale), g_value_get_object (value));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
-static void
-gtk_hscale_get_arg (GtkObject          *object,
-                    GtkArg             *arg,
-                    guint               arg_id)
+static void 
+gtk_hscale_get_property (GObject                    *object,
+			 guint                       prop_id,
+			 GValue                     *value,
+			 GParamSpec                 *pspec)
 {
   GtkHScale *hscale;
   
   hscale = GTK_HSCALE (object);
   
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ADJUSTMENT:
-      GTK_VALUE_POINTER (*arg) = GTK_RANGE (hscale);
+    case PROP_ADJUSTMENT:
+      g_value_set_object (value,
+			  G_OBJECT (gtk_range_get_adjustment (GTK_RANGE (hscale))));
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
Index: gtk/gtkhscrollbar.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkhscrollbar.c,v
retrieving revision 1.22
diff -u -p -r1.22 gtkhscrollbar.c
--- gtk/gtkhscrollbar.c	2001/03/28 04:01:21	1.22
+++ gtk/gtkhscrollbar.c	2001/03/30 15:39:06
@@ -27,6 +27,7 @@
 #include "gtkhscrollbar.h"
 #include "gtksignal.h"
 #include "gdk/gdkkeysyms.h"
+#include "gtkintl.h"
 
 
 #define EPSILON 0.01
@@ -34,18 +35,20 @@
 #define RANGE_CLASS(w)  GTK_RANGE_GET_CLASS (w)
 
 enum {
-  ARG_0,
-  ARG_ADJUSTMENT
+  PROP_0,
+  PROP_ADJUSTMENT
 };
 
 static void     gtk_hscrollbar_class_init       (GtkHScrollbarClass *klass);
 static void     gtk_hscrollbar_init             (GtkHScrollbar      *hscrollbar);
-static void     gtk_hscrollbar_set_arg          (GtkObject          *object,
-						 GtkArg             *arg,
-						 guint               arg_id);
-static void     gtk_hscrollbar_get_arg          (GtkObject          *object,
-						 GtkArg             *arg,
-						 guint               arg_id);
+static void     gtk_hscrollbar_get_property     (GObject            *object,
+						 guint               prop_id,
+						 GValue             *value,
+						 GParamSpec         *pspec);
+static void     gtk_hscrollbar_set_property     (GObject            *object,
+						 guint               prop_id,
+						 const GValue       *value,
+						 GParamSpec         *pspec);
 static void     gtk_hscrollbar_realize          (GtkWidget          *widget);
 static void     gtk_hscrollbar_size_allocate    (GtkWidget          *widget,
 						 GtkAllocation      *allocation);
@@ -87,22 +90,19 @@ gtk_hscrollbar_get_type (void)
 static void
 gtk_hscrollbar_class_init (GtkHScrollbarClass *class)
 {
+  GObjectClass *gobject_class;
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkRangeClass *range_class;
   
+  gobject_class = (GObjectClass*) class;
   object_class = (GtkObjectClass*) class;
   widget_class = (GtkWidgetClass*) class;
   range_class = (GtkRangeClass*) class;
   
-  gtk_object_add_arg_type ("GtkHScrollbar::adjustment",
-                           GTK_TYPE_ADJUSTMENT,
-                           GTK_ARG_READWRITE,
-                           ARG_ADJUSTMENT);
-  
-  object_class->set_arg = gtk_hscrollbar_set_arg;
-  object_class->get_arg = gtk_hscrollbar_get_arg;
-  
+  gobject_class->set_property = gtk_hscrollbar_set_property;
+  gobject_class->get_property = gtk_hscrollbar_get_property;
+
   widget_class->realize = gtk_hscrollbar_realize;
   widget_class->size_allocate = gtk_hscrollbar_size_allocate;
   
@@ -112,43 +112,56 @@ gtk_hscrollbar_class_init (GtkHScrollbar
   range_class->trough_click = _gtk_range_default_htrough_click;
   range_class->trough_keys = gtk_hscrollbar_trough_keys;
   range_class->motion = _gtk_range_default_hmotion;
+
+  g_object_class_install_property (gobject_class,
+				   PROP_ADJUSTMENT,
+				   g_param_spec_object ("adjustment",
+							_("Adjustment"),
+							_("The GtkAdjustment that determines the values to use for this scrollbar."),
+							GTK_TYPE_ADJUSTMENT,
+							G_PARAM_READWRITE));
+
 }
 
-static void
-gtk_hscrollbar_set_arg (GtkObject          *object,
-                        GtkArg             *arg,
-                        guint               arg_id)
+static void 
+gtk_hscrollbar_set_property (GObject                    *object,
+			     guint                       prop_id,
+			     const GValue               *value,
+			     GParamSpec                 *pspec)
 {
   GtkHScrollbar *hscrollbar;
   
   hscrollbar = GTK_HSCROLLBAR (object);
   
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ADJUSTMENT:
-      gtk_range_set_adjustment (GTK_RANGE (hscrollbar), GTK_VALUE_POINTER (*arg));
+    case PROP_ADJUSTMENT:
+      gtk_range_set_adjustment (GTK_RANGE (hscrollbar), 
+				g_value_get_object (value));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
-static void
-gtk_hscrollbar_get_arg (GtkObject          *object,
-                        GtkArg             *arg,
-                        guint               arg_id)
+static void 
+gtk_hscrollbar_get_property (GObject                    *object,
+			     guint                       prop_id,
+			     GValue                     *value,
+			     GParamSpec                 *pspec)
 {
   GtkHScrollbar *hscrollbar;
   
   hscrollbar = GTK_HSCROLLBAR (object);
   
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ADJUSTMENT:
-      GTK_VALUE_POINTER (*arg) = GTK_RANGE (hscrollbar);
+    case PROP_ADJUSTMENT:
+      g_value_set_object (value, G_OBJECT (hscrollbar));
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
Index: gtk/gtklabel.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtklabel.c,v
retrieving revision 1.84
diff -u -p -r1.84 gtklabel.c
--- gtk/gtklabel.c	2001/03/29 23:02:26	1.84
+++ gtk/gtklabel.c	2001/03/30 15:39:10
@@ -327,7 +327,7 @@ gtk_label_get_property (GObject     *obj
   switch (prop_id)
     {
     case PROP_LABEL:
-      g_value_set_string (value, g_strdup (label->label));
+      g_value_set_string (value, label->label);
       break;
     case PROP_ATTRIBUTES:
       g_value_set_boxed (value, label->attrs);
Index: gtk/gtklayout.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtklayout.c,v
retrieving revision 1.37
diff -u -p -r1.37 gtklayout.c
--- gtk/gtklayout.c	2001/03/19 21:06:37	1.37
+++ gtk/gtklayout.c	2001/03/30 15:39:12
@@ -33,6 +33,7 @@
 #include "gtklayout.h"
 #include "gtksignal.h"
 #include "gtkprivate.h"
+#include "gtkintl.h"
 
 typedef struct _GtkLayoutChild   GtkLayoutChild;
 
@@ -42,7 +43,23 @@ struct _GtkLayoutChild {
   gint y;
 };
 
+enum {
+   PROP_0,
+   PROP_HADJUSTMENT,
+   PROP_VADJUSTMENT,
+   PROP_WIDTH,
+   PROP_HEIGHT
+};
+
 static void     gtk_layout_class_init         (GtkLayoutClass *class);
+static void     gtk_layout_get_property       (GObject        *object,
+					       guint          prop_id,
+					       GValue         *value,
+					       GParamSpec     *pspec);
+static void     gtk_layout_set_property       (GObject        *object,
+					       guint          prop_id,
+					       const GValue   *value,
+					       GParamSpec     *pspec);
 static void     gtk_layout_init               (GtkLayout      *layout);
 
 static void     gtk_layout_finalize           (GObject        *object);
@@ -186,6 +203,7 @@ gtk_layout_set_hadjustment (GtkLayout   
   g_return_if_fail (GTK_IS_LAYOUT (layout));
 
   gtk_layout_set_adjustments (layout, adjustment, layout->vadjustment);
+  g_object_notify (G_OBJECT (layout), "hadjustment");
 }
  
 
@@ -197,6 +215,7 @@ gtk_layout_set_vadjustment (GtkLayout   
   g_return_if_fail (GTK_IS_LAYOUT (layout));
   
   gtk_layout_set_adjustments (layout, layout->hadjustment, adjustment);
+  g_object_notify (G_OBJECT (layout), "vadjustment");
 }
 
 
@@ -303,8 +322,16 @@ gtk_layout_set_size (GtkLayout     *layo
 
   widget = GTK_WIDGET (layout);
   
-  layout->width = width;
-  layout->height = height;
+  if (width != layout->width)
+     {
+	layout->width = width;
+	g_object_notify (G_OBJECT (layout), "width");
+     }
+  if (height != layout->height)
+     {
+	layout->height = height;
+	g_object_notify (G_OBJECT (layout), "height");
+     }
 
   gtk_layout_set_adjustment_upper (layout->hadjustment, layout->width);
   gtk_layout_set_adjustment_upper (layout->vadjustment, layout->height);
@@ -368,19 +395,56 @@ gtk_layout_get_type (void)
 static void
 gtk_layout_class_init (GtkLayoutClass *class)
 {
-  GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+  GObjectClass *gobject_class;
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;
 
+  gobject_class = (GObjectClass*) class;
   object_class = (GtkObjectClass*) class;
   widget_class = (GtkWidgetClass*) class;
   container_class = (GtkContainerClass*) class;
 
   parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
 
+  gobject_class->set_property = gtk_layout_set_property;
+  gobject_class->get_property = gtk_layout_get_property;
   gobject_class->finalize = gtk_layout_finalize;
 
+  g_object_class_install_property (gobject_class,
+				   PROP_HADJUSTMENT,
+				   g_param_spec_object ("hadjustment",
+							_("Horizontal adjustment"),
+							_("The GtkAdjustment for the horizontal position."),
+							GTK_TYPE_ADJUSTMENT,
+							G_PARAM_READWRITE));
+  
+  g_object_class_install_property (gobject_class,
+				   PROP_VADJUSTMENT,
+				   g_param_spec_object ("vadjustment",
+							_("Vertical adjustment"),
+							_("The GtkAdjustment for the vertical position."),
+							GTK_TYPE_ADJUSTMENT,
+							G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+				   PROP_WIDTH,
+				   g_param_spec_uint ("width",
+						     _("Width"),
+						     _("The width of the layout."),
+						     0,
+						     G_MAXINT,
+						     100,
+						     G_PARAM_READWRITE));
+  g_object_class_install_property (gobject_class,
+				   PROP_HEIGHT,
+				   g_param_spec_uint ("height",
+						     _("Height"),
+						     _("The height of the layout."),
+						     0,
+						     G_MAXINT,
+						     100,
+						     G_PARAM_READWRITE));
   widget_class->realize = gtk_layout_realize;
   widget_class->unrealize = gtk_layout_unrealize;
   widget_class->map = gtk_layout_map;
@@ -401,6 +465,67 @@ gtk_layout_class_init (GtkLayoutClass *c
 		    gtk_marshal_VOID__OBJECT_OBJECT,
 		    GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 }
+
+static void
+gtk_layout_get_property (GObject     *object,
+			 guint        prop_id,
+			 GValue      *value,
+			 GParamSpec  *pspec)
+{
+  GtkLayout *layout = GTK_LAYOUT (object);
+  
+  switch (prop_id)
+    {
+    case PROP_HADJUSTMENT:
+      g_value_set_object (value, G_OBJECT (layout->hadjustment));
+      break;
+    case PROP_VADJUSTMENT:
+      g_value_set_object (value, G_OBJECT (layout->vadjustment));
+      break;
+    case PROP_WIDTH:
+      g_value_set_uint (value, layout->width);
+      break;
+    case PROP_HEIGHT:
+      g_value_set_uint (value, layout->height);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_layout_set_property (GObject      *object,
+			 guint         prop_id,
+			 const GValue *value,
+			 GParamSpec   *pspec)
+{
+  GtkLayout *layout = GTK_LAYOUT (object);
+  
+  switch (prop_id)
+    {
+    case PROP_HADJUSTMENT:
+      gtk_layout_set_hadjustment (layout, 
+				  (GtkAdjustment*) g_value_get_object (value));
+      break;
+    case PROP_VADJUSTMENT:
+      gtk_layout_set_vadjustment (layout, 
+				  (GtkAdjustment*) g_value_get_object (value));
+      break;
+    case PROP_WIDTH:
+      gtk_layout_set_size (layout, g_value_get_uint (value),
+			   layout->height);
+      break;
+    case PROP_HEIGHT:
+      gtk_layout_set_size (layout, layout->width,
+			   g_value_get_uint (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
 
 static void
 gtk_layout_init (GtkLayout *layout)
Index: gtk/gtkmisc.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkmisc.c,v
retrieving revision 1.20
diff -u -p -r1.20 gtkmisc.c
--- gtk/gtkmisc.c	2000/07/26 11:32:45	1.20
+++ gtk/gtkmisc.c	2001/03/30 15:39:13
@@ -26,25 +26,28 @@
 
 #include "gtkcontainer.h"
 #include "gtkmisc.h"
+#include "gtkintl.h"
 
 
 enum {
-  ARG_0,
-  ARG_XALIGN,
-  ARG_YALIGN,
-  ARG_XPAD,
-  ARG_YPAD
+  PROP_0,
+  PROP_XALIGN,
+  PROP_YALIGN,
+  PROP_XPAD,
+  PROP_YPAD
 };
 
 static void gtk_misc_class_init (GtkMiscClass *klass);
 static void gtk_misc_init       (GtkMisc      *misc);
 static void gtk_misc_realize    (GtkWidget    *widget);
-static void gtk_misc_set_arg    (GtkObject    *object,
-				 GtkArg       *arg,
-				 guint         arg_id);
-static void gtk_misc_get_arg    (GtkObject    *object,
-				 GtkArg       *arg,
-				 guint         arg_id);
+static void gtk_misc_set_property(GObject         *object,
+				  guint            prop_id,
+				  const GValue    *value,
+				  GParamSpec      *pspec);
+static void gtk_misc_get_property(GObject         *object,
+				  guint            prop_id,
+				  GValue          *value,
+				  GParamSpec      *pspec);
 
 
 GtkType
@@ -75,21 +78,58 @@ gtk_misc_get_type (void)
 static void
 gtk_misc_class_init (GtkMiscClass *class)
 {
+  GObjectClass   *gobject_class;
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
 
+  gobject_class = G_OBJECT_CLASS (class);
   object_class = (GtkObjectClass*) class;
   widget_class = (GtkWidgetClass*) class;
 
-  gtk_object_add_arg_type ("GtkMisc::xalign", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_XALIGN);
-  gtk_object_add_arg_type ("GtkMisc::yalign", GTK_TYPE_FLOAT, GTK_ARG_READWRITE, ARG_YALIGN);
-  gtk_object_add_arg_type ("GtkMisc::xpad", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_XPAD);
-  gtk_object_add_arg_type ("GtkMisc::ypad", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_YPAD);
-
-  object_class->set_arg = gtk_misc_set_arg;
-  object_class->get_arg = gtk_misc_get_arg;
+  gobject_class->set_property = gtk_misc_set_property;
+  gobject_class->get_property = gtk_misc_get_property;
   
   widget_class->realize = gtk_misc_realize;
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_XALIGN,
+                                   g_param_spec_float ("xalign",
+						       _("X align"),
+						       _("The horizontal alignment, from 0 (left) to 1 (right)"),
+						       0.0,
+						       1.0,
+						       0.5,
+						       G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_YALIGN,
+                                   g_param_spec_float ("yalign",
+						       _("Y align"),
+						       _("The vertical alignment, from 0 (top) to 1 (bottom)"),
+						       0.0,
+						       1.0,
+						       0.5,
+						       G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_XPAD,
+                                   g_param_spec_int ("xpad",
+						     _("X pad"),
+						     _("The amount of space to add on the left and right of the widget, in pixels"),
+						     0,
+						     G_MAXINT,
+						     0,
+						     G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_YPAD,
+                                   g_param_spec_int ("ypad",
+						     _("Y pad"),
+						     _("The amount of space to add on the top and bottom of the widget, in pixels"),
+						     0,
+						     G_MAXINT,
+						     0,
+						     G_PARAM_READWRITE));
 }
 
 static void
@@ -102,58 +142,61 @@ gtk_misc_init (GtkMisc *misc)
 }
 
 static void
-gtk_misc_set_arg (GtkObject      *object,
-		  GtkArg         *arg,
-		  guint           arg_id)
+gtk_misc_set_property (GObject      *object,
+		       guint         prop_id,
+		       const GValue *value,
+		       GParamSpec   *pspec)
 {
   GtkMisc *misc;
 
   misc = GTK_MISC (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_XALIGN:
-      gtk_misc_set_alignment (misc, GTK_VALUE_FLOAT (*arg), misc->yalign);
+    case PROP_XALIGN:
+      gtk_misc_set_alignment (misc, g_value_get_float (value), misc->yalign);
       break;
-    case ARG_YALIGN:
-      gtk_misc_set_alignment (misc, misc->xalign, GTK_VALUE_FLOAT (*arg));
+    case PROP_YALIGN:
+      gtk_misc_set_alignment (misc, misc->xalign, g_value_get_float (value));
       break;
-    case ARG_XPAD:
-      gtk_misc_set_padding (misc, GTK_VALUE_INT (*arg), misc->ypad);
+    case PROP_XPAD:
+      gtk_misc_set_padding (misc, g_value_get_int (value), misc->ypad);
       break;
-    case ARG_YPAD:
-      gtk_misc_set_padding (misc, misc->xpad, GTK_VALUE_INT (*arg));
+    case PROP_YPAD:
+      gtk_misc_set_padding (misc, misc->xpad, g_value_get_int (value));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
 static void
-gtk_misc_get_arg (GtkObject	 *object,
-		  GtkArg         *arg,
-		  guint           arg_id)
+gtk_misc_get_property (GObject      *object,
+		       guint         prop_id,
+		       GValue       *value,
+		       GParamSpec   *pspec)
 {
   GtkMisc *misc;
 
   misc = GTK_MISC (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_XALIGN:
-      GTK_VALUE_FLOAT (*arg) = misc->xalign;
+    case PROP_XALIGN:
+      g_value_set_float (value, misc->xalign);
       break;
-    case ARG_YALIGN:
-      GTK_VALUE_FLOAT (*arg) = misc->yalign;
+    case PROP_YALIGN:
+      g_value_set_float (value, misc->yalign);
       break;
-    case ARG_XPAD:
-      GTK_VALUE_INT (*arg) = misc->xpad;
+    case PROP_XPAD:
+      g_value_set_int (value, misc->xpad);
       break;
-    case ARG_YPAD:
-      GTK_VALUE_INT (*arg) = misc->ypad;
+    case PROP_YPAD:
+      g_value_set_int (value, misc->ypad);
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
@@ -190,6 +233,12 @@ gtk_misc_set_alignment (GtkMisc *misc,
           widget = GTK_WIDGET (misc);
           gtk_widget_queue_clear (widget);
         }
+
+      if (xalign != misc->xalign)
+	g_object_notify (G_OBJECT (misc), "xalign");
+
+      if (yalign != misc->yalign)
+	g_object_notify (G_OBJECT (misc), "yalign");
     }
 }
 
@@ -222,6 +271,12 @@ gtk_misc_set_padding (GtkMisc *misc,
       
       if (GTK_WIDGET_DRAWABLE (misc))
 	gtk_widget_queue_resize (GTK_WIDGET (misc));
+
+      if (xpad != misc->xpad)
+	g_object_notify (G_OBJECT (misc), "xpad");
+
+      if (ypad != misc->ypad)
+	g_object_notify (G_OBJECT (misc), "ypad");
     }
 }
 
Index: gtk/gtkprogress.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkprogress.c,v
retrieving revision 1.13
diff -u -p -r1.13 gtkprogress.c
--- gtk/gtkprogress.c	2001/03/19 21:06:37	1.13
+++ gtk/gtkprogress.c	2001/03/30 15:39:14
@@ -29,26 +29,29 @@
 #include <string.h>
 #include "gtkprogress.h" 
 #include "gtksignal.h"
+#include "gtkintl.h"
 
 #define EPSILON  1e-5
 
 enum {
-  ARG_0,
-  ARG_ACTIVITY_MODE,
-  ARG_SHOW_TEXT,
-  ARG_TEXT_XALIGN,
-  ARG_TEXT_YALIGN
+  PROP_0,
+  PROP_ACTIVITY_MODE,
+  PROP_SHOW_TEXT,
+  PROP_TEXT_XALIGN,
+  PROP_TEXT_YALIGN
 };
 
 
 static void gtk_progress_class_init      (GtkProgressClass *klass);
 static void gtk_progress_init            (GtkProgress      *progress);
-static void gtk_progress_set_arg	 (GtkObject        *object,
-					  GtkArg           *arg,
-					  guint             arg_id);
-static void gtk_progress_get_arg	 (GtkObject        *object,
-					  GtkArg           *arg,
-					  guint             arg_id);
+static void gtk_progress_set_property    (GObject          *object,
+					  guint             prop_id,
+					  const GValue     *value,
+					  GParamSpec       *pspec);
+static void gtk_progress_get_property    (GObject          *object,
+					  guint             prop_id,
+					  GValue           *value,
+					  GParamSpec       *pspec);
 static void gtk_progress_destroy         (GtkObject        *object);
 static void gtk_progress_finalize        (GObject          *object);
 static void gtk_progress_realize         (GtkWidget        *widget);
@@ -100,8 +103,8 @@ gtk_progress_class_init (GtkProgressClas
 
   gobject_class->finalize = gtk_progress_finalize;
 
-  object_class->set_arg = gtk_progress_set_arg;
-  object_class->get_arg = gtk_progress_get_arg;
+  gobject_class->set_property = gtk_progress_set_property;
+  gobject_class->get_property = gtk_progress_get_property;
   object_class->destroy = gtk_progress_destroy;
 
   widget_class->realize = gtk_progress_realize;
@@ -113,77 +116,102 @@ gtk_progress_class_init (GtkProgressClas
   class->update = NULL;
   class->act_mode_enter = NULL;
 
-  gtk_object_add_arg_type ("GtkProgress::activity_mode",
-			   GTK_TYPE_BOOL,
-			   GTK_ARG_READWRITE,
-			   ARG_ACTIVITY_MODE);
-  gtk_object_add_arg_type ("GtkProgress::show_text",
-			   GTK_TYPE_BOOL,
-			   GTK_ARG_READWRITE,
-			   ARG_SHOW_TEXT);
-  gtk_object_add_arg_type ("GtkProgress::text_xalign",
-			   GTK_TYPE_FLOAT,
-			   GTK_ARG_READWRITE,
-			   ARG_TEXT_XALIGN);
-  gtk_object_add_arg_type ("GtkProgress::text_yalign",
-			   GTK_TYPE_FLOAT,
-			   GTK_ARG_READWRITE,
-			   ARG_TEXT_YALIGN);
+  g_object_class_install_property (gobject_class,
+                                   PROP_ACTIVITY_MODE,
+                                   g_param_spec_boolean ("activity_mode",
+							 _("Activity mode"),
+							 _("If true the GtkProgress is in activity mode, meaning that is signals something is happening, but not how much of the activity is finished. This is used when you're doing something that you don't know how long it will take."),
+							 FALSE,
+							 G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_SHOW_TEXT,
+                                   g_param_spec_boolean ("show_text",
+							 _("Show text"),
+							 _("Whether the progress is shown as text"),
+							 FALSE,
+							 G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+				   PROP_TEXT_XALIGN,
+				   g_param_spec_float ("text_xalign",
+						       _("Text x alignment"),
+						       _("A number between 0.0 and 1.0 specifying the horizontal alignment of the text in the progresswidget"),
+						       0.0,
+						       1.0,
+						       0.5,
+						       G_PARAM_READWRITE));  
+    g_object_class_install_property (gobject_class,
+				   PROP_TEXT_YALIGN,
+				   g_param_spec_float ("text_yalign",
+						       _("Text y alignment"),
+						       _("A number between 0.0 and 1.0 specifying the vertical alignment of the text in the progress widget"),
+						       0.0,
+						       1.0,
+						       0.5,
+						       G_PARAM_READWRITE));
 }
 
 static void
-gtk_progress_set_arg (GtkObject      *object,
-		      GtkArg         *arg,
-		      guint           arg_id)
+gtk_progress_set_property (GObject      *object,
+			   guint         prop_id,
+			   const GValue *value,
+			   GParamSpec   *pspec)
 {
   GtkProgress *progress;
   
   progress = GTK_PROGRESS (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ACTIVITY_MODE:
-      gtk_progress_set_activity_mode (progress, GTK_VALUE_BOOL (*arg));
+    case PROP_ACTIVITY_MODE:
+      gtk_progress_set_activity_mode (progress, g_value_get_boolean (value));
       break;
-    case ARG_SHOW_TEXT:
-      gtk_progress_set_show_text (progress, GTK_VALUE_BOOL (*arg));
+    case PROP_SHOW_TEXT:
+      gtk_progress_set_show_text (progress, g_value_get_boolean (value));
       break;
-    case ARG_TEXT_XALIGN:
-      gtk_progress_set_text_alignment (progress, GTK_VALUE_FLOAT (*arg), progress->y_align);
+    case PROP_TEXT_XALIGN:
+      gtk_progress_set_text_alignment (progress,
+				       g_value_get_float (value),
+				       progress->y_align);
       break;
-    case ARG_TEXT_YALIGN:
-      gtk_progress_set_text_alignment (progress, progress->x_align, GTK_VALUE_FLOAT (*arg));
+    case PROP_TEXT_YALIGN:
+      gtk_progress_set_text_alignment (progress,
+				       progress->x_align,
+				       g_value_get_float (value));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
 static void
-gtk_progress_get_arg (GtkObject      *object,
-		      GtkArg         *arg,
-		      guint           arg_id)
+gtk_progress_get_property (GObject      *object,
+			   guint         prop_id,
+			   GValue       *value,
+			   GParamSpec   *pspec)
 {
   GtkProgress *progress;
   
   progress = GTK_PROGRESS (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ACTIVITY_MODE:
-      GTK_VALUE_BOOL (*arg) = (progress->activity_mode != FALSE);
+    case PROP_ACTIVITY_MODE:
+      g_value_set_boolean (value, (progress->activity_mode != FALSE));
       break;
-    case ARG_SHOW_TEXT:
-      GTK_VALUE_BOOL (*arg) = (progress->show_text != FALSE);
+    case PROP_SHOW_TEXT:
+      g_value_set_boolean (value, (progress->show_text != FALSE));
       break;
-    case ARG_TEXT_XALIGN:
-      GTK_VALUE_FLOAT (*arg) = progress->x_align;
+    case PROP_TEXT_XALIGN:
+      g_value_set_float (value, progress->x_align);
       break;
-    case ARG_TEXT_YALIGN:
-      GTK_VALUE_FLOAT (*arg) = progress->y_align;
+    case PROP_TEXT_YALIGN:
+      g_value_set_float (value, progress->y_align);
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
@@ -602,6 +630,8 @@ gtk_progress_set_show_text (GtkProgress 
 
       if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (progress)))
 	gtk_widget_queue_resize (GTK_WIDGET (progress));
+
+      g_object_notify (G_OBJECT (progress), "show_text");
     }
 }
 
@@ -617,9 +647,18 @@ gtk_progress_set_text_alignment (GtkProg
 
   if (progress->x_align != x_align || progress->y_align != y_align)
     {
-      progress->x_align = x_align;
-      progress->y_align = y_align;
+      if (progress->x_align != x_align)
+	{
+	  progress->x_align = x_align;
+	  g_object_notify (G_OBJECT (progress), "text_xalign");
+	}
 
+      if (progress->y_align != y_align)
+	{
+	  progress->y_align = y_align;
+	  g_object_notify (G_OBJECT (progress), "text_yalign");
+	}
+
       if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (progress)))
 	gtk_widget_queue_resize (GTK_WIDGET (progress));
     }
@@ -691,5 +730,7 @@ gtk_progress_set_activity_mode (GtkProgr
 
       if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (progress)))
 	gtk_widget_queue_resize (GTK_WIDGET (progress));
+
+      g_object_notify (G_OBJECT (progress), "activity_mode");
     }
 }
Index: gtk/gtkprogressbar.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkprogressbar.c,v
retrieving revision 1.28
diff -u -p -r1.28 gtkprogressbar.c
--- gtk/gtkprogressbar.c	2001/03/19 21:06:37	1.28
+++ gtk/gtkprogressbar.c	2001/03/30 15:39:15
@@ -36,6 +36,7 @@
 
 #include "gtkprogressbar.h"
 #include "gtksignal.h"
+#include "gtkintl.h"
 
 
 #define MIN_HORIZONTAL_BAR_WIDTH   150
@@ -46,30 +47,32 @@
 #define TEXT_SPACING               2
 
 enum {
-  ARG_0,
+  PROP_0,
 
   /* Supported args */
-  ARG_FRACTION,
-  ARG_PULSE_STEP,
-  ARG_ORIENTATION,
-  ARG_TEXT,
+  PROP_FRACTION,
+  PROP_PULSE_STEP,
+  PROP_ORIENTATION,
+  PROP_TEXT,
   
   /* Deprecated args */
-  ARG_ADJUSTMENT,
-  ARG_BAR_STYLE,
-  ARG_ACTIVITY_STEP,
-  ARG_ACTIVITY_BLOCKS,
-  ARG_DISCRETE_BLOCKS
+  PROP_ADJUSTMENT,
+  PROP_BAR_STYLE,
+  PROP_ACTIVITY_STEP,
+  PROP_ACTIVITY_BLOCKS,
+  PROP_DISCRETE_BLOCKS
 };
 
 static void gtk_progress_bar_class_init    (GtkProgressBarClass *klass);
 static void gtk_progress_bar_init          (GtkProgressBar      *pbar);
-static void gtk_progress_bar_set_arg       (GtkObject           *object,
-					    GtkArg              *arg,
-					    guint                arg_id);
-static void gtk_progress_bar_get_arg       (GtkObject           *object,
-					    GtkArg              *arg,
-					    guint                arg_id);
+static void gtk_progress_bar_set_property  (GObject             *object,
+					    guint                prop_id,
+					    const GValue        *value,
+					    GParamSpec          *pspec);
+static void gtk_progress_bar_get_property  (GObject             *object,
+					    guint                prop_id,
+					    GValue              *value,
+					    GParamSpec          *pspec);
 static void gtk_progress_bar_size_request  (GtkWidget           *widget,
 					    GtkRequisition      *requisition);
 static void gtk_progress_bar_real_update   (GtkProgress         *progress);
@@ -105,59 +108,107 @@ gtk_progress_bar_get_type (void)
 static void
 gtk_progress_bar_class_init (GtkProgressBarClass *class)
 {
-  GtkObjectClass *object_class;
+  GObjectClass *gobject_class;
   GtkWidgetClass *widget_class;
   GtkProgressClass *progress_class;
   
-  object_class = (GtkObjectClass *) class;
+  gobject_class = G_OBJECT_CLASS (class);
   widget_class = (GtkWidgetClass *) class;
   progress_class = (GtkProgressClass *) class;
-  
-  gtk_object_add_arg_type ("GtkProgressBar::adjustment",
-			   GTK_TYPE_ADJUSTMENT,
-			   GTK_ARG_READWRITE,
-			   ARG_ADJUSTMENT);
-  gtk_object_add_arg_type ("GtkProgressBar::orientation",
-			   GTK_TYPE_PROGRESS_BAR_ORIENTATION,
-			   GTK_ARG_READWRITE,
-			   ARG_ORIENTATION);
-  gtk_object_add_arg_type ("GtkProgressBar::bar_style",
-			   GTK_TYPE_PROGRESS_BAR_STYLE,
-			   GTK_ARG_READWRITE,
-			   ARG_BAR_STYLE);
-  gtk_object_add_arg_type ("GtkProgressBar::activity_step",
-			   GTK_TYPE_UINT,
-			   GTK_ARG_READWRITE,
-			   ARG_ACTIVITY_STEP);
-  gtk_object_add_arg_type ("GtkProgressBar::activity_blocks",
-			   GTK_TYPE_UINT,
-			   GTK_ARG_READWRITE,
-			   ARG_ACTIVITY_BLOCKS);
-  gtk_object_add_arg_type ("GtkProgressBar::discrete_blocks",
-			   GTK_TYPE_UINT,
-			   GTK_ARG_READWRITE,
-			   ARG_DISCRETE_BLOCKS);
-  gtk_object_add_arg_type ("GtkProgressBar::fraction",
-			   GTK_TYPE_DOUBLE,
-			   GTK_ARG_READWRITE,
-			   ARG_FRACTION);
-  gtk_object_add_arg_type ("GtkProgressBar::pulse_step",
-			   GTK_TYPE_DOUBLE,
-			   GTK_ARG_READWRITE,
-			   ARG_PULSE_STEP);
-  gtk_object_add_arg_type ("GtkProgressBar::text",
-			   GTK_TYPE_STRING,
-			   GTK_ARG_READWRITE,
-			   ARG_TEXT);
-  
-  object_class->set_arg = gtk_progress_bar_set_arg;
-  object_class->get_arg = gtk_progress_bar_get_arg;
 
+  gobject_class->set_property = gtk_progress_bar_set_property;
+  gobject_class->get_property = gtk_progress_bar_get_property;
+  
   widget_class->size_request = gtk_progress_bar_size_request;
 
   progress_class->paint = gtk_progress_bar_paint;
   progress_class->update = gtk_progress_bar_real_update;
   progress_class->act_mode_enter = gtk_progress_bar_act_mode_enter;
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_ADJUSTMENT,
+                                   g_param_spec_object ("adjustment",
+                                                        _("Adjustment"),
+                                                        _("The GtkAdjustment connected to the progress bar (Deprecated)"),
+                                                        GTK_TYPE_ADJUSTMENT,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_ORIENTATION,
+                                   g_param_spec_enum ("orientation",
+						      _("Orientation"),
+						      _("Orientation and growth of the progress bar"),
+						      GTK_TYPE_PROGRESS_BAR_ORIENTATION,
+						      GTK_PROGRESS_LEFT_TO_RIGHT,
+						      G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_BAR_STYLE,
+                                   g_param_spec_enum ("bar_style",
+						      _("Bar style"),
+						      _("Specifies the visual style of the bar in percentage mode (Deprecated)"),
+						      GTK_TYPE_PROGRESS_BAR_STYLE,
+						      GTK_PROGRESS_CONTINUOUS,
+						      G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_ACTIVITY_STEP,
+                                   g_param_spec_uint ("activity_step",
+						      _("Activity Step"),
+						      _("The increment used for each iteration in activity mode (Deprecated)"),
+						      -G_MAXUINT,
+						      G_MAXUINT,
+						      3,
+						      G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_ACTIVITY_BLOCKS,
+                                   g_param_spec_uint ("activity_blocks",
+						      _("Activity Blocks"),
+						      _("The number of blocks which can fit in the progress bar area in activity mode (Deprecated)"),
+						      2,
+						      G_MAXUINT,
+						      5,
+						      G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_DISCRETE_BLOCKS,
+                                   g_param_spec_uint ("discrete_blocks",
+						      _("Discrete Blocks"),
+						      _("The number of discrete blocks in a progress bar (when shown in the discrete style"),
+						      2,
+						      G_MAXUINT,
+						      10,
+						      G_PARAM_READWRITE));
+  
+  g_object_class_install_property (gobject_class,
+				   PROP_FRACTION,
+				   g_param_spec_double ("fraction",
+							_("Fraction"),
+							_("The fraction of total work that has been completed"),
+							0.0,
+							1.0,
+							0.0,
+							G_PARAM_READWRITE));  
+  
+  g_object_class_install_property (gobject_class,
+				   PROP_PULSE_STEP,
+				   g_param_spec_double ("pulse_step",
+							_("Pulse Step"),
+							_("The fraction of total progress to move the bouncing block when pulsed"),
+							0.0,
+							1.0,
+							0.1,
+							G_PARAM_READWRITE));  
+  
+  g_object_class_install_property (gobject_class,
+				   PROP_TEXT,
+				   g_param_spec_string ("text",
+							_("Text"),
+							_("Text to be displayed in the progress bar"),
+							"%P %%",
+							G_PARAM_READWRITE));
+
 }
 
 static void
@@ -175,88 +226,92 @@ gtk_progress_bar_init (GtkProgressBar *p
 }
 
 static void
-gtk_progress_bar_set_arg (GtkObject           *object,
-			  GtkArg              *arg,
-			  guint                arg_id)
+gtk_progress_bar_set_property (GObject      *object,
+			       guint         prop_id,
+			       const GValue *value,
+			       GParamSpec   *pspec)
 {
   GtkProgressBar *pbar;
 
   pbar = GTK_PROGRESS_BAR (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ADJUSTMENT:
-      gtk_progress_set_adjustment (GTK_PROGRESS (pbar), GTK_VALUE_POINTER (*arg));
+    case PROP_ADJUSTMENT:
+      gtk_progress_set_adjustment (GTK_PROGRESS (pbar),
+				   GTK_ADJUSTMENT (g_value_get_object (value)));
       break;
-    case ARG_ORIENTATION:
-      gtk_progress_bar_set_orientation (pbar, GTK_VALUE_ENUM (*arg));
+    case PROP_ORIENTATION:
+      gtk_progress_bar_set_orientation (pbar, g_value_get_enum (value));
       break;
-    case ARG_BAR_STYLE:
-      gtk_progress_bar_set_bar_style (pbar, GTK_VALUE_ENUM (*arg));
+    case PROP_BAR_STYLE:
+      gtk_progress_bar_set_bar_style (pbar, g_value_get_enum (value));
       break;
-    case ARG_ACTIVITY_STEP:
-      gtk_progress_bar_set_activity_step (pbar, GTK_VALUE_UINT (*arg));
+    case PROP_ACTIVITY_STEP:
+      gtk_progress_bar_set_activity_step (pbar, g_value_get_uint (value));
       break;
-    case ARG_ACTIVITY_BLOCKS:
-      gtk_progress_bar_set_activity_blocks (pbar, GTK_VALUE_UINT (*arg));
+    case PROP_ACTIVITY_BLOCKS:
+      gtk_progress_bar_set_activity_blocks (pbar, g_value_get_uint (value));
       break;
-    case ARG_DISCRETE_BLOCKS:
-      gtk_progress_bar_set_discrete_blocks (pbar, GTK_VALUE_UINT (*arg));
+    case PROP_DISCRETE_BLOCKS:
+      gtk_progress_bar_set_discrete_blocks (pbar, g_value_get_uint (value));
       break;
-    case ARG_FRACTION:
-      gtk_progress_bar_set_fraction (pbar, GTK_VALUE_DOUBLE (*arg));
+    case PROP_FRACTION:
+      gtk_progress_bar_set_fraction (pbar, g_value_get_double (value));
       break;
-    case ARG_PULSE_STEP:
-      gtk_progress_bar_set_pulse_step (pbar, GTK_VALUE_DOUBLE (*arg));
+    case PROP_PULSE_STEP:
+      gtk_progress_bar_set_pulse_step (pbar, g_value_get_double (value));
       break;
-    case ARG_TEXT:
-      gtk_progress_bar_set_text (pbar, GTK_VALUE_STRING (*arg));
+    case PROP_TEXT:
+      gtk_progress_bar_set_text (pbar, g_value_get_string (value));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
 static void
-gtk_progress_bar_get_arg (GtkObject           *object,
-			  GtkArg              *arg,
-			  guint                arg_id)
+gtk_progress_bar_get_property (GObject      *object,
+			       guint         prop_id,
+			       GValue       *value,
+			       GParamSpec   *pspec)
 {
   GtkProgressBar *pbar;
 
   pbar = GTK_PROGRESS_BAR (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ADJUSTMENT:
-      GTK_VALUE_POINTER (*arg) = GTK_PROGRESS (pbar)->adjustment;
+    case PROP_ADJUSTMENT:
+      g_value_set_object (value, G_OBJECT (GTK_PROGRESS (pbar)->adjustment));
       break;
-    case ARG_ORIENTATION:
-      GTK_VALUE_ENUM (*arg) = pbar->orientation;
+    case PROP_ORIENTATION:
+      g_value_set_enum (value, pbar->orientation);
       break;
-    case ARG_BAR_STYLE:
-      GTK_VALUE_ENUM (*arg) = pbar->bar_style;
+    case PROP_BAR_STYLE:
+      g_value_set_enum (value, pbar->bar_style);
       break;
-    case ARG_ACTIVITY_STEP:
-      GTK_VALUE_UINT (*arg) = pbar->activity_step;
+    case PROP_ACTIVITY_STEP:
+      g_value_set_uint (value, pbar->activity_step);
       break;
-    case ARG_ACTIVITY_BLOCKS:
-      GTK_VALUE_UINT (*arg) = pbar->activity_blocks;
+    case PROP_ACTIVITY_BLOCKS:
+      g_value_set_uint (value, pbar->activity_blocks);
       break;
-    case ARG_DISCRETE_BLOCKS:
-      GTK_VALUE_UINT (*arg) = pbar->blocks;
+    case PROP_DISCRETE_BLOCKS:
+      g_value_set_uint (value, pbar->blocks);
       break;
-    case ARG_FRACTION:
-      GTK_VALUE_DOUBLE (*arg) = gtk_progress_get_current_percentage (GTK_PROGRESS (pbar));
+    case PROP_FRACTION:
+      g_value_set_double (value, gtk_progress_get_current_percentage (GTK_PROGRESS (pbar)));
       break;
-    case ARG_PULSE_STEP:
-      GTK_VALUE_DOUBLE (*arg) = pbar->pulse_fraction;
+    case PROP_PULSE_STEP:
+      g_value_set_double (value, pbar->pulse_fraction);
       break;
-    case ARG_TEXT:
-      GTK_VALUE_STRING (*arg) = g_strdup (gtk_progress_bar_get_text (pbar));
+    case PROP_TEXT:
+      g_value_set_string (value, gtk_progress_bar_get_text (pbar));
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
@@ -930,9 +985,9 @@ gtk_progress_bar_set_orientation (GtkPro
 
       if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
 	gtk_widget_queue_resize (GTK_WIDGET (pbar));
-    }
 
-  g_object_notify (G_OBJECT (pbar), "orientation");
+      g_object_notify (G_OBJECT (pbar), "orientation");
+    }
 }
 
 /**
@@ -1018,6 +1073,8 @@ gtk_progress_bar_set_bar_style (GtkProgr
 
       if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
 	gtk_widget_queue_resize (GTK_WIDGET (pbar));
+
+      g_object_notify (G_OBJECT (pbar), "bar_style");
     }
 }
 
@@ -1035,6 +1092,8 @@ gtk_progress_bar_set_discrete_blocks (Gt
 
       if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
 	gtk_widget_queue_resize (GTK_WIDGET (pbar));
+
+      g_object_notify (G_OBJECT (pbar), "discrete_blocks");
     }
 }
 
@@ -1046,7 +1105,10 @@ gtk_progress_bar_set_activity_step (GtkP
   g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
 
   if (pbar->activity_step != step)
-    pbar->activity_step = step;
+    {
+      pbar->activity_step = step;
+      g_object_notify (G_OBJECT (pbar), "activity_step");
+    }
 }
 
 void
@@ -1058,5 +1120,8 @@ gtk_progress_bar_set_activity_blocks (Gt
   g_return_if_fail (blocks > 1);
 
   if (pbar->activity_blocks != blocks)
-    pbar->activity_blocks = blocks;
+    {
+      pbar->activity_blocks = blocks;
+      g_object_notify (G_OBJECT (pbar), "activity_blocks");
+    }
 }
Index: gtk/gtkrange.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkrange.c,v
retrieving revision 1.48
diff -u -p -r1.48 gtkrange.c
--- gtk/gtkrange.c	2001/03/28 04:01:21	1.48
+++ gtk/gtkrange.c	2001/03/30 15:39:18
@@ -28,6 +28,7 @@
 #include "gtkmain.h"
 #include "gtkrange.h"
 #include "gtksignal.h"
+#include "gtkintl.h"
 
 #define SCROLL_TIMER_LENGTH  20
 #define SCROLL_INITIAL_DELAY 250  /* must hold button this long before ... */
@@ -37,18 +38,20 @@
 #define RANGE_CLASS(w)  GTK_RANGE_GET_CLASS (w)
 
 enum {
-  ARG_0,
-  ARG_UPDATE_POLICY
+  PROP_0,
+  PROP_UPDATE_POLICY
 };
 
 static void gtk_range_class_init               (GtkRangeClass    *klass);
 static void gtk_range_init                     (GtkRange         *range);
-static void gtk_range_set_arg		       (GtkObject        *object,
-						GtkArg           *arg,
-						guint             arg_id);
-static void gtk_range_get_arg		       (GtkObject        *object,
-						GtkArg           *arg,
-						guint             arg_id);
+static void gtk_range_set_property             (GObject          *object,
+						guint             prop_id,
+						const GValue     *value,
+						GParamSpec       *pspec);
+static void gtk_range_get_property             (GObject          *object,
+						guint             prop_id,
+						GValue           *value,
+						GParamSpec       *pspec);
 static void gtk_range_destroy                  (GtkObject        *object);
 static void gtk_range_unrealize                (GtkWidget        *widget);
 static gint gtk_range_expose                   (GtkWidget        *widget,
@@ -122,16 +125,18 @@ gtk_range_get_type (void)
 static void
 gtk_range_class_init (GtkRangeClass *class)
 {
+  GObjectClass   *gobject_class;
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
 
+  gobject_class = G_OBJECT_CLASS (class);
   object_class = (GtkObjectClass*) class;
   widget_class = (GtkWidgetClass*) class;
 
   parent_class = gtk_type_class (GTK_TYPE_WIDGET);
 
-  object_class->set_arg = gtk_range_set_arg;
-  object_class->get_arg = gtk_range_get_arg;
+  gobject_class->set_property = gtk_range_set_property;
+  gobject_class->get_property = gtk_range_get_property;
   object_class->destroy = gtk_range_destroy;
 
   widget_class->unrealize = gtk_range_unrealize;
@@ -164,47 +169,54 @@ gtk_range_class_init (GtkRangeClass *cla
   class->motion = NULL;
   class->timer = gtk_real_range_timer;
 
-  gtk_object_add_arg_type ("GtkRange::update_policy",
-			   GTK_TYPE_UPDATE_TYPE,
-			   GTK_ARG_READWRITE,
-			   ARG_UPDATE_POLICY);
+  g_object_class_install_property (gobject_class,
+                                   PROP_UPDATE_POLICY,
+                                   g_param_spec_enum ("update_policy",
+						      _("Update policy"),
+						      _("How the range should be updated on the screen"),
+						      GTK_TYPE_UPDATE_TYPE,
+						      GTK_UPDATE_CONTINUOUS,
+						      G_PARAM_READWRITE));  
 }
 
 static void
-gtk_range_set_arg (GtkObject      *object,
-		   GtkArg         *arg,
-		   guint           arg_id)
+gtk_range_set_property (GObject      *object,
+			guint         prop_id,
+			const GValue *value,
+			GParamSpec   *pspec)
 {
   GtkRange *range;
 
   range = GTK_RANGE (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_UPDATE_POLICY:
-      gtk_range_set_update_policy (range, GTK_VALUE_ENUM (*arg));
+    case PROP_UPDATE_POLICY:
+      gtk_range_set_update_policy (range, g_value_get_enum (value));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
 static void
-gtk_range_get_arg (GtkObject      *object,
-		   GtkArg         *arg,
-		   guint           arg_id)
+gtk_range_get_property (GObject      *object,
+			guint         prop_id,
+			GValue       *value,
+			GParamSpec   *pspec)
 {
   GtkRange *range;
 
   range = GTK_RANGE (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_UPDATE_POLICY:
-      GTK_VALUE_ENUM (*arg) = range->policy;
+    case PROP_UPDATE_POLICY:
+      g_value_set_enum (value, range->policy);
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
@@ -254,7 +266,11 @@ gtk_range_set_update_policy (GtkRange   
   g_return_if_fail (range != NULL);
   g_return_if_fail (GTK_IS_RANGE (range));
 
-  range->policy = policy;
+  if (range->policy != policy)
+    {
+      range->policy = policy;
+      g_object_notify (G_OBJECT (range), "update_policy");
+    }
 }
 
 void
Index: gtk/gtktable.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtktable.c,v
retrieving revision 1.41
diff -u -p -r1.41 gtktable.c
--- gtk/gtktable.c	2001/03/09 13:28:25	1.41
+++ gtk/gtktable.c	2001/03/30 15:39:21
@@ -25,15 +25,16 @@
  */
 
 #include "gtktable.h"
+#include "gtkintl.h"
 
 enum
 {
-  ARG_0,
-  ARG_N_ROWS,
-  ARG_N_COLUMNS,
-  ARG_COLUMN_SPACING,
-  ARG_ROW_SPACING,
-  ARG_HOMOGENEOUS
+  PROP_0,
+  PROP_N_ROWS,
+  PROP_N_COLUMNS,
+  PROP_COLUMN_SPACING,
+  PROP_ROW_SPACING,
+  PROP_HOMOGENEOUS
 };
 
 enum
@@ -67,12 +68,14 @@ static void gtk_table_forall	    (GtkCon
 				     gboolean	     include_internals,
 				     GtkCallback     callback,
 				     gpointer	     callback_data);
-static void gtk_table_get_arg       (GtkObject      *object,
-				     GtkArg         *arg,
-				     guint           arg_id);
-static void gtk_table_set_arg       (GtkObject      *object,
-				     GtkArg         *arg,
-				     guint           arg_id);
+static void gtk_table_get_property  (GObject         *object,
+				     guint            prop_id,
+				     GValue          *value,
+				     GParamSpec      *pspec);
+static void gtk_table_set_property  (GObject         *object,
+				     guint            prop_id,
+				     const GValue    *value,
+				     GParamSpec      *pspec);
 static void gtk_table_set_child_arg (GtkContainer   *container,
 				     GtkWidget      *child,
 				     GtkArg         *arg,
@@ -138,8 +141,8 @@ gtk_table_class_init (GtkTableClass *cla
 
   gobject_class->finalize = gtk_table_finalize;
 
-  object_class->get_arg = gtk_table_get_arg;
-  object_class->set_arg = gtk_table_set_arg;
+  gobject_class->get_property = gtk_table_get_property;
+  gobject_class->set_property = gtk_table_set_property;
   
   widget_class->map = gtk_table_map;
   widget_class->unmap = gtk_table_unmap;
@@ -153,11 +156,55 @@ gtk_table_class_init (GtkTableClass *cla
   container_class->set_child_arg = gtk_table_set_child_arg;
   container_class->get_child_arg = gtk_table_get_child_arg;
   
-  gtk_object_add_arg_type ("GtkTable::n_rows", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_N_ROWS);
-  gtk_object_add_arg_type ("GtkTable::n_columns", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_N_COLUMNS);
-  gtk_object_add_arg_type ("GtkTable::row_spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_ROW_SPACING);
-  gtk_object_add_arg_type ("GtkTable::column_spacing", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_COLUMN_SPACING);
-  gtk_object_add_arg_type ("GtkTable::homogeneous", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HOMOGENEOUS);
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_N_ROWS,
+                                   g_param_spec_uint ("n_rows",
+						     _("Rows"),
+						     _("The number of rows in the table"),
+						     0,
+						     G_MAXUINT,
+						     0,
+						     G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_N_COLUMNS,
+                                   g_param_spec_uint ("n_columns",
+						     _("Columns"),
+						     _("The number of columns in the table"),
+						     0,
+						     G_MAXUINT,
+						     0,
+						     G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_ROW_SPACING,
+                                   g_param_spec_uint ("row_spacing",
+						     _("Row spacing"),
+						     _("The amount of space between two consecutive rows"),
+						     0,
+						     G_MAXUINT,
+						     0,
+						     G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_COLUMN_SPACING,
+                                   g_param_spec_uint ("column_spacing",
+						     _("Column spacing"),
+						     _("The amount of space between two consecutive columns"),
+						     0,
+						     G_MAXUINT,
+						     0,
+						     G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_HOMOGENEOUS,
+                                   g_param_spec_boolean ("homogeneous",
+							 _("Homogenous"),
+							 _("If TRUE this means the table cells are all the same width/height"),
+							 FALSE,
+							 G_PARAM_READWRITE));
+
   gtk_container_add_child_arg_type ("GtkTable::left_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_LEFT_ATTACH);
   gtk_container_add_child_arg_type ("GtkTable::right_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_RIGHT_ATTACH);
   gtk_container_add_child_arg_type ("GtkTable::top_attach", GTK_TYPE_UINT, GTK_ARG_READWRITE, CHILD_ARG_TOP_ATTACH);
@@ -175,64 +222,67 @@ gtk_table_child_type (GtkContainer   *co
 }
 
 static void
-gtk_table_get_arg (GtkObject      *object,
-		   GtkArg         *arg,
-		   guint           arg_id)
+gtk_table_get_property (GObject      *object,
+			guint         prop_id,
+			GValue       *value,
+			GParamSpec   *pspec)
 {
   GtkTable *table;
 
   table = GTK_TABLE (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_N_ROWS:
-      GTK_VALUE_UINT (*arg) = table->nrows;
+    case PROP_N_ROWS:
+      g_value_set_uint (value, table->nrows);
       break;
-    case ARG_N_COLUMNS:
-      GTK_VALUE_UINT (*arg) = table->ncols;
+    case PROP_N_COLUMNS:
+      g_value_set_uint (value, table->ncols);
       break;
-    case ARG_ROW_SPACING:
-      GTK_VALUE_UINT (*arg) = table->row_spacing;
+    case PROP_ROW_SPACING:
+      g_value_set_uint (value, table->row_spacing);
       break;
-    case ARG_COLUMN_SPACING:
-      GTK_VALUE_UINT (*arg) = table->column_spacing;
+    case PROP_COLUMN_SPACING:
+      g_value_set_uint (value, table->column_spacing);
       break;
-    case ARG_HOMOGENEOUS:
-      GTK_VALUE_BOOL (*arg) = table->homogeneous;
+    case PROP_HOMOGENEOUS:
+      g_value_set_boolean (value, table->homogeneous);
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
 static void
-gtk_table_set_arg (GtkObject      *object,
-		   GtkArg         *arg,
-		   guint           arg_id)
+gtk_table_set_property (GObject      *object,
+			guint         prop_id,
+			const GValue *value,
+			GParamSpec   *pspec)
 {
   GtkTable *table;
 
   table = GTK_TABLE (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_N_ROWS:
-      gtk_table_resize (table, GTK_VALUE_UINT (*arg), table->ncols);
+    case PROP_N_ROWS:
+      gtk_table_resize (table, g_value_get_uint (value), table->ncols);
       break;
-    case ARG_N_COLUMNS:
-      gtk_table_resize (table, table->nrows, GTK_VALUE_UINT (*arg));
+    case PROP_N_COLUMNS:
+      gtk_table_resize (table, table->nrows, g_value_get_uint (value));
       break;
-    case ARG_ROW_SPACING:
-      gtk_table_set_row_spacings (table, GTK_VALUE_UINT (*arg));
+    case PROP_ROW_SPACING:
+      gtk_table_set_row_spacings (table, g_value_get_uint (value));
       break;
-    case ARG_COLUMN_SPACING:
-      gtk_table_set_col_spacings (table, GTK_VALUE_UINT (*arg));
+    case PROP_COLUMN_SPACING:
+      gtk_table_set_col_spacings (table, g_value_get_uint (value));
       break;
-    case ARG_HOMOGENEOUS:
-      gtk_table_set_homogeneous (table, GTK_VALUE_BOOL (*arg));
+    case PROP_HOMOGENEOUS:
+      gtk_table_set_homogeneous (table, g_value_get_boolean (value));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
@@ -458,6 +508,8 @@ gtk_table_resize (GtkTable *table,
 	      table->rows[i].expand = 0;
 	      table->rows[i].shrink = 0;
 	    }
+
+	  g_object_notify (G_OBJECT (table), "n_rows");
 	}
 
       if (n_cols != table->ncols)
@@ -478,6 +530,8 @@ gtk_table_resize (GtkTable *table,
 	      table->cols[i].expand = 0;
 	      table->cols[i].shrink = 0;
 	    }
+
+	  g_object_notify (G_OBJECT (table), "n_columns");
 	}
     }
 }
@@ -576,6 +630,8 @@ gtk_table_set_row_spacing (GtkTable *tab
       if (GTK_WIDGET_VISIBLE (table))
 	gtk_widget_queue_resize (GTK_WIDGET (table));
     }
+
+  g_object_notify (G_OBJECT (table), "row_spacing");
 }
 
 void
@@ -594,6 +650,8 @@ gtk_table_set_col_spacing (GtkTable *tab
       if (GTK_WIDGET_VISIBLE (table))
 	gtk_widget_queue_resize (GTK_WIDGET (table));
     }
+
+  g_object_notify (G_OBJECT (table), "column_spacing");
 }
 
 void
Index: gtk/gtkviewport.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkviewport.c,v
retrieving revision 1.44
diff -u -p -r1.44 gtkviewport.c
--- gtk/gtkviewport.c	2001/03/09 13:28:26	1.44
+++ gtk/gtkviewport.c	2001/03/30 15:39:23
@@ -26,24 +26,27 @@
 
 #include "gtksignal.h"
 #include "gtkviewport.h"
+#include "gtkintl.h"
 
 enum {
-  ARG_0,
-  ARG_HADJUSTMENT,
-  ARG_VADJUSTMENT,
-  ARG_SHADOW_TYPE
+  PROP_0,
+  PROP_HADJUSTMENT,
+  PROP_VADJUSTMENT,
+  PROP_SHADOW_TYPE
 };
 
 
 static void gtk_viewport_class_init               (GtkViewportClass *klass);
 static void gtk_viewport_init                     (GtkViewport      *viewport);
 static void gtk_viewport_destroy                  (GtkObject        *object);
-static void gtk_viewport_set_arg		  (GtkObject        *object,
-						   GtkArg           *arg,
-						   guint             arg_id);
-static void gtk_viewport_get_arg		  (GtkObject        *object,
-						   GtkArg           *arg,
-						   guint             arg_id);
+static void gtk_viewport_set_property             (GObject         *object,
+						   guint            prop_id,
+						   const GValue    *value,
+						   GParamSpec      *pspec);
+static void gtk_viewport_get_property             (GObject         *object,
+						   guint            prop_id,
+						   GValue          *value,
+						   GParamSpec      *pspec);
 static void gtk_viewport_set_scroll_adjustments	  (GtkViewport	    *viewport,
 						   GtkAdjustment    *hadjustment,
 						   GtkAdjustment    *vadjustment);
@@ -99,16 +102,18 @@ static void
 gtk_viewport_class_init (GtkViewportClass *class)
 {
   GtkObjectClass *object_class;
+  GObjectClass   *gobject_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;
 
   object_class = (GtkObjectClass*) class;
+  gobject_class = G_OBJECT_CLASS (class);
   widget_class = (GtkWidgetClass*) class;
   container_class = (GtkContainerClass*) class;
   parent_class = (GtkBinClass*) gtk_type_class (GTK_TYPE_BIN);
 
-  object_class->set_arg = gtk_viewport_set_arg;
-  object_class->get_arg = gtk_viewport_get_arg;
+  gobject_class->set_property = gtk_viewport_set_property;
+  gobject_class->get_property = gtk_viewport_get_property;
   object_class->destroy = gtk_viewport_destroy;
   
   widget_class->map = gtk_viewport_map;
@@ -124,18 +129,30 @@ gtk_viewport_class_init (GtkViewportClas
 
   class->set_scroll_adjustments = gtk_viewport_set_scroll_adjustments;
 
-  gtk_object_add_arg_type ("GtkViewport::hadjustment",
-			   GTK_TYPE_ADJUSTMENT,
-			   GTK_ARG_READWRITE,
-			   ARG_HADJUSTMENT);
-  gtk_object_add_arg_type ("GtkViewport::vadjustment",
-			   GTK_TYPE_ADJUSTMENT,
-			   GTK_ARG_READWRITE,
-			   ARG_VADJUSTMENT);
-  gtk_object_add_arg_type ("GtkViewport::shadow_type",
-			   GTK_TYPE_SHADOW_TYPE,
-			   GTK_ARG_READWRITE,
-			   ARG_SHADOW_TYPE);
+  g_object_class_install_property (gobject_class,
+                                   PROP_HADJUSTMENT,
+                                   g_param_spec_object ("hadjustment",
+							_("Horizontal adjustment"),
+							_("The GtkAdjustment that determines the values of the horizontal position for this viewport."),
+                                                        GTK_TYPE_ADJUSTMENT,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_VADJUSTMENT,
+                                   g_param_spec_object ("vadjustment",
+							_("Vertical adjustment"),
+							_("The GtkAdjustment that determines the values of the vertical position for this viewport."),
+                                                        GTK_TYPE_ADJUSTMENT,
+                                                        G_PARAM_READWRITE));
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_SHADOW_TYPE,
+                                   g_param_spec_enum ("shadow_type",
+						      _("Shadow type"),
+						      _("Determines how the shadowed box around the viewport is drawn."),
+						      GTK_TYPE_SHADOW_TYPE,
+						      GTK_SHADOW_IN,
+						      G_PARAM_READWRITE));
 
   widget_class->set_scroll_adjustments_signal =
     gtk_signal_new ("set_scroll_adjustments",
@@ -147,52 +164,55 @@ gtk_viewport_class_init (GtkViewportClas
 }
 
 static void
-gtk_viewport_set_arg (GtkObject        *object,
-		      GtkArg           *arg,
-		      guint             arg_id)
+gtk_viewport_set_property (GObject         *object,
+			   guint            prop_id,
+			   const GValue    *value,
+			   GParamSpec      *pspec)
 {
   GtkViewport *viewport;
 
   viewport = GTK_VIEWPORT (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_HADJUSTMENT:
-      gtk_viewport_set_hadjustment (viewport, GTK_VALUE_POINTER (*arg));
+    case PROP_HADJUSTMENT:
+      gtk_viewport_set_hadjustment (viewport, g_value_get_object (value));
       break;
-    case ARG_VADJUSTMENT:
-      gtk_viewport_set_vadjustment (viewport, GTK_VALUE_POINTER (*arg));
+    case PROP_VADJUSTMENT:
+      gtk_viewport_set_vadjustment (viewport, g_value_get_object (value));
       break;
-    case ARG_SHADOW_TYPE:
-      gtk_viewport_set_shadow_type (viewport, GTK_VALUE_ENUM (*arg));
+    case PROP_SHADOW_TYPE:
+      gtk_viewport_set_shadow_type (viewport, g_value_get_enum (value));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
 static void
-gtk_viewport_get_arg (GtkObject        *object,
-		      GtkArg           *arg,
-		      guint             arg_id)
+gtk_viewport_get_property (GObject         *object,
+			   guint            prop_id,
+			   GValue          *value,
+			   GParamSpec      *pspec)
 {
   GtkViewport *viewport;
 
   viewport = GTK_VIEWPORT (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_HADJUSTMENT:
-      GTK_VALUE_POINTER (*arg) = viewport->hadjustment;
+    case PROP_HADJUSTMENT:
+      g_value_set_object (value, viewport->hadjustment);
       break;
-    case ARG_VADJUSTMENT:
-      GTK_VALUE_POINTER (*arg) = viewport->vadjustment;
+    case PROP_VADJUSTMENT:
+      g_value_set_object (value, viewport->vadjustment);
       break;
-    case ARG_SHADOW_TYPE:
-      GTK_VALUE_ENUM (*arg) = viewport->shadow_type;
+    case PROP_SHADOW_TYPE:
+      g_value_set_enum (value, viewport->shadow_type);
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
@@ -305,6 +325,8 @@ gtk_viewport_set_hadjustment (GtkViewpor
 
       gtk_viewport_adjustment_changed (adjustment, viewport);
     }
+
+  g_object_notify (G_OBJECT (viewport), "hadjustment");
 }
 
 void
@@ -342,6 +364,8 @@ gtk_viewport_set_vadjustment (GtkViewpor
 
       gtk_viewport_adjustment_changed (adjustment, viewport);
     }
+
+  g_object_notify (G_OBJECT (viewport), "vadjustment");
 }
 
 static void
@@ -372,6 +396,8 @@ gtk_viewport_set_shadow_type (GtkViewpor
 	  gtk_widget_queue_draw (GTK_WIDGET (viewport));
 	}
     }
+
+  g_object_notify (G_OBJECT (viewport), "shadow_type");
 }
 
 
Index: gtk/gtkvscale.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkvscale.c,v
retrieving revision 1.28
diff -u -p -r1.28 gtkvscale.c
--- gtk/gtkvscale.c	2001/03/28 04:01:21	1.28
+++ gtk/gtkvscale.c	2001/03/30 15:39:24
@@ -28,24 +28,27 @@
 #include "gtkvscale.h"
 #include "gtksignal.h"
 #include "gdk/gdkkeysyms.h"
+#include "gtkintl.h"
 
 
 #define SCALE_CLASS(w)  GTK_SCALE_GET_CLASS (w)
 #define RANGE_CLASS(w)  GTK_RANGE_GET_CLASS (w)
 
 enum {
-  ARG_0,
-  ARG_ADJUSTMENT
+  PROP_0,
+  PROP_ADJUSTMENT
 };
 
 static void     gtk_vscale_class_init       (GtkVScaleClass *klass);
 static void     gtk_vscale_init             (GtkVScale      *vscale);
-static void     gtk_vscale_set_arg          (GtkObject      *object,
-					     GtkArg         *arg,
-					     guint           arg_id);
-static void     gtk_vscale_get_arg          (GtkObject      *object,
-					     GtkArg         *arg,
-					     guint           arg_id);
+static void     gtk_vscale_set_property     (GObject        *object,
+					     guint           prop_id,
+					     const GValue   *value,
+					     GParamSpec     *pspec);
+static void     gtk_vscale_get_property     (GObject        *object,
+					     guint           prop_id,
+					     GValue         *value,
+					     GParamSpec     *pspec);
 static void     gtk_vscale_realize          (GtkWidget      *widget);
 static void     gtk_vscale_size_request     (GtkWidget      *widget,
 					     GtkRequisition *requisition);
@@ -98,23 +101,20 @@ static void
 gtk_vscale_class_init (GtkVScaleClass *class)
 {
   GtkObjectClass *object_class;
+  GObjectClass   *gobject_class;
   GtkWidgetClass *widget_class;
   GtkRangeClass *range_class;
   GtkScaleClass *scale_class;
   
   object_class = (GtkObjectClass*) class;
+  gobject_class = G_OBJECT_CLASS (class);
   widget_class = (GtkWidgetClass*) class;
   range_class = (GtkRangeClass*) class;
   scale_class = (GtkScaleClass*) class;
   
-  gtk_object_add_arg_type ("GtkVScale::adjustment",
-                           GTK_TYPE_ADJUSTMENT,
-                           GTK_ARG_READWRITE,
-                           ARG_ADJUSTMENT);
+  gobject_class->set_property = gtk_vscale_set_property;
+  gobject_class->get_property = gtk_vscale_get_property;
   
-  object_class->set_arg = gtk_vscale_set_arg;
-  object_class->get_arg = gtk_vscale_get_arg;
-  
   widget_class->realize = gtk_vscale_realize;
   widget_class->size_request = gtk_vscale_size_request;
   widget_class->size_allocate = gtk_vscale_size_allocate;
@@ -127,43 +127,55 @@ gtk_vscale_class_init (GtkVScaleClass *c
   range_class->clear_background = gtk_vscale_clear_background;
   
   scale_class->draw_value = gtk_vscale_draw_value;
+
+  g_object_class_install_property (gobject_class,
+				   PROP_ADJUSTMENT,
+				   g_param_spec_object ("adjustment",
+							_("Adjustment"),
+							_("The GtkAdjustment that determines the values to use for this VScale."),
+							GTK_TYPE_ADJUSTMENT,
+							G_PARAM_READWRITE));
 }
 
 static void
-gtk_vscale_set_arg (GtkObject          *object,
-                    GtkArg             *arg,
-                    guint               arg_id)
+gtk_vscale_set_property (GObject         *object,
+			 guint            prop_id,
+			 const GValue    *value,
+			 GParamSpec      *pspec)
 {
   GtkVScale *vscale;
   
   vscale = GTK_VSCALE (object);
   
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ADJUSTMENT:
-      gtk_range_set_adjustment (GTK_RANGE (vscale), GTK_VALUE_POINTER (*arg));
+    case PROP_ADJUSTMENT:
+      gtk_range_set_adjustment (GTK_RANGE (vscale), g_value_get_object (value));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
 static void
-gtk_vscale_get_arg (GtkObject          *object,
-                    GtkArg             *arg,
-                    guint               arg_id)
+gtk_vscale_get_property (GObject         *object,
+			 guint            prop_id,
+			 GValue          *value,
+			 GParamSpec      *pspec)
 {
   GtkVScale *vscale;
   
   vscale = GTK_VSCALE (object);
   
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ADJUSTMENT:
-      GTK_VALUE_POINTER (*arg) = GTK_RANGE (vscale);
+    case PROP_ADJUSTMENT:
+      g_value_set_object (value,
+			  G_OBJECT (gtk_range_get_adjustment (GTK_RANGE (vscale))));
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
Index: gtk/gtkvscrollbar.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkvscrollbar.c,v
retrieving revision 1.23
diff -u -p -r1.23 gtkvscrollbar.c
--- gtk/gtkvscrollbar.c	2001/03/28 04:01:21	1.23
+++ gtk/gtkvscrollbar.c	2001/03/30 15:39:25
@@ -27,6 +27,7 @@
 #include "gtkvscrollbar.h"
 #include "gtksignal.h"
 #include "gdk/gdkkeysyms.h"
+#include "gtkintl.h"
 
 
 #define EPSILON 0.01
@@ -34,18 +35,20 @@
 #define RANGE_CLASS(w)  GTK_RANGE_GET_CLASS (w)
 
 enum {
-  ARG_0,
-  ARG_ADJUSTMENT
+  PROP_0,
+  PROP_ADJUSTMENT
 };
 
 static void     gtk_vscrollbar_class_init       (GtkVScrollbarClass *klass);
 static void     gtk_vscrollbar_init             (GtkVScrollbar      *vscrollbar);
-static void     gtk_vscrollbar_set_arg          (GtkObject          *object,
-						 GtkArg             *arg,
-						 guint               arg_id);
-static void     gtk_vscrollbar_get_arg          (GtkObject          *object,
-						 GtkArg             *arg,
-						 guint               arg_id);
+static void     gtk_vscrollbar_set_property	(GObject            *object,
+						 guint               prop_id,
+						 const GValue       *value,
+						 GParamSpec         *pspec);
+static void     gtk_vscrollbar_get_property     (GObject            *object,
+						 guint               prop_id,
+						 GValue             *value,
+						 GParamSpec         *pspec);
 static void     gtk_vscrollbar_realize          (GtkWidget          *widget);
 static void     gtk_vscrollbar_size_allocate    (GtkWidget          *widget,
 						 GtkAllocation      *allocation);
@@ -87,22 +90,17 @@ gtk_vscrollbar_get_type (void)
 static void
 gtk_vscrollbar_class_init (GtkVScrollbarClass *class)
 {
-  GtkObjectClass *object_class;
+  GObjectClass   *gobject_class;
   GtkWidgetClass *widget_class;
   GtkRangeClass *range_class;
   
-  object_class = (GtkObjectClass*) class;
+  gobject_class = G_OBJECT_CLASS (class);
   widget_class = (GtkWidgetClass*) class;
   range_class = (GtkRangeClass*) class;
   
-  gtk_object_add_arg_type ("GtkVScrollbar::adjustment",
-                           GTK_TYPE_ADJUSTMENT,
-                           GTK_ARG_READWRITE,
-                           ARG_ADJUSTMENT);
+  gobject_class->set_property = gtk_vscrollbar_set_property;
+  gobject_class->get_property = gtk_vscrollbar_get_property;
   
-  object_class->set_arg = gtk_vscrollbar_set_arg;
-  object_class->get_arg = gtk_vscrollbar_get_arg;
-  
   widget_class->realize = gtk_vscrollbar_realize;
   widget_class->size_allocate = gtk_vscrollbar_size_allocate;
   
@@ -112,43 +110,55 @@ gtk_vscrollbar_class_init (GtkVScrollbar
   range_class->trough_click = _gtk_range_default_vtrough_click;
   range_class->trough_keys = gtk_vscrollbar_trough_keys;
   range_class->motion = _gtk_range_default_vmotion;
+
+  g_object_class_install_property (gobject_class,
+                                   PROP_ADJUSTMENT,
+                                   g_param_spec_object ("adjustment",
+							_("Adjustment"),
+							_("The GtkAdjustment that determines the values to use for this scrollbar."),
+                                                        GTK_TYPE_ADJUSTMENT,
+                                                        G_PARAM_READWRITE));
+
 }
 
 static void
-gtk_vscrollbar_set_arg (GtkObject          *object,
-                        GtkArg             *arg,
-                        guint               arg_id)
+gtk_vscrollbar_set_property (GObject         *object,
+			     guint            prop_id,
+			     const GValue    *value,
+			     GParamSpec      *pspec)
 {
   GtkVScrollbar *vscrollbar;
   
   vscrollbar = GTK_VSCROLLBAR (object);
   
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ADJUSTMENT:
-      gtk_range_set_adjustment (GTK_RANGE (vscrollbar), GTK_VALUE_POINTER (*arg));
+    case PROP_ADJUSTMENT:
+      gtk_range_set_adjustment (GTK_RANGE (vscrollbar), g_value_get_object (value));
       break;
     default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
 static void
-gtk_vscrollbar_get_arg (GtkObject          *object,
-                        GtkArg             *arg,
-                        guint               arg_id)
+gtk_vscrollbar_get_property (GObject         *object,
+			     guint            prop_id,
+			     GValue          *value,
+			     GParamSpec      *pspec)
 {
   GtkVScrollbar *vscrollbar;
   
   vscrollbar = GTK_VSCROLLBAR (object);
   
-  switch (arg_id)
+  switch (prop_id)
     {
-    case ARG_ADJUSTMENT:
-      GTK_VALUE_POINTER (*arg) = GTK_RANGE (vscrollbar);
+    case PROP_ADJUSTMENT:
+      g_value_set_object (value, G_OBJECT (vscrollbar));
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
Index: gtk/gtkwidget.c
===================================================================
RCS file: /cvs/gnome/gtk+/gtk/gtkwidget.c,v
retrieving revision 1.201
diff -u -p -r1.201 gtkwidget.c
--- gtk/gtkwidget.c	2001/03/29 23:02:26	1.201
+++ gtk/gtkwidget.c	2001/03/30 15:39:37
@@ -41,6 +41,7 @@
 #include "gdk/gdkprivate.h" /* Used in gtk_reset_shapes_recurse to avoid copy */
 #include "gobject/gvaluecollector.h"
 #include "gdk/gdkkeysyms.h"
+#include "gtkintl.h"
 
 
 #define WIDGET_CLASS(w)	 GTK_WIDGET_GET_CLASS (w)
@@ -107,25 +108,25 @@ enum {
 };
 
 enum {
-  ARG_0,
-  ARG_NAME,
-  ARG_PARENT,
-  ARG_X,
-  ARG_Y,
-  ARG_WIDTH,
-  ARG_HEIGHT,
-  ARG_VISIBLE,
-  ARG_SENSITIVE,
-  ARG_APP_PAINTABLE,
-  ARG_CAN_FOCUS,
-  ARG_HAS_FOCUS,
-  ARG_CAN_DEFAULT,
-  ARG_HAS_DEFAULT,
-  ARG_RECEIVES_DEFAULT,
-  ARG_COMPOSITE_CHILD,
-  ARG_STYLE,
-  ARG_EVENTS,
-  ARG_EXTENSION_EVENTS
+  PROP_0,
+  PROP_NAME,
+  PROP_PARENT,
+  PROP_X,
+  PROP_Y,
+  PROP_WIDTH,
+  PROP_HEIGHT,
+  PROP_VISIBLE,
+  PROP_SENSITIVE,
+  PROP_APP_PAINTABLE,
+  PROP_CAN_FOCUS,
+  PROP_HAS_FOCUS,
+  PROP_CAN_DEFAULT,
+  PROP_HAS_DEFAULT,
+  PROP_RECEIVES_DEFAULT,
+  PROP_COMPOSITE_CHILD,
+  PROP_STYLE,
+  PROP_EVENTS,
+  PROP_EXTENSION_EVENTS
 };
 
 typedef	struct	_GtkStateData	 GtkStateData;
@@ -140,12 +141,14 @@ struct _GtkStateData
 
 static void gtk_widget_class_init		 (GtkWidgetClass    *klass);
 static void gtk_widget_init			 (GtkWidget	    *widget);
-static void gtk_widget_set_arg			 (GtkObject         *object,
-						  GtkArg	    *arg,
-						  guint		     arg_id);
-static void gtk_widget_get_arg			 (GtkObject         *object,
-						  GtkArg	    *arg,
-						  guint		     arg_id);
+static void gtk_widget_set_property		 (GObject           *object,
+						  guint              prop_id,
+						  const GValue      *value,
+						  GParamSpec        *pspec);
+static void gtk_widget_get_property		 (GObject           *object,
+						  guint              prop_id,
+						  GValue            *value,
+						  GParamSpec        *pspec);
 static void gtk_widget_shutdown			 (GObject	    *object);
 static void gtk_widget_real_destroy		 (GtkObject	    *object);
 static void gtk_widget_finalize			 (GObject	    *object);
@@ -291,9 +294,9 @@ gtk_widget_class_init (GtkWidgetClass *k
 
   gobject_class->shutdown = gtk_widget_shutdown;
   gobject_class->finalize = gtk_widget_finalize;
+  gobject_class->set_property = gtk_widget_set_property;
+  gobject_class->get_property = gtk_widget_get_property;
 
-  object_class->set_arg = gtk_widget_set_arg;
-  object_class->get_arg = gtk_widget_get_arg;
   object_class->destroy = gtk_widget_real_destroy;
   
   klass->activate_signal = 0;
@@ -364,25 +367,162 @@ gtk_widget_class_init (GtkWidgetClass *k
 
   style_property_spec_pool = g_param_spec_pool_new (FALSE);
 
-  gtk_object_add_arg_type ("GtkWidget::name", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_NAME);
-  gtk_object_add_arg_type ("GtkWidget::parent", GTK_TYPE_CONTAINER, GTK_ARG_READWRITE, ARG_PARENT);
-  gtk_object_add_arg_type ("GtkWidget::x", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_X);
-  gtk_object_add_arg_type ("GtkWidget::y", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_Y);
-  gtk_object_add_arg_type ("GtkWidget::width", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_WIDTH);
-  gtk_object_add_arg_type ("GtkWidget::height", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_HEIGHT);
-  gtk_object_add_arg_type ("GtkWidget::visible", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_VISIBLE);
-  gtk_object_add_arg_type ("GtkWidget::sensitive", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SENSITIVE);
-  gtk_object_add_arg_type ("GtkWidget::app_paintable", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_APP_PAINTABLE);
-  gtk_object_add_arg_type ("GtkWidget::can_focus", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_CAN_FOCUS);
-  gtk_object_add_arg_type ("GtkWidget::has_focus", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HAS_FOCUS);
-  gtk_object_add_arg_type ("GtkWidget::can_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_CAN_DEFAULT);
-  gtk_object_add_arg_type ("GtkWidget::has_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HAS_DEFAULT);
-  gtk_object_add_arg_type ("GtkWidget::receives_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_RECEIVES_DEFAULT);
-  gtk_object_add_arg_type ("GtkWidget::composite_child", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_COMPOSITE_CHILD);
-  gtk_object_add_arg_type ("GtkWidget::style", GTK_TYPE_STYLE, GTK_ARG_READWRITE, ARG_STYLE);
-  gtk_object_add_arg_type ("GtkWidget::events", GTK_TYPE_GDK_EVENT_MASK, GTK_ARG_READWRITE, ARG_EVENTS);
-  gtk_object_add_arg_type ("GtkWidget::extension_events", GTK_TYPE_GDK_EVENT_MASK, GTK_ARG_READWRITE, ARG_EXTENSION_EVENTS);
-  
+  g_object_class_install_property (gobject_class,
+				   PROP_NAME,
+				   g_param_spec_string ("name",
+ 							_("Widget name"),
+							_("The name of the widget"),
+							NULL,
+							G_PARAM_READWRITE));
+  
+  g_object_class_install_property (gobject_class,
+				   PROP_PARENT,
+				   g_param_spec_object ("parent",
+							_("Parent widget"),
+							_("The parent widget of this widget. Must be a Container widget."),
+							GTK_TYPE_CONTAINER,
+							G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_X,
+				   g_param_spec_int ("x",
+ 						     _("x coordinate"),
+ 						     _("The x coordinate of the top-left corner of the widget, or -1 if not set"),
+ 						     -G_MAXINT,
+ 						     G_MAXINT,
+ 						     -1,
+ 						     G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_Y,
+				   g_param_spec_int ("y",
+ 						     _("y coordinate"),
+ 						     _("The y coordinate of the top-left corner of the widget, or -1 if not set"),
+ 						     -G_MAXINT,
+ 						     G_MAXINT,
+ 						     -1,
+ 						     G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_WIDTH,
+				   g_param_spec_int ("width",
+ 						     _("Width"),
+ 						     _("The width of the widget, or -1 if unset."),
+ 						     -1,
+ 						     G_MAXINT,
+ 						     -1,
+ 						     G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_HEIGHT,
+				   g_param_spec_int ("height",
+ 						     _("Height"),
+ 						     _("The height of the widget, or -1 if unset."),
+ 						     -1,
+ 						     G_MAXINT,
+ 						     -1,
+ 						     G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_VISIBLE,
+				   g_param_spec_boolean ("visible",
+ 							 _("Visible"),
+ 							 _("Whether the widget is visible"),
+ 							 FALSE,
+ 							 G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_SENSITIVE,
+				   g_param_spec_boolean ("sensitive",
+ 							 _("Sensitive"),
+ 							 _("Whether the widget responds to input"),
+ 							 TRUE,
+ 							 G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_APP_PAINTABLE,
+				   g_param_spec_boolean ("app_paintable",
+ 							 _("Application paintable"),
+ 							 _("Whether the application will paint directly on the widget"),
+ 							 FALSE,
+ 							 G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_CAN_FOCUS,
+				   g_param_spec_boolean ("can_focus",
+ 							 _("Can focus"),
+ 							 _("Whether the widget can accept the input focus"),
+ 							 FALSE,
+ 							 G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_HAS_FOCUS,
+				   g_param_spec_boolean ("has_focus",
+ 							 _("Has focus"),
+ 							 _("Whether the widget has the input focus"),
+ 							 FALSE,
+ 							 G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_CAN_DEFAULT,
+				   g_param_spec_boolean ("can_default",
+ 							 _("Can default"),
+ 							 _("Whether the widget can be the default widget"),
+ 							 FALSE,
+ 							 G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_HAS_DEFAULT,
+				   g_param_spec_boolean ("has_default",
+ 							 _("Has default"),
+ 							 _("Whether the widget is the default widget"),
+ 							 FALSE,
+ 							 G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_RECEIVES_DEFAULT,
+				   g_param_spec_boolean ("receives_default",
+ 							 _("Receives default"),
+ 							 _("If TRUE, the widget will receive the default action when it is focused."),
+ 							 FALSE,
+ 							 G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_COMPOSITE_CHILD,
+				   g_param_spec_boolean ("composite_child",
+ 							 _("Composite child"),
+ 							 _("Whether the widget is composed of other widgets"),
+ 							 FALSE,
+ 							 G_PARAM_READWRITE));
+ 
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_STYLE,
+				   g_param_spec_object ("style",
+ 							_("Style"),
+ 							_("The style of the widget, which contains information about how it will look (colors etc)."),
+ 							GTK_TYPE_STYLE,
+ 							G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_EVENTS,
+				   g_param_spec_flags ("events",
+ 						       _("Events"),
+ 						       _("The event mask that decides what kind of GdkEvents this widget gets."),
+ 						       GTK_TYPE_GDK_EVENT_MASK,
+ 						       GDK_STRUCTURE_MASK,
+ 						       G_PARAM_READWRITE));
+ 
+  g_object_class_install_property (gobject_class,
+				   PROP_EXTENSION_EVENTS,
+				   g_param_spec_enum ("extension_events",
+ 						      _("Extension events"),
+ 						      _("The mask that decides what kind of extension events this widget gets."),
+ 						      GTK_TYPE_GDK_EXTENSION_MODE,
+ 						      GDK_EXTENSION_EVENTS_NONE,
+ 						      G_PARAM_READWRITE));
+
+
   widget_signals[SHOW] =
     gtk_signal_new ("show",
 		    GTK_RUN_FIRST,
@@ -834,112 +974,113 @@ gtk_widget_class_init (GtkWidgetClass *k
 }
 
 static void
-gtk_widget_set_arg (GtkObject   *object,
-		    GtkArg	*arg,
-		    guint	 arg_id)
+gtk_widget_set_property (GObject         *object,
+			 guint            prop_id,
+			 const GValue    *value,
+			 GParamSpec      *pspec)
 {
   GtkWidget *widget;
   GtkWidgetAuxInfo *aux_info;
 
   widget = GTK_WIDGET (object);
 
-  switch (arg_id)
+  switch (prop_id)
     {
       guint32 saved_flags;
       
-    case ARG_NAME:
-      gtk_widget_set_name (widget, GTK_VALUE_STRING (*arg));
+    case PROP_NAME:
+      gtk_widget_set_name (widget, g_value_get_string (value));
       break;
-    case ARG_PARENT:
-      gtk_container_add (GTK_CONTAINER (GTK_VALUE_OBJECT (*arg)), widget);
+    case PROP_PARENT:
+      gtk_container_add (GTK_CONTAINER (g_value_get_object (value)), widget);
       break;
-    case ARG_X:
+    case PROP_X:
       aux_info = _gtk_widget_get_aux_info (widget, TRUE);
-      if (GTK_VALUE_INT (*arg) == -1)
+      if (g_value_get_int (value) == -1)
 	aux_info->x_set = FALSE;
       else
 	{
 	  aux_info->x_set = TRUE;
-	  aux_info->x = GTK_VALUE_INT (*arg);
+	  aux_info->x = g_value_get_int (value);
 	}
       gtk_widget_do_uposition (widget);
       break;
-    case ARG_Y:
+    case PROP_Y:
       aux_info = _gtk_widget_get_aux_info (widget, TRUE);
-      if (GTK_VALUE_INT (*arg) == -1)
+      if (g_value_get_int (value) == -1)
 	aux_info->y_set = FALSE;
       else
 	{
 	  aux_info->y_set = TRUE;
-	  aux_info->y = GTK_VALUE_INT (*arg);
+	  aux_info->y = g_value_get_int (value);
 	}
       gtk_widget_do_uposition (widget);
       break;
-    case ARG_WIDTH:
-      gtk_widget_set_usize (widget, GTK_VALUE_INT (*arg), -2);
+    case PROP_WIDTH:
+      gtk_widget_set_usize (widget, g_value_get_int (value), -2);
       break;
-    case ARG_HEIGHT:
-      gtk_widget_set_usize (widget, -2, GTK_VALUE_INT (*arg));
+    case PROP_HEIGHT:
+      gtk_widget_set_usize (widget, -2, g_value_get_int (value));
       break;
-    case ARG_VISIBLE:
-      if (GTK_VALUE_BOOL(*arg))
+    case PROP_VISIBLE:
+      if (g_value_get_boolean (value))
 	gtk_widget_show (widget);
       else
 	gtk_widget_hide (widget);
       break;
-    case ARG_SENSITIVE:
-      gtk_widget_set_sensitive (widget, GTK_VALUE_BOOL (*arg));
+    case PROP_SENSITIVE:
+      gtk_widget_set_sensitive (widget, g_value_get_boolean (value));
       break;
-    case ARG_APP_PAINTABLE:
-      gtk_widget_set_app_paintable (widget, GTK_VALUE_BOOL (*arg));
+    case PROP_APP_PAINTABLE:
+      gtk_widget_set_app_paintable (widget, g_value_get_boolean (value));
       break;
-    case ARG_CAN_FOCUS:
+    case PROP_CAN_FOCUS:
       saved_flags = GTK_WIDGET_FLAGS (widget);
-      if (GTK_VALUE_BOOL (*arg))
+      if (g_value_get_boolean (value))
 	GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
       else
 	GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
       if (saved_flags != GTK_WIDGET_FLAGS (widget))
 	gtk_widget_queue_resize (widget);
       break;
-    case ARG_HAS_FOCUS:
-      if (GTK_VALUE_BOOL (*arg))
+    case PROP_HAS_FOCUS:
+      if (g_value_get_boolean (value))
 	gtk_widget_grab_focus (widget);
       break;
-    case ARG_CAN_DEFAULT:
+    case PROP_CAN_DEFAULT:
       saved_flags = GTK_WIDGET_FLAGS (widget);
-      if (GTK_VALUE_BOOL (*arg))
+      if (g_value_get_boolean (value))
 	GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
       else
 	GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_DEFAULT);
       if (saved_flags != GTK_WIDGET_FLAGS (widget))
 	gtk_widget_queue_resize (widget);
       break;
-    case ARG_HAS_DEFAULT:
-      if (GTK_VALUE_BOOL (*arg))
+    case PROP_HAS_DEFAULT:
+      if (g_value_get_boolean (value))
 	gtk_widget_grab_default (widget);
       break;
-    case ARG_RECEIVES_DEFAULT:
-      if (GTK_VALUE_BOOL (*arg))
+    case PROP_RECEIVES_DEFAULT:
+      if (g_value_get_boolean (value))
 	GTK_WIDGET_SET_FLAGS (widget, GTK_RECEIVES_DEFAULT);
       else
 	GTK_WIDGET_UNSET_FLAGS (widget, GTK_RECEIVES_DEFAULT);
       break;
-    case ARG_COMPOSITE_CHILD:
-      if (GTK_VALUE_BOOL(*arg))
+    case PROP_COMPOSITE_CHILD:
+      if (g_value_get_boolean (value))
 	GTK_WIDGET_SET_FLAGS (widget, GTK_COMPOSITE_CHILD);
       else
 	GTK_WIDGET_UNSET_FLAGS (widget, GTK_COMPOSITE_CHILD);
       break;
-    case ARG_STYLE:
-      gtk_widget_set_style (widget, (GtkStyle*) GTK_VALUE_BOXED (*arg));
+    case PROP_STYLE:
+      gtk_widget_set_style (widget, g_value_get_object (value));
       break;
-    case ARG_EVENTS:
+    case PROP_EVENTS:
       if (!GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_NO_WINDOW (widget))
-	gtk_widget_set_events (widget, GTK_VALUE_FLAGS (*arg));
+	gtk_widget_set_events (widget, g_value_get_flags (value));
       break;
-    case ARG_EXTENSION_EVENTS:
-      gtk_widget_set_extension_events (widget, GTK_VALUE_FLAGS (*arg));
+    case PROP_EXTENSION_EVENTS:
+      gtk_widget_set_extension_events (widget, g_value_get_enum (value));
       break;
     default:
       break;
@@ -947,7 +1088,7 @@ gtk_widget_set_arg (GtkObject   *object,
 }
 
 /*****************************************
- * gtk_widget_get_arg:
+ * gtk_widget_get_property:
  *
  *   arguments:
  *
@@ -955,103 +1096,104 @@ gtk_widget_set_arg (GtkObject   *object,
  *****************************************/
 
 static void
-gtk_widget_get_arg (GtkObject   *object,
-		    GtkArg	*arg,
-		    guint	 arg_id)
+gtk_widget_get_property (GObject         *object,
+			 guint            prop_id,
+			 GValue          *value,
+			 GParamSpec      *pspec)
 {
   GtkWidget *widget;
 
   widget = GTK_WIDGET (object);
   
-  switch (arg_id)
+  switch (prop_id)
     {
       GtkWidgetAuxInfo *aux_info;
       gint *eventp;
       GdkExtensionMode *modep;
 
-    case ARG_NAME:
+    case PROP_NAME:
       if (widget->name)
-	GTK_VALUE_STRING (*arg) = g_strdup (widget->name);
+	g_value_set_string (value, widget->name);
       else
-	GTK_VALUE_STRING (*arg) = g_strdup ("");
+	g_value_set_string (value, "");
       break;
-    case ARG_PARENT:
-      GTK_VALUE_OBJECT (*arg) = (GtkObject*) widget->parent;
+    case PROP_PARENT:
+      g_value_set_object (value, G_OBJECT (widget->parent));
       break;
-    case ARG_X:
+    case PROP_X:
       aux_info =_gtk_widget_get_aux_info (widget, FALSE);
       if (!aux_info || !aux_info->x_set)
-	GTK_VALUE_INT (*arg) = -1;
+	g_value_set_int (value, -1);
       else
-	GTK_VALUE_INT (*arg) = aux_info->x;
+	g_value_set_int (value, aux_info->x);
       break;
-    case ARG_Y:
+    case PROP_Y:
       aux_info =_gtk_widget_get_aux_info (widget, FALSE);
       if (!aux_info || !aux_info->y_set)
-	GTK_VALUE_INT (*arg) = -1;
+	g_value_set_int (value, -1);
       else
-	GTK_VALUE_INT (*arg) = aux_info->y;
+	g_value_set_int (value, aux_info->y);
       break;
-    case ARG_WIDTH:
+    case PROP_WIDTH:
       aux_info =_gtk_widget_get_aux_info (widget, FALSE);
       if (!aux_info)
-	GTK_VALUE_INT (*arg) = -1;
+ 	g_value_set_int (value, -1);
       else
-	GTK_VALUE_INT (*arg) = aux_info->width;
+	g_value_set_int (value, aux_info->width);
       break;
-    case ARG_HEIGHT:
+    case PROP_HEIGHT:
       aux_info =_gtk_widget_get_aux_info (widget, FALSE);
       if (!aux_info)
-	GTK_VALUE_INT (*arg) = -1;
+ 	g_value_set_int (value, -1);
       else
-	GTK_VALUE_INT (*arg) = aux_info->height;
+ 	g_value_set_int (value, aux_info->height);
       break;
-    case ARG_VISIBLE:
-      GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_VISIBLE (widget) != FALSE);
+    case PROP_VISIBLE:
+      g_value_set_boolean (value, (GTK_WIDGET_VISIBLE (widget) != FALSE));
       break;
-    case ARG_SENSITIVE:
-      GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_SENSITIVE (widget) != FALSE);
+    case PROP_SENSITIVE:
+      g_value_set_boolean (value, (GTK_WIDGET_SENSITIVE (widget) != FALSE));
       break;
-    case ARG_APP_PAINTABLE:
-      GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_APP_PAINTABLE (widget) != FALSE);
+    case PROP_APP_PAINTABLE:
+      g_value_set_boolean (value, (GTK_WIDGET_APP_PAINTABLE (widget) != FALSE));
       break;
-    case ARG_CAN_FOCUS:
-      GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_CAN_FOCUS (widget) != FALSE);
+    case PROP_CAN_FOCUS:
+      g_value_set_boolean (value, (GTK_WIDGET_CAN_FOCUS (widget) != FALSE));
       break;
-    case ARG_HAS_FOCUS:
-      GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_HAS_FOCUS (widget) != FALSE);
+    case PROP_HAS_FOCUS:
+      g_value_set_boolean (value, (GTK_WIDGET_HAS_FOCUS (widget) != FALSE));
       break;
-    case ARG_CAN_DEFAULT:
-      GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_CAN_DEFAULT (widget) != FALSE);
+    case PROP_CAN_DEFAULT:
+      g_value_set_boolean (value, (GTK_WIDGET_CAN_DEFAULT (widget) != FALSE));
       break;
-    case ARG_HAS_DEFAULT:
-      GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_HAS_DEFAULT (widget) != FALSE);
+    case PROP_HAS_DEFAULT:
+      g_value_set_boolean (value, (GTK_WIDGET_HAS_DEFAULT (widget) != FALSE));
       break;
-    case ARG_RECEIVES_DEFAULT:
-      GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_RECEIVES_DEFAULT (widget) != FALSE);
+    case PROP_RECEIVES_DEFAULT:
+      g_value_set_boolean (value, (GTK_WIDGET_RECEIVES_DEFAULT (widget) != FALSE));
       break;
-    case ARG_COMPOSITE_CHILD:
-      GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_COMPOSITE_CHILD (widget) != FALSE);
+    case PROP_COMPOSITE_CHILD:
+      g_value_set_boolean (value, (GTK_WIDGET_COMPOSITE_CHILD (widget) != FALSE));
       break;
-    case ARG_STYLE:
-      GTK_VALUE_BOXED (*arg) = (gpointer) gtk_widget_get_style (widget);
+    case PROP_STYLE:
+      g_value_set_object (value, G_OBJECT (gtk_widget_get_style (widget)));
       break;
-    case ARG_EVENTS:
+    case PROP_EVENTS:
       eventp = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_event_mask);
       if (!eventp)
-	GTK_VALUE_FLAGS (*arg) = 0;
+	g_value_set_int (value, 0);
       else
-	GTK_VALUE_FLAGS (*arg) = *eventp;
+	g_value_set_int (value, *eventp);
       break;
-    case ARG_EXTENSION_EVENTS:
+    case PROP_EXTENSION_EVENTS:
       modep = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_extension_event_mode);
       if (!modep)
-	GTK_VALUE_FLAGS (*arg) = 0;
+ 	g_value_set_flags (value, 0);
       else
-	GTK_VALUE_FLAGS (*arg) = *modep;
+ 	g_value_set_flags (value, (GdkExtensionMode) *modep);
       break;
     default:
-      arg->type = GTK_TYPE_INVALID;
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
@@ -1302,6 +1444,7 @@ gtk_widget_unparent (GtkWidget *widget)
   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[PARENT_SET], old_parent);
   gtk_widget_propagate_hierarchy_changed (widget, NULL);
   
+  g_object_notify (G_OBJECT (widget), "parent");
   gtk_widget_unref (widget);
 }
 
@@ -1388,6 +1531,7 @@ gtk_widget_show (GtkWidget *widget)
       if (!GTK_WIDGET_TOPLEVEL (widget))
 	gtk_widget_queue_resize (widget);
       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SHOW]);
+      g_object_notify (G_OBJECT (widget), "visible");
     }
 }
 
@@ -1469,6 +1613,7 @@ gtk_widget_hide (GtkWidget *widget)
       gtk_signal_emit (GTK_OBJECT (widget), widget_signals[HIDE]);
       if (!GTK_WIDGET_TOPLEVEL (widget) && !GTK_OBJECT_DESTROYED (widget))
 	gtk_widget_queue_resize (widget);
+      g_object_notify (G_OBJECT (widget), "visible");
       gtk_widget_unref (widget);
     }
 }
@@ -2786,6 +2931,8 @@ gtk_widget_grab_focus (GtkWidget *widget
   g_return_if_fail (GTK_IS_WIDGET (widget));
 
   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[GRAB_FOCUS]);
+
+  g_object_notify (G_OBJECT (widget), "has_focus");
 }
 
 static void
@@ -2926,7 +3073,10 @@ gtk_widget_grab_default (GtkWidget *widg
     window = window->parent;
   
   if (window && gtk_type_is_a (GTK_WIDGET_TYPE (window), window_type))
-    gtk_window_set_default (GTK_WINDOW (window), widget);
+    {
+      gtk_window_set_default (GTK_WINDOW (window), widget);
+      g_object_notify (G_OBJECT (window), "has_default");
+    }
   else
     g_warning("gtk_widget_grab_default() called on a widget not within a GtkWindow");
 }
@@ -2955,6 +3105,8 @@ gtk_widget_set_name (GtkWidget	 *widget,
 
   if (GTK_WIDGET_RC_STYLE (widget))
     gtk_widget_set_rc_style (widget);
+
+  g_object_notify (G_OBJECT (widget), "name");
 }
 
 /**
@@ -3038,6 +3190,8 @@ gtk_widget_set_app_paintable (GtkWidget 
       if (GTK_WIDGET_DRAWABLE (widget))
 	gtk_widget_queue_clear (widget);
     }
+
+  g_object_notify (G_OBJECT (widget), "app_paintable");
 }
 
 /**
@@ -3119,6 +3273,8 @@ gtk_widget_set_sensitive (GtkWidget *wid
   gtk_widget_propagate_state (widget, &data);
   if (GTK_WIDGET_DRAWABLE (widget))
     gtk_widget_queue_clear (widget);
+
+  g_object_notify (G_OBJECT (widget), "sensitive");
 }
 
 /**
@@ -3168,6 +3324,7 @@ gtk_widget_set_parent (GtkWidget *widget
 
   gtk_signal_emit (GTK_OBJECT (widget), widget_signals[PARENT_SET], NULL);
   gtk_widget_propagate_hierarchy_changed (widget, NULL);
+  g_object_notify (G_OBJECT (widget), "parent");
 }
 
 /*****************************************
@@ -3210,6 +3367,8 @@ gtk_widget_set_style (GtkWidget *widget,
     }
 
   gtk_widget_set_style_internal (widget, style, initial_emission);
+
+  g_object_notify (G_OBJECT (widget), "style");
 }
 
 /**
@@ -3950,7 +4109,7 @@ gtk_widget_get_parent_window   (GtkWidge
 }
 
 /* Update the position from aux_info. Used from gtk_widget_set_uposition
- * and gtk_widget_set_arg().
+ * and gtk_widget_set_property().
  */
 static void
 gtk_widget_do_uposition (GtkWidget *widget)
@@ -3962,6 +4121,11 @@ gtk_widget_do_uposition (GtkWidget *widg
   
   if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
     gtk_widget_size_allocate (widget, &widget->allocation);
+
+  if (aux_info->x_set)
+    g_object_notify (G_OBJECT (widget), "x");
+  if (aux_info->y_set)
+    g_object_notify (G_OBJECT (widget), "y");
 }
 
 /**
@@ -4070,6 +4234,11 @@ gtk_widget_set_usize (GtkWidget *widget,
   
   if (GTK_WIDGET_VISIBLE (widget))
     gtk_widget_queue_resize (widget);
+
+  if (width > -2)
+    g_object_notify (G_OBJECT (widget), "width");
+  if (height > -2)
+    g_object_notify (G_OBJECT (widget), "height");  
 }
 
 /**
@@ -4115,6 +4284,8 @@ gtk_widget_set_events (GtkWidget *widget
       g_free (eventp);
       gtk_object_remove_data_by_id (GTK_OBJECT (widget), quark_event_mask);
     }
+
+  g_object_notify (G_OBJECT (widget), "events");
 }
 
 /**
@@ -4160,6 +4331,8 @@ gtk_widget_add_events (GtkWidget *widget
       gdk_window_set_events (widget->window,
 			     gdk_window_get_events (widget->window) | events);
     }
+
+  g_object_notify (G_OBJECT (widget), "events");
 }
 
 /**
@@ -4187,6 +4360,7 @@ gtk_widget_set_extension_events (GtkWidg
   
   *modep = mode;
   gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_extension_event_mode, modep);
+  g_object_notify (G_OBJECT (widget), "extension_events");
 }
 
 /**





[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]