[glade3/signal-tree-model: 56/358] signal-model: Implemented signal model inside GladeSignalEditor



commit 5da94940c930397625e7f1bbc1fbdddba27e42a9
Author: Johannes Schmid <jhs gnome org>
Date:   Tue Jun 29 21:41:03 2010 +0200

    signal-model: Implemented signal model inside GladeSignalEditor
    
    This is the initial implementation, it is able to show all signals and also shows a dummy
    signal handler to be able to add new handlers to a signal.

 gladeui/glade-app.c           |   28 -
 gladeui/glade-app.h           |    1 -
 gladeui/glade-base-editor.c   |    2 +-
 gladeui/glade-editor.c        |    2 +-
 gladeui/glade-signal-editor.c | 1640 +++--------------------------------------
 gladeui/glade-signal-editor.h |    4 +-
 gladeui/glade-signal-model.c  |  199 ++++--
 gladeui/glade-signal-model.h  |    4 +-
 8 files changed, 239 insertions(+), 1641 deletions(-)
---
diff --git a/gladeui/glade-app.c b/gladeui/glade-app.c
index 8c52bb1..deda205 100644
--- a/gladeui/glade-app.c
+++ b/gladeui/glade-app.c
@@ -60,7 +60,6 @@
 enum
 {
 	UPDATE_UI,
-	SIGNAL_EDITOR_CREATED,
 	LAST_SIGNAL
 };
 
@@ -295,12 +294,6 @@ glade_app_update_ui_default (GladeApp *app)
 			glade_app_refresh_undo_redo_button (app, list->data, FALSE);
 }
 
-static void
-glade_app_signal_editor_created_default (GladeApp *app, GladeSignalEditor *signal_editor)
-{
-	glade_signal_editor_construct_signals_list (signal_editor);
-}
-
 static gboolean
 clipboard_view_on_delete_cb (GtkWidget *clipboard_view, GdkEvent *e, GladeApp *app)
 {
@@ -478,7 +471,6 @@ glade_app_class_init (GladeAppClass * klass)
 	object_class->set_property = glade_app_set_property;
 
 	klass->update_ui_signal = glade_app_update_ui_default;
-	klass->signal_editor_created = glade_app_signal_editor_created_default;
 	klass->show_properties  = NULL;
 	klass->hide_properties  = NULL;
 
@@ -498,26 +490,6 @@ glade_app_class_init (GladeAppClass * klass)
 			      g_cclosure_marshal_VOID__VOID,
 			      G_TYPE_NONE, 0);
 
-	/**
-	 * GladeApp::signal-editor-created:
-	 * @gladeapp: the #GladeApp which received the signal.
-	 * @signal_editor: the new #GladeSignalEditor.
-	 *
-	 * Emitted when a new signal editor created.
-	 * A tree view is created in the default handler.
-	 * Connect your handler before the default handler for setting a custom column or renderer
-	 * and after it for connecting to the tree view signals
-	 */
-	glade_app_signals[SIGNAL_EDITOR_CREATED] =
-		g_signal_new ("signal-editor-created",
-			      G_TYPE_FROM_CLASS (object_class),
-			      G_SIGNAL_RUN_LAST,
-			      G_STRUCT_OFFSET (GladeAppClass,
-					       signal_editor_created),
-			      NULL, NULL,
-			      glade_marshal_VOID__OBJECT,
-			      G_TYPE_NONE, 1, G_TYPE_OBJECT);
-
 	g_object_class_install_property 
 		(object_class, PROP_ACTIVE_PROJECT,
 		 g_param_spec_object 
diff --git a/gladeui/glade-app.h b/gladeui/glade-app.h
index 6892416..86057cc 100644
--- a/gladeui/glade-app.h
+++ b/gladeui/glade-app.h
@@ -82,7 +82,6 @@ struct _GladeAppClass
 
 	/* signals */
 	void   (* update_ui_signal) (GladeApp    *app);
-	void   (* signal_editor_created) (GladeApp *app, GladeSignalEditor *signal_editor);
 };
 
  
diff --git a/gladeui/glade-base-editor.c b/gladeui/glade-base-editor.c
index 3746c91..ef32f7d 100644
--- a/gladeui/glade-base-editor.c
+++ b/gladeui/glade-base-editor.c
@@ -1781,7 +1781,7 @@ glade_base_editor_init (GladeBaseEditor *editor)
 	gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll), e->table);
 
 	/* Signal Editor */
-	e->signal_editor = glade_signal_editor_new (NULL);
+	e->signal_editor = glade_signal_editor_new ();
 	gtk_widget_show (GTK_WIDGET(e->signal_editor));
 	gtk_widget_set_size_request (GTK_WIDGET(e->signal_editor), -1, 96);
 	gtk_paned_pack2 (GTK_PANED (paned), GTK_WIDGET(e->signal_editor), FALSE, FALSE);
diff --git a/gladeui/glade-editor.c b/gladeui/glade-editor.c
index 21935e7..ec78c88 100644
--- a/gladeui/glade-editor.c
+++ b/gladeui/glade-editor.c
@@ -597,7 +597,7 @@ static void
 glade_editor_load_signal_page (GladeEditor *editor)
 {
 	if (editor->signal_editor == NULL) {
-		editor->signal_editor = glade_signal_editor_new ((gpointer) editor);
+		editor->signal_editor = glade_signal_editor_new ();
 		gtk_container_add (GTK_CONTAINER (editor->page_signals),
 				   GTK_WIDGET(editor->signal_editor));
 	}
diff --git a/gladeui/glade-signal-editor.c b/gladeui/glade-signal-editor.c
index ee883e9..0bc4de4 100644
--- a/gladeui/glade-signal-editor.c
+++ b/gladeui/glade-signal-editor.c
@@ -46,1098 +46,21 @@
 #include "glade-marshallers.h"
 #include "glade-accumulators.h"
 
-typedef gboolean (*IsVoidFunc) (const gchar *signal_handler);
-
-enum
-{
-	GSE_COLUMN_SIGNAL,
-	GSE_COLUMN_HANDLER,
-	GSE_COLUMN_AFTER,
-	GSE_COLUMN_USERDATA,
-	GSE_COLUMN_SWAPPED,
-
-	GSE_COLUMN_USERDATA_SLOT,
-	GSE_COLUMN_SWAPPED_VISIBLE,
-	GSE_COLUMN_AFTER_VISIBLE,
-	GSE_COLUMN_HANDLER_EDITABLE,
-	GSE_COLUMN_USERDATA_EDITABLE,
-	GSE_COLUMN_SLOT, /* if this row contains a "<Type...>" label */
-	GSE_COLUMN_BOLD,
-	GSE_COLUMN_CONTENT,
-
-	GSE_COLUMN_WARN,
-	GSE_COLUMN_TOOLTIP,
-	GSE_NUM_COLUMNS
-};
-
-enum
-{
-	HANDLER_EDITING_STARTED,
-	USERDATA_EDITING_STARTED,
-	LAST_SIGNAL
-};
-
-enum
-{
-	PROP_0,
-	PROP_HANDLER_COLUMN,
-	PROP_USERDATA_COLUMN,
-	PROP_HANDLER_COMPLETION,
-	PROP_USERDATA_COMPLETION,
-	PROP_HANDLER_RENDERER,
-	PROP_USERDATA_RENDERER
-};
-
 G_DEFINE_TYPE (GladeSignalEditor, glade_signal_editor, GTK_TYPE_VBOX)
 
 struct _GladeSignalEditorPrivate
 {
+	GtkTreeModel *model;
+	
 	GladeWidget *widget;
-	GladeWidgetAdaptor *adaptor;
+	GladeWidgetAdaptor* adaptor;
 
-	gpointer  *editor;
-
-	GtkWidget *signals_list;
-	GtkTreeStore *model;
-	GtkTreeView *tree_view;
-
-	GtkTreeModel *handler_store;
-	GtkTreeModel *userdata_store;
-	GtkCellRenderer *handler_renderer;
-	GtkCellRenderer *userdata_renderer;
-
-	GtkTreeViewColumn *handler_column;
-	GtkTreeViewColumn *userdata_column;
-	GtkTreeViewColumn *swapped_column_ptr;
-	IsVoidFunc is_void_handler;
-	IsVoidFunc is_void_userdata;
-	
-	gulong refresh_id;
+	GtkWidget* signal_tree;
 };
 
 #define HANDLER_DEFAULT  _("<Type here>")
 #define USERDATA_DEFAULT _("<Object>")
 
-static gboolean
-glade_signal_editor_handler_editing_started_default (GladeSignalEditor *editor,
-                                                     gchar *signal_name,
-                                                     GtkTreeIter *iter,
-                                                     GtkCellEditable *editable);
-static gboolean
-glade_signal_editor_userdata_editing_started_default (GladeSignalEditor *editor,
-                                                      gchar *signal_name,
-                                                      GtkTreeIter *iter,
-                                                      GtkCellEditable *editable);
-
-static gboolean
-is_void_handler (const gchar *signal_handler)
-{
-	return ( signal_handler == NULL ||
-		*signal_handler == 0    ||
-		 g_utf8_collate (signal_handler, HANDLER_DEFAULT) == 0);
-}
-
-static gboolean
-is_void_userdata (const gchar *user_data)
-{
-	return ( user_data == NULL ||
-		*user_data == 0    ||
-		 g_utf8_collate (user_data, USERDATA_DEFAULT) == 0);
-}
-
-static void
-glade_signal_editor_after_swapped_toggled (GtkCellRendererToggle *cell,
-					   gchar                 *path_str,
-					   gpointer               data)
-{
-	GladeSignalEditor *editor = (GladeSignalEditor*) data;
-	GladeSignalEditorPrivate* priv = editor->priv;
-	GtkTreeModel *model = GTK_TREE_MODEL (priv->model);
-	GtkTreeIter  iter;
-	GtkTreeIter iter_parent;
-	GladeSignal *old_signal;
-	GladeSignal *new_signal;
-	GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
-	gchar     *signal_name;
-	gchar     *handler;
-	gchar     *userdata;
-	gboolean   swapped, new_swapped;
-	gboolean   after, new_after;
-
-	/* get toggled iter */
-	gtk_tree_model_get_iter (model, &iter, path);
-	gtk_tree_model_get (model, &iter,
-			    GSE_COLUMN_SIGNAL,  &signal_name,
-			    GSE_COLUMN_HANDLER, &handler,
-			    GSE_COLUMN_USERDATA,&userdata,
-			    GSE_COLUMN_SWAPPED, &swapped,
-			    GSE_COLUMN_AFTER,   &after, -1);
-
-	if (signal_name == NULL)
-	{
-		if (!gtk_tree_model_iter_parent (model, &iter_parent, &iter))
-			g_assert (FALSE);
-
-		gtk_tree_model_get (model, &iter_parent, GSE_COLUMN_SIGNAL, &signal_name, -1);
-		g_assert (signal_name != NULL);
-	}
-
-	if (is_void_userdata (userdata))
-	{
-		g_free (userdata);
-		userdata = NULL;
-	}
-
-	new_after = after;
-	new_swapped = swapped;
-	if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "signal-after-cell")))
-		new_after = !after;
-	else
-		new_swapped = !swapped;
-
-	old_signal = glade_signal_new (signal_name, handler, userdata, after, swapped);
-	new_signal = glade_signal_new (signal_name, handler, userdata, new_after, new_swapped);
-
-	glade_command_change_signal (priv->widget, old_signal, new_signal);
-
-	gtk_tree_store_set (GTK_TREE_STORE (model), &iter, 
-			    GSE_COLUMN_AFTER, new_after, 
-			    GSE_COLUMN_SWAPPED, new_swapped, 
-			    -1);
-
-	glade_signal_free (old_signal);
-	glade_signal_free (new_signal);
-	gtk_tree_path_free (path);
-	g_free (signal_name);
-	g_free (handler);
-	g_free (userdata);
-}
-
-static void
-append_slot (GladeSignalEditor *self, GtkTreeIter *iter_signal, const gchar *signal_name)
-{
-	GtkTreeIter iter_new_slot;
-	GtkTreeIter iter_class;
-	GladeSignalEditorPrivate* priv = self->priv;
-	GtkTreeModel *model = GTK_TREE_MODEL (priv->model);
-	GladeSignal *sig = glade_signal_new (signal_name, NULL, NULL, FALSE, FALSE);
-
-	/* Check versioning warning here with a virtual signal */
-	glade_project_update_signal_support_warning (priv->widget, sig);
-
-	gtk_tree_store_append (GTK_TREE_STORE (model), &iter_new_slot, iter_signal);
-	gtk_tree_store_set (GTK_TREE_STORE (model), &iter_new_slot,
-			    GSE_COLUMN_HANDLER,          HANDLER_DEFAULT,
-			    GSE_COLUMN_USERDATA,         USERDATA_DEFAULT,
-			    GSE_COLUMN_SWAPPED,          FALSE,
-			    GSE_COLUMN_SWAPPED_VISIBLE,  FALSE,
-			    GSE_COLUMN_HANDLER_EDITABLE, TRUE,
-			    GSE_COLUMN_USERDATA_EDITABLE,FALSE,
-			    GSE_COLUMN_AFTER,            FALSE,
-			    GSE_COLUMN_AFTER_VISIBLE,    FALSE,
-			    GSE_COLUMN_SLOT,             TRUE,
-			    GSE_COLUMN_USERDATA_SLOT,    TRUE,
-			    GSE_COLUMN_CONTENT,          TRUE,
-			    GSE_COLUMN_WARN,             FALSE,
-			    GSE_COLUMN_TOOLTIP,          sig->support_warning,
-			    -1);
-	gtk_tree_model_iter_parent (model, &iter_class, iter_signal);
-
-	/* mark the signal & class name as bold */
-	gtk_tree_store_set (GTK_TREE_STORE (model), iter_signal, GSE_COLUMN_BOLD, TRUE, -1);
-	gtk_tree_store_set (GTK_TREE_STORE (model), &iter_class, GSE_COLUMN_BOLD, TRUE, -1);
-
-	glade_signal_free (sig);
-}
-
-static void
-move_row (GtkTreeModel *model, GtkTreeIter *from, GtkTreeIter *to)
-{
-	gchar *handler;
-	gchar *userdata, *support_warning;
-	gboolean after;
-	gboolean slot;
-	gboolean visible;
-	gboolean userdata_slot;
-	gboolean handler_editable;
-	gboolean userdata_editable;
-	gboolean swapped;
-	gboolean swapped_visible;
-	gboolean bold, content, warn;
-
-	gtk_tree_model_get (model,                        from,
-			    GSE_COLUMN_HANDLER,           &handler,
-			    GSE_COLUMN_USERDATA,          &userdata,
-			    GSE_COLUMN_AFTER,             &after,
-			    GSE_COLUMN_SLOT,              &slot,
-			    GSE_COLUMN_AFTER_VISIBLE,     &visible,
-			    GSE_COLUMN_HANDLER_EDITABLE,  &handler_editable,
-			    GSE_COLUMN_USERDATA_EDITABLE, &userdata_editable,
-			    GSE_COLUMN_USERDATA_SLOT,     &userdata_slot,
-			    GSE_COLUMN_SWAPPED,           &swapped,
-			    GSE_COLUMN_SWAPPED_VISIBLE,   &swapped_visible,
-			    GSE_COLUMN_BOLD,              &bold,
-			    GSE_COLUMN_CONTENT,           &content,
-			    GSE_COLUMN_WARN,              &warn,
-			    GSE_COLUMN_TOOLTIP,           &support_warning,
-			    -1);
-
-	gtk_tree_store_set (GTK_TREE_STORE (model),       to,
-			    GSE_COLUMN_HANDLER,           handler,
-			    GSE_COLUMN_USERDATA,          userdata,
-			    GSE_COLUMN_AFTER,             after,
-			    GSE_COLUMN_SLOT,              slot,
-			    GSE_COLUMN_AFTER_VISIBLE,     visible,
-			    GSE_COLUMN_HANDLER_EDITABLE,  handler_editable,
-			    GSE_COLUMN_USERDATA_EDITABLE, userdata_editable,
-			    GSE_COLUMN_USERDATA_SLOT,     userdata_slot,
-			    GSE_COLUMN_SWAPPED,           swapped,
-			    GSE_COLUMN_SWAPPED_VISIBLE,   swapped_visible,
-			    GSE_COLUMN_BOLD,              bold,
-			    GSE_COLUMN_CONTENT,           content,
-			    GSE_COLUMN_WARN,              warn,
-			    GSE_COLUMN_TOOLTIP,           support_warning,
-			    -1);
-
-	g_free (support_warning);
-	g_free (handler);
-	g_free (userdata);
-}
-
-static void
-remove_slot (GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *iter_signal)
-{
-	GtkTreeIter iter_class;
-
-	gtk_tree_model_iter_parent (model, &iter_class, iter_signal);
-
-	/* special case for removing the handler of the first row */
-	if (iter == NULL)
-	{
-		GtkTreeIter first_iter;
-
-		gtk_tree_model_iter_nth_child (model, &first_iter, iter_signal, 0);
-		move_row (model, &first_iter, iter_signal);
-		gtk_tree_store_remove (GTK_TREE_STORE (model), &first_iter);
-	}
-	else
-		gtk_tree_store_remove (GTK_TREE_STORE (model), iter);
-
-	if (!gtk_tree_model_iter_has_child (model, iter_signal))
-	{
-		/* mark the signal & class name as normal */
-		gtk_tree_store_set (GTK_TREE_STORE (model), iter_signal,
-				    GSE_COLUMN_BOLD, FALSE, -1);
-		gtk_tree_store_set (GTK_TREE_STORE (model), &iter_class,
-				    GSE_COLUMN_BOLD, FALSE, -1);
-	}
-}
-
-static gboolean
-glade_signal_editor_handler_editing_done  (GladeSignalEditor *self,
-                                           const gchar *signal_name,
-                                           const gchar *old_handler,
-                                           const gchar *new_handler,
-                                           GtkTreeIter *iter)
-{
-	GladeSignalEditorPrivate *priv = self->priv;
-	GladeWidget *glade_widget = priv->widget;
-	GtkTreeModel *model = GTK_TREE_MODEL (priv->model);
-	gchar *tmp_signal_name;
-	gchar *userdata;
-	GtkTreeIter iter_signal;
-	gboolean  after, swapped;
-	gboolean is_top_handler;
-
-	gtk_tree_model_get (model,               iter,
-			    GSE_COLUMN_SIGNAL,   &tmp_signal_name,
-			    GSE_COLUMN_USERDATA, &userdata,
-			    GSE_COLUMN_AFTER,    &after,
-			    GSE_COLUMN_SWAPPED,  &swapped,
-			    -1);
-
-	if (priv->is_void_userdata (userdata))
-	{
-		g_free (userdata);
-		userdata = NULL;
-	}
-
-	if (tmp_signal_name == NULL)
-	{
-		is_top_handler = FALSE;
-		gtk_tree_model_iter_parent (model, &iter_signal, iter);
-	}
-	else
-	{
-		is_top_handler = TRUE;
-		iter_signal = *iter;
-		g_free (tmp_signal_name);
-	}
-
-	/* we're adding a new handler */
-	if (old_handler == NULL && new_handler)
-	{
-		GladeSignal *new_signal = glade_signal_new (signal_name, new_handler,
-							    NULL, FALSE, FALSE);
-		glade_command_add_signal (glade_widget, new_signal);
-		glade_signal_free (new_signal);
-		gtk_tree_store_set (GTK_TREE_STORE (model), iter,
-				    GSE_COLUMN_HANDLER,          new_handler,
-				    GSE_COLUMN_AFTER_VISIBLE,    TRUE,
-				    GSE_COLUMN_SLOT,             FALSE,
-				    GSE_COLUMN_USERDATA_EDITABLE,TRUE, -1);
-
-		/* append a <Type...> slot */
-		append_slot (self, &iter_signal, signal_name);
-	}
-
-	/* we're removing a signal handler */
-	else if (old_handler && new_handler == NULL)
-	{
-		GladeSignal *old_signal =
-			glade_signal_new (signal_name,
-					  old_handler,
-					  userdata, 
-					  after, 
-					  swapped);
-		glade_command_remove_signal (glade_widget, old_signal);
-		glade_signal_free (old_signal);
-
-		gtk_tree_store_set
-			(GTK_TREE_STORE (model),          iter,
-				 GSE_COLUMN_HANDLER,          HANDLER_DEFAULT,
-				 GSE_COLUMN_AFTER,            FALSE,
-				 GSE_COLUMN_USERDATA,         USERDATA_DEFAULT,
-				 GSE_COLUMN_SWAPPED,          FALSE,
-				 GSE_COLUMN_SWAPPED_VISIBLE,  FALSE,
-				 GSE_COLUMN_HANDLER_EDITABLE, TRUE,
-				 GSE_COLUMN_USERDATA_EDITABLE,FALSE,
-				 GSE_COLUMN_AFTER_VISIBLE,    FALSE,
-				 GSE_COLUMN_SLOT,             TRUE,
-				 GSE_COLUMN_USERDATA_SLOT,    TRUE,
-				 GSE_COLUMN_CONTENT,          TRUE,
-				 -1);
-
-		remove_slot (model, is_top_handler ? NULL : iter, &iter_signal);
-	}
-
-	/* we're changing a signal handler */
-	else if (old_handler && new_handler)
-	{
-		GladeSignal *old_signal =
-			glade_signal_new
-			(signal_name,
-			 old_handler,
-			 userdata,
-			 after,
-			 swapped);
-		GladeSignal *new_signal =
-			glade_signal_new
-			(signal_name,
-			 new_handler,
-			 userdata,
-			 after, 
-			 swapped);
-
-		if (glade_signal_equal (old_signal, new_signal) == FALSE)
-			glade_command_change_signal (glade_widget, old_signal, new_signal);
-
-		glade_signal_free (old_signal);
-		glade_signal_free (new_signal);
-
-		gtk_tree_store_set (GTK_TREE_STORE (model), iter,
-				    GSE_COLUMN_HANDLER,       new_handler,
-				    GSE_COLUMN_AFTER_VISIBLE, TRUE,
-				    GSE_COLUMN_SLOT,          FALSE,
-				    GSE_COLUMN_USERDATA_EDITABLE,TRUE, -1);
-	}
-
-	g_free (userdata);
-
-	return FALSE;
-}
-
-static gboolean
-glade_signal_editor_userdata_editing_done (GladeSignalEditor *self,
-                                           const gchar *signal_name,
-                                           const gchar *old_userdata,
-                                           const gchar *new_userdata,
-                                           GtkTreeIter *iter)
-{
-	GladeSignalEditorPrivate *priv = self->priv;
-	GtkTreeModel *model = GTK_TREE_MODEL (priv->model);
-	GladeWidget  *glade_widget = priv->widget;
-	gchar *handler;
-	gboolean after, swapped;
-	GladeSignal *old_signal, *new_signal;
-
-	gtk_tree_model_get (model,               iter,
-			    GSE_COLUMN_HANDLER,  &handler,
-			    GSE_COLUMN_AFTER,    &after, 
-			    GSE_COLUMN_SWAPPED,  &swapped, 
-			    -1);
-
-	/* We are removing userdata */
-	if (new_userdata == NULL)
-	{
-		gtk_tree_store_set (GTK_TREE_STORE (model), iter,
-				    GSE_COLUMN_USERDATA_SLOT,   TRUE,
-				    GSE_COLUMN_USERDATA,        USERDATA_DEFAULT,
-				    GSE_COLUMN_SWAPPED,         FALSE,
-				    GSE_COLUMN_SWAPPED_VISIBLE, FALSE, -1);
-	}
-	else
-	{
-		gtk_tree_store_set (GTK_TREE_STORE (model), iter,
-				    GSE_COLUMN_USERDATA_SLOT,   FALSE,
-				    GSE_COLUMN_USERDATA,        new_userdata,
-				    GSE_COLUMN_SWAPPED_VISIBLE, TRUE,
-				    -1);
-	}
-
-	old_signal = glade_signal_new (signal_name, handler, old_userdata, after, swapped);
-
-	new_signal = glade_signal_new (signal_name, handler, new_userdata, after, swapped);
-
-	if (glade_signal_equal (old_signal, new_signal) == FALSE)
-		glade_command_change_signal (glade_widget, old_signal, new_signal);
-
-	glade_signal_free (old_signal);
-	glade_signal_free (new_signal);
-
-	g_free (handler);
-	return FALSE;
-}
-
-static gchar *
-glade_signal_editor_get_signal_name (GtkTreeModel *model, GtkTreeIter *iter)
-{
-	gchar *signal_name;
-	gtk_tree_model_get (model,           iter,
-			    GSE_COLUMN_SIGNAL,   &signal_name,
-			    -1);
-	if (signal_name == NULL)
-	{
-		GtkTreeIter iter_signal;
-
-		if (!gtk_tree_model_iter_parent (model, &iter_signal, iter))
-			g_assert (FALSE);
-
-		gtk_tree_model_get (model, &iter_signal, GSE_COLUMN_SIGNAL, &signal_name, -1);
-		g_assert (signal_name != NULL);
-	}
-
-	return signal_name;
-}
-
-static void
-glade_signal_editor_column_cell_edited (const gchar *path_str,
-					const gchar *new_value,
-					gpointer     data,
-					gint         column,
-					IsVoidFunc   is_void_callback)
-{
-	GladeSignalEditor* self = GLADE_SIGNAL_EDITOR (data);
-	GladeSignalEditorPrivate *priv = self->priv;
-	GtkTreeModel *model = GTK_TREE_MODEL (priv->model);
-	GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
-	GtkTreeIter iter;
-	gchar    *signal_name;
-	gchar    *old_value;
-
-	g_return_if_fail (gtk_tree_model_get_iter (model, &iter, path));
-	gtk_tree_path_free (path);
-	gtk_tree_model_get (model,  &iter,
-			    column, &old_value,
-			    -1);
-
-	signal_name = glade_signal_editor_get_signal_name (model, &iter);
-
-	if (is_void_callback (new_value))
-		new_value = NULL;
-
-	if (is_void_callback (old_value))
-	{
-		g_free (old_value);
-		old_value = NULL;
-	}
-
-	/* if not a false alarm */
-	if (old_value || new_value);
-	{
-		switch (column)
-		{
-			case GSE_COLUMN_HANDLER:
-				glade_signal_editor_handler_editing_done (self,
-				                                          signal_name,
-				                                          old_value,
-				                                          new_value,
-				                                          &iter);
-				break;
-			case GSE_COLUMN_USERDATA:
-				glade_signal_editor_userdata_editing_done (self,
-				                                           signal_name,
-				                                           old_value,
-				                                           new_value,
-				                                           &iter);
-				break;
-			
-		}
-	}
-
-	g_free (signal_name);
-	g_free (old_value);
-}
-
-static void
-glade_signal_editor_handler_cell_edited (GtkCellRendererText *cell,
-					 const gchar         *path_str,
-					 const gchar         *new_handler,
-					 gpointer             data)
-{
-	GladeSignalEditor *editor = GLADE_SIGNAL_EDITOR (data);
-
-	glade_signal_editor_column_cell_edited (path_str, new_handler, data,
-	                                        GSE_COLUMN_HANDLER,
-	                                        editor->priv->is_void_handler);
-}
-
-static void
-glade_signal_editor_userdata_cell_edited (GtkCellRendererText *cell,
-					  const gchar         *path_str,
-					  const gchar         *new_userdata,
-					  gpointer             data)
-{
-	GladeSignalEditor *editor = GLADE_SIGNAL_EDITOR (data);
-
-	glade_signal_editor_column_cell_edited (path_str, new_userdata, data,
-	                                        GSE_COLUMN_USERDATA,
-						editor->priv->is_void_userdata);
-}
-
-static void
-glade_signal_editor_column_editing_started (GtkCellEditable *editable,
-					    const gchar *path_str,
-					    GladeSignalEditor *editor,
-					    guint signal)
-{
-	GladeSignalEditorPrivate *priv = editor->priv;
-	GtkTreeModel *model = GTK_TREE_MODEL (priv->model);
-	GtkTreePath *path;
-	GtkTreeIter iter;
-	gchar *signal_name;
-
-	path = gtk_tree_path_new_from_string (path_str);
-	g_return_if_fail (gtk_tree_model_get_iter (model, &iter, path));
-	gtk_tree_path_free (path);
-	signal_name = glade_signal_editor_get_signal_name (model, &iter);
-	switch (signal)
-	{
-		case HANDLER_EDITING_STARTED:
-			glade_signal_editor_handler_editing_started_default (editor,
-			                                                     signal_name,
-			                                                     &iter,
-			                                                     editable);
-			break;
-		case USERDATA_EDITING_STARTED:
-			glade_signal_editor_userdata_editing_started_default (editor,
-			                                                      signal_name,
-			                                                      &iter,
-			                                                      editable);
-			break;
-	}
-	g_free (signal_name);
-}
-
-static void
-glade_signal_editor_handler_editing_started (GtkCellRenderer *cell,
-					     GtkCellEditable *editable,
-					     const gchar *path,
-					     GladeSignalEditor *editor)
-{
-	glade_signal_editor_column_editing_started (editable, path,
-						    editor, HANDLER_EDITING_STARTED);
-}
-
-static void
-glade_signal_editor_userdata_editing_started (GtkCellRenderer *cell,
-					      GtkCellEditable *editable,
-					      const gchar *path,
-					      GladeSignalEditor *editor)
-{
-	glade_signal_editor_column_editing_started (editable, path,
-						    editor, USERDATA_EDITING_STARTED);
-}
-
-static void
-glade_signal_editor_signal_cell_data_func (GtkTreeViewColumn *tree_column,
-					   GtkCellRenderer *cell,
-					   GtkTreeModel *tree_model,
-					   GtkTreeIter *iter,
-					   gpointer data)
-{
-	gboolean bold;
-
-	gtk_tree_model_get (tree_model, iter, GSE_COLUMN_BOLD, &bold, -1);
-	if (bold)
-		g_object_set (G_OBJECT (cell), "weight", PANGO_WEIGHT_BOLD, NULL);
-	else
-		g_object_set (G_OBJECT (cell), "weight", PANGO_WEIGHT_NORMAL, NULL);
-}
-
-static void
-glade_signal_editor_handler_cell_data_func (GtkTreeViewColumn *tree_column,
-					    GtkCellRenderer *cell,
-					    GtkTreeModel *tree_model,
-					    GtkTreeIter *iter,
-					    gpointer data)
-{
-	gboolean slot;
-
-	gtk_tree_model_get (tree_model, iter, GSE_COLUMN_SLOT, &slot, -1);
-	if (slot)
-		g_object_set (G_OBJECT (cell),
-			      "style", PANGO_STYLE_ITALIC,
-			      "foreground", "Gray", NULL);
-	else
-		g_object_set (G_OBJECT (cell),
-			      "style", PANGO_STYLE_NORMAL,
-			      "foreground", NULL, NULL);
-}
-
-static void
-glade_signal_editor_userdata_cell_data_func (GtkTreeViewColumn *tree_column,
-					     GtkCellRenderer *cell,
-					     GtkTreeModel *tree_model,
-					     GtkTreeIter *iter,
-					     gpointer data)
-{
-	gboolean userdata_slot;
-
-	gtk_tree_model_get (tree_model, iter, GSE_COLUMN_USERDATA_SLOT, &userdata_slot, -1);
-	if (userdata_slot)
-		g_object_set (G_OBJECT (cell),
-			      "style", PANGO_STYLE_ITALIC,
-			      "foreground", "Gray", NULL);
-	else
-		g_object_set (G_OBJECT (cell),
-			      "style", PANGO_STYLE_NORMAL,
-			      "foreground", NULL, NULL);
-}
-
-static void 
-glade_signal_editor_devhelp_cb (GtkCellRenderer   *cell,
-				const gchar       *path_str,
-				GladeSignalEditor *editor)
-{
-	GladeSignalEditorPrivate *priv = editor->priv;
-	GtkTreePath  *path = gtk_tree_path_new_from_string (path_str);
-	GtkTreeModel *model = GTK_TREE_MODEL (priv->model);
-	GtkTreeIter   iter;
-	GladeSignalClass *signal_class;
-	gchar        *signal, *search, *book = NULL;
-
-	g_return_if_fail (gtk_tree_model_get_iter (model, &iter, path));
-	gtk_tree_path_free (path);
-
-	signal  = glade_signal_editor_get_signal_name (model, &iter);
-	search  = g_strdup_printf ("The %s signal", signal);
-
-	signal_class = glade_widget_adaptor_get_signal_class (priv->widget->adaptor,
-							      signal);
-	g_assert (signal_class);
-
-	g_object_get (signal_class->adaptor, "book", &book, NULL);
-
-	glade_editor_search_doc_search (glade_app_get_editor (),
-					book, signal_class->adaptor->name, search);
-
-	g_free (search);
-	g_free (book);
-	g_free (signal);
-}
-
-static void
-set_column_header_tooltip_on_realize (GtkWidget *label,
-				      const gchar *tooltip_txt)
-{
-	GtkWidget *header = 
-		gtk_widget_get_ancestor (label, GTK_TYPE_BUTTON);
-
-	if (header)
-		gtk_widget_set_tooltip_text (header, tooltip_txt);
-}
-
-/* convenience function: tooltip_txt must be static memory */
-static void
-column_header_widget (GtkTreeViewColumn *column,
-		      const gchar *txt, 
-		      const gchar *tooltip_txt)
-{
-	GtkWidget *event_box, *label;
-
-	event_box = gtk_event_box_new ();
-	gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
-
-	gtk_widget_set_tooltip_text (event_box, tooltip_txt);
-
-	label = gtk_label_new (txt);
-
-	gtk_widget_show (event_box);
-	gtk_widget_show (label);
-	
-	g_signal_connect_after (G_OBJECT (label), "realize",
-				G_CALLBACK (set_column_header_tooltip_on_realize), (gpointer)tooltip_txt);
-
-	gtk_container_add (GTK_CONTAINER (event_box), label);
-	
-	gtk_tree_view_column_set_widget (column, event_box);
-}	
-
-static void
-glade_signal_editor_user_data_activate (GtkCellRenderer *icon_renderer,
-					const gchar     *path_str,
-					GladeSignalEditor *editor)
-{
-	GladeSignalEditorPrivate *priv = editor->priv;
-	GtkTreePath  *path = gtk_tree_path_new_from_string (path_str);
-	GtkTreeModel *model = GTK_TREE_MODEL (priv->model);
-	GtkTreeIter   iter;
-	gchar        *object_name = NULL, *signal_name = NULL, *handler = NULL;
-	gboolean      after, swapped;
-	GladeWidget  *project_object = NULL;
-	GladeProject *project;
-	GList        *selected = NULL, *exception = NULL;
-
-	gtk_tree_model_get_iter (model, &iter, path);
-	gtk_tree_model_get (model, &iter,
-			    GSE_COLUMN_HANDLER, &handler,
-			    GSE_COLUMN_USERDATA,&object_name,
-			    GSE_COLUMN_SWAPPED, &swapped,
-			    GSE_COLUMN_AFTER,   &after, -1);
-
-	signal_name  = glade_signal_editor_get_signal_name (model, &iter);
-	project      = glade_widget_get_project (priv->widget);
-	
-	if (object_name)
-	{
-		project_object = glade_project_get_widget_by_name (project, NULL, object_name);
-		selected = g_list_prepend (selected, project_object);
-	}
-
-	exception = g_list_prepend (exception, priv->widget);
-	
-	if (glade_editor_property_show_object_dialog (project,
-						      _("Select an object to pass to the handler"),
-						      gtk_widget_get_toplevel (GTK_WIDGET(editor)), 
-						      G_TYPE_OBJECT,
-						      priv->widget, &project_object))
-	{
-		GladeSignal *old_signal = glade_signal_new (signal_name, handler, object_name, after, swapped);
-		GladeSignal *new_signal = glade_signal_new (signal_name, handler, 
-							    project_object ? project_object->name : NULL, 
-							    after, swapped);
-
-		glade_command_change_signal (priv->widget, old_signal, new_signal);
-		glade_signal_free (old_signal);
-		glade_signal_free (new_signal);
-
-		/* We are removing userdata */
-		if (project_object == NULL)
-		{
-			gtk_tree_store_set (GTK_TREE_STORE (model),     &iter,
-					    GSE_COLUMN_USERDATA_SLOT,   TRUE,
-					    GSE_COLUMN_USERDATA,        USERDATA_DEFAULT,
-					    GSE_COLUMN_SWAPPED,         FALSE,
-					    GSE_COLUMN_SWAPPED_VISIBLE, FALSE, -1);
-		}
-		else
-		{
-			gtk_tree_store_set (GTK_TREE_STORE (model),     &iter,
-					    GSE_COLUMN_USERDATA_SLOT,   FALSE,
-					    GSE_COLUMN_USERDATA,        project_object->name,
-					    GSE_COLUMN_SWAPPED_VISIBLE, TRUE,
-					    -1);
-		}
-	}
-
-	gtk_tree_path_free (path);
-	g_free (signal_name);
-	g_free (object_name);
-	g_free (handler);
-}
-
-
-void
-glade_signal_editor_construct_signals_list (GladeSignalEditor *editor)
-{
-	GtkTreeView *view;
-	GtkWidget *view_widget;
-	GtkTreeViewColumn *column;
- 	GtkCellRenderer *renderer;
-	GtkTreeModel *model;
-
-	GladeSignalEditorPrivate *priv = editor->priv;
-	
-	priv->model = gtk_tree_store_new
-		(GSE_NUM_COLUMNS,
-		 G_TYPE_STRING,   /* Signal  value      */
-		 G_TYPE_STRING,   /* Handler value      */
-		 G_TYPE_BOOLEAN,  /* After   value      */
-		 G_TYPE_STRING,   /* User data value    */
-		 G_TYPE_BOOLEAN,  /* Swapped value */
-		 G_TYPE_BOOLEAN,  /* Whether userdata is a slot */
-		 G_TYPE_BOOLEAN,  /* Swapped visibility  */
-		 G_TYPE_BOOLEAN,  /* After visibility */
-		 G_TYPE_BOOLEAN,  /* Handler editable   */
-		 G_TYPE_BOOLEAN,  /* Userdata editable  */
-		 G_TYPE_BOOLEAN,  /* New slot           */
-		 G_TYPE_BOOLEAN,  /* Mark with bold     */
-		 G_TYPE_BOOLEAN,  /* Not a class title slot */ 
-		 G_TYPE_BOOLEAN,  /* Show a warning icon for the signal */ 
-		 G_TYPE_STRING);  /* A tooltip for the signal row */ 
-
-	model = GTK_TREE_MODEL (priv->model);
-
-	view_widget = gtk_tree_view_new_with_model (model);
-	g_object_set (G_OBJECT (view_widget), "enable-search", FALSE, NULL);
-
-	view = GTK_TREE_VIEW (view_widget);
-
-	gtk_tree_view_set_tooltip_column (view, GSE_COLUMN_TOOLTIP);
-
-	/* the view now holds a reference, we can get rid of our own */
-	g_object_unref (G_OBJECT (priv->model));
-
-	/************************ signal column ************************/
-	column = gtk_tree_view_column_new ();
-	column_header_widget (column, _("Signal"), _("The name of the signal to connect to"));
-
-	renderer = gtk_cell_renderer_pixbuf_new ();
-	g_object_set (G_OBJECT (renderer), "icon-name", GTK_STOCK_DIALOG_WARNING, NULL);
-
-	gtk_tree_view_column_pack_start (column, renderer, FALSE);
-	gtk_tree_view_column_set_attributes (column, renderer, 
-					     "visible", GSE_COLUMN_WARN, 
-					     NULL);
-
-
- 	renderer = gtk_cell_renderer_text_new ();
-	g_object_set (G_OBJECT (renderer),
-		      "ellipsize", PANGO_ELLIPSIZE_END,
-		      "width-chars", 20,
-		      NULL);
-	gtk_tree_view_column_pack_end (column, renderer, TRUE);
-	gtk_tree_view_column_set_attributes (column, renderer, 
-					     "text", GSE_COLUMN_SIGNAL, 
-					     NULL);
-
-	gtk_tree_view_column_set_cell_data_func (column, renderer,
-						 glade_signal_editor_signal_cell_data_func,
-						 NULL, NULL);
-
- 	gtk_tree_view_column_set_resizable (column, TRUE);
- 	gtk_tree_view_column_set_expand (column, TRUE);
- 	gtk_tree_view_append_column (view, column);
-
-	/************************ handler column ************************/
- 	if (!priv->handler_store)
-			priv->handler_store = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
-
-	if (!priv->handler_renderer)
- 	{
- 		priv->handler_renderer = gtk_cell_renderer_combo_new ();
-		g_object_set (G_OBJECT (priv->handler_renderer),
-			      "model", priv->handler_store,
-			      "text-column", 0,
-			      "ellipsize", PANGO_ELLIPSIZE_END,
-			      "width-chars", 14,
-			      NULL);
-	}
-
-	g_signal_connect (priv->handler_renderer, "edited",
-			  G_CALLBACK (glade_signal_editor_handler_cell_edited), editor);
-
-	g_signal_connect (priv->handler_renderer, "editing-started",
-			  G_CALLBACK (glade_signal_editor_handler_editing_started),
-			  editor);
-
-	if (!priv->handler_column)
-	{
-		priv->handler_column = gtk_tree_view_column_new_with_attributes
-			(NULL,             priv->handler_renderer,
-			 "editable",       GSE_COLUMN_HANDLER_EDITABLE,
-			 "text",           GSE_COLUMN_HANDLER, NULL);
-
-		column_header_widget (priv->handler_column, _("Handler"), 
-				      _("Enter the handler to run for this signal"));
-
-		gtk_tree_view_column_set_cell_data_func (priv->handler_column, priv->handler_renderer,
-							 glade_signal_editor_handler_cell_data_func,
-							 NULL, NULL);
-	}
-
- 	gtk_tree_view_column_set_resizable (priv->handler_column, TRUE);
- 	gtk_tree_view_column_set_expand (priv->handler_column, TRUE);
- 	gtk_tree_view_append_column (view, priv->handler_column);
-
-	/************************ userdata column ************************/
- 	if (!priv->userdata_renderer)
- 	{
- 		priv->userdata_renderer = gtk_cell_renderer_text_new ();
-	}
-			      
-	if (!priv->userdata_store)
-		priv->userdata_store = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
-
-	g_signal_connect (priv->userdata_renderer, "edited",
-			  G_CALLBACK (glade_signal_editor_userdata_cell_edited), editor);
-
-	g_signal_connect (priv->userdata_renderer, "editing-started",
-			  G_CALLBACK (glade_signal_editor_userdata_editing_started),
-			  editor);
-	
-	if (!priv->userdata_column)
-	{
-		priv->userdata_column =
-			gtk_tree_view_column_new_with_attributes
-				(NULL,        priv->userdata_renderer,
-				 "text",      GSE_COLUMN_USERDATA, NULL);
-
-		column_header_widget (priv->userdata_column, _("Object"), 
-				      _("An object to pass to the handler"));
-
-		gtk_tree_view_column_set_cell_data_func (priv->userdata_column, priv->userdata_renderer,
-							 glade_signal_editor_userdata_cell_data_func,
-							 NULL, NULL);
-
-		g_object_set (G_OBJECT (priv->userdata_renderer), 
-			      "editable", FALSE, 
-			      "ellipsize", PANGO_ELLIPSIZE_END,
-			      "width-chars", 10,
-			      NULL);
-
-		renderer = glade_cell_renderer_icon_new ();
-		g_object_set (G_OBJECT (renderer), "icon-name", GTK_STOCK_EDIT, NULL);
-
-		g_signal_connect (G_OBJECT (renderer), "activate",
-				  G_CALLBACK (glade_signal_editor_user_data_activate), editor);
-		gtk_tree_view_column_pack_end (priv->userdata_column, renderer, FALSE);
-		gtk_tree_view_column_set_attributes (priv->userdata_column, renderer, 
-						     "activatable", GSE_COLUMN_USERDATA_EDITABLE,
-						     "visible",     GSE_COLUMN_USERDATA_EDITABLE, 
-						     NULL);
-	}
-
- 	gtk_tree_view_column_set_resizable (priv->userdata_column, TRUE);
- 	gtk_tree_view_column_set_expand (priv->userdata_column, TRUE);
- 	gtk_tree_view_append_column (view, priv->userdata_column);
-
-	/************************ swapped column ************************/
- 	renderer = gtk_cell_renderer_toggle_new ();
-	g_signal_connect (renderer, "toggled",
-			  G_CALLBACK (glade_signal_editor_after_swapped_toggled), editor);
-	column = gtk_tree_view_column_new_with_attributes
-		(NULL, renderer,
-		 "active",  GSE_COLUMN_SWAPPED,
-		 "sensitive", GSE_COLUMN_SWAPPED_VISIBLE, 
-		 "activatable", GSE_COLUMN_SWAPPED_VISIBLE,
-		 "visible", GSE_COLUMN_CONTENT,
-		 NULL);
-
-	column_header_widget (column,_("Swap"), 
-			      _("Whether the instance and object should be swapped when calling the handler"));
-
- 	gtk_tree_view_append_column (view, column);
-
-	/* - No need for a ref here - */
-	priv->swapped_column_ptr = column;
-
-	/************************ after column ************************/
-	renderer = gtk_cell_renderer_toggle_new ();
-
-	g_object_set (G_OBJECT (renderer), 
-		      "xpad", 15,
-		      NULL);
-	g_object_set_data (G_OBJECT (renderer), "signal-after-cell",
-			       GINT_TO_POINTER (TRUE));
-
-	g_signal_connect (renderer, "toggled",
-			  G_CALLBACK (glade_signal_editor_after_swapped_toggled), editor);
- 	column = gtk_tree_view_column_new_with_attributes
-		(NULL, renderer,
-		 "active",  GSE_COLUMN_AFTER,
-		 "sensitive", GSE_COLUMN_AFTER_VISIBLE, 
-		 "activatable", GSE_COLUMN_AFTER_VISIBLE, 
-		 "visible", GSE_COLUMN_CONTENT,
-		 NULL);
-
-	column_header_widget (column, _("After"), 
-			      _("Whether the handler should be called before "
-				"or after the default handler of the signal"));
-
-	/* Append the devhelp icon if we have it */
-	if (glade_util_have_devhelp ())
-	{
-		renderer = glade_cell_renderer_icon_new ();
-
-		g_object_set (G_OBJECT (renderer), 
-			      "activatable", TRUE,
-			      NULL);
-
-		if (gtk_icon_theme_has_icon (gtk_icon_theme_get_default (), GLADE_DEVHELP_ICON_NAME))
-			g_object_set (G_OBJECT (renderer), "icon-name", GLADE_DEVHELP_ICON_NAME, NULL);
-		else
-			g_object_set (G_OBJECT (renderer), "icon-name", GTK_STOCK_INFO, NULL);
-
-		g_signal_connect (G_OBJECT (renderer), "activate",
-				  G_CALLBACK (glade_signal_editor_devhelp_cb), editor);
-
-		gtk_tree_view_column_pack_end (column, renderer, FALSE);
-		gtk_tree_view_column_set_attributes (column, renderer, 
-						     "visible", GSE_COLUMN_CONTENT, NULL);
-
-	}
-
- 	gtk_tree_view_append_column (view, column);
-
-
-	priv->signals_list = view_widget;
-}
-
-static GObject*
-glade_signal_editor_constructor (GType                  type,
-				 guint                  n_construct_properties,
-				 GObjectConstructParam *construct_properties)
-{
-	GtkWidget *scroll;
-	GladeSignalEditor *editor;
-	GladeSignalEditorPrivate *priv;
-	GObject *retval;
-
-	retval = G_OBJECT_CLASS (glade_signal_editor_parent_class)->constructor
-		(type, n_construct_properties, construct_properties);
-	editor = GLADE_SIGNAL_EDITOR (retval);
-	priv = editor->priv;
-
-	scroll = gtk_scrolled_window_new (NULL, NULL);
-	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
-					GTK_POLICY_AUTOMATIC,
-					GTK_POLICY_AUTOMATIC);
-	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
-					     GTK_SHADOW_IN);
-
-	g_signal_emit_by_name (glade_app_get(), "signal-editor-created", retval);
-
-	gtk_container_add (GTK_CONTAINER (scroll), priv->signals_list);
-
-	gtk_box_pack_start (GTK_BOX (editor), scroll, TRUE, TRUE, 0);
-
-	gtk_widget_show_all (GTK_WIDGET(editor));
-
-	return retval;
-}
-
 /**
  * glade_signal_editor_new:
  * @editor: a #GladeEditor
@@ -1145,27 +68,16 @@ glade_signal_editor_constructor (GType                  type,
  * Returns: a new #GladeSignalEditor associated with @editor
  */
 GladeSignalEditor *
-glade_signal_editor_new (gpointer *editor)
+glade_signal_editor_new ()
 {
 	GladeSignalEditor *signal_editor;
 
 	signal_editor = GLADE_SIGNAL_EDITOR (g_object_new (GLADE_TYPE_SIGNAL_EDITOR,
 	                                                   NULL, NULL));
-	signal_editor->priv->editor = editor;
 
 	return signal_editor;
 }
 
-static void
-glade_signal_editor_refresh_support (GladeWidget *widget,
-				     GladeSignalEditor *editor)
-{
-	GladeSignalEditorPrivate *priv = editor->priv;
-	
-	g_assert (priv->widget == widget);
-	glade_signal_editor_load_widget (editor, priv->widget);
-}
-
 /**
  * glade_signal_editor_load_widget:
  * @editor: a #GladeSignalEditor
@@ -1177,28 +89,11 @@ void
 glade_signal_editor_load_widget (GladeSignalEditor *editor,
 				 GladeWidget *widget)
 {
-	GList *list;
-	const gchar *last_type = "";
-	GtkTreeIter iter;
-	GtkTreeIter parent_class;
-	GtkTreeIter parent_signal;
-	GtkTreePath *path_first;
-	GPtrArray *signals;
-
 	GladeSignalEditorPrivate *priv = editor->priv;
-
-
-	g_return_if_fail (GLADE_IS_SIGNAL_EDITOR (editor));
-	g_return_if_fail (widget == NULL || GLADE_IS_WIDGET (widget));
-
+	
 	if (priv->widget != widget)
 	{
 		if (priv->widget)
-		{
-			g_signal_handler_disconnect (priv->widget, priv->refresh_id);
-			priv->refresh_id = 0;
-			g_object_unref (priv->widget);
-		}
 		
 		priv->widget = widget;
 		priv->adaptor = widget ? widget->adaptor : NULL;
@@ -1206,252 +101,20 @@ glade_signal_editor_load_widget (GladeSignalEditor *editor,
 		if (priv->widget)
 		{
 			g_object_ref (priv->widget);
-			priv->refresh_id =
-				g_signal_connect (G_OBJECT (priv->widget), "support-changed",
-						  G_CALLBACK (glade_signal_editor_refresh_support), editor);
 		}
 	}
+
+	gtk_tree_view_set_model (GTK_TREE_VIEW (priv->signal_tree), NULL);
+	if (priv->model)
+		g_object_unref (priv->model);
+	priv->model = NULL;
+
 	
 	if (!widget)
 		return;
 
-	gtk_tree_store_clear (priv->model);
-
-	if (glade_project_get_format (glade_widget_get_project (widget)) == GLADE_PROJECT_FORMAT_GTKBUILDER)
-		gtk_tree_view_column_set_visible (priv->swapped_column_ptr, TRUE);
-	else
-		gtk_tree_view_column_set_visible (priv->swapped_column_ptr, FALSE);
-
-	/* Loop over every signal type
-	 */
-	for (list = priv->adaptor->signals; list; list = list->next)
-	{
-		GladeSignalClass *signal = (GladeSignalClass *) list->data;
-		GladeSignal *sig = glade_signal_new (signal->name, NULL, NULL, FALSE, FALSE);
-
-		/* Check versioning here with a virtual signal */
-		glade_project_update_signal_support_warning (priv->widget, sig);
-
-		/* Add class name that this signal belongs to.
-		 */
-		if (strcmp(last_type, signal->type))
-		{
-			gtk_tree_store_append (priv->model, &parent_class, NULL);
-			gtk_tree_store_set    (priv->model,          &parent_class,
-					       GSE_COLUMN_SIGNAL,           signal->type,
-					       GSE_COLUMN_AFTER_VISIBLE,    FALSE,
-					       GSE_COLUMN_HANDLER_EDITABLE, FALSE,
-					       GSE_COLUMN_USERDATA_EDITABLE,FALSE,
-					       GSE_COLUMN_SLOT,             FALSE,
-					       GSE_COLUMN_BOLD,             FALSE, 
-					       GSE_COLUMN_CONTENT,          FALSE,
-					       -1);
-			last_type = signal->type;
-		}
-
-		gtk_tree_store_append (priv->model, &parent_signal, &parent_class);
-		signals = glade_widget_list_signal_handlers (widget, signal->name);
-
-		if (!signals || signals->len == 0)
-		{
-
-			gtk_tree_store_set
-				(priv->model,              &parent_signal,
-				 GSE_COLUMN_SIGNAL,           signal->name,
-				 GSE_COLUMN_HANDLER,          HANDLER_DEFAULT,
-				 GSE_COLUMN_AFTER,            FALSE,
-				 GSE_COLUMN_USERDATA,         USERDATA_DEFAULT,
-				 GSE_COLUMN_SWAPPED,          FALSE,
-				 GSE_COLUMN_SWAPPED_VISIBLE,  FALSE,
-				 GSE_COLUMN_HANDLER_EDITABLE, TRUE,
-				 GSE_COLUMN_USERDATA_EDITABLE,FALSE,
-				 GSE_COLUMN_AFTER_VISIBLE,    FALSE,
-				 GSE_COLUMN_SLOT,             TRUE,
-				 GSE_COLUMN_USERDATA_SLOT,    TRUE,
-				 GSE_COLUMN_CONTENT,          TRUE,
-				 GSE_COLUMN_WARN,             sig->support_warning != NULL,
-				 GSE_COLUMN_TOOLTIP,          sig->support_warning,	
-				 -1);
-		}
-		else
-		{
-			guint i;
-			GtkTreePath *path_parent_class;
-			GladeSignal *widget_signal =
-				(GladeSignal*) g_ptr_array_index (signals, 0);
-
-			/* mark the class of this signal as bold and expand it,
-                         * as there is at least one signal with handler */
-			gtk_tree_store_set (priv->model, &parent_class, GSE_COLUMN_BOLD, TRUE, -1);
-			path_parent_class =
-				gtk_tree_model_get_path (GTK_TREE_MODEL (priv->model),
-							 &parent_class);
-			gtk_tree_view_expand_row (GTK_TREE_VIEW (priv->signals_list),
-						  path_parent_class, FALSE);
-			gtk_tree_path_free (path_parent_class);
-
-			gtk_tree_store_set
-				(priv->model,            &parent_signal,
-				 GSE_COLUMN_SIGNAL,             signal->name,
-				 GSE_COLUMN_HANDLER,            widget_signal->handler,
-				 GSE_COLUMN_AFTER,              widget_signal->after,
-				 GSE_COLUMN_USERDATA,
-				 widget_signal->userdata ?
-				 widget_signal->userdata : USERDATA_DEFAULT,
-				 GSE_COLUMN_SWAPPED,            widget_signal->swapped,
-				 GSE_COLUMN_SWAPPED_VISIBLE,
-				 widget_signal->userdata ?  TRUE : FALSE,
-				 GSE_COLUMN_AFTER_VISIBLE,      TRUE,
-				 GSE_COLUMN_HANDLER_EDITABLE,   TRUE,
-				 GSE_COLUMN_USERDATA_EDITABLE,  TRUE,
-				 GSE_COLUMN_SLOT,               FALSE,
-				 GSE_COLUMN_USERDATA_SLOT,
-				 widget_signal->userdata  ? FALSE : TRUE,
-				 GSE_COLUMN_BOLD,               TRUE, 
-				 GSE_COLUMN_CONTENT,            TRUE,
-				 GSE_COLUMN_WARN,               widget_signal->support_warning != NULL,
-				 GSE_COLUMN_TOOLTIP,            widget_signal->support_warning,
-				 -1);
-
-			for (i = 1; i < signals->len; i++)
-			{
-				widget_signal = (GladeSignal*) g_ptr_array_index (signals, i);
-				gtk_tree_store_append (priv->model, &iter, &parent_signal);
-
-				gtk_tree_store_set
-					(priv->model,            &iter,
-					 GSE_COLUMN_HANDLER,            widget_signal->handler,
-					 GSE_COLUMN_AFTER,              widget_signal->after,
-					 GSE_COLUMN_USERDATA,
-					 widget_signal->userdata  ?
-					 widget_signal->userdata : USERDATA_DEFAULT,
-					 GSE_COLUMN_SWAPPED,            widget_signal->swapped,
-					 GSE_COLUMN_SWAPPED_VISIBLE,
-					 widget_signal->userdata  ? TRUE : FALSE,
-					 GSE_COLUMN_AFTER_VISIBLE,      TRUE,
-					 GSE_COLUMN_HANDLER_EDITABLE,   TRUE,
-					 GSE_COLUMN_USERDATA_EDITABLE,  TRUE,
-					 GSE_COLUMN_SLOT,               FALSE,
-					 GSE_COLUMN_USERDATA_SLOT,
-					 widget_signal->userdata  ? FALSE : TRUE,
-					 GSE_COLUMN_CONTENT,            TRUE,
-					 GSE_COLUMN_WARN,               FALSE,
-					 GSE_COLUMN_TOOLTIP,            widget_signal->support_warning,
-					 -1);
-			}
-
-			/* add the <Type...> slot */
-			gtk_tree_store_append (priv->model, &iter, &parent_signal);
-			gtk_tree_store_set
-				(priv->model,          &iter,
-				 GSE_COLUMN_HANDLER,          HANDLER_DEFAULT,
-				 GSE_COLUMN_AFTER,            FALSE,
-				 GSE_COLUMN_USERDATA,         USERDATA_DEFAULT,
-				 GSE_COLUMN_SWAPPED,          FALSE,
-				 GSE_COLUMN_SWAPPED_VISIBLE,  FALSE,
-				 GSE_COLUMN_HANDLER_EDITABLE, TRUE,
-				 GSE_COLUMN_USERDATA_EDITABLE,FALSE,
-				 GSE_COLUMN_AFTER_VISIBLE,    FALSE,
-				 GSE_COLUMN_SLOT,             TRUE,
-				 GSE_COLUMN_USERDATA_SLOT,    TRUE,
-				 GSE_COLUMN_CONTENT,          TRUE,
-				 GSE_COLUMN_WARN,             FALSE,
-				 GSE_COLUMN_TOOLTIP,          sig->support_warning,
-				 -1);
-		}
-
-		glade_signal_free (sig);
-
-	}
-
-	path_first = gtk_tree_path_new_first ();
-	gtk_tree_view_expand_row (GTK_TREE_VIEW (priv->signals_list), path_first, FALSE);
-	gtk_tree_path_free (path_first);
-
-	/* DEBUG */
-	{
-		GtkWidget* window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-		GtkWidget* tree = gtk_tree_view_new_with_model (glade_signal_model_new (widget));
-		GtkCellRenderer* renderer = gtk_cell_renderer_text_new ();
-		GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes ("Name",
-		                                                             renderer,
-		                                                             "text", GLADE_SIGNAL_COLUMN_NAME,
-		                                                             NULL);
-		gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
-
-		gtk_container_add (GTK_CONTAINER (window), tree);
-		gtk_widget_show_all (window);
-	}
-}
-
-static void
-glade_signal_editor_get_property  (GObject      *object,
-				   guint         prop_id,
-				   GValue *value,
-				   GParamSpec   *pspec)
-{
-	GladeSignalEditor *self = GLADE_SIGNAL_EDITOR (object);
-	GladeSignalEditorPrivate *priv = self->priv;
-
-	switch (prop_id)
-	{
-	case PROP_HANDLER_COLUMN:
-		g_value_set_object (value, priv->handler_column);
-		break;
-	case PROP_USERDATA_COLUMN:
-		g_value_set_object (value, priv->userdata_column);
-		break;
-	case PROP_HANDLER_COMPLETION:
-		g_value_set_object (value, priv->handler_store);
-		break;
-	case PROP_USERDATA_COMPLETION:
-		g_value_set_object (value, priv->userdata_store);
-		break;
-	case PROP_HANDLER_RENDERER:
-		g_value_set_object (value, priv->handler_renderer);
-		break;
-	case PROP_USERDATA_RENDERER:
-		g_value_set_object (value, priv->userdata_renderer);
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-		break;
-	}
-}
-
-static void
-glade_signal_editor_set_property  (GObject      *object,
-				   guint         prop_id,
-				   const GValue *value,
-				   GParamSpec   *pspec)
-{
-	GladeSignalEditor *self = GLADE_SIGNAL_EDITOR (object);
-	GladeSignalEditorPrivate *priv = self->priv;
-
-	switch (prop_id)
-	{
-	case PROP_HANDLER_COLUMN:
-		priv->handler_column = g_value_get_object (value);
-		break;
-	case PROP_USERDATA_COLUMN:
-		priv->userdata_column = g_value_get_object (value);
-		break;
-	case PROP_HANDLER_COMPLETION:
-		priv->handler_store = g_value_get_object (value);
-		break;
-	case PROP_USERDATA_COMPLETION:
-		priv->userdata_store = g_value_get_object (value);
-		break;
-	case PROP_HANDLER_RENDERER:
-		priv->handler_renderer = g_value_get_object (value);
-		break;
-	case PROP_USERDATA_RENDERER:
-		priv->userdata_renderer = g_value_get_object (value);
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-		break;
-	}
+	priv->model = glade_signal_model_new (widget);
+	gtk_tree_view_set_model (GTK_TREE_VIEW (priv->signal_tree), priv->model);
 }
 
 static void
@@ -1467,10 +130,78 @@ glade_signal_editor_dispose (GObject *object)
 static void
 glade_signal_editor_init (GladeSignalEditor *self)
 {
+	GtkWidget *scroll;
+	GtkCellRenderer* renderer;
+	GtkTreeViewColumn* column;
+
 	self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GLADE_TYPE_SIGNAL_EDITOR, GladeSignalEditorPrivate);
+
+	/* Create signal tree */
+	self->priv->signal_tree = gtk_tree_view_new ();
+
+	/* Create columns */
+	/* Signal name */
+	renderer = gtk_cell_renderer_text_new ();
+	column = gtk_tree_view_column_new_with_attributes (_("Signal"),
+	                                                   renderer,
+	                                                   "text", GLADE_SIGNAL_COLUMN_NAME,
+	                                                   NULL);
+	gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->signal_tree), column);
+
+	/* Signal handler */
+	renderer = gtk_cell_renderer_text_new ();
+	g_object_set (renderer, "foreground", "grey", NULL);
+	column = gtk_tree_view_column_new_with_attributes (_("Handler"),
+	                                                   renderer,
+	                                                   "text", GLADE_SIGNAL_COLUMN_HANDLER,
+	                                                   "visible", GLADE_SIGNAL_COLUMN_IS_HANDLER,
+	                                                   "foreground-set", GLADE_SIGNAL_COLUMN_IS_DUMMY,
+	                                                   NULL);
+	gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->signal_tree), column);
+
+	/* Signal user_data */
+	renderer = gtk_cell_renderer_text_new ();
+	column = gtk_tree_view_column_new_with_attributes (_("User data"),
+	                                                   renderer,
+	                                                   "text", GLADE_SIGNAL_COLUMN_OBJECT,
+	                                                   "visible", GLADE_SIGNAL_COLUMN_IS_HANDLER,
+	                                                   "sensitive", GLADE_SIGNAL_COLUMN_IS_DUMMY, 
+	                                                   NULL);
+	gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->signal_tree), column);
+
+	/* Swap signal */
+	renderer = gtk_cell_renderer_toggle_new ();
+	column = gtk_tree_view_column_new_with_attributes (_("Swap"),
+	                                                   renderer,
+	                                                   "active", GLADE_SIGNAL_COLUMN_SWAP,
+	                                                   "visible", GLADE_SIGNAL_COLUMN_IS_HANDLER,
+	                                                   "sensitive", GLADE_SIGNAL_COLUMN_IS_DUMMY,
+	                                                   NULL);
+	gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->signal_tree), column);
+
+	/* After */
+	renderer = gtk_cell_renderer_toggle_new ();
+	column = gtk_tree_view_column_new_with_attributes (_("After"),
+	                                                   renderer,
+	                                                   "active", GLADE_SIGNAL_COLUMN_AFTER,
+	                                                   "visible", GLADE_SIGNAL_COLUMN_IS_HANDLER,
+	                                                   "sensitive", GLADE_SIGNAL_COLUMN_IS_DUMMY,
+	                                                   NULL);
+	gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->signal_tree), column);
 	
-	self->priv->is_void_handler = is_void_handler;
-	self->priv->is_void_userdata = is_void_userdata;
+	/* Create scrolled window */
+	scroll = gtk_scrolled_window_new (NULL, NULL);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
+					GTK_POLICY_AUTOMATIC,
+					GTK_POLICY_AUTOMATIC);
+	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
+					     GTK_SHADOW_IN);
+	
+	gtk_container_add (GTK_CONTAINER (scroll), self->priv->signal_tree);
+
+	gtk_box_pack_start (GTK_BOX (self), scroll, TRUE, TRUE, 0);
+
+	gtk_widget_show_all (GTK_WIDGET(self));
 }
 
 static void
@@ -1481,210 +212,7 @@ glade_signal_editor_class_init (GladeSignalEditorClass *klass)
 	glade_signal_editor_parent_class = g_type_class_peek_parent (klass);
 
 	object_class = G_OBJECT_CLASS (klass);
-
-	object_class->constructor = glade_signal_editor_constructor;
-	object_class->get_property = glade_signal_editor_get_property;
-	object_class->set_property = glade_signal_editor_set_property;
 	object_class->dispose = glade_signal_editor_dispose;
 
-	g_object_class_install_property (object_class,
-	                                 PROP_HANDLER_COLUMN,
-	                                 g_param_spec_object ("handler-column",
-	                                                      NULL,
-	                                                      NULL,
-	                                                      GTK_TYPE_TREE_VIEW_COLUMN,
-	                                                      G_PARAM_READABLE |
-	                                                      G_PARAM_WRITABLE |
-	                                                      G_PARAM_CONSTRUCT));
-
-	g_object_class_install_property (object_class,
-	                                 PROP_USERDATA_COLUMN,
-	                                 g_param_spec_object ("userdata-column",
-	                                                      NULL,
-	                                                      NULL,
-	                                                      GTK_TYPE_TREE_VIEW_COLUMN,
-	                                                      G_PARAM_READABLE |
-	                                                      G_PARAM_WRITABLE |
-	                                                      G_PARAM_CONSTRUCT));
-
-	g_object_class_install_property (object_class,
-	                                 PROP_HANDLER_COMPLETION,
-	                                 g_param_spec_object ("handler-completion",
-	                                                      NULL,
-	                                                      NULL,
-	                                                      GTK_TYPE_TREE_MODEL,
-	                                                      G_PARAM_READABLE |
-	                                                      G_PARAM_WRITABLE |
-	                                                      G_PARAM_CONSTRUCT));
-
-	g_object_class_install_property (object_class,
-	                                 PROP_USERDATA_COMPLETION,
-	                                 g_param_spec_object ("userdata-completion",
-	                                                      NULL,
-	                                                      NULL,
-	                                                      GTK_TYPE_TREE_MODEL,
-	                                                      G_PARAM_READABLE |
-	                                                      G_PARAM_WRITABLE |
-	                                                      G_PARAM_CONSTRUCT));
-
-	g_object_class_install_property (object_class,
-	                                 PROP_HANDLER_RENDERER,
-	                                 g_param_spec_object ("handler-renderer",
-	                                                      NULL,
-	                                                      NULL,
-	                                                      GTK_TYPE_CELL_RENDERER,
-	                                                      G_PARAM_READABLE |
-	                                                      G_PARAM_WRITABLE |
-	                                                      G_PARAM_CONSTRUCT));
-
-	g_object_class_install_property (object_class,
-	                                 PROP_USERDATA_RENDERER,
-	                                 g_param_spec_object ("userdata-renderer",
-	                                                      NULL,
-	                                                      NULL,
-	                                                      GTK_TYPE_CELL_RENDERER,
-	                                                      G_PARAM_READABLE |
-	                                                      G_PARAM_WRITABLE |
-	                                                      G_PARAM_CONSTRUCT));
 	g_type_class_add_private (klass, sizeof (GladeSignalEditorPrivate));
 }
-
-static void
-glade_signal_editor_editing_started (GtkEntry *entry, IsVoidFunc callback)
-{
-	if (callback (gtk_entry_get_text (entry)))
-		gtk_entry_set_text (entry, "");
-}
-
-static void
-glade_signal_editor_handler_store_update (GladeSignalEditor *editor,
-					  const gchar *signal_name,
-					  GtkListStore *store)
-{
-	GladeSignalEditorPrivate *priv = editor->priv;
-	
-	const gchar *handlers[] = {"gtk_widget_show",
-				   "gtk_widget_hide",
-				   "gtk_widget_grab_focus",
-				   "gtk_widget_destroy",
-				   "gtk_true",
-				   "gtk_false",
-				   "gtk_main_quit",
-				   NULL};
-
-	GtkTreeIter tmp_iter;
-	gint i;
-	gchar *handler, *signal, *name;
-
-	name = (gchar *) glade_widget_get_name (priv->widget);
-
-	signal = g_strdup (signal_name);
-	glade_util_replace (signal, '-', '_');
-
-	gtk_list_store_clear (store);
-
-	gtk_list_store_append (store, &tmp_iter);
-	handler = g_strdup_printf ("on_%s_%s", name, signal);
-	gtk_list_store_set (store, &tmp_iter, 0, handler, -1);
-	g_free (handler);
-
-	gtk_list_store_append (store, &tmp_iter);
-	handler = g_strdup_printf ("%s_%s_cb", name, signal);
-	gtk_list_store_set (store, &tmp_iter, 0, handler, -1);
-	g_free (handler);
-
-	g_free (signal);
-	for (i = 0; handlers[i]; i++)
-	{
-		gtk_list_store_append (store, &tmp_iter);
-		gtk_list_store_set (store, &tmp_iter, 0, handlers[i], -1);
-	}
-}
-
-static gboolean
-glade_signal_editor_handler_editing_started_default (GladeSignalEditor *editor,
-                                                     gchar *signal_name,
-                                                     GtkTreeIter *iter,
-                                                     GtkCellEditable *editable)
-{
-	GladeSignalEditorPrivate *priv = editor->priv;
-	GtkEntry *entry;
-	GtkEntryCompletion *completion;
-	GtkTreeModel *completion_store = priv->handler_store;
-
-	g_return_val_if_fail (GTK_IS_BIN (editable), FALSE);
-	g_return_val_if_fail (GTK_IS_LIST_STORE (completion_store), FALSE);
-
-	entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (editable)));
-
-	glade_signal_editor_editing_started (entry, priv->is_void_handler);
-
-	glade_signal_editor_handler_store_update (editor, signal_name,
-						  GTK_LIST_STORE (completion_store));
-
-	completion = gtk_entry_completion_new ();
-	gtk_entry_completion_set_text_column (completion, 0);
-	gtk_entry_completion_set_inline_completion (completion, TRUE);
-	gtk_entry_completion_set_popup_completion (completion, FALSE);
-	gtk_entry_completion_set_model (completion, completion_store);
-	gtk_entry_set_completion (entry, completion);
-
-	return FALSE;
-}
-
-static void
-glade_signal_editor_userdata_store_update (GladeSignalEditor *self,
-					   GtkListStore *store)
-{
-	GtkTreeIter tmp_iter;
-	GList *list;
-
-	GladeSignalEditorPrivate *priv = self->priv;
-
-	gtk_list_store_clear (store);
-
-	for (list = (GList *) glade_project_get_objects (priv->widget->project);
-	     list && list->data;
-	     list = g_list_next (list))
-	{
-		GladeWidget *widget = glade_widget_get_from_gobject (list->data);
-
-		if (widget)
-		{
-			gtk_list_store_append (store, &tmp_iter);
-			gtk_list_store_set (store, &tmp_iter, 0, widget->name, -1);
-		}
-	}
-
-	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), 0,
-					      GTK_SORT_DESCENDING);
-}
-
-static gboolean
-glade_signal_editor_userdata_editing_started_default (GladeSignalEditor *editor,
-                                                      gchar *signal_name,
-                                                      GtkTreeIter *iter,
-                                                      GtkCellEditable *editable)
-{
-	GtkEntry *entry;
-	GtkEntryCompletion *completion;
-	GladeSignalEditorPrivate *priv = editor->priv;
-	GtkTreeModel *completion_store = priv->userdata_store;
-	
-	g_return_val_if_fail (priv->widget != NULL, FALSE);
-	g_return_val_if_fail (GTK_IS_LIST_STORE (completion_store), FALSE);
-	g_return_val_if_fail (GTK_IS_ENTRY (editable), FALSE);
-
-	entry = GTK_ENTRY (editable);
-
-	glade_signal_editor_editing_started (entry, priv->is_void_handler);
-
-	glade_signal_editor_userdata_store_update (editor, GTK_LIST_STORE (completion_store));
-
-	completion = gtk_entry_completion_new ();
-	gtk_entry_completion_set_text_column (completion, 0);
-	gtk_entry_completion_set_model (completion, completion_store);
-	gtk_entry_set_completion (entry, completion);
-
-	return FALSE;
-}
diff --git a/gladeui/glade-signal-editor.h b/gladeui/glade-signal-editor.h
index 8a8ef2d..6efd69b 100644
--- a/gladeui/glade-signal-editor.h
+++ b/gladeui/glade-signal-editor.h
@@ -35,9 +35,7 @@ struct _GladeSignalEditorClass
 
 GType glade_signal_editor_get_type (void) G_GNUC_CONST;
 
-GladeSignalEditor *glade_signal_editor_new (gpointer *editor);
-
-void glade_signal_editor_construct_signals_list (GladeSignalEditor *editor);
+GladeSignalEditor *glade_signal_editor_new (void);
 
 void glade_signal_editor_load_widget (GladeSignalEditor *editor, GladeWidget *widget);
 
diff --git a/gladeui/glade-signal-model.c b/gladeui/glade-signal-model.c
index da97fbf..a4e5513 100644
--- a/gladeui/glade-signal-model.c
+++ b/gladeui/glade-signal-model.c
@@ -25,6 +25,8 @@ struct _GladeSignalModelPrivate
 	GladeWidget *widget;
 	GList* widgets; /* names of the widgets that this widgets derives from and that have signals */
 	gint stamp;
+
+	GHashTable* dummy_signals;
 };
 
 enum
@@ -43,6 +45,9 @@ static void
 glade_signal_model_init (GladeSignalModel *object)
 {
 	object->priv = G_TYPE_INSTANCE_GET_PRIVATE (object, GLADE_TYPE_SIGNAL_MODEL, GladeSignalModelPrivate);
+
+	object->priv->dummy_signals = 
+		g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify) glade_signal_free);
 }
 
 static void
@@ -55,7 +60,7 @@ glade_signal_model_create_widget_list (GladeSignalModel* sig_model)
 		GladeSignalClass *signal = (GladeSignalClass *) list->data;
 		if (!g_list_find_custom (sig_model->priv->widgets, signal->type, (GCompareFunc) strcmp))
 		{
-			sig_model->priv->widgets = g_list_prepend (sig_model->priv->widgets, signal->type);
+			sig_model->priv->widgets = g_list_prepend (sig_model->priv->widgets, (gpointer) signal->type);
 		}
 	}
 	sig_model->priv->widgets = g_list_reverse (sig_model->priv->widgets);
@@ -66,6 +71,7 @@ glade_signal_model_finalize (GObject *object)
 {
 	GladeSignalModel* sig_model = GLADE_SIGNAL_MODEL (object);
 	g_list_free (sig_model->priv->widgets);
+	g_hash_table_destroy (sig_model->priv->dummy_signals);
 	G_OBJECT_CLASS (glade_signal_model_parent_class)->finalize (object);
 }
 
@@ -174,6 +180,8 @@ glade_signal_model_get_column_type (GtkTreeModel* model,
 			return G_TYPE_BOOLEAN;
 		case GLADE_SIGNAL_COLUMN_IS_HANDLER:
 			return G_TYPE_BOOLEAN;
+		case GLADE_SIGNAL_COLUMN_IS_DUMMY:
+			return G_TYPE_BOOLEAN;
 		default:
 			g_assert_not_reached();
 			return G_TYPE_NONE;
@@ -182,11 +190,43 @@ glade_signal_model_get_column_type (GtkTreeModel* model,
 
 enum
 {
-	ITER_WIDGET = 1,
-	ITER_SIGNAL = 2,
-	ITER_HANDLER = 3
+	ITER_WIDGET = 0,
+	ITER_SIGNAL = 1,
+	ITER_HANDLER = 2
 };
 
+static GladeSignal*
+glade_signal_model_get_dummy_handler (GladeSignalModel* model, GladeSignalClass* sig_class)
+{
+	GladeSignal* signal;
+
+	signal = g_hash_table_lookup (model->priv->dummy_signals, sig_class->name);
+
+	if (!signal)
+	{
+		signal = glade_signal_new (sig_class->name,
+		                           "<Handler>",
+		                           "",
+		                           FALSE,
+		                           FALSE);
+		g_hash_table_insert (model->priv->dummy_signals, (gpointer) sig_class->name, signal);
+	}
+	return signal;
+}
+
+static gboolean
+glade_signal_model_is_dummy_handler (GladeSignalModel* model, 
+                                     GtkTreeIter* iter)
+{
+	const gchar* widget = iter->user_data;
+	GladeSignalClass* sig_class = iter->user_data2;
+	GladeSignal* handler = iter->user_data3;
+
+	if (widget && sig_class && handler)
+		return handler == glade_signal_model_get_dummy_handler (model,
+		                                                       sig_class);
+	return FALSE;
+}
 
 static void
 glade_signal_model_create_widget_iter (GladeSignalModel* sig_model,
@@ -230,7 +270,7 @@ static GList* glade_signal_model_create_signal_list (GladeSignalModel* sig_model
 	     signals = g_list_next (signals))
 	{
 		GladeSignalClass* sig_class = signals->data;
-		if (g_str_equal (sig_class->name, widget))
+		if (g_str_equal (sig_class->type, widget))
 		{
 			widget_signals = g_list_append (widget_signals, sig_class);
 		}
@@ -246,8 +286,6 @@ glade_signal_model_get_iter (GtkTreeModel* model,
 	gint* indices;
 	gint depth;
 	GladeSignalModel* sig_model;
-
-	g_message ("Get Iter: %s", gtk_tree_path_to_string (path));
 	
 	g_return_val_if_fail (path != NULL, FALSE);
 	g_return_val_if_fail (iter != NULL, FALSE);
@@ -259,7 +297,7 @@ glade_signal_model_get_iter (GtkTreeModel* model,
 
 	switch (depth)
 	{
-		case ITER_WIDGET:
+		case 1:
 		/* Widget */
 		{
 			glade_signal_model_create_widget_iter (sig_model,
@@ -268,7 +306,7 @@ glade_signal_model_get_iter (GtkTreeModel* model,
 			                                       iter);
 			return TRUE;
 		}
-		case ITER_SIGNAL:
+		case 2:
 		/* Signal */
 		{
 			const gchar* widget = g_list_nth_data (sig_model->priv->widgets,
@@ -285,7 +323,7 @@ glade_signal_model_get_iter (GtkTreeModel* model,
 			}
 			return FALSE;
 		}
-		case ITER_HANDLER:
+		case 3:
 		/* Handler */
 		{
 			GPtrArray* handlers;
@@ -298,7 +336,7 @@ glade_signal_model_get_iter (GtkTreeModel* model,
 				GladeSignalClass* signal = g_list_nth_data (signals, indices[ITER_SIGNAL]);
 				handlers = g_hash_table_lookup (sig_model->priv->widget->signals,
 					                            signal->name);
-				if (indices[ITER_HANDLER] < handlers->len)
+				if (handlers && indices[ITER_HANDLER] < handlers->len)
 				{
 					GladeSignal* handler =
 						(GladeSignal*) g_ptr_array_index (handlers, indices[ITER_HANDLER]);
@@ -307,7 +345,15 @@ glade_signal_model_get_iter (GtkTreeModel* model,
 							                                handler, iter);
 					return TRUE;
 				}
-				g_list_free (signals);
+				else if ((!handlers && indices[ITER_HANDLER] == 0) || indices[ITER_HANDLER] == handlers->len)
+				{
+					GladeSignal *handler = 
+						glade_signal_model_get_dummy_handler (sig_model, signal);
+					glade_signal_model_create_handler_iter (sig_model, widget, 
+					                                        signal,
+					                                        handler, iter);
+					return TRUE;
+				}
 			}
 			return FALSE;
 		}
@@ -338,8 +384,6 @@ glade_signal_model_get_path (GtkTreeModel* model,
 	GladeSignalClass* sig_class = iter->user_data2;
 	GladeSignal* handler = iter->user_data3;
 	GladeSignalModel* sig_model = GLADE_SIGNAL_MODEL (model);
-
-	g_message (__FUNCTION__);
 	
 	if (handler)
 	{
@@ -354,9 +398,20 @@ glade_signal_model_get_path (GtkTreeModel* model,
 
 		handlers = g_hash_table_lookup (sig_model->priv->widget->signals,
 			                            sig_class->name);
-		
-		index2 = g_ptr_array_find (handlers, handler);
 
+		if (handler == glade_signal_model_get_dummy_handler (sig_model,
+		                                                     sig_class))
+		{
+			if (handlers)
+				index2 = handlers->len;
+			else
+				index2 = 0;
+		}
+		else if (handlers)
+			index2 = g_ptr_array_find (handlers, handler);
+		else
+			g_assert_not_reached();
+		
 		g_list_free (signals);
 		return gtk_tree_path_new_from_indices (index0, index1, index2, -1);
 	}
@@ -394,7 +449,10 @@ glade_signal_model_get_value (GtkTreeModel* model,
 	GladeSignalClass* sig_class = iter->user_data2;
 	GladeSignal* handler = iter->user_data3;
 
-	g_message (__FUNCTION__);
+	GladeSignalModel* sig_model = GLADE_SIGNAL_MODEL (model);
+	
+	value = g_value_init (value, 
+	                      glade_signal_model_get_column_type (model, column));
 	
 	switch (column)
 	{
@@ -405,7 +463,7 @@ glade_signal_model_get_value (GtkTreeModel* model,
 		case GLADE_SIGNAL_COLUMN_NAME:
 			if (widget && sig_class && handler)
 				g_value_set_static_string (value,
-				                           handler->name);
+				                           "");
 			else if (widget && sig_class)
 				g_value_set_static_string (value,
 				                           sig_class->name);
@@ -418,33 +476,46 @@ glade_signal_model_get_value (GtkTreeModel* model,
 				g_value_set_static_string (value,
 				                           handler->handler);
 			else 
-				g_assert_not_reached();
+				g_value_set_static_string (value,
+				                           "");
 			break;
 		case GLADE_SIGNAL_COLUMN_OBJECT:
 			if (widget && sig_class && handler)
 				g_value_set_static_string (value,
 				                           handler->userdata);
 			else 
-				g_assert_not_reached();
+				g_value_set_static_string (value,
+				                           "");
 			break;
 		case GLADE_SIGNAL_COLUMN_SWAP:
 			if (widget && sig_class && handler)
 				g_value_set_boolean (value,
 				                     handler->swapped);
 			else 
-				g_assert_not_reached();
+				g_value_set_boolean (value,
+				                     FALSE);
 			break;
 		case GLADE_SIGNAL_COLUMN_AFTER:
 			if (widget && sig_class && handler)
 				g_value_set_boolean (value,
 				                     handler->after);
 			else 
-				g_assert_not_reached();
+				g_value_set_boolean (value,
+				                     FALSE);
 			break;
 		case GLADE_SIGNAL_COLUMN_IS_HANDLER:
 			g_value_set_boolean (value,
 			                     widget && sig_class && handler);
 			break;
+		case GLADE_SIGNAL_COLUMN_IS_LABEL:
+			g_value_set_boolean (value,
+			                     !(widget && sig_class && handler));
+			break;
+		case GLADE_SIGNAL_COLUMN_IS_DUMMY:
+			g_value_set_boolean (value,
+				                 glade_signal_model_is_dummy_handler (sig_model,
+				                                                      iter));
+			break;
 		default:
 			g_assert_not_reached();
 	}
@@ -461,18 +532,37 @@ glade_signal_model_iter_next (GtkTreeModel* model,
 	GladeSignalModel* sig_model = GLADE_SIGNAL_MODEL (model);
 	GladeSignalClass* sig_class = iter->user_data2;
 	const gchar* widget = iter->user_data;
+	GtkTreeIter parent;
+
+	gtk_tree_model_iter_parent (model, &parent, iter);		
 
-	g_message (__FUNCTION__);
 	
 	if (handler)
 	{
 		GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->widget->signals,
 		                                           sig_class->name);
-		gint new_index = g_ptr_array_find (handlers, handler) + 1;
-		if (new_index < handlers->len)
+		GladeSignal* dummy = glade_signal_model_get_dummy_handler (sig_model,
+		                                                           sig_class);
+		if (handler == dummy)
+		{
+			return FALSE;
+		}
+		else if (handlers)
 		{
-			GladeSignal* new_handler = g_ptr_array_index (handlers, new_index);
-			iter->user_data3 = new_handler;
+			gint new_index = g_ptr_array_find (handlers, handler) + 1;
+			if (new_index > 0)
+			{
+				gtk_tree_model_iter_nth_child (model, iter, &parent, new_index);
+				return TRUE;
+			}
+		}
+		else
+		{
+			glade_signal_model_create_handler_iter (sig_model,
+			                                        widget,
+			                                        sig_class,
+			                                        dummy,
+			                                        iter);
 			return TRUE;
 		}
 	}
@@ -480,16 +570,16 @@ glade_signal_model_iter_next (GtkTreeModel* model,
 	{
 		GList* signals = glade_signal_model_create_signal_list (sig_model,
 		                                                        widget);
+		
 		gint new_index = g_list_index (signals, sig_class) + 1;
-		if ((iter->user_data2 = g_list_nth_data (signals, new_index)))
-		    return TRUE;
+		return gtk_tree_model_iter_nth_child (model, iter, &parent, new_index);
 	}
 	else if (widget)
 	{
 		gint new_index = g_list_index (sig_model->priv->widgets,
 		                               widget) + 1;
-		if ((iter->user_data = g_list_nth_data (sig_model->priv->widgets, new_index)))
-		    return TRUE;
+		
+		return gtk_tree_model_iter_nth_child (model, iter, NULL, new_index);
 	}
 	iter->user_data = NULL;
 	iter->user_data2 = NULL;
@@ -509,8 +599,6 @@ glade_signal_model_iter_n_children (GtkTreeModel* model,
 	GladeSignalModel* sig_model = GLADE_SIGNAL_MODEL (model);
 	GladeSignalClass* sig_class = iter->user_data2;
 	const gchar* widget = iter->user_data;
-
-	g_message (__FUNCTION__);
 	
 	if (handler)
 	{
@@ -518,18 +606,19 @@ glade_signal_model_iter_n_children (GtkTreeModel* model,
 	}
 	else if (sig_class)
 	{
+		gint children = 0;
 		GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->widget->signals,
 		                                           sig_class->name);
 		if (handlers)
-			return handlers->len;
-		else
-			return 0;
+			children = handlers->len;
+		return children + 1;
 	}
 	else if (widget)
 	{
 		GList* signals = glade_signal_model_create_signal_list (sig_model,
 		                                                        widget);
 		gint retval = g_list_length (signals);
+		
 		g_list_free (signals);
 		return retval;
 	}
@@ -542,7 +631,7 @@ glade_signal_model_iter_has_child (GtkTreeModel* model,
 {
 	g_return_val_if_fail (iter != NULL, FALSE);
 	g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
-
+	
 	return (glade_signal_model_iter_n_children (model, iter) != 0);
 }
 
@@ -555,12 +644,10 @@ glade_signal_model_iter_nth_child (GtkTreeModel* model,
 	g_return_val_if_fail (iter != NULL, FALSE);
 	g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), 0);
 
-	GladeSignal* handler = parent ? parent->user_data3 : NULL;
 	GladeSignalModel* sig_model = GLADE_SIGNAL_MODEL (model);
+	GladeSignal* handler = parent ? parent->user_data3 : NULL;
 	GladeSignalClass* sig_class = parent ? parent->user_data2 : NULL;
 	const gchar* widget = parent ? parent->user_data : NULL;
-
-	g_message (__FUNCTION__);
 	
 	if (handler)
 	{
@@ -570,15 +657,26 @@ glade_signal_model_iter_nth_child (GtkTreeModel* model,
 	{
 		GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->widget->signals,
 		                                           sig_class->name);
-		if (n < handlers->len)
+
+		if (handlers)
+		{
+			if (n < handlers->len)
+			{
+				glade_signal_model_create_handler_iter (sig_model, widget, sig_class,
+					                                    g_ptr_array_index (handlers, n),
+			    		                                iter);
+				return TRUE;
+			}
+		}
+		if (!handlers || handlers->len == n)
 		{
 			glade_signal_model_create_handler_iter (sig_model, widget, sig_class,
-			                                        g_ptr_array_index (handlers, n),
+					                                glade_signal_model_get_dummy_handler (sig_model,
+					                                                                      sig_class),
 			                                        iter);
 			return TRUE;
 		}
-		else
-			return FALSE;
+		return FALSE;
 	}
 	else if (widget)
 	{
@@ -597,10 +695,10 @@ glade_signal_model_iter_nth_child (GtkTreeModel* model,
 	}
 	else
 	{
-		if (sig_model->priv->widgets)
+		if (g_list_length (sig_model->priv->widgets) > n)
 		{
 			glade_signal_model_create_widget_iter (sig_model,
-			                                       sig_model->priv->widgets->data,
+			                                       g_list_nth_data (sig_model->priv->widgets, n),
 			                                       iter);
 			return TRUE;
 		}
@@ -622,12 +720,13 @@ glade_signal_model_iter_parent (GtkTreeModel* model,
                                 GtkTreeIter* child)
 {
 	g_return_val_if_fail (iter != NULL, FALSE);
+	g_return_val_if_fail (child != NULL, FALSE);
 	g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
-
-	GladeSignal* handler = iter->user_data3;
+	
 	GladeSignalModel* sig_model = GLADE_SIGNAL_MODEL (model);
-	GladeSignalClass* sig_class = iter->user_data2;
-	const gchar* widget = iter->user_data;
+	GladeSignal* handler = child->user_data3;
+	GladeSignalClass* sig_class = child->user_data2;
+	const gchar* widget = child->user_data;
 
 	if (handler)
 	{
diff --git a/gladeui/glade-signal-model.h b/gladeui/glade-signal-model.h
index 3fbd60f..3eb10ab 100644
--- a/gladeui/glade-signal-model.h
+++ b/gladeui/glade-signal-model.h
@@ -38,13 +38,15 @@ typedef struct _GladeSignalModelPrivate GladeSignalModelPrivate;
 
 typedef enum
 {
-	GLADE_SIGNAL_COLUMN_VERSION_WARNING,
 	GLADE_SIGNAL_COLUMN_NAME,
 	GLADE_SIGNAL_COLUMN_HANDLER,
 	GLADE_SIGNAL_COLUMN_OBJECT,
 	GLADE_SIGNAL_COLUMN_SWAP,
 	GLADE_SIGNAL_COLUMN_AFTER,
 	GLADE_SIGNAL_COLUMN_IS_HANDLER,
+	GLADE_SIGNAL_COLUMN_IS_LABEL,
+	GLADE_SIGNAL_COLUMN_IS_DUMMY,
+	GLADE_SIGNAL_COLUMN_VERSION_WARNING,
 	GLADE_SIGNAL_N_COLUMNS
 } GladeSignalModelColumns;
 



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