Added support for signal detail. Fixes bug #670792 "Unable to connect to specific notify signals."

7 files changed, 427 insertions, 276 deletions

diff --git a/gladeui/glade-signal-editor.c b/gladeui/glade-signal-editor.c
index 132f6d5b..c674b121 100644
--- a/gladeui/glade-signal-editor.c
+++ b/gladeui/glade-signal-editor.c
@@ -59,7 +59,8 @@ struct _GladeSignalEditorPrivate
   GladeWidgetAdaptor *adaptor;
 
   GtkWidget *signal_tree;
-  GtkTreeViewColumn *column_name;	
+  GtkTreeViewColumn *column_name;
+  GtkTreeViewColumn *column_detail;
   GtkTreeViewColumn *column_handler;
   GtkTreeViewColumn *column_userdata;
   GtkTreeViewColumn *column_swap;
@@ -86,13 +87,10 @@ enum
 static guint glade_signal_editor_signals[LAST_SIGNAL] = { 0 };
 
 /* Utils */
-static gboolean
+static inline gboolean
 glade_signal_is_dummy (GladeSignal *signal)
 {
-  gboolean dummy;
-  dummy = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (signal),
-					      DUMMY_DATA));
-  return dummy;
+  return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (signal), DUMMY_DATA));
 }
 
 /* Signal handlers */
@@ -130,8 +128,8 @@ on_handler_edited (GtkCellRendererText *renderer,
 	  if (strlen (handler))
 	    {
 	      /* change an existing signal handler */
-	      GladeSignal* old_signal;
-	      GladeSignal* new_signal;
+	      GladeSignal *old_signal;
+	      GladeSignal *new_signal;
 				
 	      gtk_tree_model_get (self->priv->model,
 				  &iter,
@@ -149,7 +147,7 @@ on_handler_edited (GtkCellRendererText *renderer,
 	    }
 	  else
 	    {
-	      GladeSignal* deleted_signal;
+	      GladeSignal *deleted_signal;
 	      gtk_tree_model_get (self->priv->model,
 				  &iter,
 				  GLADE_SIGNAL_COLUMN_SIGNAL,
@@ -157,15 +155,14 @@ on_handler_edited (GtkCellRendererText *renderer,
 				
 				
 	      /* Delete signal */
-	      glade_command_remove_signal (self->priv->widget,
-					   deleted_signal);
+	      glade_command_remove_signal (self->priv->widget, deleted_signal);
 	    }
 	}
       else if (strlen (handler))
 	{
-	  GladeSignal* signal;
-	  GladeSignal* dummy;
-	  gchar* name;
+	  GladeSignal *signal;
+	  GladeSignal *dummy;
+	  gchar *name;
 			
 	  /* Get the signal name */
 	  gtk_tree_model_get (self->priv->model, &iter,
@@ -192,15 +189,18 @@ glade_signal_editor_callback_suggestions (GladeSignalEditor *editor,
 					  GladeSignal *signal)
 {
   GladeWidget *widget = glade_signal_editor_get_widget (editor);
-  gchar *signal_name, *name, **suggestions;
+  gchar *signal_name, **suggestions = g_new (gchar *, 10);
+  const gchar *name, *detail;
 
-  suggestions = g_new (gchar *, 10);
-  
-  name = (gchar *) glade_widget_get_name (widget);
+  if ((detail = glade_signal_get_detail (signal)))
+    signal_name = g_strdup_printf ("%s_%s", detail, glade_signal_get_name (signal));
+  else
+    signal_name = g_strdup (glade_signal_get_name (signal));
 
-  signal_name = g_strdup (glade_signal_get_name (signal));
   glade_util_replace (signal_name, '-', '_');
-
+  
+  name = glade_widget_get_name (widget);
+  
   suggestions[0] = g_strdup_printf ("on_%s_%s", name, signal_name);
   suggestions[1] = g_strdup_printf ("%s_%s_cb", name, signal_name);
   suggestions[2] = g_strdup ("gtk_widget_show");
@@ -216,6 +216,48 @@ glade_signal_editor_callback_suggestions (GladeSignalEditor *editor,
 }
 
 static void
+on_detail_edited (GtkCellRendererText *renderer,
+                  gchar *path,
+                  gchar *detail,
+                  gpointer user_data)
+{
+  GladeSignalEditor *self = GLADE_SIGNAL_EDITOR(user_data);
+  GtkTreePath *tree_path = gtk_tree_path_new_from_string (path);
+  GtkTreeIter iter;
+  gchar *old_detail;
+
+  g_return_if_fail (self->priv->widget != NULL);
+	
+  gtk_tree_model_get_iter (self->priv->model, &iter, tree_path);
+
+  gtk_tree_model_get (self->priv->model, &iter,
+		      GLADE_SIGNAL_COLUMN_DETAIL, &old_detail, -1);
+
+  if (detail && g_strcmp0 (old_detail, detail))
+    {
+      /* change an existing signal detail */
+      GladeSignal *old_signal;
+      GladeSignal *new_signal;
+
+      gtk_tree_model_get (self->priv->model,
+                          &iter,
+                          GLADE_SIGNAL_COLUMN_SIGNAL,
+                          &old_signal, -1);
+
+      new_signal = glade_signal_clone (old_signal);
+
+      /* Change the new signal detail */
+      glade_signal_set_detail (new_signal, detail);
+
+      glade_command_change_signal (self->priv->widget, old_signal, new_signal);
+
+      g_object_unref (new_signal);
+    }
+  g_free (old_detail);
+  gtk_tree_path_free (tree_path);
+}
+
+static void
 on_handler_editing_started (GtkCellRenderer *renderer,
                             GtkCellEditable *editable,
                             gchar *path,
@@ -758,6 +800,65 @@ glade_signal_editor_handler_cell_data_func (GtkTreeViewColumn *column,
 }
 
 static void
+glade_signal_editor_detail_cell_data_func (GtkTreeViewColumn *column,
+                                           GtkCellRenderer *renderer,
+                                           GtkTreeModel *model,
+                                           GtkTreeIter *iter,
+                                           gpointer data)
+{
+  GladeSignalEditor *editor = GLADE_SIGNAL_EDITOR (data);
+  GladeSignal *signal;
+
+  gtk_tree_model_get (model, iter,
+		      GLADE_SIGNAL_COLUMN_SIGNAL, &signal,
+		      -1);
+  if (signal &&
+      (glade_signal_class_get_flags (glade_signal_get_class (signal)) & G_SIGNAL_DETAILED))
+    {
+      GdkRGBA color;
+      gboolean dummy;
+      GtkStyleContext* context = gtk_widget_get_style_context (editor->priv->signal_tree);
+
+      dummy = glade_signal_is_dummy (signal);
+      if (dummy || !glade_signal_get_detail (signal))
+	{
+	  gtk_style_context_get_color (context, 
+				       GTK_STATE_FLAG_INSENSITIVE, &color);
+	  g_object_set (renderer,
+			"style", PANGO_STYLE_ITALIC,
+			"foreground-rgba", &color,
+			NULL);
+	}
+      else
+	{
+	  gtk_style_context_get_color (context, 
+				       GTK_STATE_FLAG_NORMAL,
+				       &color);
+	  g_object_set (renderer,
+			"style", PANGO_STYLE_NORMAL,
+			"foreground-rgba", &color,
+			NULL);
+	}
+
+      g_object_set (renderer,
+                    "sensitive", !dummy,
+                    "visible", TRUE,
+                    "editable", TRUE,
+                    NULL);
+
+      g_object_unref (signal);
+    }
+  else
+    {
+      g_object_set (renderer,
+                    "editable", FALSE,
+                    "sensitive", FALSE,
+		    "visible", FALSE,
+		    NULL);
+    }
+}
+
+static void
 glade_signal_editor_data_cell_data_func (GtkTreeViewColumn *column,
                                          GtkCellRenderer *renderer,
                                          GtkTreeModel *model,
@@ -966,8 +1067,22 @@ glade_signal_editor_init (GladeSignalEditor *self)
   gtk_tree_view_column_set_title (priv->column_name, _("Signal"));
   gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->signal_tree), priv->column_name);
 
+  /* Signal detail */
+  renderer = gtk_cell_renderer_text_new ();
+  g_signal_connect (renderer, "edited", G_CALLBACK(on_detail_edited), self);
+  priv->column_detail = gtk_tree_view_column_new_with_attributes (_("Detail"),
+                                                                  renderer,
+                                                                  "text", GLADE_SIGNAL_COLUMN_DETAIL,
+                                                                  NULL);
+  gtk_tree_view_column_set_cell_data_func (priv->column_detail, renderer,
+					   glade_signal_editor_detail_cell_data_func,
+					   self,
+					   NULL);
+  gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->signal_tree), priv->column_detail);
+
   /* Signal handler */
   renderer = gtk_cell_renderer_text_new ();
+  g_object_set (renderer, "editable", FALSE, NULL);
   g_signal_connect (renderer, "edited", G_CALLBACK(on_handler_edited), self);
   g_signal_connect (renderer, "editing-started", G_CALLBACK (on_handler_editing_started), self);
   priv->column_handler = gtk_tree_view_column_new_with_attributes (_("Handler"),
@@ -979,7 +1094,7 @@ glade_signal_editor_init (GladeSignalEditor *self)
 					   self,
 					   NULL);
   gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->signal_tree), priv->column_handler);
-
+  
   /* Signal user_data */
   priv->renderer_userdata = gtk_cell_renderer_text_new ();
   g_object_set (G_OBJECT (priv->renderer_userdata),
@@ -1158,15 +1273,14 @@ glade_signal_editor_class_init (GladeSignalEditorClass *klass)
                   _glade_strv_handled_accumulator,
                   NULL, _glade_marshal_BOXED__OBJECT,
                   G_TYPE_STRV, 1,
-                  GLADE_TYPE_SIGNAL
-                  );   
+                  GLADE_TYPE_SIGNAL);   
   
 
   g_object_class_install_property (object_class,
                                    PROP_GLADE_WIDGET,
                                    g_param_spec_object ("glade-widget",
-	                                                "Glade Widget",
-	                                                "The glade widget to edit signals",
+	                                                _("Glade Widget"),
+	                                                _("The glade widget to edit signals"),
 	                                                GTK_TYPE_TREE_MODEL,
 	                                                G_PARAM_READWRITE));
 }
diff --git a/gladeui/glade-signal-editor.h b/gladeui/glade-signal-editor.h
index 9bceba43..79028947 100644
--- a/gladeui/glade-signal-editor.h
+++ b/gladeui/glade-signal-editor.h
@@ -24,7 +24,7 @@ struct _GladeSignalEditor
 {
   GtkVBox parent;
 
-  GladeSignalEditorPrivate* priv;
+  GladeSignalEditorPrivate *priv;
 };
 
 struct _GladeSignalEditorClass
diff --git a/gladeui/glade-signal-model.c b/gladeui/glade-signal-model.c
index 4c37507f..525fdb67 100644
--- a/gladeui/glade-signal-model.c
+++ b/gladeui/glade-signal-model.c
@@ -26,6 +26,7 @@
 #include <glib/gi18n-lib.h>
 #include <string.h>
 
+#define DETAIL_DEFAULT  _("<Type here>")
 #define HANDLER_DEFAULT  _("<Type here>")
 #define USERDATA_DEFAULT _("<Click here>")
 
@@ -110,7 +111,7 @@ glade_signal_model_create_widget_list (GladeSignalModel *sig_model)
 static void
 glade_signal_model_finalize (GObject *object)
 {
-  GladeSignalModel* sig_model = GLADE_SIGNAL_MODEL (object);
+  GladeSignalModel *sig_model = GLADE_SIGNAL_MODEL (object);
 
   g_list_free (sig_model->priv->widgets);
   g_hash_table_destroy (sig_model->priv->dummy_signals);
@@ -118,7 +119,10 @@ glade_signal_model_finalize (GObject *object)
 }
 
 static void
-glade_signal_model_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+glade_signal_model_set_property (GObject *object,
+                                 guint prop_id,
+                                 const GValue *value,
+                                 GParamSpec *pspec)
 {
   GladeSignalModel *sig_model;
 
@@ -128,30 +132,32 @@ glade_signal_model_set_property (GObject *object, guint prop_id, const GValue *v
 
   switch (prop_id)
     {
-    case PROP_WIDGET:
-      sig_model->priv->widget = g_value_get_object (value);
-      glade_signal_model_create_widget_list (sig_model);
-      g_signal_connect (sig_model->priv->widget,
-			"add-signal-handler",
-			G_CALLBACK (on_glade_signal_model_added), sig_model);
-      g_signal_connect (sig_model->priv->widget, "remove-signal-handler",
-			G_CALLBACK (on_glade_signal_model_removed), sig_model);
-      g_signal_connect (sig_model->priv->widget, "change-signal-handler",
-			G_CALLBACK (on_glade_signal_model_changed), sig_model);
-      g_signal_connect (sig_model->priv->widget, "support-changed",
-			G_CALLBACK (on_glade_widget_support_changed), sig_model);
+      case PROP_WIDGET:
+        sig_model->priv->widget = g_value_get_object (value);
+        glade_signal_model_create_widget_list (sig_model);
+        g_signal_connect (sig_model->priv->widget, "add-signal-handler",
+                          G_CALLBACK (on_glade_signal_model_added), sig_model);
+        g_signal_connect (sig_model->priv->widget, "remove-signal-handler",
+                          G_CALLBACK (on_glade_signal_model_removed), sig_model);
+        g_signal_connect (sig_model->priv->widget, "change-signal-handler",
+                          G_CALLBACK (on_glade_signal_model_changed), sig_model);
+        g_signal_connect (sig_model->priv->widget, "support-changed",
+                          G_CALLBACK (on_glade_widget_support_changed), sig_model);
       break;
-    case PROP_SIGNALS:
-      sig_model->priv->signals = g_value_get_pointer (value);
+      case PROP_SIGNALS:
+        sig_model->priv->signals = g_value_get_pointer (value);
       break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
 
 static void
-glade_signal_model_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+glade_signal_model_get_property (GObject *object,
+                                 guint prop_id,
+                                 GValue *value,
+                                 GParamSpec *pspec)
 {
   GladeSignalModel *sig_model;
 
@@ -161,14 +167,14 @@ glade_signal_model_get_property (GObject *object, guint prop_id, GValue *value,
 
   switch (prop_id)
     {
-    case PROP_WIDGET:
-      g_value_set_object (value, sig_model->priv->widget);
+      case PROP_WIDGET:
+        g_value_set_object (value, sig_model->priv->widget);
       break;
-    case PROP_SIGNALS:
-      g_value_set_pointer (value, sig_model->priv->signals);
+      case PROP_SIGNALS:
+        g_value_set_pointer (value, sig_model->priv->signals);
       break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
       break;
     }
 }
@@ -209,8 +215,7 @@ glade_signal_model_class_init (GladeSignalModelClass *klass)
  */
 
 GtkTreeModel *
-glade_signal_model_new (GladeWidget *widget,
-                        GHashTable *signals)
+glade_signal_model_new (GladeWidget *widget, GHashTable *signals)
 {
   GObject *object = g_object_new (GLADE_TYPE_SIGNAL_MODEL,
 				  "widget", widget, 
@@ -231,30 +236,31 @@ glade_signal_model_get_n_columns (GtkTreeModel *model)
 }
 
 static GType
-glade_signal_model_get_column_type (GtkTreeModel *model,
-                                    gint column)
+glade_signal_model_get_column_type (GtkTreeModel *model, gint column)
 {
   switch (column)
     {
-    case GLADE_SIGNAL_COLUMN_NAME:
-      return G_TYPE_STRING;
-    case GLADE_SIGNAL_COLUMN_SHOW_NAME:
-      return G_TYPE_BOOLEAN;
-    case GLADE_SIGNAL_COLUMN_HANDLER:
-      return G_TYPE_STRING;
-    case GLADE_SIGNAL_COLUMN_OBJECT:
-      return G_TYPE_STRING;
-    case GLADE_SIGNAL_COLUMN_SWAP:
-      return G_TYPE_BOOLEAN;
-    case GLADE_SIGNAL_COLUMN_AFTER:
-      return G_TYPE_BOOLEAN;
-    case GLADE_SIGNAL_COLUMN_TOOLTIP:
-      return G_TYPE_STRING;
-    case GLADE_SIGNAL_COLUMN_SIGNAL:
-      return G_TYPE_OBJECT;
-    default:
-      g_assert_not_reached();
-      return G_TYPE_NONE;
+      case GLADE_SIGNAL_COLUMN_NAME:
+        return G_TYPE_STRING;
+      case GLADE_SIGNAL_COLUMN_SHOW_NAME:
+        return G_TYPE_BOOLEAN;
+      case GLADE_SIGNAL_COLUMN_HANDLER:
+        return G_TYPE_STRING;
+      case GLADE_SIGNAL_COLUMN_OBJECT:
+        return G_TYPE_STRING;
+      case GLADE_SIGNAL_COLUMN_SWAP:
+        return G_TYPE_BOOLEAN;
+      case GLADE_SIGNAL_COLUMN_AFTER:
+        return G_TYPE_BOOLEAN;
+      case GLADE_SIGNAL_COLUMN_TOOLTIP:
+        return G_TYPE_STRING;
+      case GLADE_SIGNAL_COLUMN_SIGNAL:
+        return G_TYPE_OBJECT;
+      case GLADE_SIGNAL_COLUMN_DETAIL:
+        return G_TYPE_STRING;
+      default:
+        g_assert_not_reached();
+        return G_TYPE_NONE;
     }
 }
 
@@ -264,15 +270,11 @@ enum
   ITER_SIGNAL = 1,
 };
 
-static gboolean
+static inline gboolean
 glade_signal_model_is_dummy_handler (GladeSignalModel *model,
                                      GladeSignal *signal)
 {
-  gboolean dummy;
-  dummy = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (signal),
-					      DUMMY_DATA));
-
-  return dummy;
+  return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (signal), DUMMY_DATA));
 }
 
 static GladeSignal *
@@ -291,6 +293,7 @@ glade_signal_model_get_dummy_handler (GladeSignalModel *model,
 				 USERDATA_DEFAULT,
 				 FALSE,
 				 FALSE);
+      glade_signal_set_detail (signal, DETAIL_DEFAULT);
       g_object_set_data (G_OBJECT (signal), DUMMY_DATA, GINT_TO_POINTER (TRUE)); 
       g_hash_table_insert (model->priv->dummy_signals, 
 			   (gpointer) glade_signal_class_get_name (sig_class), 
@@ -319,7 +322,7 @@ glade_signal_model_create_signal_iter (GladeSignalModel *sig_model,
                                        GtkTreeIter *iter)
 {
 	glade_signal_model_create_widget_iter (sig_model, widget, iter);
-	iter->user_data2 = (GladeSignal *) signal;
+	iter->user_data2 = GLADE_SIGNAL (signal);
 }
 
 static GList *
@@ -345,7 +348,8 @@ glade_signal_model_create_signal_list (GladeSignalModel *sig_model,
 }
 
 static void
-on_glade_signal_model_added (GladeWidget *widget, const GladeSignal *signal,
+on_glade_signal_model_added (GladeWidget *widget,
+                             const GladeSignal *signal,
                              GladeSignalModel* model)
 {
   GtkTreeIter iter;	
@@ -356,18 +360,16 @@ on_glade_signal_model_added (GladeWidget *widget, const GladeSignal *signal,
 					 glade_signal_class_get_type (sig_class),
 					 signal, 
 					 &iter);
-  path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
-				  &iter);
+  path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
 
-  gtk_tree_model_row_inserted (GTK_TREE_MODEL (model),
-			       path,
-			       &iter);
+  gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter);
   gtk_tree_path_free (path);
   model->priv->stamp++;
 }
 
 static void
-on_glade_signal_model_removed (GladeWidget *widget, const GladeSignal *signal,
+on_glade_signal_model_removed (GladeWidget *widget,
+                               const GladeSignal *signal,
                                GladeSignalModel *model)
 {
   GtkTreeIter iter;
@@ -378,16 +380,15 @@ on_glade_signal_model_removed (GladeWidget *widget, const GladeSignal *signal,
 					 glade_signal_class_get_type (sig_class),
 					 signal, 
 					 &iter);
-  path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
-				  &iter);
-  gtk_tree_model_row_deleted (GTK_TREE_MODEL (model),
-			      path);
+  path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
+  gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
   gtk_tree_path_free (path);
   model->priv->stamp++;
 }
 
 static void
-on_glade_signal_model_changed (GladeWidget *widget, const GladeSignal *signal,
+on_glade_signal_model_changed (GladeWidget *widget,
+                               const GladeSignal *signal,
                                GladeSignalModel *model)
 {
   GtkTreeIter iter;
@@ -399,17 +400,15 @@ on_glade_signal_model_changed (GladeWidget *widget, const GladeSignal *signal,
 					 signal, 
 					 &iter);
   path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
-  gtk_tree_model_row_changed (GTK_TREE_MODEL (model),
-			      path,
-			      &iter);
+  gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
   gtk_tree_path_free (path);
   model->priv->stamp++;
 }
 
 static void
-verify_dummies (const gchar      *signal_name,
-		GladeSignal      *signal,
-		GladeSignalModel *model)
+verify_dummies (const gchar *signal_name,
+                GladeSignal *signal,
+                GladeSignalModel *model)
 {
   glade_project_verify_signal (model->priv->widget, signal);
 
@@ -417,8 +416,8 @@ verify_dummies (const gchar      *signal_name,
 }
 
 static void
-emit_changed (const gchar      *signal_name,
-	      GPtrArray        *signals,
+emit_changed (const gchar *signal_name,
+	      GPtrArray *signals,
 	      GladeSignalModel *model)
 {
   gint i;
@@ -432,8 +431,7 @@ emit_changed (const gchar      *signal_name,
 }
 
 static void
-on_glade_widget_support_changed (GladeWidget      *widget, 
-				 GladeSignalModel *model)
+on_glade_widget_support_changed (GladeWidget *widget, GladeSignalModel *model)
 {
   /* Update support warning on dummy signals */
   g_hash_table_foreach (model->priv->dummy_signals, (GHFunc)verify_dummies, model);
@@ -461,38 +459,37 @@ glade_signal_model_get_iter (GtkTreeModel *model,
 
   switch (depth)
     {
-    case 1:
-      /* Widget */
-      {
-	glade_signal_model_create_widget_iter (sig_model,
-					       g_list_nth_data (sig_model->priv->widgets,
-								indices[ITER_WIDGET]),
-					       iter);
-	return TRUE;
-      }
-    case 2:
-      /* Signal */
-      {
-	gboolean retval;
-	GtkTreePath *path =
-	  gtk_tree_path_new_from_indices (indices[ITER_WIDGET], -1);
-	GtkTreeIter widget_iter;
-	
-	gtk_tree_model_get_iter (model, &widget_iter, path);
-	retval = gtk_tree_model_iter_nth_child (model,
-						iter,
-						&widget_iter,
-						indices[ITER_SIGNAL]);
-	gtk_tree_path_free (path);
-	return retval;
-      }
+      case 1:
+        /* Widget */
+        {
+          glade_signal_model_create_widget_iter (sig_model,
+                                                 g_list_nth_data (sig_model->priv->widgets,
+                                                                  indices[ITER_WIDGET]),
+                                                 iter);
+          return TRUE;
+        }
+      case 2:
+        /* Signal */
+        {
+          gboolean retval;
+          GtkTreePath *path =
+            gtk_tree_path_new_from_indices (indices[ITER_WIDGET], -1);
+          GtkTreeIter widget_iter;
+
+          gtk_tree_model_get_iter (model, &widget_iter, path);
+          retval = gtk_tree_model_iter_nth_child (model,
+                                                  iter,
+                                                  &widget_iter,
+                                                  indices[ITER_SIGNAL]);
+          gtk_tree_path_free (path);
+          return retval;
+        }
     }
   return FALSE;
 }
 
 static GtkTreePath*
-glade_signal_model_get_path (GtkTreeModel *model,
-                             GtkTreeIter *iter)
+glade_signal_model_get_path (GtkTreeModel *model, GtkTreeIter *iter)
 {
   const gchar *widget;
   GladeSignal *handler;
@@ -524,8 +521,8 @@ glade_signal_model_get_path (GtkTreeModel *model,
 
 	  if (signal->data != sig_class)
 	    {
-	      if (handlers)
-		index1 += handlers->len;
+	      if (handlers) 
+                index1 += handlers->len;
 	      index1++; /* dummy_handler */
 	    }
 	  else
@@ -576,72 +573,78 @@ glade_signal_model_get_value (GtkTreeModel *model,
 
   switch (column)
     {
-    case GLADE_SIGNAL_COLUMN_NAME:
-      if (handler)
-	{
-	  g_value_set_static_string (value, glade_signal_get_name (handler));
-	  break;
-	}
-      else
-	g_value_set_static_string (value, widget);
+      case GLADE_SIGNAL_COLUMN_NAME:
+        if (handler)
+        {
+          g_value_set_static_string (value, glade_signal_get_name (handler));
+          break;
+        }
+        else
+          g_value_set_static_string (value, widget);
       break;
-    case GLADE_SIGNAL_COLUMN_SHOW_NAME:
-      if (handler)
-	{
-	  GPtrArray *handlers = g_hash_table_lookup (sig_model->priv->signals,
-						     glade_signal_get_name (handler));
-	  if (!handlers || !handlers->len || g_ptr_array_find (handlers, handler) == 0)
-	    g_value_set_boolean (value, TRUE);
-	  else
-	    g_value_set_boolean (value,
-				 FALSE);
-	  break;
-	}
-      else if (widget)
-	g_value_set_boolean (value, TRUE);
+      case GLADE_SIGNAL_COLUMN_SHOW_NAME:
+        if (handler)
+        {
+          GPtrArray *handlers = g_hash_table_lookup (sig_model->priv->signals,
+                                                     glade_signal_get_name (handler));
+          if (!handlers || !handlers->len || g_ptr_array_find (handlers, handler) == 0)
+            g_value_set_boolean (value, TRUE);
+          else
+            g_value_set_boolean (value,
+                                 FALSE);
+          break;
+        }
+        else if (widget)
+          g_value_set_boolean (value, TRUE);
       break;	
-    case GLADE_SIGNAL_COLUMN_HANDLER:
-      if (handler)
-	g_value_set_static_string (value, glade_signal_get_handler (handler));
-      else 
-	g_value_set_static_string (value, "");
+      case GLADE_SIGNAL_COLUMN_HANDLER:
+        if (handler)
+          g_value_set_static_string (value, glade_signal_get_handler (handler));
+        else 
+          g_value_set_static_string (value, "");
       break;
-    case GLADE_SIGNAL_COLUMN_OBJECT:
-      if (handler)
-	{
-	  const gchar *userdata = glade_signal_get_userdata (handler);
-	  if (userdata && strlen (userdata))
-	    g_value_set_static_string (value, userdata);
-	  else
-	    g_value_set_static_string (value, USERDATA_DEFAULT);
-	  break;
-	}
-      else 
-	g_value_set_static_string (value, "");
+      case GLADE_SIGNAL_COLUMN_OBJECT:
+        if (handler)
+        {
+          const gchar *userdata = glade_signal_get_userdata (handler);
+          if (userdata && strlen (userdata))
+            g_value_set_static_string (value, userdata);
+          else
+            g_value_set_static_string (value, USERDATA_DEFAULT);
+          break;
+        }
+        else 
+          g_value_set_static_string (value, "");
       break;
-    case GLADE_SIGNAL_COLUMN_SWAP:
-      if (handler)
-	g_value_set_boolean (value, glade_signal_get_swapped (handler));
-      else 
-	g_value_set_boolean (value, FALSE);
+      case GLADE_SIGNAL_COLUMN_SWAP:
+        if (handler)
+          g_value_set_boolean (value, glade_signal_get_swapped (handler));
+        else 
+          g_value_set_boolean (value, FALSE);
       break;
-    case GLADE_SIGNAL_COLUMN_AFTER:
-      if (handler)
-	g_value_set_boolean (value, glade_signal_get_after (handler));
-      else 
-	g_value_set_boolean (value, FALSE);
+      case GLADE_SIGNAL_COLUMN_AFTER:
+        if (handler)
+          g_value_set_boolean (value, glade_signal_get_after (handler));
+        else 
+          g_value_set_boolean (value, FALSE);
+        break;
+      case GLADE_SIGNAL_COLUMN_TOOLTIP:
+        if (handler)
+          g_value_set_string (value, glade_signal_get_support_warning (handler));
+        else
+          g_value_set_static_string (value, NULL);
       break;
-    case GLADE_SIGNAL_COLUMN_TOOLTIP:
-      if (handler)
-	g_value_set_string (value, glade_signal_get_support_warning (handler));
-      else
-	g_value_set_static_string (value, NULL);
+      case GLADE_SIGNAL_COLUMN_SIGNAL:
+        g_value_set_object (value, handler);
       break;
-    case GLADE_SIGNAL_COLUMN_SIGNAL:
-      g_value_set_object (value, handler);
+      case GLADE_SIGNAL_COLUMN_DETAIL:
+        if (handler)
+          g_value_set_static_string (value, glade_signal_get_detail (handler));
+        else 
+          g_value_set_static_string (value, "");
       break;
-    default:
-      g_assert_not_reached();
+      default:
+        g_assert_not_reached();
     }
 }
 
@@ -683,8 +686,7 @@ glade_signal_model_iter_next_signal (GladeSignalModel *sig_model,
 
 
 static gboolean
-glade_signal_model_iter_next (GtkTreeModel *model,
-                              GtkTreeIter *iter)
+glade_signal_model_iter_next (GtkTreeModel *model, GtkTreeIter *iter)
 {
   const gchar *widget;
   GladeSignal *handler;
@@ -801,8 +803,7 @@ glade_signal_model_iter_n_children (GtkTreeModel *model, GtkTreeIter *iter)
 }
 
 static gboolean
-glade_signal_model_iter_has_child (GtkTreeModel *model,
-                                   GtkTreeIter *iter)
+glade_signal_model_iter_has_child (GtkTreeModel *model, GtkTreeIter *iter)
 {
   g_return_val_if_fail (iter != NULL, FALSE);
   g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
@@ -934,8 +935,7 @@ gtk_tree_model_iface_init (GtkTreeModelIface *iface)
 }
 
 static gboolean
-glade_signal_model_row_draggable (GtkTreeDragSource *model, 
-                                  GtkTreePath *path)
+glade_signal_model_row_draggable (GtkTreeDragSource *model, GtkTreePath *path)
 {
   GtkTreeIter iter;
   GladeSignal *signal;
diff --git a/gladeui/glade-signal-model.h b/gladeui/glade-signal-model.h
index 49ee89a6..8d9fe736 100644
--- a/gladeui/glade-signal-model.h
+++ b/gladeui/glade-signal-model.h
@@ -46,6 +46,7 @@ typedef enum
   GLADE_SIGNAL_COLUMN_AFTER,
   GLADE_SIGNAL_COLUMN_TOOLTIP,
   GLADE_SIGNAL_COLUMN_SIGNAL,
+  GLADE_SIGNAL_COLUMN_DETAIL,
   GLADE_SIGNAL_N_COLUMNS
 } GladeSignalModelColumns;
 
diff --git a/gladeui/glade-signal.c b/gladeui/glade-signal.c
index 1b2c5d5f..6dc24cff 100644
--- a/gladeui/glade-signal.c
+++ b/gladeui/glade-signal.c
@@ -32,7 +32,8 @@
 
 struct _GladeSignalPrivate
 {
-  const GladeSignalClass* class;   /* Pointer to the signal class */
+  const GladeSignalClass *class;   /* Pointer to the signal class */
+  gchar    *detail;       /* Signal detail */
   gchar    *handler;      /* Handler function eg "gtk_main_quit" */
   gchar    *userdata;     /* User data signal handler argument   */
 
@@ -45,6 +46,7 @@ struct _GladeSignalPrivate
 enum {
   PROP_0,
   PROP_CLASS,
+  PROP_DETAIL,
   PROP_HANDLER,
   PROP_USERDATA,
   PROP_SUPPORT_WARNING,
@@ -53,26 +55,36 @@ enum {
   N_PROPERTIES
 };
 
-static GParamSpec *properties[N_PROPERTIES];
+/* We need these defines because GladeSignalClass is another object type!
+ * So we use GladeSignalKlass as the class name for GladeSignal
+ */
+#define GladeSignalClass GladeSignalKlass
+#define glade_signal_class_init glade_signal_klass_init
+
+G_DEFINE_TYPE (GladeSignal, glade_signal, G_TYPE_OBJECT)
 
-static GObjectClass *parent_class;
+#undef GladeSignalClass
+#undef glade_signal_class_init
+
+static GParamSpec *properties[N_PROPERTIES];
 
 static void
 glade_signal_finalize (GObject *object)
 {
   GladeSignal *signal = GLADE_SIGNAL (object);
 
+  g_free (signal->priv->detail);
   g_free (signal->priv->handler);
   g_free (signal->priv->userdata);
   g_free (signal->priv->support_warning);
 
-  G_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (glade_signal_parent_class)->finalize (object);
 }
 
 static void
-glade_signal_get_property (GObject * object,
+glade_signal_get_property (GObject *object,
 			   guint prop_id,
-			   GValue * value, GParamSpec * pspec)
+			   GValue *value, GParamSpec *pspec)
 {
   GladeSignal *signal = GLADE_SIGNAL (object);
 
@@ -81,6 +93,9 @@ glade_signal_get_property (GObject * object,
       case PROP_CLASS:
         g_value_set_pointer (value, (gpointer) signal->priv->class);
         break;
+      case PROP_DETAIL:
+        g_value_set_string (value, signal->priv->detail);
+        break;
       case PROP_HANDLER:
         g_value_set_string (value, signal->priv->handler);
         break;
@@ -103,9 +118,9 @@ glade_signal_get_property (GObject * object,
 }
 
 static void
-glade_signal_set_property (GObject * object,
+glade_signal_set_property (GObject *object,
 			   guint prop_id,
-			   const GValue * value, GParamSpec * pspec)
+			   const GValue *value, GParamSpec *pspec)
 {
   GladeSignal *signal = GLADE_SIGNAL (object);
 
@@ -114,6 +129,9 @@ glade_signal_set_property (GObject * object,
       case PROP_CLASS:
 	signal->priv->class = g_value_get_pointer (value);
         break;
+      case PROP_DETAIL:
+	glade_signal_set_detail (signal, g_value_get_string (value));
+        break;
       case PROP_HANDLER:
 	glade_signal_set_handler (signal, g_value_get_string (value));
         break;
@@ -149,7 +167,7 @@ glade_signal_klass_init (GladeSignalKlass *klass)
   GObjectClass *object_class;
 
   object_class = G_OBJECT_CLASS (klass);
-  parent_class = g_type_class_peek_parent (klass);
+  glade_signal_parent_class = g_type_class_peek_parent (klass);
 
   object_class->set_property = glade_signal_set_property;
   object_class->get_property = glade_signal_get_property;
@@ -162,6 +180,12 @@ glade_signal_klass_init (GladeSignalKlass *klass)
                           _("The signal class of this signal"),
                           G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 
+  properties[PROP_DETAIL] =
+    g_param_spec_string ("detail",
+                         _("Detail"),
+                         _("The detail for this signal"),
+                         NULL, G_PARAM_READWRITE);
+  
   properties[PROP_HANDLER] =
     g_param_spec_string ("handler",
                          _("Handler"),
@@ -198,33 +222,6 @@ glade_signal_klass_init (GladeSignalKlass *klass)
   g_type_class_add_private (klass, sizeof (GladeSignalPrivate));
 }
 
-
-GType
-glade_signal_get_type (void)
-{
-  static GType signal_type = 0;
-
-  if (!signal_type)
-    {
-      static const GTypeInfo signal_info = {
-        sizeof (GladeSignalKlass),    /* Klass is our class */
-        (GBaseInitFunc) NULL,
-        (GBaseFinalizeFunc) NULL,
-        (GClassInitFunc) glade_signal_klass_init,
-        (GClassFinalizeFunc) NULL,
-        NULL,                   /* class_data */
-        sizeof (GladeSignal),
-        0,                      /* n_preallocs */
-        (GInstanceInitFunc) glade_signal_init,
-      };
-      signal_type =
-          g_type_register_static (G_TYPE_OBJECT,
-                                  "GladeSignal", &signal_info, 0);
-    }
-  return signal_type;
-}
-
-
 /**
  * glade_signal_new:
  * @name: a name for the signal
@@ -238,21 +235,21 @@ glade_signal_get_type (void)
  * Returns: the new #GladeSignal
  */
 GladeSignal *
-glade_signal_new (const GladeSignalClass* sig_class,
-                  const gchar * handler,
-                  const gchar * userdata, 
+glade_signal_new (const GladeSignalClass *sig_class,
+                  const gchar *handler,
+                  const gchar *userdata, 
 		  gboolean after, 
 		  gboolean swapped)
 {
   g_return_val_if_fail (sig_class != NULL, NULL);
 
-  return (GladeSignal *)g_object_new (GLADE_TYPE_SIGNAL,
-				      "class", sig_class,
-				      "handler", handler,
-				      "userdata", userdata,
-				      "after", after,
-				      "swapped", swapped,
-				      NULL);
+  return GLADE_SIGNAL (g_object_new (GLADE_TYPE_SIGNAL,
+                                     "class", sig_class,
+                                     "handler", handler,
+                                     "userdata", userdata,
+                                     "after", after,
+                                     "swapped", swapped,
+                                     NULL));
 }
 
 /**
@@ -271,13 +268,14 @@ glade_signal_equal (const GladeSignal *sig1, const GladeSignal *sig2)
   g_return_val_if_fail (GLADE_IS_SIGNAL (sig2), FALSE);
 
   /* Intentionally ignore support_warning */
-  if (!strcmp (glade_signal_get_name (sig1), glade_signal_get_name (sig2)) &&
-      !strcmp (sig1->priv->handler, sig2->priv->handler) &&
+  if (!g_strcmp0 (glade_signal_get_name (sig1), glade_signal_get_name (sig2)) &&
+      !g_strcmp0 (sig1->priv->handler, sig2->priv->handler) &&
+      !g_strcmp0 (sig1->priv->detail, sig2->priv->detail) &&
       sig1->priv->after == sig2->priv->after && sig1->priv->swapped == sig2->priv->swapped)
     {
       if ((sig1->priv->userdata == NULL && sig2->priv->userdata == NULL) ||
           (sig1->priv->userdata != NULL && sig2->priv->userdata != NULL &&
-           !strcmp (sig1->priv->userdata, sig2->priv->userdata)))
+           !g_strcmp0 (sig1->priv->userdata, sig2->priv->userdata)))
         ret = TRUE;
     }
 
@@ -291,7 +289,7 @@ glade_signal_equal (const GladeSignal *sig1, const GladeSignal *sig2)
  * Returns: a new #GladeSignal with the same attributes as @signal
  */
 GladeSignal *
-glade_signal_clone (const GladeSignal * signal)
+glade_signal_clone (const GladeSignal *signal)
 {
   GladeSignal *dup;
 
@@ -303,6 +301,7 @@ glade_signal_clone (const GladeSignal * signal)
 			  signal->priv->after, 
 			  signal->priv->swapped);
 
+  glade_signal_set_detail (dup, signal->priv->detail);
   glade_signal_set_support_warning (dup, signal->priv->support_warning);
 
   return dup;
@@ -317,8 +316,9 @@ glade_signal_clone (const GladeSignal * signal)
  * Writes @signal to @node
  */
 void
-glade_signal_write (GladeSignal * signal,
-                    GladeXmlContext * context, GladeXmlNode * node)
+glade_signal_write (GladeSignal *signal,
+                    GladeXmlContext *context,
+                    GladeXmlNode *node)
 {
   GladeXmlNode *signal_node;
   gchar *name;
@@ -327,7 +327,12 @@ glade_signal_write (GladeSignal * signal,
    * access to project, so not really seriosly needed 
    */
 
-  name = g_strdup (glade_signal_get_name (signal));
+  if (signal->priv->detail)
+    name = g_strdup_printf ("%s::%s",
+                            glade_signal_get_name (signal),
+                            signal->priv->detail);
+  else
+    name = g_strdup (glade_signal_get_name (signal));
 
   /* Now dump the node values... */
   signal_node = glade_xml_node_new (context, GLADE_XML_TAG_SIGNAL);
@@ -369,11 +374,11 @@ glade_signal_write (GladeSignal * signal,
  * Returns: A newly created #GladeSignal
  */
 GladeSignal *
-glade_signal_read (GladeXmlNode * node, GladeWidgetAdaptor* adaptor)
+glade_signal_read (GladeXmlNode *node, GladeWidgetAdaptor *adaptor)
 {
   GladeSignal *signal = NULL;
   GladeSignalClass *signal_class;
-  gchar *name, *handler, *userdata;
+  gchar *name, *handler, *userdata, *detail;
 
   g_return_val_if_fail (glade_xml_node_verify_silent
                         (node, GLADE_XML_TAG_SIGNAL), NULL);
@@ -384,6 +389,9 @@ glade_signal_read (GladeXmlNode * node, GladeWidgetAdaptor* adaptor)
     return NULL;
   glade_util_replace (name, '_', '-');
 
+  /* Search for a detail, and strip it from the signal name */
+  if ((detail = g_strstr_len (name, -1, "::"))) *detail = '\0';
+  
   if (!(handler =
         glade_xml_get_property_string_required (node, GLADE_XML_TAG_HANDLER,
                                                 NULL)))
@@ -396,12 +404,15 @@ glade_signal_read (GladeXmlNode * node, GladeWidgetAdaptor* adaptor)
   signal_class = glade_widget_adaptor_get_signal_class (adaptor, name);
 
   if (signal_class)
-    signal = 
-      glade_signal_new (signal_class,
-			handler, userdata,
-			glade_xml_get_property_boolean (node, GLADE_XML_TAG_AFTER, FALSE),
-			glade_xml_get_property_boolean (node, GLADE_XML_TAG_SWAPPED,
-							userdata != NULL));
+    {
+      signal = glade_signal_new (signal_class,
+                                 handler, userdata,
+                                 glade_xml_get_property_boolean (node, GLADE_XML_TAG_AFTER, FALSE),
+                                 glade_xml_get_property_boolean (node, GLADE_XML_TAG_SWAPPED,
+                                                                 userdata != NULL));
+
+      if (detail && detail[2]) glade_signal_set_detail (signal, &detail[2]);
+    }
   else
     {
       /* XXX These errors should be collected and reported to the user */
@@ -425,14 +436,35 @@ glade_signal_get_name (const GladeSignal *signal)
 }
 
 G_CONST_RETURN GladeSignalClass *
-glade_signal_get_class (const GladeSignal * signal)
+glade_signal_get_class (const GladeSignal *signal)
 {
 	return signal->priv->class;
 }
 
 void
-glade_signal_set_handler (GladeSignal *signal,
-			  const gchar *handler)
+glade_signal_set_detail (GladeSignal *signal, const gchar *detail)
+{
+  g_return_if_fail (GLADE_IS_SIGNAL (signal));
+  
+  if (glade_signal_class_get_flags (signal->priv->class) & G_SIGNAL_DETAILED &&
+      g_strcmp0 (signal->priv->detail, detail))
+    {
+      g_free (signal->priv->detail);
+      signal->priv->detail = (detail || g_utf8_strlen (detail, -1)) ? g_strdup (detail) : NULL;
+      g_object_notify_by_pspec (G_OBJECT (signal), properties[PROP_DETAIL]);
+    }
+}
+
+G_CONST_RETURN gchar *
+glade_signal_get_detail (const GladeSignal *signal)
+{
+  g_return_val_if_fail (GLADE_IS_SIGNAL (signal), NULL);
+
+  return signal->priv->detail;
+}
+
+void
+glade_signal_set_handler (GladeSignal *signal, const gchar *handler)
 {
   g_return_if_fail (GLADE_IS_SIGNAL (signal));
 
@@ -455,8 +487,7 @@ glade_signal_get_handler (const GladeSignal *signal)
 }
 
 void
-glade_signal_set_userdata (GladeSignal *signal,
-			   const gchar *userdata)
+glade_signal_set_userdata (GladeSignal *signal, const gchar *userdata)
 {
   g_return_if_fail (GLADE_IS_SIGNAL (signal));
 
@@ -479,8 +510,7 @@ glade_signal_get_userdata (const GladeSignal *signal)
 }
 
 void
-glade_signal_set_after (GladeSignal *signal,
-			gboolean     after)
+glade_signal_set_after (GladeSignal *signal, gboolean after)
 {
   g_return_if_fail (GLADE_IS_SIGNAL (signal));
 
@@ -501,8 +531,7 @@ glade_signal_get_after (const GladeSignal *signal)
 }
 
 void
-glade_signal_set_swapped (GladeSignal *signal,
-			  gboolean     swapped)
+glade_signal_set_swapped (GladeSignal *signal, gboolean swapped)
 {
   g_return_if_fail (GLADE_IS_SIGNAL (signal));
 
diff --git a/gladeui/glade-signal.h b/gladeui/glade-signal.h
index 91e1eeda..763095d3 100644
--- a/gladeui/glade-signal.h
+++ b/gladeui/glade-signal.h
@@ -36,37 +36,40 @@ struct _GladeSignalKlass {
 
 GType                 glade_signal_get_type            (void) G_GNUC_CONST;
 
-GladeSignal          *glade_signal_new                 (const GladeSignalClass* sig_class,
+GladeSignal          *glade_signal_new                 (const GladeSignalClass *sig_class,
 							const gchar        *handler,
 							const gchar        *userdata,
 							gboolean            after,
 							gboolean            swapped);
 GladeSignal          *glade_signal_clone               (const GladeSignal  *signal);
-gboolean              glade_signal_equal               (const GladeSignal        *sig1, 
-							const GladeSignal        *sig2);
+gboolean              glade_signal_equal               (const GladeSignal  *sig1, 
+							const GladeSignal  *sig2);
 GladeSignal          *glade_signal_read                (GladeXmlNode       *node,
-                                                        GladeWidgetAdaptor* adaptor);
+                                                        GladeWidgetAdaptor *adaptor);
 void                  glade_signal_write               (GladeSignal        *signal,
 							GladeXmlContext    *context,
 							GladeXmlNode       *node);
 
-G_CONST_RETURN gchar *glade_signal_get_name            (const GladeSignal        *signal);
+G_CONST_RETURN gchar *glade_signal_get_name            (const GladeSignal  *signal);
 G_CONST_RETURN GladeSignalClass *glade_signal_get_class (const GladeSignal * signal);
+void                  glade_signal_set_detail          (GladeSignal        *signal,
+							const gchar        *detail);
+G_CONST_RETURN gchar *glade_signal_get_detail          (const GladeSignal  *signal);
 void                  glade_signal_set_handler         (GladeSignal        *signal,
 							const gchar        *handler);
-G_CONST_RETURN gchar *glade_signal_get_handler         (const GladeSignal        *signal);
+G_CONST_RETURN gchar *glade_signal_get_handler         (const GladeSignal  *signal);
 void                  glade_signal_set_userdata        (GladeSignal        *signal,
 							const gchar        *userdata);
-G_CONST_RETURN gchar *glade_signal_get_userdata        (const GladeSignal        *signal);
+G_CONST_RETURN gchar *glade_signal_get_userdata        (const GladeSignal  *signal);
 void                  glade_signal_set_after           (GladeSignal        *signal,
 							gboolean            after);
-gboolean              glade_signal_get_after           (const GladeSignal        *signal);
+gboolean              glade_signal_get_after           (const GladeSignal  *signal);
 void                  glade_signal_set_swapped         (GladeSignal        *signal,
 							gboolean            swapped);
-gboolean              glade_signal_get_swapped         (const GladeSignal        *signal);
+gboolean              glade_signal_get_swapped         (const GladeSignal  *signal);
 void                  glade_signal_set_support_warning (GladeSignal        *signal,
 							const gchar        *support_warning);
-G_CONST_RETURN gchar *glade_signal_get_support_warning (const GladeSignal        *signal);
+G_CONST_RETURN gchar *glade_signal_get_support_warning (const GladeSignal  *signal);
 
 G_END_DECLS
 
diff --git a/gladeui/glade-widget.c b/gladeui/glade-widget.c
index 53226bda..7e4bd6c0 100644
--- a/gladeui/glade-widget.c
+++ b/gladeui/glade-widget.c
@@ -405,6 +405,10 @@ glade_widget_change_signal_handler (GladeWidget * widget,
       signal_handler_iter = g_ptr_array_index (signals, i);
       if (glade_signal_equal (signal_handler_iter, old_signal_handler))
         {
+          /* Detail */
+	  glade_signal_set_detail (signal_handler_iter, 
+				   glade_signal_get_detail (new_signal_handler));
+          
           /* Handler */
 	  glade_signal_set_handler (signal_handler_iter, 
 				    glade_signal_get_handler (new_signal_handler));