Deprecation cleanup

Fri Oct 11 15:56:20 2002  Manish Singh  <yosh@gimp.org>

        * gtk/gtkaccellabel.[ch] gtk/gtkaccessible.[ch] gtk/gtkbutton.[ch]
        gtk/gtkcheckbutton.[ch] gtk/gtkcolorseldialog.[ch] gtk/gtkdialog.[ch]
        gtk/gtkhandlebox.[ch] gtk/gtkinputdialog.[ch] gtk/gtkmessagedialog.[ch]
        gtk/gtktearoffmenuitem.[ch] gtk/gtktogglebutton.[ch]: Deprecation
        cleanup

22 files changed, 498 insertions, 461 deletions

diff --git a/gtk/gtkaccellabel.c b/gtk/gtkaccellabel.c
index 291f58aa3d..d05376247e 100644
--- a/gtk/gtkaccellabel.c
+++ b/gtk/gtkaccellabel.c
@@ -26,14 +26,14 @@
  * files for a list of changes.  These files are distributed with
  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  */
+
+#include <string.h>
+
 #include "gtkaccellabel.h"
 #include "gtkaccelmap.h"
 #include "gtkmain.h"
-#include "gtksignal.h"
 #include "gtkintl.h"
 
-#include <string.h>
-
 enum {
   PROP_0,
   PROP_ACCEL_CLOSURE,
@@ -58,30 +58,32 @@ static gboolean gtk_accel_label_expose_event (GtkWidget          *widget,
 					      GdkEventExpose     *event);
 static gboolean gtk_accel_label_refetch_idle (GtkAccelLabel      *accel_label);
 
-static GtkAccelLabelClass *accel_label_class = NULL;
 static GtkLabelClass *parent_class = NULL;
 
 
-GtkType
+GType
 gtk_accel_label_get_type (void)
 {
-  static GtkType accel_label_type = 0;
+  static GType accel_label_type = 0;
   
   if (!accel_label_type)
     {
-      static const GtkTypeInfo accel_label_info =
+      static const GTypeInfo accel_label_info =
       {
-	"GtkAccelLabel",
-	sizeof (GtkAccelLabel),
 	sizeof (GtkAccelLabelClass),
-	(GtkClassInitFunc) gtk_accel_label_class_init,
-	(GtkObjectInitFunc) gtk_accel_label_init,
-        /* reserved_1 */ NULL,
-	/* reserved_2 */ NULL,
-	(GtkClassInitFunc) NULL,
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) gtk_accel_label_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkAccelLabel),
+	0,		/* n_preallocs */
+	(GInstanceInitFunc) gtk_accel_label_init,
       };
       
-      accel_label_type = gtk_type_unique (GTK_TYPE_LABEL, &accel_label_info);
+      accel_label_type =
+	g_type_register_static (GTK_TYPE_LABEL, "GtkAccelLabel",
+				&accel_label_info, 0);
     }
   
   return accel_label_type;
@@ -94,7 +96,6 @@ gtk_accel_label_class_init (GtkAccelLabelClass *class)
   GtkObjectClass *object_class = GTK_OBJECT_CLASS (class);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
   
-  accel_label_class = class;
   parent_class = g_type_class_peek_parent (class);
   
   gobject_class->finalize = gtk_accel_label_finalize;
@@ -130,14 +131,14 @@ gtk_accel_label_class_init (GtkAccelLabelClass *class)
   class->accel_seperator = g_strdup (" / ");
   class->latin1_to_char = TRUE;
   
-  g_object_class_install_property (G_OBJECT_CLASS (object_class),
+  g_object_class_install_property (gobject_class,
                                    PROP_ACCEL_CLOSURE,
                                    g_param_spec_boxed ("accel_closure",
 						       _("Accelerator Closure"),
 						       _("The closure to be monitored for accelerator changes"),
 						       G_TYPE_CLOSURE,
 						       G_PARAM_READABLE | G_PARAM_WRITABLE));
-  g_object_class_install_property (G_OBJECT_CLASS (object_class),
+  g_object_class_install_property (gobject_class,
                                    PROP_ACCEL_WIDGET,
                                    g_param_spec_object ("accel_widget",
                                                         _("Accelerator Widget"),
@@ -214,7 +215,7 @@ gtk_accel_label_new (const gchar *string)
   
   g_return_val_if_fail (string != NULL, NULL);
   
-  accel_label = gtk_type_new (GTK_TYPE_ACCEL_LABEL);
+  accel_label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
   
   gtk_label_set_text (GTK_LABEL (accel_label), string);
   
@@ -289,7 +290,7 @@ gtk_accel_label_size_request (GtkWidget	     *widget,
   pango_layout_get_pixel_size (layout, &width, NULL);
   accel_label->accel_string_width = width;
   
-  g_object_unref (G_OBJECT (layout));
+  g_object_unref (layout);
 }
 
 static gboolean 
@@ -335,7 +336,7 @@ gtk_accel_label_expose_event (GtkWidget      *widget,
                             x, y,
                             layout);                            
 
-          g_object_unref (G_OBJECT (layout));
+          g_object_unref (layout);
 	}
       else
 	{
@@ -388,7 +389,7 @@ gtk_accel_label_set_accel_widget (GtkAccelLabel *accel_label,
 	{
 	  gtk_accel_label_set_accel_closure (accel_label, NULL);
 	  g_signal_handlers_disconnect_by_func (accel_label->accel_widget,
-						(gpointer) refetch_widget_accel_closure,
+						refetch_widget_accel_closure,
 						accel_label);
 	  g_object_unref (accel_label->accel_widget);
 	}
@@ -448,7 +449,7 @@ gtk_accel_label_set_accel_closure (GtkAccelLabel *accel_label,
       if (accel_label->accel_closure)
 	{
 	  g_signal_handlers_disconnect_by_func (accel_label->accel_group,
-						(gpointer) check_accel_changed,
+						check_accel_changed,
 						accel_label);
 	  accel_label->accel_group = NULL;
 	  g_closure_unref (accel_label->accel_closure);
diff --git a/gtk/gtkaccellabel.h b/gtk/gtkaccellabel.h
index bef97381f5..08826d4394 100644
--- a/gtk/gtkaccellabel.h
+++ b/gtk/gtkaccellabel.h
@@ -40,11 +40,11 @@ extern "C" {
 
 
 #define GTK_TYPE_ACCEL_LABEL		(gtk_accel_label_get_type ())
-#define GTK_ACCEL_LABEL(obj)		(GTK_CHECK_CAST ((obj), GTK_TYPE_ACCEL_LABEL, GtkAccelLabel))
-#define GTK_ACCEL_LABEL_CLASS(klass)	(GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCEL_LABEL, GtkAccelLabelClass))
-#define GTK_IS_ACCEL_LABEL(obj)		(GTK_CHECK_TYPE ((obj), GTK_TYPE_ACCEL_LABEL))
-#define GTK_IS_ACCEL_LABEL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCEL_LABEL))
-#define GTK_ACCEL_LABEL_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_ACCEL_LABEL, GtkAccelLabelClass))
+#define GTK_ACCEL_LABEL(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACCEL_LABEL, GtkAccelLabel))
+#define GTK_ACCEL_LABEL_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCEL_LABEL, GtkAccelLabelClass))
+#define GTK_IS_ACCEL_LABEL(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACCEL_LABEL))
+#define GTK_IS_ACCEL_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCEL_LABEL))
+#define GTK_ACCEL_LABEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCEL_LABEL, GtkAccelLabelClass))
 
 
 typedef struct _GtkAccelLabel	    GtkAccelLabel;
@@ -87,7 +87,7 @@ struct _GtkAccelLabelClass
 #define	gtk_accel_label_accelerator_width	gtk_accel_label_get_accel_width
 #endif /* GTK_DISABLE_DEPRECATED */
 
-GtkType	   gtk_accel_label_get_type	     (void) G_GNUC_CONST;
+GType	   gtk_accel_label_get_type	     (void) G_GNUC_CONST;
 GtkWidget* gtk_accel_label_new		     (const gchar   *string);
 GtkWidget* gtk_accel_label_get_accel_widget  (GtkAccelLabel *accel_label);
 guint	   gtk_accel_label_get_accel_width   (GtkAccelLabel *accel_label);
diff --git a/gtk/gtkaccessible.c b/gtk/gtkaccessible.c
index 817fab77dd..0b48bca4e4 100644
--- a/gtk/gtkaccessible.c
+++ b/gtk/gtkaccessible.c
@@ -18,18 +18,18 @@
  */
 
 #include <string.h>
-#include <gtk/gtkwidget.h>
-#include <gtk/gtksignal.h>
-#include <gtk/gtkaccessible.h>
+
+#include "gtkwidget.h"
+#include "gtkaccessible.h"
 
 static void gtk_accessible_class_init (GtkAccessibleClass *klass);
 
 static void gtk_accessible_real_connect_widget_destroyed (GtkAccessible *accessible);
 
-GtkType
+GType
 gtk_accessible_get_type (void)
 {
-  static GtkType accessible_type = 0;
+  static GType accessible_type = 0;
 
   if (!accessible_type)
     {
@@ -46,7 +46,9 @@ gtk_accessible_get_type (void)
 	(GInstanceInitFunc) NULL,
       };
 
-      accessible_type = g_type_register_static (ATK_TYPE_OBJECT, "GtkAccessible", &accessible_info, 0);
+      accessible_type =
+	g_type_register_static (ATK_TYPE_OBJECT, "GtkAccessible",
+				&accessible_info, 0);
     }
 
   return accessible_type;
@@ -56,7 +58,6 @@ static void
 gtk_accessible_class_init (GtkAccessibleClass *klass)
 {
   klass->connect_widget_destroyed = gtk_accessible_real_connect_widget_destroyed;
-
 }
 
 /**
@@ -84,9 +85,9 @@ gtk_accessible_real_connect_widget_destroyed (GtkAccessible *accessible)
 {
   if (accessible->widget)
   {
-    gtk_signal_connect (GTK_OBJECT (accessible->widget),
-                        "destroy",
-                        GTK_SIGNAL_FUNC (gtk_widget_destroyed),
-                        &accessible->widget);
+    g_signal_connect (accessible->widget,
+                      "destroy",
+                      G_CALLBACK (gtk_widget_destroyed),
+                      &accessible->widget);
   }
 }
diff --git a/gtk/gtkaccessible.h b/gtk/gtkaccessible.h
index 35e4937fbc..0dedcd7981 100644
--- a/gtk/gtkaccessible.h
+++ b/gtk/gtkaccessible.h
@@ -28,11 +28,11 @@ extern "C" {
 #endif /* __cplusplus */
 
 #define GTK_TYPE_ACCESSIBLE                  (gtk_accessible_get_type ())
-#define GTK_ACCESSIBLE(obj)                  (GTK_CHECK_CAST ((obj), GTK_TYPE_ACCESSIBLE, GtkAccessible))
-#define GTK_ACCESSIBLE_CLASS(klass)          (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCESSIBLE, GtkAccessibleClass))
-#define GTK_IS_ACCESSIBLE(obj)               (GTK_CHECK_TYPE ((obj), GTK_TYPE_ACCESSIBLE))
-#define GTK_IS_ACCESSIBLE_CLASS(klass)       (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCESSIBLE))
-#define GTK_ACCESSIBLE_GET_CLASS(obj)        (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_ACCESSIBLE, GtkAccessibleClass))
+#define GTK_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACCESSIBLE, GtkAccessible))
+#define GTK_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCESSIBLE, GtkAccessibleClass))
+#define GTK_IS_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACCESSIBLE))
+#define GTK_IS_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCESSIBLE))
+#define GTK_ACCESSIBLE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCESSIBLE, GtkAccessibleClass))
 
 typedef struct _GtkAccessible                GtkAccessible;
 typedef struct _GtkAccessibleClass           GtkAccessibleClass;
@@ -50,11 +50,8 @@ struct _GtkAccessible
    * accessible instance.
    */
   GtkWidget *widget;
-
 };
 
-GtkType gtk_accessible_get_type (void);
-
 struct _GtkAccessibleClass
 {
   AtkObjectClass parent_class;
@@ -68,7 +65,10 @@ struct _GtkAccessibleClass
   void (*_gtk_reserved4) (void);
 };
 
+GType gtk_accessible_get_type (void);
+
 void gtk_accessible_connect_widget_destroyed    (GtkAccessible     *accessible);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/gtk/gtkbutton.c b/gtk/gtkbutton.c
index 2647ec0cef..92dbd20628 100644
--- a/gtk/gtkbutton.c
+++ b/gtk/gtkbutton.c
@@ -30,7 +30,6 @@
 #include "gtklabel.h"
 #include "gtkmain.h"
 #include "gtkmarshalers.h"
-#include "gtksignal.h"
 #include "gtkimage.h"
 #include "gtkhbox.h"
 #include "gtkstock.h"
@@ -98,9 +97,9 @@ static gint gtk_button_leave_notify   (GtkWidget        *widget,
 				       GdkEventCrossing *event);
 static void gtk_real_button_pressed   (GtkButton        *button);
 static void gtk_real_button_released  (GtkButton        *button);
-static void gtk_real_button_activate (GtkButton         *button);
+static void gtk_real_button_activate  (GtkButton         *button);
 static void gtk_button_update_state   (GtkButton        *button);
-static GtkType gtk_button_child_type  (GtkContainer     *container);
+static GType gtk_button_child_type    (GtkContainer     *container);
 static void gtk_button_finish_activate (GtkButton *button,
 					gboolean   do_it);
 
@@ -114,10 +113,10 @@ static GtkBinClass *parent_class = NULL;
 static guint button_signals[LAST_SIGNAL] = { 0 };
 
 
-GtkType
+GType
 gtk_button_get_type (void)
 {
-  static GtkType button_type = 0;
+  static GType button_type = 0;
 
   if (!button_type)
     {
@@ -134,7 +133,8 @@ gtk_button_get_type (void)
 	(GInstanceInitFunc) gtk_button_init,
       };
 
-      button_type = g_type_register_static (GTK_TYPE_BIN, "GtkButton", &button_info, 0);
+      button_type = g_type_register_static (GTK_TYPE_BIN, "GtkButton",
+					    &button_info, 0);
     }
 
   return button_type;
@@ -143,21 +143,21 @@ gtk_button_get_type (void)
 static void
 gtk_button_class_init (GtkButtonClass *klass)
 {
-  GObjectClass *g_object_class;
+  GObjectClass *gobject_class;
   GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;
 
-  g_object_class = G_OBJECT_CLASS (klass);
+  gobject_class = G_OBJECT_CLASS (klass);
   object_class = (GtkObjectClass*) klass;
   widget_class = (GtkWidgetClass*) klass;
   container_class = (GtkContainerClass*) klass;
   
   parent_class = g_type_class_peek_parent (klass);
 
-  g_object_class->constructor = gtk_button_constructor;
-  g_object_class->set_property = gtk_button_set_property;
-  g_object_class->get_property = gtk_button_get_property;
+  gobject_class->constructor = gtk_button_constructor;
+  gobject_class->set_property = gtk_button_set_property;
+  gobject_class->get_property = gtk_button_get_property;
 
   object_class->destroy = gtk_button_destroy;
 
@@ -183,7 +183,7 @@ gtk_button_class_init (GtkButtonClass *klass)
   klass->leave = gtk_button_update_state;
   klass->activate = gtk_real_button_activate;
 
-  g_object_class_install_property (G_OBJECT_CLASS(object_class),
+  g_object_class_install_property (gobject_class,
                                    PROP_LABEL,
                                    g_param_spec_string ("label",
                                                         _("Label"),
@@ -191,7 +191,7 @@ gtk_button_class_init (GtkButtonClass *klass)
                                                         NULL,
                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
   
-  g_object_class_install_property (G_OBJECT_CLASS(object_class),
+  g_object_class_install_property (gobject_class,
                                    PROP_USE_UNDERLINE,
                                    g_param_spec_boolean ("use_underline",
 							 _("Use underline"),
@@ -199,7 +199,7 @@ gtk_button_class_init (GtkButtonClass *klass)
                                                         FALSE,
                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
   
-  g_object_class_install_property (G_OBJECT_CLASS(object_class),
+  g_object_class_install_property (gobject_class,
                                    PROP_USE_STOCK,
                                    g_param_spec_boolean ("use_stock",
 							 _("Use stock"),
@@ -207,7 +207,7 @@ gtk_button_class_init (GtkButtonClass *klass)
                                                         FALSE,
                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
   
-  g_object_class_install_property (G_OBJECT_CLASS(object_class),
+  g_object_class_install_property (gobject_class,
                                    PROP_RELIEF,
                                    g_param_spec_enum ("relief",
                                                       _("Border relief"),
@@ -217,47 +217,53 @@ gtk_button_class_init (GtkButtonClass *klass)
                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 
   button_signals[PRESSED] =
-    gtk_signal_new ("pressed",
-                    GTK_RUN_FIRST,
-                    GTK_CLASS_TYPE (object_class),
-                    GTK_SIGNAL_OFFSET (GtkButtonClass, pressed),
-                    _gtk_marshal_VOID__VOID,
-		    GTK_TYPE_NONE, 0);
+    g_signal_new ("pressed",
+		  G_OBJECT_CLASS_TYPE (object_class),
+		  G_SIGNAL_RUN_FIRST,
+		  G_STRUCT_OFFSET (GtkButtonClass, pressed),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
   button_signals[RELEASED] =
-    gtk_signal_new ("released",
-                    GTK_RUN_FIRST,
-                    GTK_CLASS_TYPE (object_class),
-                    GTK_SIGNAL_OFFSET (GtkButtonClass, released),
-                    _gtk_marshal_VOID__VOID,
-		    GTK_TYPE_NONE, 0);
+    g_signal_new ("released",
+		  G_OBJECT_CLASS_TYPE (object_class),
+		  G_SIGNAL_RUN_FIRST,
+		  G_STRUCT_OFFSET (GtkButtonClass, released),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
   button_signals[CLICKED] =
-    gtk_signal_new ("clicked",
-                    GTK_RUN_FIRST | GTK_RUN_ACTION,
-                    GTK_CLASS_TYPE (object_class),
-                    GTK_SIGNAL_OFFSET (GtkButtonClass, clicked),
-                    _gtk_marshal_VOID__VOID,
-		    GTK_TYPE_NONE, 0);
+    g_signal_new ("clicked",
+		  G_OBJECT_CLASS_TYPE (object_class),
+		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
+		  G_STRUCT_OFFSET (GtkButtonClass, clicked),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
   button_signals[ENTER] =
-    gtk_signal_new ("enter",
-                    GTK_RUN_FIRST,
-                    GTK_CLASS_TYPE (object_class),
-                    GTK_SIGNAL_OFFSET (GtkButtonClass, enter),
-                    _gtk_marshal_VOID__VOID,
-		    GTK_TYPE_NONE, 0);
+    g_signal_new ("enter",
+		  G_OBJECT_CLASS_TYPE (object_class),
+		  G_SIGNAL_RUN_FIRST,
+		  G_STRUCT_OFFSET (GtkButtonClass, enter),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
   button_signals[LEAVE] =
-    gtk_signal_new ("leave",
-                    GTK_RUN_FIRST,
-                    GTK_CLASS_TYPE (object_class),
-                    GTK_SIGNAL_OFFSET (GtkButtonClass, leave),
-                    _gtk_marshal_VOID__VOID,
-		    GTK_TYPE_NONE, 0);
+    g_signal_new ("leave",
+		  G_OBJECT_CLASS_TYPE (object_class),
+		  G_SIGNAL_RUN_FIRST,
+		  G_STRUCT_OFFSET (GtkButtonClass, leave),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
   button_signals[ACTIVATE] =
-    gtk_signal_new ("activate",
-                    GTK_RUN_FIRST | GTK_RUN_ACTION,
-                    GTK_CLASS_TYPE (object_class),
-                    GTK_SIGNAL_OFFSET (GtkButtonClass, activate),
-                    _gtk_marshal_VOID__VOID,
-		    GTK_TYPE_NONE, 0);
+    g_signal_new ("activate",
+		  G_OBJECT_CLASS_TYPE (object_class),
+		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
+		  G_STRUCT_OFFSET (GtkButtonClass, activate),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
   widget_class->activate_signal = button_signals[ACTIVATE];
 
   gtk_widget_class_install_style_property (widget_class,
@@ -345,13 +351,13 @@ gtk_button_constructor (GType                  type,
 }
 
 
-static GtkType
+static GType
 gtk_button_child_type  (GtkContainer     *container)
 {
   if (!GTK_BIN (container)->child)
     return GTK_TYPE_WIDGET;
   else
-    return GTK_TYPE_NONE;
+    return G_TYPE_NONE;
 }
 
 static void
@@ -417,7 +423,7 @@ gtk_button_get_property (GObject         *object,
 GtkWidget*
 gtk_button_new (void)
 {
-  return GTK_WIDGET (gtk_type_new (gtk_button_get_type ()));
+  return g_object_new (GTK_TYPE_BUTTON, NULL);
 }
 
 static void
@@ -530,7 +536,7 @@ gtk_button_pressed (GtkButton *button)
 {
   g_return_if_fail (GTK_IS_BUTTON (button));
 
-  gtk_signal_emit (GTK_OBJECT (button), button_signals[PRESSED]);
+  g_signal_emit (button, button_signals[PRESSED], 0);
 }
 
 void
@@ -538,7 +544,7 @@ gtk_button_released (GtkButton *button)
 {
   g_return_if_fail (GTK_IS_BUTTON (button));
 
-  gtk_signal_emit (GTK_OBJECT (button), button_signals[RELEASED]);
+  g_signal_emit (button, button_signals[RELEASED], 0);
 }
 
 void
@@ -546,7 +552,7 @@ gtk_button_clicked (GtkButton *button)
 {
   g_return_if_fail (GTK_IS_BUTTON (button));
 
-  gtk_signal_emit (GTK_OBJECT (button), button_signals[CLICKED]);
+  g_signal_emit (button, button_signals[CLICKED], 0);
 }
 
 void
@@ -554,7 +560,7 @@ gtk_button_enter (GtkButton *button)
 {
   g_return_if_fail (GTK_IS_BUTTON (button));
 
-  gtk_signal_emit (GTK_OBJECT (button), button_signals[ENTER]);
+  g_signal_emit (button, button_signals[ENTER], 0);
 }
 
 void
@@ -562,7 +568,7 @@ gtk_button_leave (GtkButton *button)
 {
   g_return_if_fail (GTK_IS_BUTTON (button));
 
-  gtk_signal_emit (GTK_OBJECT (button), button_signals[LEAVE]);
+  g_signal_emit (button, button_signals[LEAVE], 0);
 }
 
 void
@@ -617,7 +623,7 @@ gtk_button_realize (GtkWidget *widget)
   attributes_mask = GDK_WA_X | GDK_WA_Y;
 
   widget->window = gtk_widget_get_parent_window (widget);
-  gdk_window_ref (widget->window);
+  g_object_ref (widget->window);
   
   button->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
 					 &attributes, attributes_mask);
diff --git a/gtk/gtkbutton.h b/gtk/gtkbutton.h
index acdb05e255..f3500c3f2a 100644
--- a/gtk/gtkbutton.h
+++ b/gtk/gtkbutton.h
@@ -38,11 +38,11 @@ extern "C" {
 #endif /* __cplusplus */
 
 #define GTK_TYPE_BUTTON                 (gtk_button_get_type ())
-#define GTK_BUTTON(obj)                 (GTK_CHECK_CAST ((obj), GTK_TYPE_BUTTON, GtkButton))
-#define GTK_BUTTON_CLASS(klass)         (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_BUTTON, GtkButtonClass))
-#define GTK_IS_BUTTON(obj)              (GTK_CHECK_TYPE ((obj), GTK_TYPE_BUTTON))
-#define GTK_IS_BUTTON_CLASS(klass)      (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BUTTON))
-#define GTK_BUTTON_GET_CLASS(obj)       (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_BUTTON, GtkButtonClass))
+#define GTK_BUTTON(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BUTTON, GtkButton))
+#define GTK_BUTTON_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BUTTON, GtkButtonClass))
+#define GTK_IS_BUTTON(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BUTTON))
+#define GTK_IS_BUTTON_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BUTTON))
+#define GTK_BUTTON_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BUTTON, GtkButtonClass))
 
 
 typedef struct _GtkButton       GtkButton;
@@ -87,7 +87,7 @@ struct _GtkButtonClass
 };
 
 
-GtkType        gtk_button_get_type          (void) G_GNUC_CONST;
+GType          gtk_button_get_type          (void) G_GNUC_CONST;
 GtkWidget*     gtk_button_new               (void);
 GtkWidget*     gtk_button_new_with_label    (const gchar    *label);
 GtkWidget*     gtk_button_new_from_stock    (const gchar    *stock_id);
diff --git a/gtk/gtkcheckbutton.c b/gtk/gtkcheckbutton.c
index 5e3ef30d51..1fa1c1f832 100644
--- a/gtk/gtkcheckbutton.c
+++ b/gtk/gtkcheckbutton.c
@@ -51,26 +51,29 @@ static void gtk_real_check_button_draw_indicator (GtkCheckButton      *check_but
 static GtkToggleButtonClass *parent_class = NULL;
 
 
-GtkType
+GType
 gtk_check_button_get_type (void)
 {
-  static GtkType check_button_type = 0;
+  static GType check_button_type = 0;
   
   if (!check_button_type)
     {
-      static const GtkTypeInfo check_button_info =
+      static const GTypeInfo check_button_info =
       {
-	"GtkCheckButton",
-	sizeof (GtkCheckButton),
 	sizeof (GtkCheckButtonClass),
-	(GtkClassInitFunc) gtk_check_button_class_init,
-	(GtkObjectInitFunc) gtk_check_button_init,
-	/* reserved_1 */ NULL,
-        /* reserved_2 */ NULL,
-        (GtkClassInitFunc) NULL,
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) gtk_check_button_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkCheckButton),
+	0,		/* n_preallocs */
+	(GInstanceInitFunc) gtk_check_button_init,
       };
       
-      check_button_type = gtk_type_unique (GTK_TYPE_TOGGLE_BUTTON, &check_button_info);
+      check_button_type =
+	g_type_register_static (GTK_TYPE_TOGGLE_BUTTON, "GtkCheckButton",
+				&check_button_info, 0);
     }
   
   return check_button_type;
@@ -82,7 +85,7 @@ gtk_check_button_class_init (GtkCheckButtonClass *class)
   GtkWidgetClass *widget_class;
   
   widget_class = (GtkWidgetClass*) class;
-  parent_class = gtk_type_class (gtk_toggle_button_get_type ());
+  parent_class = g_type_class_peek_parent (class);
   
   widget_class->size_request = gtk_check_button_size_request;
   widget_class->size_allocate = gtk_check_button_size_allocate;
@@ -120,7 +123,7 @@ gtk_check_button_init (GtkCheckButton *check_button)
 GtkWidget*
 gtk_check_button_new (void)
 {
-  return gtk_widget_new (GTK_TYPE_CHECK_BUTTON, NULL);
+  return g_object_new (GTK_TYPE_CHECK_BUTTON, NULL);
 }
 
 
diff --git a/gtk/gtkcheckbutton.h b/gtk/gtkcheckbutton.h
index 62587f5f53..b2f3e1eaef 100644
--- a/gtk/gtkcheckbutton.h
+++ b/gtk/gtkcheckbutton.h
@@ -38,11 +38,11 @@ extern "C" {
 
 
 #define GTK_TYPE_CHECK_BUTTON                  (gtk_check_button_get_type ())
-#define GTK_CHECK_BUTTON(obj)                  (GTK_CHECK_CAST ((obj), GTK_TYPE_CHECK_BUTTON, GtkCheckButton))
-#define GTK_CHECK_BUTTON_CLASS(klass)          (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_CHECK_BUTTON, GtkCheckButtonClass))
-#define GTK_IS_CHECK_BUTTON(obj)               (GTK_CHECK_TYPE ((obj), GTK_TYPE_CHECK_BUTTON))
-#define GTK_IS_CHECK_BUTTON_CLASS(klass)       (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CHECK_BUTTON))
-#define GTK_CHECK_BUTTON_GET_CLASS(obj)        (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_CHECK_BUTTON, GtkCheckButtonClass))
+#define GTK_CHECK_BUTTON(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CHECK_BUTTON, GtkCheckButton))
+#define GTK_CHECK_BUTTON_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CHECK_BUTTON, GtkCheckButtonClass))
+#define GTK_IS_CHECK_BUTTON(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CHECK_BUTTON))
+#define GTK_IS_CHECK_BUTTON_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CHECK_BUTTON))
+#define GTK_CHECK_BUTTON_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CHECK_BUTTON, GtkCheckButtonClass))
 
 
 typedef struct _GtkCheckButton       GtkCheckButton;
@@ -68,7 +68,7 @@ struct _GtkCheckButtonClass
 };
 
 
-GtkType    gtk_check_button_get_type       (void) G_GNUC_CONST;
+GType      gtk_check_button_get_type       (void) G_GNUC_CONST;
 GtkWidget* gtk_check_button_new               (void);
 GtkWidget* gtk_check_button_new_with_label    (const gchar *label);
 GtkWidget* gtk_check_button_new_with_mnemonic (const gchar *label);
diff --git a/gtk/gtkcolorseldialog.c b/gtk/gtkcolorseldialog.c
index aa010b02d2..3d16c0a029 100644
--- a/gtk/gtkcolorseldialog.c
+++ b/gtk/gtkcolorseldialog.c
@@ -42,26 +42,29 @@ static GtkWindowClass *color_selection_dialog_parent_class = NULL;
 /* GtkColorSelectionDialog */
 /***************************/
 
-GtkType
+GType
 gtk_color_selection_dialog_get_type (void)
 {
-  static GtkType color_selection_dialog_type = 0;
+  static GType color_selection_dialog_type = 0;
   
   if (!color_selection_dialog_type)
     {
-      GtkTypeInfo colorsel_diag_info =
+      static const GTypeInfo colorsel_diag_info =
       {
-	"GtkColorSelectionDialog",
-	sizeof (GtkColorSelectionDialog),
 	sizeof (GtkColorSelectionDialogClass),
-	(GtkClassInitFunc) gtk_color_selection_dialog_class_init,
-	(GtkObjectInitFunc) gtk_color_selection_dialog_init,
-	/* reserved_1 */ NULL,
-	/* reserved_2 */ NULL,
-        (GtkClassInitFunc) NULL,
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) gtk_color_selection_dialog_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkColorSelectionDialog),
+	0,		/* n_preallocs */
+	(GInstanceInitFunc) gtk_color_selection_dialog_init,
       };
       
-      color_selection_dialog_type = gtk_type_unique (GTK_TYPE_DIALOG, &colorsel_diag_info);
+      color_selection_dialog_type =
+	g_type_register_static (GTK_TYPE_DIALOG, "GtkColorSelectionDialog",
+				&colorsel_diag_info, 0);
     }
   
   return color_selection_dialog_type;
@@ -70,11 +73,7 @@ gtk_color_selection_dialog_get_type (void)
 static void
 gtk_color_selection_dialog_class_init (GtkColorSelectionDialogClass *klass)
 {
-  GtkObjectClass *object_class;
-  
-  object_class = (GtkObjectClass*) klass;
-  
-  color_selection_dialog_parent_class = gtk_type_class (GTK_TYPE_DIALOG);
+  color_selection_dialog_parent_class = g_type_class_peek_parent (klass);
 }
 
 static void
@@ -118,9 +117,8 @@ gtk_color_selection_dialog_new (const gchar *title)
 {
   GtkColorSelectionDialog *colorseldiag;
   
-  colorseldiag = gtk_type_new (GTK_TYPE_COLOR_SELECTION_DIALOG);
+  colorseldiag = g_object_new (GTK_TYPE_COLOR_SELECTION_DIALOG, NULL);
   gtk_window_set_title (GTK_WINDOW (colorseldiag), title);
-  gtk_window_set_policy(GTK_WINDOW (colorseldiag), FALSE, FALSE, TRUE);
   
   return GTK_WIDGET (colorseldiag);
 }
diff --git a/gtk/gtkcolorseldialog.h b/gtk/gtkcolorseldialog.h
index 276df5b2ab..6a1c657de3 100644
--- a/gtk/gtkcolorseldialog.h
+++ b/gtk/gtkcolorseldialog.h
@@ -35,11 +35,11 @@ extern "C" {
 #endif /* __cplusplus */
 
 #define GTK_TYPE_COLOR_SELECTION_DIALOG            (gtk_color_selection_dialog_get_type ())
-#define GTK_COLOR_SELECTION_DIALOG(obj)            (GTK_CHECK_CAST ((obj), GTK_TYPE_COLOR_SELECTION_DIALOG, GtkColorSelectionDialog))
-#define GTK_COLOR_SELECTION_DIALOG_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_SELECTION_DIALOG, GtkColorSelectionDialogClass))
-#define GTK_IS_COLOR_SELECTION_DIALOG(obj)         (GTK_CHECK_TYPE ((obj), GTK_TYPE_COLOR_SELECTION_DIALOG))
-#define GTK_IS_COLOR_SELECTION_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COLOR_SELECTION_DIALOG))
-#define GTK_COLOR_SELECTION_DIALOG_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_COLOR_SELECTION_DIALOG, GtkColorSelectionDialogClass))
+#define GTK_COLOR_SELECTION_DIALOG(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_SELECTION_DIALOG, GtkColorSelectionDialog))
+#define GTK_COLOR_SELECTION_DIALOG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_SELECTION_DIALOG, GtkColorSelectionDialogClass))
+#define GTK_IS_COLOR_SELECTION_DIALOG(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_SELECTION_DIALOG))
+#define GTK_IS_COLOR_SELECTION_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COLOR_SELECTION_DIALOG))
+#define GTK_COLOR_SELECTION_DIALOG_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COLOR_SELECTION_DIALOG, GtkColorSelectionDialogClass))
 
 
 typedef struct _GtkColorSelectionDialog       GtkColorSelectionDialog;
@@ -69,7 +69,7 @@ struct _GtkColorSelectionDialogClass
 
 
 /* ColorSelectionDialog */ 
-GtkType    gtk_color_selection_dialog_get_type (void) G_GNUC_CONST;
+GType      gtk_color_selection_dialog_get_type (void) G_GNUC_CONST;
 GtkWidget* gtk_color_selection_dialog_new      (const gchar *title); 
 
 
diff --git a/gtk/gtkdialog.c b/gtk/gtkdialog.c
index 228a6decc0..f5c5614a09 100644
--- a/gtk/gtkdialog.c
+++ b/gtk/gtkdialog.c
@@ -30,7 +30,6 @@
 #include "gtkhseparator.h"
 #include "gtkmarshalers.h"
 #include "gtkvbox.h"
-#include "gtksignal.h"
 #include "gdkkeysyms.h"
 #include "gtkmain.h"
 #include "gtkintl.h"
@@ -75,26 +74,28 @@ enum {
 static gpointer parent_class;
 static guint dialog_signals[LAST_SIGNAL];
 
-GtkType
+GType
 gtk_dialog_get_type (void)
 {
-  static GtkType dialog_type = 0;
+  static GType dialog_type = 0;
 
   if (!dialog_type)
     {
-      static const GtkTypeInfo dialog_info =
+      static const GTypeInfo dialog_info =
       {
-	"GtkDialog",
-	sizeof (GtkDialog),
 	sizeof (GtkDialogClass),
-	(GtkClassInitFunc) gtk_dialog_class_init,
-	(GtkObjectInitFunc) gtk_dialog_init,
-	/* reserved_1 */ NULL,
-        /* reserved_2 */ NULL,
-        (GtkClassInitFunc) NULL,
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) gtk_dialog_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkDialog),
+	0,		/* n_preallocs */
+	(GInstanceInitFunc) gtk_dialog_init,
       };
 
-      dialog_type = gtk_type_unique (GTK_TYPE_WINDOW, &dialog_info);
+      dialog_type = g_type_register_static (GTK_TYPE_WINDOW, "GtkDialog",
+					    &dialog_info, 0);
     }
 
   return dialog_type;
@@ -104,12 +105,10 @@ static void
 gtk_dialog_class_init (GtkDialogClass *class)
 {
   GObjectClass *gobject_class;
-  GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkBindingSet *binding_set;
   
   gobject_class = G_OBJECT_CLASS (class);
-  object_class = GTK_OBJECT_CLASS (class);
   widget_class = GTK_WIDGET_CLASS (class);
   
   parent_class = g_type_class_peek_parent (class);
@@ -131,21 +130,23 @@ gtk_dialog_class_init (GtkDialogClass *class)
                                                          G_PARAM_READWRITE));
   
   dialog_signals[RESPONSE] =
-    gtk_signal_new ("response",
-                    GTK_RUN_LAST,
-                    GTK_CLASS_TYPE (object_class),
-                    GTK_SIGNAL_OFFSET (GtkDialogClass, response),
-                    _gtk_marshal_NONE__INT,
-		    GTK_TYPE_NONE, 1,
-                    GTK_TYPE_INT);
+    g_signal_new ("response",
+		  G_OBJECT_CLASS_TYPE (class),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (GtkDialogClass, response),
+		  NULL, NULL,
+		  _gtk_marshal_NONE__INT,
+		  G_TYPE_NONE, 1,
+		  G_TYPE_INT);
 
   dialog_signals[CLOSE] =
-    gtk_signal_new ("close",
-                    GTK_RUN_LAST | GTK_RUN_ACTION,
-                    GTK_CLASS_TYPE (object_class),
-                    GTK_SIGNAL_OFFSET (GtkDialogClass, close),
-                    _gtk_marshal_NONE__NONE,
-		    GTK_TYPE_NONE, 0);
+    g_signal_new ("close",
+		  G_OBJECT_CLASS_TYPE (class),
+		  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+		  G_STRUCT_OFFSET (GtkDialogClass, close),
+		  NULL, NULL,
+		  _gtk_marshal_NONE__NONE,
+		  G_TYPE_NONE, 0);
   
   gtk_widget_class_install_style_property (widget_class,
 					   g_param_spec_int ("content_area_border",
@@ -213,10 +214,10 @@ gtk_dialog_init (GtkDialog *dialog)
    * by connecting a handler, we have to have the FIRST signal
    * connection on the dialog.
    */
-  gtk_signal_connect (GTK_OBJECT (dialog),
-                      "delete_event",
-                      GTK_SIGNAL_FUNC (gtk_dialog_delete_event_handler),
-                      NULL);
+  g_signal_connect (dialog,
+                    "delete_event",
+                    G_CALLBACK (gtk_dialog_delete_event_handler),
+                    NULL);
   
   dialog->vbox = gtk_vbox_new (FALSE, 0);
   
@@ -364,7 +365,7 @@ gtk_dialog_close (GtkDialog *dialog)
 GtkWidget*
 gtk_dialog_new (void)
 {
-  return GTK_WIDGET (gtk_type_new (GTK_TYPE_DIALOG));
+  return g_object_new (GTK_TYPE_DIALOG, NULL);
 }
 
 static GtkWidget*
@@ -374,7 +375,7 @@ gtk_dialog_new_empty (const gchar     *title,
 {
   GtkDialog *dialog;
 
-  dialog = GTK_DIALOG (g_object_new (GTK_TYPE_DIALOG, NULL));
+  dialog = g_object_new (GTK_TYPE_DIALOG, NULL);
 
   if (title)
     gtk_window_set_title (GTK_WINDOW (dialog), title);
@@ -468,17 +469,17 @@ struct _ResponseData
 static ResponseData*
 get_response_data (GtkWidget *widget)
 {
-  ResponseData *ad = gtk_object_get_data (GTK_OBJECT (widget),
-                                          "gtk-dialog-response-data");
+  ResponseData *ad = g_object_get_data (G_OBJECT (widget),
+                                        "gtk-dialog-response-data");
 
   if (ad == NULL)
     {
       ad = g_new (ResponseData, 1);
       
-      gtk_object_set_data_full (GTK_OBJECT (widget),
-                                "gtk-dialog-response-data",
-                                ad,
-                                g_free);
+      g_object_set_data_full (G_OBJECT (widget),
+                              "gtk-dialog-response-data",
+                              ad,
+                              g_free);
     }
 
   return ad;
@@ -502,6 +503,7 @@ action_widget_activated (GtkWidget *widget, GtkDialog *dialog)
 
   gtk_dialog_response (dialog, response_id);
 }
+
 /**
  * gtk_dialog_add_action_widget:
  * @dialog: a #GtkDialog
@@ -516,9 +518,9 @@ action_widget_activated (GtkWidget *widget, GtkDialog *dialog)
  * <literal>action_area</literal> field of the #GtkDialog struct.
  **/
 void
-gtk_dialog_add_action_widget  (GtkDialog *dialog,
-                               GtkWidget *child,
-                               gint       response_id)
+gtk_dialog_add_action_widget (GtkDialog *dialog,
+                              GtkWidget *child,
+                              gint       response_id)
 {
   ResponseData *ad;
   gint signal_id = 0;
@@ -531,21 +533,21 @@ gtk_dialog_add_action_widget  (GtkDialog *dialog,
   ad->response_id = response_id;
 
   if (GTK_IS_BUTTON (child))
-    {
-      signal_id = g_signal_lookup ("clicked", GTK_TYPE_BUTTON);
-    }
+    signal_id = g_signal_lookup ("clicked", GTK_TYPE_BUTTON);
   else
     signal_id = GTK_WIDGET_GET_CLASS (child)->activate_signal != 0;
 
   if (signal_id)
     {
-      const gchar* name = gtk_signal_name (signal_id);
-
-      gtk_signal_connect_while_alive (GTK_OBJECT (child),
-                                      name,
-                                      GTK_SIGNAL_FUNC (action_widget_activated),
-                                      dialog,
-                                      GTK_OBJECT (dialog));
+      GClosure *closure;
+
+      closure = g_cclosure_new_object (G_CALLBACK (action_widget_activated),
+				       G_OBJECT (dialog));
+      g_signal_connect_closure_by_id (child,
+				      signal_id,
+				      0,
+				      closure,
+				      FALSE);
     }
   else
     g_warning ("Only 'activatable' widgets can be packed into the action area of a GtkDialog");
@@ -797,9 +799,10 @@ gtk_dialog_response (GtkDialog *dialog,
 {
   g_return_if_fail (GTK_IS_DIALOG (dialog));
 
-  gtk_signal_emit (GTK_OBJECT (dialog),
-                   dialog_signals[RESPONSE],
-                   response_id);
+  g_signal_emit (dialog,
+		 dialog_signals[RESPONSE],
+		 0,
+		 response_id);
 }
 
 typedef struct
@@ -915,7 +918,7 @@ gtk_dialog_run (GtkDialog *dialog)
   
   g_return_val_if_fail (GTK_IS_DIALOG (dialog), -1);
 
-  gtk_object_ref (GTK_OBJECT (dialog));
+  g_object_ref (dialog);
 
   if (!GTK_WIDGET_VISIBLE (dialog))
     gtk_widget_show (GTK_WIDGET (dialog));
@@ -925,30 +928,30 @@ gtk_dialog_run (GtkDialog *dialog)
     gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
 
   response_handler =
-    gtk_signal_connect (GTK_OBJECT (dialog),
-                        "response",
-                        GTK_SIGNAL_FUNC (run_response_handler),
-                        &ri);
+    g_signal_connect (dialog,
+                      "response",
+                      G_CALLBACK (run_response_handler),
+                      &ri);
   
   unmap_handler =
-    gtk_signal_connect (GTK_OBJECT (dialog),
-                        "unmap",
-                        GTK_SIGNAL_FUNC (run_unmap_handler),
-                        &ri);
+    g_signal_connect (dialog,
+                      "unmap",
+                      G_CALLBACK (run_unmap_handler),
+                      &ri);
   
   delete_handler =
-    gtk_signal_connect (GTK_OBJECT (dialog),
-                        "delete_event",
-                        GTK_SIGNAL_FUNC (run_delete_handler),
-                        &ri);
+    g_signal_connect (dialog,
+                      "delete_event",
+                      G_CALLBACK (run_delete_handler),
+                      &ri);
   
   destroy_handler =
-    gtk_signal_connect (GTK_OBJECT (dialog),
-                        "destroy",
-                        GTK_SIGNAL_FUNC (run_destroy_handler),
-                        &ri);
+    g_signal_connect (dialog,
+                      "destroy",
+                      G_CALLBACK (run_destroy_handler),
+                      &ri);
   
-  ri.loop = g_main_new (FALSE);
+  ri.loop = g_main_loop_new (NULL, FALSE);
 
   GDK_THREADS_LEAVE ();  
   g_main_loop_run (ri.loop);
@@ -964,13 +967,13 @@ gtk_dialog_run (GtkDialog *dialog)
       if (!was_modal)
         gtk_window_set_modal (GTK_WINDOW(dialog), FALSE);
       
-      gtk_signal_disconnect (GTK_OBJECT (dialog), response_handler);
-      gtk_signal_disconnect (GTK_OBJECT (dialog), unmap_handler);
-      gtk_signal_disconnect (GTK_OBJECT (dialog), delete_handler);
-      gtk_signal_disconnect (GTK_OBJECT (dialog), destroy_handler);
+      g_signal_handler_disconnect (dialog, response_handler);
+      g_signal_handler_disconnect (dialog, unmap_handler);
+      g_signal_handler_disconnect (dialog, delete_handler);
+      g_signal_handler_disconnect (dialog, destroy_handler);
     }
 
-  gtk_object_unref (GTK_OBJECT (dialog));
+  g_object_unref (dialog);
 
   return ri.response_id;
 }
diff --git a/gtk/gtkdialog.h b/gtk/gtkdialog.h
index ebe7bcf619..953857c465 100644
--- a/gtk/gtkdialog.h
+++ b/gtk/gtkdialog.h
@@ -83,11 +83,11 @@ typedef enum
 
 
 #define GTK_TYPE_DIALOG                  (gtk_dialog_get_type ())
-#define GTK_DIALOG(obj)                  (GTK_CHECK_CAST ((obj), GTK_TYPE_DIALOG, GtkDialog))
-#define GTK_DIALOG_CLASS(klass)          (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_DIALOG, GtkDialogClass))
-#define GTK_IS_DIALOG(obj)               (GTK_CHECK_TYPE ((obj), GTK_TYPE_DIALOG))
-#define GTK_IS_DIALOG_CLASS(klass)       (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_DIALOG))
-#define GTK_DIALOG_GET_CLASS(obj)        (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_DIALOG, GtkDialogClass))
+#define GTK_DIALOG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_DIALOG, GtkDialog))
+#define GTK_DIALOG_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_DIALOG, GtkDialogClass))
+#define GTK_IS_DIALOG(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_DIALOG))
+#define GTK_IS_DIALOG_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_DIALOG))
+#define GTK_DIALOG_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_DIALOG, GtkDialogClass))
 
 
 typedef struct _GtkDialog        GtkDialog;
@@ -123,7 +123,7 @@ struct _GtkDialogClass
 };
 
 
-GtkType    gtk_dialog_get_type (void) G_GNUC_CONST;
+GType      gtk_dialog_get_type (void) G_GNUC_CONST;
 GtkWidget* gtk_dialog_new      (void);
 
 GtkWidget* gtk_dialog_new_with_buttons (const gchar     *title,
diff --git a/gtk/gtkhandlebox.c b/gtk/gtkhandlebox.c
index 4c72df49d8..41f5afd2bb 100644
--- a/gtk/gtkhandlebox.c
+++ b/gtk/gtkhandlebox.c
@@ -29,7 +29,6 @@
 #include "gtkhandlebox.h"
 #include "gtkmain.h"
 #include "gtkmarshalers.h"
-#include "gtksignal.h"
 #include "gtkwindow.h"
 #include "gtkintl.h"
 
@@ -136,26 +135,28 @@ static GtkBinClass *parent_class;
 static guint        handle_box_signals[SIGNAL_LAST] = { 0 };
 
 
-GtkType
+GType
 gtk_handle_box_get_type (void)
 {
-  static GtkType handle_box_type = 0;
+  static GType handle_box_type = 0;
 
   if (!handle_box_type)
     {
-      static const GtkTypeInfo handle_box_info =
+      static const GTypeInfo handle_box_info =
       {
-	"GtkHandleBox",
-	sizeof (GtkHandleBox),
 	sizeof (GtkHandleBoxClass),
-	(GtkClassInitFunc) gtk_handle_box_class_init,
-	(GtkObjectInitFunc) gtk_handle_box_init,
-	/* reserved_1 */ NULL,
-        /* reserved_2 */ NULL,
-        (GtkClassInitFunc) NULL,
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) gtk_handle_box_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkHandleBox),
+	0,		/* n_preallocs */
+	(GInstanceInitFunc) gtk_handle_box_init,
       };
 
-      handle_box_type = gtk_type_unique (GTK_TYPE_BIN, &handle_box_info);
+      handle_box_type = g_type_register_static (GTK_TYPE_BIN, "GtkHandleBox",
+						&handle_box_info, 0);
     }
 
   return handle_box_type;
@@ -174,7 +175,7 @@ gtk_handle_box_class_init (GtkHandleBoxClass *class)
   widget_class = (GtkWidgetClass *) class;
   container_class = (GtkContainerClass *) class;
 
-  parent_class = gtk_type_class (GTK_TYPE_BIN);
+  parent_class = g_type_class_peek_parent (class);
 
   gobject_class->set_property = gtk_handle_box_set_property;
   gobject_class->get_property = gtk_handle_box_get_property;
@@ -212,6 +213,7 @@ gtk_handle_box_class_init (GtkHandleBoxClass *class)
 						      GTK_TYPE_POSITION_TYPE,
 						      GTK_POS_TOP,
                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
+
   object_class->destroy = gtk_handle_box_destroy;
 
   widget_class->map = gtk_handle_box_map;
@@ -234,21 +236,23 @@ gtk_handle_box_class_init (GtkHandleBoxClass *class)
   class->child_detached = NULL;
 
   handle_box_signals[SIGNAL_CHILD_ATTACHED] =
-    gtk_signal_new ("child_attached",
-		    GTK_RUN_FIRST,
-		    GTK_CLASS_TYPE (object_class),
-		    GTK_SIGNAL_OFFSET (GtkHandleBoxClass, child_attached),
-		    _gtk_marshal_VOID__OBJECT,
-		    GTK_TYPE_NONE, 1,
-		    GTK_TYPE_WIDGET);
+    g_signal_new ("child_attached",
+		  G_OBJECT_CLASS_TYPE (gobject_class),
+		  G_SIGNAL_RUN_FIRST,
+		  G_STRUCT_OFFSET (GtkHandleBoxClass, child_attached),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__OBJECT,
+		  G_TYPE_NONE, 1,
+		  GTK_TYPE_WIDGET);
   handle_box_signals[SIGNAL_CHILD_DETACHED] =
-    gtk_signal_new ("child_detached",
-		    GTK_RUN_FIRST,
-		    GTK_CLASS_TYPE (object_class),
-		    GTK_SIGNAL_OFFSET (GtkHandleBoxClass, child_detached),
-		    _gtk_marshal_VOID__OBJECT,
-		    GTK_TYPE_NONE, 1,
-		    GTK_TYPE_WIDGET);
+    g_signal_new ("child_detached",
+		  G_OBJECT_CLASS_TYPE (gobject_class),
+		  G_SIGNAL_RUN_FIRST,
+		  G_STRUCT_OFFSET (GtkHandleBoxClass, child_detached),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__OBJECT,
+		  G_TYPE_NONE, 1,
+		  GTK_TYPE_WIDGET);
 }
 
 static void
@@ -322,7 +326,7 @@ gtk_handle_box_get_property (GObject         *object,
 GtkWidget*
 gtk_handle_box_new (void)
 {
-  return GTK_WIDGET (gtk_type_new (gtk_handle_box_get_type ()));
+  return g_object_new (GTK_TYPE_HANDLE_BOX, NULL);
 }
 
 static void
@@ -818,7 +822,7 @@ gtk_handle_box_paint (GtkWidget      *widget,
   bin = GTK_BIN (widget);
   hb = GTK_HANDLE_BOX (widget);
 
-  gdk_window_get_size (hb->bin_window, &width, &height);
+  gdk_drawable_get_size (hb->bin_window, &width, &height);
   
   if (!event)
     gtk_paint_box (widget->style,
@@ -961,7 +965,7 @@ gtk_handle_box_button_changed (GtkWidget      *widget,
 	      
 	      gdk_window_get_deskrelative_origin (hb->bin_window, &desk_x, &desk_y);
 	      gdk_window_get_origin (hb->bin_window, &root_x, &root_y);
-	      gdk_window_get_size (hb->bin_window, &width, &height);
+	      gdk_drawable_get_size (hb->bin_window, &width, &height);
 	      
 	      hb->float_allocation.x = root_x - event->x_root;
 	      hb->float_allocation.y = root_y - event->y_root;
@@ -972,7 +976,7 @@ gtk_handle_box_button_changed (GtkWidget      *widget,
 	      hb->deskoff_y = desk_y - root_y;
 	      
 	      gdk_window_get_origin (widget->window, &root_x, &root_y);
-	      gdk_window_get_size (widget->window, &width, &height);
+	      gdk_drawable_get_size (widget->window, &width, &height);
 	      
 	      hb->attach_allocation.x = root_x;
 	      hb->attach_allocation.y = root_y;
@@ -994,7 +998,7 @@ gtk_handle_box_button_changed (GtkWidget      *widget,
 		  hb->in_drag = FALSE;
 		}
 	      
-	      gdk_cursor_destroy (fleur);
+	      gdk_cursor_unref (fleur);
 	      event_handled = TRUE;
 	    }
 	  else if (hb->child_detached) /* Double click */
@@ -1112,9 +1116,10 @@ gtk_handle_box_motion (GtkWidget      *widget,
 	  gdk_window_hide (hb->float_window);
 	  gdk_window_reparent (hb->bin_window, widget->window, 0, 0);
 	  hb->float_window_mapped = FALSE;
-	  gtk_signal_emit (GTK_OBJECT (hb),
-			   handle_box_signals[SIGNAL_CHILD_ATTACHED],
-			   GTK_BIN (hb)->child);
+	  g_signal_emit (hb,
+			 handle_box_signals[SIGNAL_CHILD_ATTACHED],
+			 0,
+			 GTK_BIN (hb)->child);
 	  
 	  gtk_widget_queue_resize (widget);
 	}
@@ -1123,7 +1128,7 @@ gtk_handle_box_motion (GtkWidget      *widget,
     {
       gint width, height;
 
-      gdk_window_get_size (hb->float_window, &width, &height);
+      gdk_drawable_get_size (hb->float_window, &width, &height);
       new_x += hb->deskoff_x;
       new_y += hb->deskoff_y;
 
@@ -1187,9 +1192,10 @@ gtk_handle_box_motion (GtkWidget      *widget,
 	  gdk_window_move (hb->float_window, new_x, new_y);
 	  gdk_display_sync (gtk_widget_get_display (widget));
 #endif	/* 0 */
-	  gtk_signal_emit (GTK_OBJECT (hb),
-			   handle_box_signals[SIGNAL_CHILD_DETACHED],
-			   GTK_BIN (hb)->child);
+	  g_signal_emit (hb,
+			 handle_box_signals[SIGNAL_CHILD_DETACHED],
+			 0,
+			 GTK_BIN (hb)->child);
 	  gtk_handle_box_draw_ghost (hb);
 	  
 	  gtk_widget_queue_resize (widget);
@@ -1246,9 +1252,10 @@ gtk_handle_box_reattach (GtkHandleBox *hb)
 	  gdk_window_reparent (hb->bin_window, widget->window, 0, 0);
 
 	  if (GTK_BIN (hb)->child)
-	    gtk_signal_emit (GTK_OBJECT (hb),
-			     handle_box_signals[SIGNAL_CHILD_ATTACHED],
-			     GTK_BIN (hb)->child);
+	    g_signal_emit (hb,
+			   handle_box_signals[SIGNAL_CHILD_ATTACHED],
+			   0,
+			   GTK_BIN (hb)->child);
 
 	}
       hb->float_window_mapped = FALSE;
diff --git a/gtk/gtkhandlebox.h b/gtk/gtkhandlebox.h
index 1f6ec3e292..07010ba071 100644
--- a/gtk/gtkhandlebox.h
+++ b/gtk/gtkhandlebox.h
@@ -44,11 +44,11 @@ extern "C" {
 
 
 #define GTK_TYPE_HANDLE_BOX            (gtk_handle_box_get_type ())
-#define GTK_HANDLE_BOX(obj)            (GTK_CHECK_CAST ((obj), GTK_TYPE_HANDLE_BOX, GtkHandleBox))
-#define GTK_HANDLE_BOX_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_HANDLE_BOX, GtkHandleBoxClass))
-#define GTK_IS_HANDLE_BOX(obj)         (GTK_CHECK_TYPE ((obj), GTK_TYPE_HANDLE_BOX))
-#define GTK_IS_HANDLE_BOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HANDLE_BOX))
-#define GTK_HANDLE_BOX_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_HANDLE_BOX, GtkHandleBoxClass))
+#define GTK_HANDLE_BOX(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HANDLE_BOX, GtkHandleBox))
+#define GTK_HANDLE_BOX_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HANDLE_BOX, GtkHandleBoxClass))
+#define GTK_IS_HANDLE_BOX(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HANDLE_BOX))
+#define GTK_IS_HANDLE_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HANDLE_BOX))
+#define GTK_HANDLE_BOX_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HANDLE_BOX, GtkHandleBoxClass))
 
 
 typedef struct _GtkHandleBox       GtkHandleBox;
@@ -94,8 +94,8 @@ struct _GtkHandleBoxClass
 };
 
 
-GtkType       gtk_handle_box_get_type        (void) G_GNUC_CONST;
-GtkWidget*    gtk_handle_box_new             (void);
+GType         gtk_handle_box_get_type             (void) G_GNUC_CONST;
+GtkWidget*    gtk_handle_box_new                  (void);
 void          gtk_handle_box_set_shadow_type      (GtkHandleBox    *handle_box,
                                                    GtkShadowType    type);
 GtkShadowType gtk_handle_box_get_shadow_type      (GtkHandleBox    *handle_box);
diff --git a/gtk/gtkinputdialog.c b/gtk/gtkinputdialog.c
index 7d9a3af7a1..3bb0584aef 100644
--- a/gtk/gtkinputdialog.c
+++ b/gtk/gtkinputdialog.c
@@ -49,7 +49,6 @@
 #include "gtknotebook.h"
 #include "gtkoptionmenu.h"
 #include "gtkscrolledwindow.h"
-#include "gtksignal.h"
 #include "gtkstock.h"
 #include "gtktable.h"
 #include "gtkvbox.h"
@@ -76,6 +75,8 @@ enum
 #define KEYS_LIST_WIDTH 200
 #define KEYS_LIST_HEIGHT 175
 
+#define GTK_INPUT_DIALOG_KEY "gtk-input-dialog-key"
+
 /* Forward declarations */
 
 static void gtk_input_dialog_class_init       (GtkInputDialogClass *klass);
@@ -104,27 +105,29 @@ static void gtk_input_dialog_fill_keys        (GtkInputDialog      *inputd,
 static GtkObjectClass *parent_class = NULL;
 static guint input_dialog_signals[LAST_SIGNAL] = { 0 };
 
-GtkType
+GType
 gtk_input_dialog_get_type (void)
 {
-  static GtkType input_dialog_type = 0;
+  static GType input_dialog_type = 0;
 
   if (!input_dialog_type)
     {
-      static const GtkTypeInfo input_dialog_info =
+      static const GTypeInfo input_dialog_info =
       {
-	"GtkInputDialog",
-	sizeof (GtkInputDialog),
 	sizeof (GtkInputDialogClass),
-	(GtkClassInitFunc) gtk_input_dialog_class_init,
-	(GtkObjectInitFunc) gtk_input_dialog_init,
-	/* reserved_1 */ NULL,
-        /* reserved_2 */ NULL,
-        (GtkClassInitFunc) NULL,
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) gtk_input_dialog_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkInputDialog),
+	0,		/* n_preallocs */
+	(GInstanceInitFunc) gtk_input_dialog_init,
       };
 
-      input_dialog_type = gtk_type_unique (GTK_TYPE_DIALOG,
-					   &input_dialog_info);
+      input_dialog_type =
+	g_type_register_static (GTK_TYPE_DIALOG, "GtkInputDialog",
+				&input_dialog_info, 0);
     }
 
   return input_dialog_type;
@@ -133,30 +136,30 @@ gtk_input_dialog_get_type (void)
 static void
 gtk_input_dialog_class_init (GtkInputDialogClass *klass)
 {
-  GtkObjectClass *object_class;
-
-  object_class = (GtkObjectClass*) klass;
-
-  parent_class = gtk_type_class (GTK_TYPE_DIALOG);
+  parent_class = g_type_class_peek_parent (klass);
 
   klass->enable_device = NULL;
   klass->disable_device = NULL;
 
   input_dialog_signals[ENABLE_DEVICE] =
-    gtk_signal_new ("enable_device",
-		    GTK_RUN_LAST,
-		    GTK_CLASS_TYPE (object_class),
-		    GTK_SIGNAL_OFFSET (GtkInputDialogClass, enable_device),
-		    _gtk_marshal_VOID__OBJECT,
-		    GTK_TYPE_NONE, 1, GDK_TYPE_DEVICE);
+    g_signal_new ("enable_device",
+		  G_OBJECT_CLASS_TYPE (klass),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (GtkInputDialogClass, enable_device),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__OBJECT,
+		  G_TYPE_NONE, 1,
+		  GDK_TYPE_DEVICE);
 
   input_dialog_signals[DISABLE_DEVICE] =
-    gtk_signal_new ("disable_device",
-		    GTK_RUN_LAST,
-		    GTK_CLASS_TYPE (object_class),
-		    GTK_SIGNAL_OFFSET (GtkInputDialogClass, disable_device),
-		    _gtk_marshal_VOID__OBJECT,
-		    GTK_TYPE_NONE, 1, GDK_TYPE_DEVICE);
+    g_signal_new ("disable_device",
+		  G_OBJECT_CLASS_TYPE (klass),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (GtkInputDialogClass, disable_device),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__OBJECT,
+		  G_TYPE_NONE, 1,
+		  GDK_TYPE_DEVICE);
 }
 
 static void
@@ -204,14 +207,15 @@ gtk_input_dialog_init (GtkInputDialog *inputd)
 	GdkDevice *info = (GdkDevice *)(tmp_list->data);
 	if (info != gdk_device_get_core_pointer ())
 	  {
-	    menuitem = gtk_menu_item_new_with_label(info->name);
+	    menuitem = gtk_menu_item_new_with_label (info->name);
 
 	    gtk_menu_shell_append (GTK_MENU_SHELL (device_menu), menuitem);
 	    gtk_widget_show (menuitem);
-	    gtk_object_set_user_data (GTK_OBJECT (menuitem), inputd);
-	    gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
-				(GtkSignalFunc) gtk_input_dialog_set_device,
-				info);
+	    g_object_set_data (G_OBJECT (menuitem), GTK_INPUT_DIALOG_KEY,
+			       inputd);
+	    g_signal_connect (menuitem, "activate",
+			      G_CALLBACK (gtk_input_dialog_set_device),
+			      info);
 	  }
       }
 
@@ -237,27 +241,27 @@ gtk_input_dialog_init (GtkInputDialog *inputd)
 
       menuitem = gtk_menu_item_new_with_label(_("Disabled"));
       gtk_menu_shell_append (GTK_MENU_SHELL (mapping_menu), menuitem);
-      gtk_object_set_user_data (GTK_OBJECT (menuitem), inputd);
+      g_object_set_data (G_OBJECT (menuitem), GTK_INPUT_DIALOG_KEY, inputd);
       gtk_widget_show (menuitem);
-      gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
-			  (GtkSignalFunc) gtk_input_dialog_set_mapping_mode,
-			  GINT_TO_POINTER (GDK_MODE_DISABLED));
+      g_signal_connect (menuitem, "activate",
+			G_CALLBACK (gtk_input_dialog_set_mapping_mode),
+			GINT_TO_POINTER (GDK_MODE_DISABLED));
 
       menuitem = gtk_menu_item_new_with_label(_("Screen"));
       gtk_menu_shell_append (GTK_MENU_SHELL (mapping_menu), menuitem);
-      gtk_object_set_user_data (GTK_OBJECT (menuitem), inputd);
+      g_object_set_data (G_OBJECT (menuitem), GTK_INPUT_DIALOG_KEY, inputd);
       gtk_widget_show (menuitem);
-      gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
-			  (GtkSignalFunc) gtk_input_dialog_set_mapping_mode,
-			  GINT_TO_POINTER (GDK_MODE_SCREEN));
+      g_signal_connect (menuitem, "activate",
+			G_CALLBACK (gtk_input_dialog_set_mapping_mode),
+			GINT_TO_POINTER (GDK_MODE_SCREEN));
 
       menuitem = gtk_menu_item_new_with_label(_("Window"));
       gtk_menu_shell_append (GTK_MENU_SHELL (mapping_menu), menuitem);
-      gtk_object_set_user_data (GTK_OBJECT (menuitem), inputd);
+      g_object_set_data (G_OBJECT (menuitem), GTK_INPUT_DIALOG_KEY, inputd);
       gtk_widget_show (menuitem);
-      gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
-			  (GtkSignalFunc) gtk_input_dialog_set_mapping_mode,
-			  GINT_TO_POINTER (GDK_MODE_WINDOW));
+      g_signal_connect (menuitem, "activate",
+			G_CALLBACK (gtk_input_dialog_set_mapping_mode),
+			GINT_TO_POINTER (GDK_MODE_WINDOW));
 
       label = gtk_label_new_with_mnemonic (_("_Mode: "));
       gtk_box_pack_start (GTK_BOX (util_box), label, FALSE, FALSE, 2);
@@ -296,7 +300,8 @@ gtk_input_dialog_init (GtkInputDialog *inputd)
       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(inputd->axis_listbox),
 				      GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
       
-      gtk_widget_set_usize (inputd->axis_listbox, AXIS_LIST_WIDTH, AXIS_LIST_HEIGHT);
+      gtk_widget_set_size_request (inputd->axis_listbox,
+				   AXIS_LIST_WIDTH, AXIS_LIST_HEIGHT);
       gtk_notebook_append_page (GTK_NOTEBOOK(notebook), 
 				inputd->axis_listbox, label);
 
@@ -309,10 +314,11 @@ gtk_input_dialog_init (GtkInputDialog *inputd)
       label = gtk_label_new_with_mnemonic (_("_Keys"));
 
       inputd->keys_listbox = gtk_scrolled_window_new (NULL, NULL);
-      gtk_widget_set_usize (inputd->keys_listbox, KEYS_LIST_WIDTH, KEYS_LIST_HEIGHT);
-      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(inputd->keys_listbox),
+      gtk_widget_set_size_request (inputd->keys_listbox,
+				   KEYS_LIST_WIDTH, KEYS_LIST_HEIGHT);
+      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (inputd->keys_listbox),
 				      GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
-      gtk_notebook_append_page (GTK_NOTEBOOK(notebook), 
+      gtk_notebook_append_page (GTK_NOTEBOOK (notebook), 
 				inputd->keys_listbox, label);
 
       gtk_widget_show (inputd->keys_listbox);
@@ -320,7 +326,7 @@ gtk_input_dialog_init (GtkInputDialog *inputd)
       inputd->keys_list = 0;
 
       /* ...set_device expects to get input dialog from widget user data */
-      gtk_object_set_user_data (GTK_OBJECT (inputd), inputd);
+      g_object_set_data (G_OBJECT (inputd), GTK_INPUT_DIALOG_KEY, inputd);
       gtk_input_dialog_set_device (GTK_WIDGET(inputd), device_info->data);
 
     }
@@ -355,34 +361,34 @@ gtk_input_dialog_new (void)
 {
   GtkInputDialog *inputd;
 
-  inputd = gtk_type_new (GTK_TYPE_INPUT_DIALOG);
+  inputd = g_object_new (GTK_TYPE_INPUT_DIALOG, NULL);
 
   return GTK_WIDGET (inputd);
 }
 
 static void
-gtk_input_dialog_set_device(GtkWidget *widget, gpointer data)
+gtk_input_dialog_set_device (GtkWidget *w,
+			     gpointer   data)
 {
   GdkDevice *device = data;
-
-  GtkInputDialog *inputd = GTK_INPUT_DIALOG(
-                gtk_object_get_user_data(GTK_OBJECT(widget)));
+  GtkInputDialog *inputd =
+    GTK_INPUT_DIALOG (g_object_get_data (G_OBJECT (w), GTK_INPUT_DIALOG_KEY));
 
   inputd->current_device = device;
 
-  gtk_input_dialog_fill_axes(inputd, device);
-  gtk_input_dialog_fill_keys(inputd, device);
+  gtk_input_dialog_fill_axes (inputd, device);
+  gtk_input_dialog_fill_keys (inputd, device);
 
-  gtk_option_menu_set_history(GTK_OPTION_MENU(inputd->mode_optionmenu),
-			      device->mode);
+  gtk_option_menu_set_history (GTK_OPTION_MENU (inputd->mode_optionmenu),
+			       device->mode);
 }
 
 static void
 gtk_input_dialog_set_mapping_mode (GtkWidget *w,
 				   gpointer   data)
 {
-  GtkInputDialog *inputd = GTK_INPUT_DIALOG(
-                gtk_object_get_user_data(GTK_OBJECT(w)));
+  GtkInputDialog *inputd =
+    GTK_INPUT_DIALOG (g_object_get_data (G_OBJECT (w), GTK_INPUT_DIALOG_KEY));
   GdkDevice *info = inputd->current_device;
   GdkInputMode old_mode = info->mode;
   GdkInputMode mode = GPOINTER_TO_INT (data);
@@ -392,13 +398,15 @@ gtk_input_dialog_set_mapping_mode (GtkWidget *w,
       if (gdk_device_set_mode (inputd->current_device, mode))
 	{
 	  if (mode == GDK_MODE_DISABLED)
-	    gtk_signal_emit (GTK_OBJECT (inputd),
-			     input_dialog_signals[DISABLE_DEVICE],
-			     info);
+	    g_signal_emit (inputd,
+			   input_dialog_signals[DISABLE_DEVICE],
+			   0,
+			   info);
 	  else
-	    gtk_signal_emit (GTK_OBJECT (inputd),
-			     input_dialog_signals[ENABLE_DEVICE],
-			     info);
+	    g_signal_emit (inputd,
+			   input_dialog_signals[ENABLE_DEVICE],
+			   0,
+			   info);
 	}
       else
 	gtk_option_menu_set_history (GTK_OPTION_MENU (inputd->mode_optionmenu),
@@ -409,12 +417,14 @@ gtk_input_dialog_set_mapping_mode (GtkWidget *w,
 }
 
 static void
-gtk_input_dialog_set_axis(GtkWidget *widget, gpointer data)
+gtk_input_dialog_set_axis (GtkWidget *w,
+			   gpointer   data)
 {
   GdkAxisUse use = GPOINTER_TO_INT(data) & 0xFFFF;
   GdkAxisUse old_use;
   GdkAxisUse *new_axes;
-  GtkInputDialog *inputd = GTK_INPUT_DIALOG (gtk_object_get_user_data (GTK_OBJECT (widget)));
+  GtkInputDialog *inputd =
+    GTK_INPUT_DIALOG (g_object_get_data (G_OBJECT (w), GTK_INPUT_DIALOG_KEY));
   GdkDevice *info = inputd->current_device;
 
   gint axis = (GPOINTER_TO_INT(data) >> 16) - 1;
@@ -522,10 +532,11 @@ gtk_input_dialog_fill_axes(GtkInputDialog *inputd, GdkDevice *info)
 	      sprintf (buffer,"%d",j+1);
 	      menu_item = gtk_menu_item_new_with_label (buffer);
 	    }
-	  gtk_object_set_user_data (GTK_OBJECT (menu_item), inputd);
-	  gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
-			      (GtkSignalFunc) gtk_input_dialog_set_axis,
-			      GINT_TO_POINTER (0x10000 * (j + 1) + i));
+	  g_object_set_data (G_OBJECT (menu_item), GTK_INPUT_DIALOG_KEY,
+			     inputd);
+	  g_signal_connect (menu_item, "activate",
+			    G_CALLBACK (gtk_input_dialog_set_axis),
+			    GINT_TO_POINTER (0x10000 * (j + 1) + i));
 	  gtk_widget_show (menu_item);
 	  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
 	}
@@ -599,7 +610,7 @@ gtk_input_dialog_key_press (GtkWidget *widget,
   gdk_device_set_key (key->inputd->current_device, key->index, 
 		      event->keyval, event->state & 0xFF);
 
-  gtk_signal_emit_stop_by_name (GTK_OBJECT(widget), "key_press_event");
+  g_signal_stop_emission_by_name (widget, "key_press_event");
   
   return TRUE;
 }
@@ -656,11 +667,10 @@ gtk_input_dialog_fill_keys(GtkInputDialog *inputd, GdkDevice *info)
 			GTK_EXPAND | GTK_FILL , 0, 2, 2);
       gtk_widget_show (key->entry);
 
-      gtk_signal_connect (GTK_OBJECT(key->entry), "key_press_event",
-			  GTK_SIGNAL_FUNC (gtk_input_dialog_key_press), key);
-      gtk_signal_connect (GTK_OBJECT(key->entry), "destroy",
-			  GTK_SIGNAL_FUNC (gtk_input_dialog_destroy_key), 
-			  key);
+      g_signal_connect (key->entry, "key_press_event",
+			G_CALLBACK (gtk_input_dialog_key_press), key);
+      g_signal_connect (key->entry, "destroy",
+			G_CALLBACK (gtk_input_dialog_destroy_key), key);
       
       /* and clear button */
 
@@ -669,8 +679,8 @@ gtk_input_dialog_fill_keys(GtkInputDialog *inputd, GdkDevice *info)
 			0, 0, 2, 2);
       gtk_widget_show (button);
 
-      gtk_signal_connect (GTK_OBJECT(button), "clicked",
-			  GTK_SIGNAL_FUNC (gtk_input_dialog_clear_key), key);
+      g_signal_connect (button, "clicked",
+			G_CALLBACK (gtk_input_dialog_clear_key), key);
 
       gtk_input_dialog_set_key (key, info->keys[i].keyval,
 				info->keys[i].modifiers);
diff --git a/gtk/gtkinputdialog.h b/gtk/gtkinputdialog.h
index ae9ddecc9e..e386240722 100644
--- a/gtk/gtkinputdialog.h
+++ b/gtk/gtkinputdialog.h
@@ -48,11 +48,11 @@ extern "C" {
 
 
 #define GTK_TYPE_INPUT_DIALOG              (gtk_input_dialog_get_type ())
-#define GTK_INPUT_DIALOG(obj)              (GTK_CHECK_CAST ((obj), GTK_TYPE_INPUT_DIALOG, GtkInputDialog))
-#define GTK_INPUT_DIALOG_CLASS(klass)      (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_INPUT_DIALOG, GtkInputDialogClass))
-#define GTK_IS_INPUT_DIALOG(obj)           (GTK_CHECK_TYPE ((obj), GTK_TYPE_INPUT_DIALOG))
-#define GTK_IS_INPUT_DIALOG_CLASS(klass)   (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_INPUT_DIALOG))
-#define GTK_INPUT_DIALOG_GET_CLASS(obj)    (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_INPUT_DIALOG, GtkInputDialogClass))
+#define GTK_INPUT_DIALOG(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_INPUT_DIALOG, GtkInputDialog))
+#define GTK_INPUT_DIALOG_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_INPUT_DIALOG, GtkInputDialogClass))
+#define GTK_IS_INPUT_DIALOG(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_INPUT_DIALOG))
+#define GTK_IS_INPUT_DIALOG_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_INPUT_DIALOG))
+#define GTK_INPUT_DIALOG_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_INPUT_DIALOG, GtkInputDialogClass))
 
 
 typedef struct _GtkInputDialog       GtkInputDialog;
@@ -93,7 +93,7 @@ struct _GtkInputDialogClass
 };
 
 
-GtkType    gtk_input_dialog_get_type     (void) G_GNUC_CONST;
+GType      gtk_input_dialog_get_type     (void) G_GNUC_CONST;
 GtkWidget* gtk_input_dialog_new          (void);
 
 
diff --git a/gtk/gtkmessagedialog.c b/gtk/gtkmessagedialog.c
index 41899e19f7..66bf533fdd 100644
--- a/gtk/gtkmessagedialog.c
+++ b/gtk/gtkmessagedialog.c
@@ -58,26 +58,28 @@ enum {
 
 static gpointer parent_class;
 
-GtkType
+GType
 gtk_message_dialog_get_type (void)
 {
-  static GtkType dialog_type = 0;
+  static GType dialog_type = 0;
 
   if (!dialog_type)
     {
-      static const GtkTypeInfo dialog_info =
+      static const GTypeInfo dialog_info =
       {
-	"GtkMessageDialog",
-	sizeof (GtkMessageDialog),
 	sizeof (GtkMessageDialogClass),
-	(GtkClassInitFunc) gtk_message_dialog_class_init,
-	(GtkObjectInitFunc) gtk_message_dialog_init,
-	/* reserved_1 */ NULL,
-        /* reserved_2 */ NULL,
-        (GtkClassInitFunc) NULL,
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) gtk_message_dialog_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkMessageDialog),
+	0,		/* n_preallocs */
+	(GInstanceInitFunc) gtk_message_dialog_init,
       };
 
-      dialog_type = gtk_type_unique (GTK_TYPE_DIALOG, &dialog_info);
+      dialog_type = g_type_register_static (GTK_TYPE_DIALOG, "GtkMessageDialog",
+					    &dialog_info, 0);
     }
 
   return dialog_type;
@@ -301,9 +303,10 @@ gtk_message_dialog_new (GtkWindow     *parent,
   gchar* msg = 0;
   va_list args;
   
-  widget = GTK_WIDGET (g_object_new (GTK_TYPE_MESSAGE_DIALOG,
-				     "message_type", type,
-				     "buttons", buttons, 0));
+  widget = g_object_new (GTK_TYPE_MESSAGE_DIALOG,
+			 "message_type", type,
+			 "buttons", buttons,
+			 NULL);
   dialog = GTK_DIALOG (widget);
 
   if (flags & GTK_DIALOG_NO_SEPARATOR)
@@ -315,7 +318,7 @@ gtk_message_dialog_new (GtkWindow     *parent,
   if (message_format)
     {
       va_start (args, message_format);
-      msg = g_strdup_vprintf(message_format, args);
+      msg = g_strdup_vprintf (message_format, args);
       va_end (args);
       
       
diff --git a/gtk/gtkmessagedialog.h b/gtk/gtkmessagedialog.h
index d1ac786f24..68c1b409fd 100644
--- a/gtk/gtkmessagedialog.h
+++ b/gtk/gtkmessagedialog.h
@@ -52,11 +52,11 @@ typedef enum
 } GtkButtonsType;
 
 #define GTK_TYPE_MESSAGE_DIALOG                  (gtk_message_dialog_get_type ())
-#define GTK_MESSAGE_DIALOG(obj)                  (GTK_CHECK_CAST ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialog))
-#define GTK_MESSAGE_DIALOG_CLASS(klass)          (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass))
-#define GTK_IS_MESSAGE_DIALOG(obj)               (GTK_CHECK_TYPE ((obj), GTK_TYPE_MESSAGE_DIALOG))
-#define GTK_IS_MESSAGE_DIALOG_CLASS(klass)       (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MESSAGE_DIALOG))
-#define GTK_MESSAGE_DIALOG_GET_CLASS(obj)        (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass))
+#define GTK_MESSAGE_DIALOG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialog))
+#define GTK_MESSAGE_DIALOG_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass))
+#define GTK_IS_MESSAGE_DIALOG(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MESSAGE_DIALOG))
+#define GTK_IS_MESSAGE_DIALOG_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MESSAGE_DIALOG))
+#define GTK_MESSAGE_DIALOG_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass))
 
 
 typedef struct _GtkMessageDialog        GtkMessageDialog;
@@ -83,7 +83,7 @@ struct _GtkMessageDialogClass
   void (*_gtk_reserved4) (void);
 };
 
-GtkType    gtk_message_dialog_get_type (void);
+GType      gtk_message_dialog_get_type (void);
 
 GtkWidget* gtk_message_dialog_new      (GtkWindow      *parent,
                                         GtkDialogFlags  flags,
diff --git a/gtk/gtktearoffmenuitem.c b/gtk/gtktearoffmenuitem.c
index fd8dd9cabf..8ca1dccf93 100644
--- a/gtk/gtktearoffmenuitem.c
+++ b/gtk/gtktearoffmenuitem.c
@@ -25,7 +25,6 @@
  */
 
 #include "gtkmenu.h"
-#include "gtksignal.h"
 #include "gtktearoffmenuitem.h"
 
 #define ARROW_SIZE 10
@@ -42,26 +41,29 @@ static void gtk_tearoff_menu_item_activate   (GtkMenuItem           *menu_item);
 static gint gtk_tearoff_menu_item_delete_cb  (GtkMenuItem           *menu_item,
 					      GdkEventAny           *event);
 
-GtkType
+GType
 gtk_tearoff_menu_item_get_type (void)
 {
-  static GtkType tearoff_menu_item_type = 0;
+  static GType tearoff_menu_item_type = 0;
 
   if (!tearoff_menu_item_type)
     {
-      static const GtkTypeInfo tearoff_menu_item_info =
+      static const GTypeInfo tearoff_menu_item_info =
       {
-        "GtkTearoffMenuItem",
-        sizeof (GtkTearoffMenuItem),
         sizeof (GtkTearoffMenuItemClass),
-        (GtkClassInitFunc) gtk_tearoff_menu_item_class_init,
-        (GtkObjectInitFunc) gtk_tearoff_menu_item_init,
-        /* reserved_1 */ NULL,
-        /* reserved_2 */ NULL,
-        (GtkClassInitFunc) NULL,
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) gtk_tearoff_menu_item_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkTearoffMenuItem),
+	0,		/* n_preallocs */
+	(GInstanceInitFunc) gtk_tearoff_menu_item_init,
       };
 
-      tearoff_menu_item_type = gtk_type_unique (gtk_menu_item_get_type (), &tearoff_menu_item_info);
+      tearoff_menu_item_type =
+	g_type_register_static (GTK_TYPE_MENU_ITEM, "GtkTearoffMenuItem",
+			        &tearoff_menu_item_info, 0);
     }
 
   return tearoff_menu_item_type;
@@ -70,7 +72,7 @@ gtk_tearoff_menu_item_get_type (void)
 GtkWidget*
 gtk_tearoff_menu_item_new (void)
 {
-  return GTK_WIDGET (gtk_type_new (gtk_tearoff_menu_item_get_type ()));
+  return g_object_new (GTK_TYPE_TEAROFF_MENU_ITEM, NULL);
 }
 
 static void
@@ -172,17 +174,20 @@ gtk_tearoff_menu_item_paint (GtkWidget   *widget,
 	      x += 2 * ARROW_SIZE;
 	    }
 	  
-	  gtk_draw_arrow (widget->style, widget->window,
-			  widget->state, shadow_type, GTK_ARROW_LEFT, FALSE,
-			  arrow_x, y + height / 2 - 5, 
-			  ARROW_SIZE, ARROW_SIZE);
+	  gtk_paint_arrow (widget->style, widget->window,
+			   widget->state, shadow_type,
+			   NULL, widget, "tearoffmenuitem",
+			   GTK_ARROW_LEFT, FALSE,
+			   arrow_x, y + height / 2 - 5, 
+			   ARROW_SIZE, ARROW_SIZE);
 	}
 
       while (x < right_max)
 	{
-	  gtk_draw_hline (widget->style, widget->window, GTK_STATE_NORMAL,
-			  x, MIN (x+TEAR_LENGTH, right_max),
-			  y + (height - widget->style->ythickness)/2);
+	  gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
+			   NULL, widget, "tearoffmenuitem",
+			   x, MIN (x + TEAR_LENGTH, right_max),
+			   y + (height - widget->style->ythickness) / 2);
 	  x += 2 * TEAR_LENGTH;
 	}
     }
@@ -223,10 +228,10 @@ gtk_tearoff_menu_item_activate (GtkMenuItem *menu_item)
 				    tearoff_menu_item->torn_off);
 
 	if (need_connect)
-	  gtk_signal_connect_object (GTK_OBJECT (menu->tearoff_window),  
-				     "delete_event",
-				     GTK_SIGNAL_FUNC (gtk_tearoff_menu_item_delete_cb),
-				     GTK_OBJECT (menu_item));
+	  g_signal_connect_swapped (menu->tearoff_window,
+				    "delete_event",
+				    G_CALLBACK (gtk_tearoff_menu_item_delete_cb),
+				    menu_item);
     }
 }
 
diff --git a/gtk/gtktearoffmenuitem.h b/gtk/gtktearoffmenuitem.h
index e6503ef408..ba5ff76a8a 100644
--- a/gtk/gtktearoffmenuitem.h
+++ b/gtk/gtktearoffmenuitem.h
@@ -38,11 +38,11 @@ extern "C" {
 
 
 #define GTK_TYPE_TEAROFF_MENU_ITEM	      (gtk_tearoff_menu_item_get_type ())
-#define GTK_TEAROFF_MENU_ITEM(obj)	      (GTK_CHECK_CAST ((obj), GTK_TYPE_TEAROFF_MENU_ITEM, GtkTearoffMenuItem))
-#define GTK_TEAROFF_MENU_ITEM_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEAROFF_MENU_ITEM, GtkTearoffMenuItemClass))
-#define GTK_IS_TEAROFF_MENU_ITEM(obj)	      (GTK_CHECK_TYPE ((obj), GTK_TYPE_TEAROFF_MENU_ITEM))
-#define GTK_IS_TEAROFF_MENU_ITEM_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEAROFF_MENU_ITEM))
-#define GTK_TEAROFF_MENU_ITEM_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_TEAROFF_MENU_ITEM, GtkTearoffMenuItemClass))
+#define GTK_TEAROFF_MENU_ITEM(obj)	      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEAROFF_MENU_ITEM, GtkTearoffMenuItem))
+#define GTK_TEAROFF_MENU_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEAROFF_MENU_ITEM, GtkTearoffMenuItemClass))
+#define GTK_IS_TEAROFF_MENU_ITEM(obj)	      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEAROFF_MENU_ITEM))
+#define GTK_IS_TEAROFF_MENU_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEAROFF_MENU_ITEM))
+#define GTK_TEAROFF_MENU_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEAROFF_MENU_ITEM, GtkTearoffMenuItemClass))
 
 
 typedef struct _GtkTearoffMenuItem       GtkTearoffMenuItem;
@@ -67,7 +67,7 @@ struct _GtkTearoffMenuItemClass
 };
 
 
-GtkType	   gtk_tearoff_menu_item_get_type     (void) G_GNUC_CONST;
+GType	   gtk_tearoff_menu_item_get_type     (void) G_GNUC_CONST;
 GtkWidget* gtk_tearoff_menu_item_new	      (void);
 
 #ifdef __cplusplus
diff --git a/gtk/gtktogglebutton.c b/gtk/gtktogglebutton.c
index 45aaae9252..b6c57a165b 100644
--- a/gtk/gtktogglebutton.c
+++ b/gtk/gtktogglebutton.c
@@ -27,7 +27,6 @@
 #include "gtklabel.h"
 #include "gtkmain.h"
 #include "gtkmarshalers.h"
-#include "gtksignal.h"
 #include "gtktogglebutton.h"
 #include "gtkintl.h"
 
@@ -70,26 +69,29 @@ static void gtk_toggle_button_update_state  (GtkButton            *button);
 static guint toggle_button_signals[LAST_SIGNAL] = { 0 };
 static GtkContainerClass *parent_class = NULL;
 
-GtkType
+GType
 gtk_toggle_button_get_type (void)
 {
-  static GtkType toggle_button_type = 0;
+  static GType toggle_button_type = 0;
 
   if (!toggle_button_type)
     {
-      static const GtkTypeInfo toggle_button_info =
+      static const GTypeInfo toggle_button_info =
       {
-	"GtkToggleButton",
-	sizeof (GtkToggleButton),
 	sizeof (GtkToggleButtonClass),
-	(GtkClassInitFunc) gtk_toggle_button_class_init,
-	(GtkObjectInitFunc) gtk_toggle_button_init,
-        /* reserved_1 */ NULL,
-	/* reserved_2 */ NULL,
-	(GtkClassInitFunc) NULL,
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) gtk_toggle_button_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+	sizeof (GtkToggleButton),
+	0,		/* n_preallocs */
+	(GInstanceInitFunc) gtk_toggle_button_init,
       };
 
-      toggle_button_type = gtk_type_unique (GTK_TYPE_BUTTON, &toggle_button_info);
+      toggle_button_type =
+	g_type_register_static (GTK_TYPE_BUTTON, "GtkToggleButton",
+				&toggle_button_info, 0);
     }
 
   return toggle_button_type;
@@ -98,20 +100,17 @@ gtk_toggle_button_get_type (void)
 static void
 gtk_toggle_button_class_init (GtkToggleButtonClass *class)
 {
-  GtkObjectClass *object_class;
-  GObjectClass   *gobject_class;
+  GObjectClass *gobject_class;
   GtkWidgetClass *widget_class;
   GtkContainerClass *container_class;
   GtkButtonClass *button_class;
 
-  object_class = (GtkObjectClass*) class;
   gobject_class = G_OBJECT_CLASS (class);
   widget_class = (GtkWidgetClass*) class;
   container_class = (GtkContainerClass*) class;
   button_class = (GtkButtonClass*) class;
 
-  parent_class = gtk_type_class (GTK_TYPE_BUTTON);
-
+  parent_class = g_type_class_peek_parent (class);
 
   gobject_class->set_property = gtk_toggle_button_set_property;
   gobject_class->get_property = gtk_toggle_button_get_property;
@@ -152,12 +151,13 @@ gtk_toggle_button_class_init (GtkToggleButtonClass *class)
 							 G_PARAM_READWRITE));
 
   toggle_button_signals[TOGGLED] =
-    gtk_signal_new ("toggled",
-                    GTK_RUN_FIRST,
-                    GTK_CLASS_TYPE (object_class),
-                    GTK_SIGNAL_OFFSET (GtkToggleButtonClass, toggled),
-                    _gtk_marshal_VOID__VOID,
-		    GTK_TYPE_NONE, 0);
+    g_signal_new ("toggled",
+		  G_OBJECT_CLASS_TYPE (gobject_class),
+		  G_SIGNAL_RUN_FIRST,
+		  G_STRUCT_OFFSET (GtkToggleButtonClass, toggled),
+		  NULL, NULL,
+		  _gtk_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
 }
 
 static void
@@ -172,7 +172,7 @@ gtk_toggle_button_init (GtkToggleButton *toggle_button)
 GtkWidget*
 gtk_toggle_button_new (void)
 {
-  return GTK_WIDGET (gtk_type_new (gtk_toggle_button_get_type ()));
+  return g_object_new (GTK_TYPE_TOGGLE_BUTTON, NULL);
 }
 
 GtkWidget*
@@ -333,7 +333,7 @@ gtk_toggle_button_toggled (GtkToggleButton *toggle_button)
 {
   g_return_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button));
 
-  gtk_signal_emit (GTK_OBJECT (toggle_button), toggle_button_signals[TOGGLED]);
+  g_signal_emit (toggle_button, toggle_button_signals[TOGGLED], 0);
 }
 
 /**
diff --git a/gtk/gtktogglebutton.h b/gtk/gtktogglebutton.h
index dcf5d8df33..5ab74ec5f7 100644
--- a/gtk/gtktogglebutton.h
+++ b/gtk/gtktogglebutton.h
@@ -38,11 +38,11 @@ extern "C" {
 
 
 #define GTK_TYPE_TOGGLE_BUTTON                  (gtk_toggle_button_get_type ())
-#define GTK_TOGGLE_BUTTON(obj)                  (GTK_CHECK_CAST ((obj), GTK_TYPE_TOGGLE_BUTTON, GtkToggleButton))
-#define GTK_TOGGLE_BUTTON_CLASS(klass)          (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_BUTTON, GtkToggleButtonClass))
-#define GTK_IS_TOGGLE_BUTTON(obj)               (GTK_CHECK_TYPE ((obj), GTK_TYPE_TOGGLE_BUTTON))
-#define GTK_IS_TOGGLE_BUTTON_CLASS(klass)       (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOGGLE_BUTTON))
-#define GTK_TOGGLE_BUTTON_GET_CLASS(obj)        (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_TOGGLE_BUTTON, GtkToggleButtonClass))
+#define GTK_TOGGLE_BUTTON(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOGGLE_BUTTON, GtkToggleButton))
+#define GTK_TOGGLE_BUTTON_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_BUTTON, GtkToggleButtonClass))
+#define GTK_IS_TOGGLE_BUTTON(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOGGLE_BUTTON))
+#define GTK_IS_TOGGLE_BUTTON_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOGGLE_BUTTON))
+#define GTK_TOGGLE_BUTTON_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOGGLE_BUTTON, GtkToggleButtonClass))
 
 
 typedef struct _GtkToggleButton       GtkToggleButton;
@@ -71,7 +71,7 @@ struct _GtkToggleButtonClass
 };
 
 
-GtkType    gtk_toggle_button_get_type          (void) G_GNUC_CONST;
+GType      gtk_toggle_button_get_type          (void) G_GNUC_CONST;
 
 GtkWidget* gtk_toggle_button_new               (void);
 GtkWidget* gtk_toggle_button_new_with_label    (const gchar     *label);