/*

 * glade-signal-model.c

 * Copyright (C) Johannes Schmid 2010 <jhs@gnome.org>

 * 

 * This library is free software; you can redistribute it and/or modify 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>

#endif

#include "glade-signal-model.h"

#include "glade-project.h"

#include <glib/gi18n-lib.h>

#include <string.h>

#define DETAIL_DEFAULT  _("<Type here>")

#define HANDLER_DEFAULT  _("<Type here>")

#define USERDATA_DEFAULT _("<Click here>")

struct _GladeSignalModelPrivate

{

  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 */

};

enum

{

  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_widget_support_changed (GladeWidget *widget, GladeSignalModel *model);

G_DEFINE_TYPE_WITH_CODE (GladeSignalModel, glade_signal_model, G_TYPE_OBJECT,

                         G_ADD_PRIVATE (GladeSignalModel)

                         G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,

                                                gtk_tree_model_iface_init);

                         G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,

                                                gtk_tree_drag_source_iface_init))

static void

glade_signal_model_init (GladeSignalModel *object)

{

  object->priv = glade_signal_model_get_instance_private (object);

  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);

  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));

	}

    }

  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);

  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);

        g_signal_connect (sig_model->priv->widget, "support-changed",

                          G_CALLBACK (on_glade_widget_support_changed), sig_model);

      break;

      case PROP_SIGNALS:

        sig_model->priv->signals = g_value_get_pointer (value);

      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;

  g_return_if_fail (GLADE_IS_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;

    }

}

static void

glade_signal_model_class_init (GladeSignalModelClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  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));

}

/*

 * glade_signal_model_new:

 * @widget: The GladeWidget the signals belong to

 * @signals: The signals of the #GladeWidget

 *

 * Creates a new GladeSignalModel object to show and edit the

 * signals of a widgets in a GtkTreeView

 */

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);

}

static GtkTreeModelFlags

glade_signal_model_get_flags (GtkTreeModel *model)

{

  return 0;

}

static gint

glade_signal_model_get_n_columns (GtkTreeModel *model)

{

  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;

      case GLADE_SIGNAL_COLUMN_DETAIL:

        return G_TYPE_STRING;

      default:

        g_assert_not_reached();

        return G_TYPE_NONE;

    }

}

enum

{

  ITER_WIDGET = 0,

  ITER_SIGNAL = 1,

};

static inline gboolean

glade_signal_model_is_dummy_handler (GladeSignalModel *model,

                                     GladeSignal *signal)

{

  return glade_signal_get_handler (signal) == NULL;

}

static GladeSignal *

glade_signal_model_get_dummy_handler (GladeSignalModel *model, 

                                      const GladeSignalClass *sig_class)

{

  GladeSignal *signal;

  signal = g_hash_table_lookup (model->priv->dummy_signals, 

				glade_signal_class_get_name (sig_class));

  if (!signal)

    {

      signal = glade_signal_new (sig_class,

				 NULL,

				 NULL,

				 FALSE,

				 FALSE);

      g_hash_table_insert (model->priv->dummy_signals, 

			   (gpointer) glade_signal_class_get_name (sig_class), 

			   signal);

      glade_project_verify_signal (model->priv->widget, signal);

    }

  return signal;

}

static void

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;

}

static void

glade_signal_model_create_signal_iter (GladeSignalModel *sig_model,

                                       const gchar *widget,

                                       const GladeSignal *signal,

                                       GtkTreeIter *iter)

{

	glade_signal_model_create_widget_iter (sig_model, widget, iter);

	iter->user_data2 = GLADE_SIGNAL (signal);

}

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);

  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))

	{

	  widget_signals = g_list_append (widget_signals, sig_class);

	}

    }

  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++;

}

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++;

}

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++;

}

static void

verify_dummies (const gchar *signal_name,

                GladeSignal *signal,

                GladeSignalModel *model)

{

  glade_project_verify_signal (model->priv->widget, signal);

  on_glade_signal_model_changed (model->priv->widget, signal, model);

}

static void

emit_changed (const gchar *signal_name,

	      GPtrArray *signals,

	      GladeSignalModel *model)

{

  gint i;

  GladeSignal *signal;

  for (i = 0; i < signals->len; i++)

    {

      signal = (GladeSignal *)signals->pdata[i];

      on_glade_signal_model_changed (model->priv->widget, signal, model);

    }

}

static void

on_glade_widget_support_changed (GladeWidget *widget, GladeSignalModel *model)

{

  /* Update support warning on dummy signals */

  g_hash_table_foreach (model->priv->dummy_signals, (GHFunc)verify_dummies, model);

  /* row changed on every row */

  g_hash_table_foreach (model->priv->signals, (GHFunc)emit_changed, model);

}

static gboolean

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;

}

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)

		{

		  guint handler_index;

		  if (g_ptr_array_find (handlers, handler, &handler_index))

		    index1 += handler_index;

		  else

		    index1 += handlers->len;

		}

	      break;

	    }

	}

      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

glade_signal_model_get_value (GtkTreeModel *model,

                              GtkTreeIter *iter,

                              gint column,

                              GValue *value)

{	

  const gchar *widget;

  GladeSignal *signal;

  GladeSignalModel *sig_model;

  g_return_if_fail (iter != NULL);

  g_return_if_fail (GLADE_IS_SIGNAL_MODEL(model));

  widget = iter->user_data;

  signal = iter->user_data2;

  sig_model = GLADE_SIGNAL_MODEL (model);

  value = g_value_init (value, 

			glade_signal_model_get_column_type (model, column));

  switch (column)

    {

      case GLADE_SIGNAL_COLUMN_NAME:

        if (signal)

        {

          g_value_set_static_string (value, glade_signal_get_name (signal));

          break;

        }

        else

          g_value_set_static_string (value, widget);

      break;

      case GLADE_SIGNAL_COLUMN_SHOW_NAME:

        if (signal)

        {

          GPtrArray *handlers = g_hash_table_lookup (sig_model->priv->signals,

                                                     glade_signal_get_name (signal));

          guint index;

          if (!handlers || !handlers->len || (g_ptr_array_find (handlers, signal, &index) && index == 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 (signal)

          {

            const gchar *handler = glade_signal_get_handler (signal);

            g_value_set_static_string (value, handler ? handler : HANDLER_DEFAULT);

          }

        else 

          g_value_set_static_string (value, "");

      break;

      case GLADE_SIGNAL_COLUMN_OBJECT:

        if (signal)

        {

          const gchar *userdata = glade_signal_get_userdata (signal);

          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 (signal)

          g_value_set_boolean (value, glade_signal_get_swapped (signal));

        else 

          g_value_set_boolean (value, FALSE);

      break;

      case GLADE_SIGNAL_COLUMN_AFTER:

        if (signal)

          g_value_set_boolean (value, glade_signal_get_after (signal));

        else 

          g_value_set_boolean (value, FALSE);

        break;

      case GLADE_SIGNAL_COLUMN_TOOLTIP:

        if (signal)

          g_value_set_string (value, glade_signal_get_support_warning (signal));

        else

          g_value_set_static_string (value, NULL);

      break;

      case GLADE_SIGNAL_COLUMN_SIGNAL:

        g_value_set_object (value, signal);

      break;

      case GLADE_SIGNAL_COLUMN_DETAIL:

        if (signal)

          {

            const gchar *detail = glade_signal_get_detail (signal);

            g_value_set_static_string (value, detail ? detail : DETAIL_DEFAULT);

          }

        else 

          g_value_set_static_string (value, "");

      break;

      default:

        g_assert_not_reached();

    }

}

static gboolean

glade_signal_model_iter_next_signal (GladeSignalModel *sig_model,

                                     const gchar *widget,

                                     GtkTreeIter *iter,

                                     GList *signal)

{

  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)

	{

	  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;

    }

  else

    {

      g_list_free (signal);

      return FALSE;

    }

}

static gboolean

glade_signal_model_iter_next (GtkTreeModel *model, GtkTreeIter *iter)

{

  const gchar *widget;

  GladeSignal *handler;

  GtkTreeIter parent;

  GladeSignalModel *sig_model;

  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;

  sig_model = GLADE_SIGNAL_MODEL (model);  

  gtk_tree_model_iter_parent (model, &parent, iter);		

  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))

	{

	  return glade_signal_model_iter_next_signal (sig_model, widget, iter, signal);

	}

      else if (handlers)

	{

	  guint new_index = 0;

	  if (g_ptr_array_find (handlers, handler, &new_index))

	    new_index++;

	  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;

	}

    }

  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 (GLADE_IS_SIGNAL_MODEL(model), 0);

  /* FIXME: return the number of toplevels, if it makes sense in this context */

  if (iter == NULL) return 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))

	{

	  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;

    }

  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);

  return (glade_signal_model_iter_n_children (model, iter) != 0);

}

static gboolean

glade_signal_model_iter_nth_child (GtkTreeModel *model,

                                   GtkTreeIter *iter,

                                   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)

    {

      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

		{

		  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--;

	}

      return FALSE;

    }

  else

    {

      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;

	}

    }

  return FALSE;

}

static gboolean

glade_signal_model_iter_children (GtkTreeModel *model,

                                  GtkTreeIter *iter,

                                  GtkTreeIter *parent)