* gladeui/glade-signal-model.[ch]:

	  - Fixed indentation
	  - Relicense as LGPL as Johannes Schmid said that was ok.

3 files changed, 704 insertions, 702 deletions

diff --git a/ChangeLog b/ChangeLog
index 55dee144..0c05e04e 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2011-01-10  Tristan Van Berkom <tristanvb@openismus.com>
+
+	* gladeui/glade-signal-model.[ch]:
+	  - Fixed indentation
+	  - Relicense as LGPL as Johannes Schmid said that was ok.
+
 2011-01-09  Tristan Van Berkom <tristanvb@openismus.com>
 
 	* gladeui/glade-design-layout.c: Fixed to not hide widgets when removing
diff --git a/gladeui/glade-signal-model.c b/gladeui/glade-signal-model.c
index 4b3dcd45..b2fccd44 100644
--- a/gladeui/glade-signal-model.c
+++ b/gladeui/glade-signal-model.c
@@ -1,19 +1,20 @@
 /*
  * glade3
  * Copyright (C) Johannes Schmid 2010 <jhs@gnome.org>
-	 * 
- * glade3 is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
-	 * 
- * glade3 is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU General Public License for more details.
  * 
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * This library is free software; you can redistribute it and/or it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public 
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifdef HAVE_CONFIG_H
 #include <config.h>
@@ -32,33 +33,29 @@
 
 struct _GladeSignalModelPrivate
 {
-	GladeWidget *widget;
-	GList* widgets; /* names of the widgets that this widgets derives from and that have signals */
-	gint stamp;
+  GladeWidget *widget;
+  GList       *widgets; /* names of the widgets that this widgets derives from and that have signals */
+  gint         stamp;
 
-	GHashTable* dummy_signals;
-	GHashTable* signals; /* signals of the widget */
+  GHashTable  *dummy_signals;
+  GHashTable  *signals; /* signals of the widget */
 };
 
 enum
 {
-	PROP_0,
-	PROP_WIDGET,
-	PROP_SIGNALS
+  PROP_0,
+  PROP_WIDGET,
+  PROP_SIGNALS
 };
 
 static void gtk_tree_model_iface_init (GtkTreeModelIface* iface);
 static void gtk_tree_drag_source_iface_init (GtkTreeDragSourceIface* iface);
-
-static void
-on_glade_signal_model_added (GladeWidget* widget, const GladeSignal* signal,
-                             GladeSignalModel* model);
-static void
-on_glade_signal_model_removed (GladeWidget* widget, const GladeSignal* signal,
-                               GladeSignalModel* model);
-static void
-on_glade_signal_model_changed (GladeWidget* widget, const GladeSignal* signal,
-                               GladeSignalModel* model);	
+static void on_glade_signal_model_added (GladeWidget* widget, const GladeSignal* signal,
+					 GladeSignalModel* model);
+static void on_glade_signal_model_removed (GladeWidget* widget, const GladeSignal* signal,
+					   GladeSignalModel* model);
+static void on_glade_signal_model_changed (GladeWidget* widget, const GladeSignal* signal,
+					   GladeSignalModel* model);	
 
 G_DEFINE_TYPE_WITH_CODE (GladeSignalModel, glade_signal_model, G_TYPE_OBJECT,
                          G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
@@ -69,134 +66,136 @@ G_DEFINE_TYPE_WITH_CODE (GladeSignalModel, glade_signal_model, G_TYPE_OBJECT,
 static gint
 g_ptr_array_find (GPtrArray* array, gpointer data)
 {
-	gint i;
-	for (i = 0; i < array->len; i++)
-	{
-		if (array->pdata[i] == data)
-			return i;
-	}
-	return -1;
+  gint i;
+  for (i = 0; i < array->len; i++)
+    {
+      if (array->pdata[i] == data)
+	return i;
+    }
+  return -1;
 }
 
 static void
 glade_signal_model_init (GladeSignalModel *object)
 {
-	object->priv = G_TYPE_INSTANCE_GET_PRIVATE (object, GLADE_TYPE_SIGNAL_MODEL, GladeSignalModelPrivate);
+  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) g_object_unref);
+  object->priv->dummy_signals = 
+    g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify) g_object_unref);
 }
 
 static void
 glade_signal_model_create_widget_list (GladeSignalModel* sig_model)
 {
-	const GList* list;
-	GladeWidget *widget = sig_model->priv->widget;
-	GladeWidgetAdaptor *adaptor = glade_widget_get_adaptor (widget);
+  const GList* list;
+  GladeWidget *widget = sig_model->priv->widget;
+  GladeWidgetAdaptor *adaptor = glade_widget_get_adaptor (widget);
 
-	for (list = glade_widget_adaptor_get_signals (adaptor);
-	     list != NULL; list = g_list_next (list))
-	{
-		GladeSignalClass *signal = (GladeSignalClass *) list->data;
+  for (list = glade_widget_adaptor_get_signals (adaptor);
+       list != NULL; list = g_list_next (list))
+    {
+      GladeSignalClass *signal = (GladeSignalClass *) list->data;
 
-		if (!g_list_find_custom (sig_model->priv->widgets, (gpointer) glade_signal_class_get_type (signal), (GCompareFunc) strcmp))
-		{
-			sig_model->priv->widgets = g_list_prepend (sig_model->priv->widgets, (gpointer) glade_signal_class_get_type (signal));
-		}
+      if (!g_list_find_custom (sig_model->priv->widgets, 
+			       (gpointer) glade_signal_class_get_type (signal), (GCompareFunc) strcmp))
+	{
+	  sig_model->priv->widgets = 
+	    g_list_prepend (sig_model->priv->widgets, (gpointer) glade_signal_class_get_type (signal));
 	}
-	sig_model->priv->widgets = g_list_reverse (sig_model->priv->widgets);
+    }
+  sig_model->priv->widgets = g_list_reverse (sig_model->priv->widgets);
 }
 
 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);
-	G_OBJECT_CLASS (glade_signal_model_parent_class)->finalize (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);
 }
 
 static void
 glade_signal_model_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 {
-	GladeSignalModel* sig_model;
-
-	g_return_if_fail (GLADE_IS_SIGNAL_MODEL (object));
-
-	sig_model = GLADE_SIGNAL_MODEL (object);
-
-	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);			
-			break;
-		case PROP_SIGNALS:
-			sig_model->priv->signals = g_value_get_pointer (value);
-			break;
-		default:
-			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-			break;
-	}
+  GladeSignalModel* sig_model;
+
+  g_return_if_fail (GLADE_IS_SIGNAL_MODEL (object));
+
+  sig_model = GLADE_SIGNAL_MODEL (object);
+
+  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);			
+      break;
+    case PROP_SIGNALS:
+      sig_model->priv->signals = g_value_get_pointer (value);
+      break;
+    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)
 {
-	GladeSignalModel* sig_model;
+  GladeSignalModel* sig_model;
 
-	g_return_if_fail (GLADE_IS_SIGNAL_MODEL (object));
+  g_return_if_fail (GLADE_IS_SIGNAL_MODEL (object));
 
-	sig_model = GLADE_SIGNAL_MODEL (object);
+  sig_model = GLADE_SIGNAL_MODEL (object);
 
-	switch (prop_id)
-	{
-		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);
-			break;
-		default:
-			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-			break;
-	}
+  switch (prop_id)
+    {
+    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);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
 }
 
 static void
 glade_signal_model_class_init (GladeSignalModelClass *klass)
 {
-	GObjectClass* object_class = G_OBJECT_CLASS (klass);
+  GObjectClass* object_class = G_OBJECT_CLASS (klass);
 
-	g_type_class_add_private (klass, sizeof (GladeSignalModelPrivate));
+  g_type_class_add_private (klass, sizeof (GladeSignalModelPrivate));
 
-	object_class->finalize = glade_signal_model_finalize;
-	object_class->set_property = glade_signal_model_set_property;
-	object_class->get_property = glade_signal_model_get_property;
+  object_class->finalize = glade_signal_model_finalize;
+  object_class->set_property = glade_signal_model_set_property;
+  object_class->get_property = glade_signal_model_get_property;
 
-	g_object_class_install_property (object_class,
-	                                 PROP_WIDGET,
-	                                 g_param_spec_object ("widget",
-	                                                      "A GladeWidget",
-	                                                      "The GladeWidget used to query the signals",
-	                                                      GLADE_TYPE_WIDGET,
-	                                                      G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE));
-	g_object_class_install_property (object_class,
-	                                 PROP_SIGNALS,
-	                                 g_param_spec_pointer ("signals",
-	                                                       "A GHashTable containing the widget signals",
-	                                                       "Use to query signals",
-	                                                       G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE));
+  g_object_class_install_property (object_class,
+				   PROP_WIDGET,
+				   g_param_spec_object ("widget",
+							"A GladeWidget",
+							"The GladeWidget used to query the signals",
+							GLADE_TYPE_WIDGET,
+							G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE));
+  g_object_class_install_property (object_class,
+				   PROP_SIGNALS,
+				   g_param_spec_pointer ("signals",
+							 "A GHashTable containing the widget signals",
+							 "Use to query signals",
+							 G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE));
 }
 
 /*
@@ -212,91 +211,91 @@ GtkTreeModel*
 glade_signal_model_new (GladeWidget *widget,
                         GHashTable *signals)
 {
-	GObject* object = g_object_new (GLADE_TYPE_SIGNAL_MODEL,
-	                                "widget", widget, 
-	                                "signals", signals, NULL);
-	return GTK_TREE_MODEL (object);
+  GObject* object = g_object_new (GLADE_TYPE_SIGNAL_MODEL,
+				  "widget", widget, 
+				  "signals", signals, NULL);
+  return GTK_TREE_MODEL (object);
 }
 
 static GtkTreeModelFlags
 glade_signal_model_get_flags (GtkTreeModel* model)
 {
-	return 0;
+  return 0;
 }
 
 static gint
 glade_signal_model_get_n_columns (GtkTreeModel* model)
 {
-	return GLADE_SIGNAL_N_COLUMNS;
+  return GLADE_SIGNAL_N_COLUMNS;
 }
 
 static GType
 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;
-	}
+  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;
+    }
 }
 
 enum
 {
-	ITER_WIDGET = 0,
-	ITER_SIGNAL = 1,
+  ITER_WIDGET = 0,
+  ITER_SIGNAL = 1,
 };
 
 static 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));
+  gboolean dummy;
+  dummy = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (signal),
+					      DUMMY_DATA));
 
-	return dummy;
+  return dummy;
 }
 
 static GladeSignal*
 glade_signal_model_get_dummy_handler (GladeSignalModel* model, 
                                       const GladeSignalClass* sig_class)
 {
-	GladeSignal* signal;
+  GladeSignal* signal;
 
-	signal = g_hash_table_lookup (model->priv->dummy_signals, 
-	                              glade_signal_class_get_name (sig_class));
+  signal = g_hash_table_lookup (model->priv->dummy_signals, 
+				glade_signal_class_get_name (sig_class));
 
-	if (!signal)
-	{
-		signal = glade_signal_new (sig_class,
-		                           HANDLER_DEFAULT,
-		                           USERDATA_DEFAULT,
-		                           FALSE,
-		                           FALSE);
-		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), 
-		                     signal);
-	}
-	return signal;
+  if (!signal)
+    {
+      signal = glade_signal_new (sig_class,
+				 HANDLER_DEFAULT,
+				 USERDATA_DEFAULT,
+				 FALSE,
+				 FALSE);
+      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), 
+			   signal);
+    }
+  return signal;
 }
 
 static void
@@ -304,10 +303,10 @@ glade_signal_model_create_widget_iter (GladeSignalModel* sig_model,
                                        const gchar* widget,
                                        GtkTreeIter* iter)
 {
-	iter->stamp = sig_model->priv->stamp;
-	iter->user_data = (gpointer) widget;
-	iter->user_data2 = NULL;
-	iter->user_data3 = NULL;
+  iter->stamp = sig_model->priv->stamp;
+  iter->user_data = (gpointer) widget;
+  iter->user_data2 = NULL;
+  iter->user_data3 = NULL;
 }
 
 static void
@@ -320,88 +319,89 @@ glade_signal_model_create_signal_iter (GladeSignalModel* sig_model,
 	iter->user_data2 = (GladeSignal*) signal;
 }
 
-static GList* glade_signal_model_create_signal_list (GladeSignalModel* sig_model,
-                                                     const gchar* widget_type)
+static GList *
+glade_signal_model_create_signal_list (GladeSignalModel* sig_model,
+				       const gchar* widget_type)
 {
-	GList* widget_signals = NULL;
-	const GList* signals;
-	GladeWidget *widget = sig_model->priv->widget;
-	GladeWidgetAdaptor *adaptor = glade_widget_get_adaptor (widget);
+  GList* widget_signals = NULL;
+  const GList* signals;
+  GladeWidget *widget = sig_model->priv->widget;
+  GladeWidgetAdaptor *adaptor = glade_widget_get_adaptor (widget);
 
-	for (signals = glade_widget_adaptor_get_signals (adaptor);
-	     signals != NULL;
-	     signals = g_list_next (signals))
+  for (signals = glade_widget_adaptor_get_signals (adaptor);
+       signals != NULL;
+       signals = g_list_next (signals))
+    {
+      GladeSignalClass* sig_class = signals->data;
+      if (g_str_equal (glade_signal_class_get_type (sig_class), widget_type))
 	{
-		GladeSignalClass* sig_class = signals->data;
-		if (g_str_equal (glade_signal_class_get_type (sig_class), widget_type))
-		{
-			widget_signals = g_list_append (widget_signals, sig_class);
-		}
+	  widget_signals = g_list_append (widget_signals, sig_class);
 	}
-	return widget_signals;
+    }
+  return widget_signals;
 }
 
 static void
 on_glade_signal_model_added (GladeWidget* widget, const GladeSignal* signal,
                              GladeSignalModel* model)
 {
-	GtkTreeIter iter;	
-	GtkTreePath* path;
-	const GladeSignalClass* sig_class =
-		glade_signal_get_class (signal);
-	glade_signal_model_create_signal_iter (model,
-	                                       glade_signal_class_get_type (sig_class),
-	                                       signal, 
-	                                       &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_path_free (path);
-	model->priv->stamp++;
+  GtkTreeIter iter;	
+  GtkTreePath* path;
+  const GladeSignalClass* sig_class =
+    glade_signal_get_class (signal);
+  glade_signal_model_create_signal_iter (model,
+					 glade_signal_class_get_type (sig_class),
+					 signal, 
+					 &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_path_free (path);
+  model->priv->stamp++;
 }
 
 static void
 on_glade_signal_model_removed (GladeWidget* widget, const GladeSignal* signal,
                                GladeSignalModel* model)
 {
-	GtkTreeIter iter;
-	GtkTreePath* path;
-	const GladeSignalClass* sig_class =
-		glade_signal_get_class (signal);
-	glade_signal_model_create_signal_iter (model,
-	                                       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);
-	gtk_tree_path_free (path);
-	model->priv->stamp++;
+  GtkTreeIter iter;
+  GtkTreePath* path;
+  const GladeSignalClass* sig_class =
+    glade_signal_get_class (signal);
+  glade_signal_model_create_signal_iter (model,
+					 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);
+  gtk_tree_path_free (path);
+  model->priv->stamp++;
 }
 
 static void
 on_glade_signal_model_changed (GladeWidget* widget, const GladeSignal* signal,
                                GladeSignalModel* model)
 {
-	GtkTreeIter iter;
-	GtkTreePath* path;
-	const GladeSignalClass* sig_class =
-		glade_signal_get_class (signal);
-	glade_signal_model_create_signal_iter (model,
-	                                       glade_signal_class_get_type (sig_class),
-	                                       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_path_free (path);
-	model->priv->stamp++;
+  GtkTreeIter iter;
+  GtkTreePath* path;
+  const GladeSignalClass* sig_class =
+    glade_signal_get_class (signal);
+  glade_signal_model_create_signal_iter (model,
+					 glade_signal_class_get_type (sig_class),
+					 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_path_free (path);
+  model->priv->stamp++;
 }
 
 static gboolean
@@ -409,113 +409,111 @@ glade_signal_model_get_iter (GtkTreeModel* model,
                              GtkTreeIter* iter,
                              GtkTreePath* path)
 {
-	gint* indices;
-	gint depth;
-	GladeSignalModel* sig_model;
-
-	g_return_val_if_fail (path != NULL, FALSE);
-	g_return_val_if_fail (iter != NULL, FALSE);
-	g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
-
-	indices = gtk_tree_path_get_indices(path);
-	depth = gtk_tree_path_get_depth (path);
-	sig_model = GLADE_SIGNAL_MODEL (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;
-		}
-	}
-	return FALSE;
+  gint* indices;
+  gint depth;
+  GladeSignalModel* sig_model;
+
+  g_return_val_if_fail (path != NULL, FALSE);
+  g_return_val_if_fail (iter != NULL, FALSE);
+  g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
+
+  indices = gtk_tree_path_get_indices(path);
+  depth = gtk_tree_path_get_depth (path);
+  sig_model = GLADE_SIGNAL_MODEL (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;
+      }
+    }
+  return FALSE;
 }
 
 static GtkTreePath*
 glade_signal_model_get_path (GtkTreeModel* model,
                              GtkTreeIter* iter)
 {
-	const gchar* widget;
-	GladeSignal* handler;
-
-	GladeSignalModel* sig_model;
-
-	g_return_val_if_fail (iter != NULL, NULL);
-	g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), NULL);
-
-	widget = iter->user_data;
-	handler = iter->user_data2;
-	sig_model = GLADE_SIGNAL_MODEL (model);
-
-	if (handler)
-	{
-		/* Signal */
-		const GladeSignalClass* sig_class = glade_signal_get_class (handler);
-		gint index0, index1 = 0;
-		GList* signal;
-		GList* signals = glade_signal_model_create_signal_list (sig_model,
-		                                                        widget);
-
-		index0 = g_list_index (sig_model->priv->widgets,
-		                       widget);
-		
-		for (signal = signals; signal != NULL; signal = g_list_next (signal))
-		{		
-
-			GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
-			                                           glade_signal_class_get_name (signal->data));
-
-			if (signal->data != sig_class)
-			{
-				if (handlers)
-					index1 += handlers->len;
-				index1++; /* dummy_handler */
-			}
-			else
-			{
-				if (handlers)
-				{
-					gint handler_index = g_ptr_array_find (handlers, handler);
-					if (handler_index == -1) /* dummy handler */
-					{
-						index1 += handlers->len;
-					}
-					else
-						index1 += handler_index;
-				}
-				break;
-			}
+  const gchar* widget;
+  GladeSignal* handler;
+  GladeSignalModel* sig_model;
+
+  g_return_val_if_fail (iter != NULL, NULL);
+  g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), NULL);
+
+  widget = iter->user_data;
+  handler = iter->user_data2;
+  sig_model = GLADE_SIGNAL_MODEL (model);
+
+  if (handler)
+    {
+      /* Signal */
+      const GladeSignalClass* sig_class = glade_signal_get_class (handler);
+      gint index0, index1 = 0;
+      GList* signal;
+      GList* signals = glade_signal_model_create_signal_list (sig_model,
+							      widget);
+
+      index0 = g_list_index (sig_model->priv->widgets,
+			     widget);
+
+      for (signal = signals; signal != NULL; signal = g_list_next (signal))
+	{		
+	  GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
+						     glade_signal_class_get_name (signal->data));
+
+	  if (signal->data != sig_class)
+	    {
+	      if (handlers)
+		index1 += handlers->len;
+	      index1++; /* dummy_handler */
+	    }
+	  else
+	    {
+	      if (handlers)
+		{
+		  gint handler_index = g_ptr_array_find (handlers, handler);
+		  if (handler_index == -1) /* dummy handler */
+		    {
+		      index1 += handlers->len;
+		    }
+		  else
+		    index1 += handler_index;
 		}
-		return gtk_tree_path_new_from_indices (index0, index1, -1);
-	}
-	else if (widget)
-	{
-		/* Widget */
-		return gtk_tree_path_new_from_indices (g_list_index (sig_model->priv->widgets,
-		                                                     widget), -1);
+	      break;
+	    }
 	}
-	g_assert_not_reached();
+      return gtk_tree_path_new_from_indices (index0, index1, -1);
+    }
+  else if (widget)
+    {
+      /* Widget */
+      return gtk_tree_path_new_from_indices (g_list_index (sig_model->priv->widgets,
+							   widget), -1);
+    }
+  g_assert_not_reached();
 }
 
 static void
@@ -524,104 +522,103 @@ glade_signal_model_get_value (GtkTreeModel* model,
                               gint column,
                               GValue* value)
 {	
-	const gchar* widget;
-	GladeSignal* handler;
-
-	GladeSignalModel* sig_model;
+  const gchar* widget;
+  GladeSignal* handler;
+  GladeSignalModel* sig_model;
 
-	g_return_if_fail (iter != NULL);
-	g_return_if_fail (GLADE_IS_SIGNAL_MODEL(model));
+  g_return_if_fail (iter != NULL);
+  g_return_if_fail (GLADE_IS_SIGNAL_MODEL(model));
 
-	widget = iter->user_data;
-	handler = iter->user_data2;
-	sig_model = GLADE_SIGNAL_MODEL (model);
+  widget = iter->user_data;
+  handler = iter->user_data2;
+  sig_model = GLADE_SIGNAL_MODEL (model);
 
-	value = g_value_init (value, 
-	                      glade_signal_model_get_column_type (model, column));
+  value = g_value_init (value, 
+			glade_signal_model_get_column_type (model, column));
 
-	switch (column)
+  switch (column)
+    {
+    case GLADE_SIGNAL_COLUMN_NAME:
+      if (handler)
 	{
-		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);
-			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,
-				                           "");
-			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,
-				                           "");
-			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);
-			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);
-			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_SIGNAL:
-			g_value_set_object (value, handler);
-			break;
-		default:
-			g_assert_not_reached();
+	  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);
+      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,
+				   "");
+      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,
+				   "");
+      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);
+      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);
+      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_SIGNAL:
+      g_value_set_object (value, handler);
+      break;
+    default:
+      g_assert_not_reached();
+    }
 }
 
 static gboolean
@@ -630,34 +627,34 @@ glade_signal_model_iter_next_signal (GladeSignalModel* sig_model,
                                      GtkTreeIter* iter,
                                      GList* signal)
 {
-	if (signal->next)
+  if (signal->next)
+    {
+      signal = signal->next;
+      GladeSignal* next_handler;
+      GPtrArray* next_handlers = 
+	g_hash_table_lookup (sig_model->priv->signals,
+			     glade_signal_class_get_name (signal->data));
+      if (next_handlers && next_handlers->len)
 	{
-		signal = signal->next;
-		GladeSignal* next_handler;
-		GPtrArray* next_handlers = 
-			g_hash_table_lookup (sig_model->priv->signals,
-			                     glade_signal_class_get_name (signal->data));
-		if (next_handlers && next_handlers->len)
-		{
-			next_handler = g_ptr_array_index (next_handlers, 0);
-		}
-		else
-		{
-			next_handler = 
-				glade_signal_model_get_dummy_handler (sig_model,
-				                                      signal->data);
-		}
-		glade_signal_model_create_signal_iter (sig_model, widget,
-		                                       next_handler,
-		                                       iter);
-		g_list_free (signal);
-		return TRUE;
+	  next_handler = g_ptr_array_index (next_handlers, 0);
 	}
-	else
+      else
 	{
-		g_list_free (signal);
-		return FALSE;
+	  next_handler = 
+	    glade_signal_model_get_dummy_handler (sig_model,
+						  signal->data);
 	}
+      glade_signal_model_create_signal_iter (sig_model, widget,
+					     next_handler,
+					     iter);
+      g_list_free (signal);
+      return TRUE;
+    }
+  else
+    {
+      g_list_free (signal);
+      return FALSE;
+    }
 }
 
 
@@ -665,131 +662,129 @@ static gboolean
 glade_signal_model_iter_next (GtkTreeModel* model,
                               GtkTreeIter* iter)
 {
-	const gchar* widget;
-	GladeSignal* handler;
-	GtkTreeIter parent;
-
+  const gchar* widget;
+  GladeSignal* handler;
+  GtkTreeIter parent;
+  GladeSignalModel* sig_model;
 
-	GladeSignalModel* sig_model;
+  g_return_val_if_fail (iter != NULL, FALSE);
+  g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
 
-	g_return_val_if_fail (iter != NULL, FALSE);
-	g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), FALSE);
+  widget = iter->user_data;
+  handler = iter->user_data2;
 
-	widget = iter->user_data;
-	handler = iter->user_data2;
+  sig_model = GLADE_SIGNAL_MODEL (model);  
 
-	sig_model = GLADE_SIGNAL_MODEL (model);  
+  gtk_tree_model_iter_parent (model, &parent, iter);		
 
-	gtk_tree_model_iter_parent (model, &parent, iter);		
-
-	if (handler)
+  if (handler)
+    {
+      const GladeSignalClass* sig_class = 
+	glade_signal_get_class (handler);
+      GList* signals = 
+	glade_signal_model_create_signal_list (sig_model,
+					       widget);
+      GList* signal = g_list_find (signals, sig_class);
+      GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
+						 glade_signal_class_get_name (sig_class));
+      if (glade_signal_model_is_dummy_handler (sig_model, handler))
 	{
-		const GladeSignalClass* sig_class = 
-			glade_signal_get_class (handler);
-		GList* signals = 
-			glade_signal_model_create_signal_list (sig_model,
-			                                       widget);
-		GList* signal = g_list_find (signals, sig_class);
-		GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
-		                                           glade_signal_class_get_name (sig_class));
-		if (glade_signal_model_is_dummy_handler (sig_model, handler))
-		{
-			return glade_signal_model_iter_next_signal (sig_model, widget, iter, signal);
-		}
-		else if (handlers)
-		{
-			gint new_index = g_ptr_array_find (handlers, handler) + 1;
-			if (new_index < handlers->len)
-			{
-				glade_signal_model_create_signal_iter (sig_model, widget,
-				                                       g_ptr_array_index (handlers, new_index),
-				                                       iter);
-				g_list_free (signals);
-				return TRUE;
-			}
-			else if (new_index == handlers->len)
-			{
-				glade_signal_model_create_signal_iter (sig_model, widget,
-				                                       glade_signal_model_get_dummy_handler (sig_model,
-				                                                                             sig_class),
-				                                       iter);
-				g_list_free (signals);
-				return TRUE;
-			}
-			else
-			{
-				return glade_signal_model_iter_next_signal (sig_model, widget, iter, signal);
-			}
-		}
-		else
-		{
-			g_list_free (signals);
-			return FALSE;
-		}
+	  return glade_signal_model_iter_next_signal (sig_model, widget, iter, signal);
 	}
-	else if (widget)
+      else if (handlers)
 	{
-		gint new_index = g_list_index (sig_model->priv->widgets,
-		                               widget) + 1;
-
-		return gtk_tree_model_iter_nth_child (model, iter, NULL, new_index);
+	  gint new_index = g_ptr_array_find (handlers, handler) + 1;
+	  if (new_index < handlers->len)
+	    {
+	      glade_signal_model_create_signal_iter (sig_model, widget,
+						     g_ptr_array_index (handlers, new_index),
+						     iter);
+	      g_list_free (signals);
+	      return TRUE;
+	    }
+	  else if (new_index == handlers->len)
+	    {
+	      glade_signal_model_create_signal_iter (sig_model, widget,
+						     glade_signal_model_get_dummy_handler (sig_model,
+											   sig_class),
+						     iter);
+	      g_list_free (signals);
+	      return TRUE;
+	    }
+	  else
+	    {
+	      return glade_signal_model_iter_next_signal (sig_model, widget, iter, signal);
+	    }
+	}
+      else
+	{
+	  g_list_free (signals);
+	  return FALSE;
 	}
-	iter->user_data = NULL;
-	iter->user_data2 = NULL;
-	iter->user_data3 = NULL;
-	iter->stamp = 0;
-	return FALSE;
+    }
+  else if (widget)
+    {
+      gint new_index = g_list_index (sig_model->priv->widgets,
+				     widget) + 1;
+      
+      return gtk_tree_model_iter_nth_child (model, iter, NULL, new_index);
+    }
+  iter->user_data = NULL;
+  iter->user_data2 = NULL;
+  iter->user_data3 = NULL;
+  iter->stamp = 0;
+  return FALSE;
 }
 
 static gint
 glade_signal_model_iter_n_children (GtkTreeModel* model,
                                     GtkTreeIter* iter)
 {
-	GladeSignal* handler;
-	GladeSignalModel* sig_model;
-	const gchar* widget;
-
-	g_return_val_if_fail (iter != NULL, 0);
-	g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), 0);
-
-	handler = iter->user_data2;
-	sig_model = GLADE_SIGNAL_MODEL (model);
-	widget = iter->user_data;
-
-	if (handler)
-	{
-		return 0;
-	}
-	else if (widget)
+  GladeSignal* handler;
+  GladeSignalModel* sig_model;
+  const gchar* widget;
+
+  g_return_val_if_fail (iter != NULL, 0);
+  g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), 0);
+
+  handler = iter->user_data2;
+  sig_model = GLADE_SIGNAL_MODEL (model);
+  widget = iter->user_data;
+
+  if (handler)
+    {
+      return 0;
+    }
+  else if (widget)
+    {
+      GList* signals = glade_signal_model_create_signal_list (sig_model,
+							      widget);
+      GList* signal;
+      gint retval = 0;
+
+      for (signal = signals; signal != NULL; signal = g_list_next (signal))
 	{
-		GList* signals = glade_signal_model_create_signal_list (sig_model,
-		                                                        widget);
-		GList* signal;
-		gint retval = 0;
-
-		for (signal = signals; signal != NULL; signal = g_list_next (signal))
-		{
-			GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
-			                                           glade_signal_class_get_name (signal->data));
-			if (handlers)
-				retval += handlers->len;
-			retval++; 
-		}
-		g_list_free (signals);
-
-		return retval;
+	  GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
+						     glade_signal_class_get_name (signal->data));
+	  if (handlers)
+	    retval += handlers->len;
+	  retval++; 
 	}
-	g_assert_not_reached ();	
+      g_list_free (signals);
+      
+      return retval;
+    }
+  g_assert_not_reached ();	
 }
 
 static gboolean
 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);
+  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);
+  return (glade_signal_model_iter_n_children (model, iter) != 0);
 }
 
 static gboolean
@@ -798,71 +793,71 @@ glade_signal_model_iter_nth_child (GtkTreeModel* model,
                                    GtkTreeIter* parent,
                                    gint n)
 {
-	GladeSignal* handler;
-	GladeSignalModel* sig_model;
-	const gchar* widget;
-
-	g_return_val_if_fail (iter != NULL, 0);
-	g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), 0);
-
-	handler = parent ? parent->user_data2 : NULL;
-	sig_model = GLADE_SIGNAL_MODEL (model);
-	widget = parent ? parent->user_data : NULL;
-
-	if (handler)
+  GladeSignal* handler;
+  GladeSignalModel* sig_model;
+  const gchar* widget;
+
+  g_return_val_if_fail (iter != NULL, 0);
+  g_return_val_if_fail (GLADE_IS_SIGNAL_MODEL(model), 0);
+
+  handler = parent ? parent->user_data2 : NULL;
+  sig_model = GLADE_SIGNAL_MODEL (model);
+  widget = parent ? parent->user_data : NULL;
+
+  if (handler)
+    {
+      return FALSE;
+    }
+  else if (widget)
+    {
+      GList* signals = glade_signal_model_create_signal_list (sig_model,
+							      widget);
+      GList* signal;
+      for (signal = signals; signal != NULL; signal = g_list_next (signal))
 	{
-		return FALSE;
-	}
-	else if (widget)
-	{
-		GList* signals = glade_signal_model_create_signal_list (sig_model,
-		                                                        widget);
-		GList* signal;
-		for (signal = signals; signal != NULL; signal = g_list_next (signal))
+	  GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
+						     glade_signal_class_get_name (signal->data));
+	  if (handlers)
+	    {
+	      if (n >= handlers->len)
+		n -= handlers->len;
+	      else
 		{
-			GPtrArray* handlers = g_hash_table_lookup (sig_model->priv->signals,
-			                                           glade_signal_class_get_name (signal->data));
-			if (handlers)
-			{
-				if (n >= handlers->len)
-					n -= handlers->len;
-				else
-				{
-					glade_signal_model_create_signal_iter (sig_model,
-					                                       widget,
-					                                       g_ptr_array_index (handlers, n),
-					                                       iter);
-					g_list_free (signals);
-					return TRUE;
-				}
-			}
-			if (n == 0)
-			{
-				GladeSignal* handler =
-					glade_signal_model_get_dummy_handler (sig_model,
-					                                      signal->data);
-				glade_signal_model_create_signal_iter (sig_model,
-				                                       widget,
-				                                       handler,
-				                                       iter);
-				g_list_free (signals);
-				return TRUE;
-			}
-			n--;
+		  glade_signal_model_create_signal_iter (sig_model,
+							 widget,
+							 g_ptr_array_index (handlers, n),
+							 iter);
+		  g_list_free (signals);
+		  return TRUE;
 		}
-		return FALSE;
+	    }
+	  if (n == 0)
+	    {
+	      GladeSignal* handler =
+		glade_signal_model_get_dummy_handler (sig_model,
+						      signal->data);
+	      glade_signal_model_create_signal_iter (sig_model,
+						     widget,
+						     handler,
+						     iter);
+	      g_list_free (signals);
+	      return TRUE;
+	    }
+	  n--;
 	}
-	else
+      return FALSE;
+    }
+  else
+    {
+      if (g_list_length (sig_model->priv->widgets) > n)
 	{
-		if (g_list_length (sig_model->priv->widgets) > n)
-		{
-			glade_signal_model_create_widget_iter (sig_model,
-			                                       g_list_nth_data (sig_model->priv->widgets, n),
-			                                       iter);
-			return TRUE;
-		}
+	  glade_signal_model_create_widget_iter (sig_model,
+						 g_list_nth_data (sig_model->priv->widgets, n),
+						 iter);
+	  return TRUE;
 	}
-	return FALSE;
+    }
+  return FALSE;
 }
 
 static gboolean
@@ -870,7 +865,7 @@ glade_signal_model_iter_children (GtkTreeModel* model,
                                   GtkTreeIter* iter,
                                   GtkTreeIter* parent)
 {
-	return glade_signal_model_iter_nth_child (model, iter, parent, 0);
+  return glade_signal_model_iter_nth_child (model, iter, parent, 0);
 }
 
 static gboolean
@@ -878,61 +873,61 @@ glade_signal_model_iter_parent (GtkTreeModel* model,
                                 GtkTreeIter* iter,
                                 GtkTreeIter* child)
 {
-	GladeSignalModel* sig_model;
-	GladeSignal* handler;
-	const gchar* widget;
+  GladeSignalModel* sig_model;
+  GladeSignal* handler;
+  const gchar* widget;
 
-	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);  
+  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);  
 
-	sig_model = GLADE_SIGNAL_MODEL (model);
-	handler = child->user_data2;
-	widget = child->user_data;
+  sig_model = GLADE_SIGNAL_MODEL (model);
+  handler = child->user_data2;
+  widget = child->user_data;
 
-	if (handler)
-	{
-		glade_signal_model_create_widget_iter (sig_model, widget, iter);
-		return TRUE;
-	}
-	return FALSE;
+  if (handler)
+    {
+      glade_signal_model_create_widget_iter (sig_model, widget, iter);
+      return TRUE;
+    }
+  return FALSE;
 }
 
 static void
 gtk_tree_model_iface_init (GtkTreeModelIface *iface)
 {
-	iface->get_flags = glade_signal_model_get_flags;
-	iface->get_column_type = glade_signal_model_get_column_type;
-	iface->get_n_columns = glade_signal_model_get_n_columns;
-	iface->get_iter = glade_signal_model_get_iter;
-	iface->get_path = glade_signal_model_get_path;
-	iface->get_value = glade_signal_model_get_value;	
-	iface->iter_next = glade_signal_model_iter_next;
-	iface->iter_children = glade_signal_model_iter_children;
-	iface->iter_has_child = glade_signal_model_iter_has_child;
-	iface->iter_n_children = glade_signal_model_iter_n_children;
-	iface->iter_nth_child = glade_signal_model_iter_nth_child;
-	iface->iter_parent = glade_signal_model_iter_parent;
+  iface->get_flags = glade_signal_model_get_flags;
+  iface->get_column_type = glade_signal_model_get_column_type;
+  iface->get_n_columns = glade_signal_model_get_n_columns;
+  iface->get_iter = glade_signal_model_get_iter;
+  iface->get_path = glade_signal_model_get_path;
+  iface->get_value = glade_signal_model_get_value;	
+  iface->iter_next = glade_signal_model_iter_next;
+  iface->iter_children = glade_signal_model_iter_children;
+  iface->iter_has_child = glade_signal_model_iter_has_child;
+  iface->iter_n_children = glade_signal_model_iter_n_children;
+  iface->iter_nth_child = glade_signal_model_iter_nth_child;
+  iface->iter_parent = glade_signal_model_iter_parent;
 }
 
 static gboolean
 glade_signal_model_row_draggable (GtkTreeDragSource* model, 
                                   GtkTreePath* path)
 {
-	GtkTreeIter iter;
-	GladeSignal* signal;
-	gboolean retval;
-	gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path);
+  GtkTreeIter iter;
+  GladeSignal* signal;
+  gboolean retval;
+  gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path);
 
-	gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
-	                    GLADE_SIGNAL_COLUMN_SIGNAL, &signal,
-	                    -1);
+  gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
+		      GLADE_SIGNAL_COLUMN_SIGNAL, &signal,
+		      -1);
 
-	retval = signal && !glade_signal_model_is_dummy_handler (GLADE_SIGNAL_MODEL (model),
-	                                                         signal);
+  retval = signal && !glade_signal_model_is_dummy_handler (GLADE_SIGNAL_MODEL (model),
+							   signal);
 
-	g_object_unref (signal);
-	return retval;
+  g_object_unref (signal);
+  return retval;
 }
 
 static gboolean
@@ -940,47 +935,47 @@ glade_signal_model_drag_data_get (GtkTreeDragSource* model,
                                   GtkTreePath* path,
                                   GtkSelectionData* data)
 {
-	GtkTreeIter iter;
+  GtkTreeIter iter;
 
-	if (gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
-	{
-		GladeSignal* signal;
-		const gchar* widget = iter.user_data;
-		gchar* dnd_text;
-
-		gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
-		                    GLADE_SIGNAL_COLUMN_SIGNAL, &signal, -1);
-
-		dnd_text = g_strdup_printf ("%s:%s:%s", widget, glade_signal_get_name (signal),
-		                            glade_signal_get_handler (signal));
-		g_message ("Sent: %s", dnd_text);
-		gtk_selection_data_set (data,
-		                        gdk_atom_intern_static_string ("application/x-glade-signal"),
-		                        8,
-		                        (guchar*) dnd_text,
-		                        strlen (dnd_text));
-
-		g_free (dnd_text);
-		return TRUE;
-	}
-	else
-	{
-		return FALSE;
-	}
+  if (gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
+    {
+      GladeSignal* signal;
+      const gchar* widget = iter.user_data;
+      gchar* dnd_text;
+
+      gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
+			  GLADE_SIGNAL_COLUMN_SIGNAL, &signal, -1);
+
+      dnd_text = g_strdup_printf ("%s:%s:%s", widget, glade_signal_get_name (signal),
+				  glade_signal_get_handler (signal));
+      g_message ("Sent: %s", dnd_text);
+      gtk_selection_data_set (data,
+			      gdk_atom_intern_static_string ("application/x-glade-signal"),
+			      8,
+			      (guchar*) dnd_text,
+			      strlen (dnd_text));
+
+      g_free (dnd_text);
+      return TRUE;
+    }
+  else
+    {
+      return FALSE;
+    }
 }
 
 static gboolean
 glade_signal_model_drag_data_delete (GtkTreeDragSource* model, 
                                      GtkTreePath* path)
 {
-	/* We don't move rows... */
-	return FALSE;
+  /* We don't move rows... */
+  return FALSE;
 }
 
 static void
 gtk_tree_drag_source_iface_init (GtkTreeDragSourceIface* iface)
 {
-	iface->row_draggable = glade_signal_model_row_draggable;
-	iface->drag_data_get = glade_signal_model_drag_data_get;
-	iface->drag_data_delete = glade_signal_model_drag_data_delete;
+  iface->row_draggable = glade_signal_model_row_draggable;
+  iface->drag_data_get = glade_signal_model_drag_data_get;
+  iface->drag_data_delete = glade_signal_model_drag_data_delete;
 }
diff --git a/gladeui/glade-signal-model.h b/gladeui/glade-signal-model.h
index dff82f8b..32c173f7 100644
--- a/gladeui/glade-signal-model.h
+++ b/gladeui/glade-signal-model.h
@@ -2,18 +2,19 @@
  * glade3
  * Copyright (C) Johannes Schmid 2010 <jhs@gnome.org>
  * 
- * glade3 is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- * 
- * glade3 is distributed in the hope that it will be useful, but
+ * This library is free software; you can redistribute it and/or it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public 
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef _GLADE_SIGNAL_MODEL_H_
@@ -37,32 +38,32 @@ typedef struct _GladeSignalModelPrivate GladeSignalModelPrivate;
 
 typedef enum
 {
-	GLADE_SIGNAL_COLUMN_NAME,
-	GLADE_SIGNAL_COLUMN_SHOW_NAME,
-	GLADE_SIGNAL_COLUMN_HANDLER,
-	GLADE_SIGNAL_COLUMN_OBJECT,
-	GLADE_SIGNAL_COLUMN_SWAP,
-	GLADE_SIGNAL_COLUMN_AFTER,
-    GLADE_SIGNAL_COLUMN_TOOLTIP,
-	GLADE_SIGNAL_COLUMN_SIGNAL,
-	GLADE_SIGNAL_N_COLUMNS
+  GLADE_SIGNAL_COLUMN_NAME,
+  GLADE_SIGNAL_COLUMN_SHOW_NAME,
+  GLADE_SIGNAL_COLUMN_HANDLER,
+  GLADE_SIGNAL_COLUMN_OBJECT,
+  GLADE_SIGNAL_COLUMN_SWAP,
+  GLADE_SIGNAL_COLUMN_AFTER,
+  GLADE_SIGNAL_COLUMN_TOOLTIP,
+  GLADE_SIGNAL_COLUMN_SIGNAL,
+  GLADE_SIGNAL_N_COLUMNS
 } GladeSignalModelColumns;
 
 struct _GladeSignalModelClass
 {
-	GObjectClass parent_class;
+  GObjectClass parent_class;
 };
 
 struct _GladeSignalModel
 {
-	GObject parent_instance;
+  GObject parent_instance;
 
-	GladeSignalModelPrivate *priv;
+  GladeSignalModelPrivate *priv;
 };
 
-GType glade_signal_model_get_type (void) G_GNUC_CONST;
-GtkTreeModel *glade_signal_model_new (GladeWidget *widget,
-                                      GHashTable *signals);
+GType         glade_signal_model_get_type (void) G_GNUC_CONST;
+GtkTreeModel *glade_signal_model_new      (GladeWidget *widget,
+					   GHashTable  *signals);
 
 G_END_DECLS