/*

 * Copyright (C) 2006-2016 Juan Pablo Ugarte.

 *

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

 *

 * Authors:

 *   Juan Pablo Ugarte <juanpablougarte@gmail.com>

 */

#include "config.h"

/**

 * SECTION:glade-base-editor

 * @Short_Description: A customisable editor

 *

 * Convenience object to edit containers where placeholders do not make sense, like GtkMenubar.

 */

#include "glade.h"

#include "glade-marshallers.h"

#include "glade-editor-property.h"

#include "glade-base-editor.h"

#include "glade-app.h"

#include "glade-popup.h"

#include "glade-accumulators.h"

#include <string.h>

#include <glib/gi18n-lib.h>

#include <gdk/gdkkeysyms.h>

typedef enum

{

  GLADE_BASE_EDITOR_GTYPE,

  GLADE_BASE_EDITOR_CLASS_NAME,

  GLADE_BASE_EDITOR_TYPES_N_COLUMNS

} GladeBaseEditorChildEnum;

typedef enum

{

  GLADE_BASE_EDITOR_GWIDGET,

  GLADE_BASE_EDITOR_OBJECT,

  GLADE_BASE_EDITOR_TYPE_NAME,

  GLADE_BASE_EDITOR_NAME,

  GLADE_BASE_EDITOR_CHILD_TYPES,

  GLADE_BASE_EDITOR_N_COLUMNS

} GladeBaseEditorEnum;

typedef enum {

  ADD_ROOT = 0,

  ADD_SIBLING,

  ADD_CHILD

} GladeBaseEditorAddMode;

typedef struct

{

  GType parent_type;

  GtkTreeModel *children;

} ChildTypeTab;

struct _GladeBaseEditorPrivate

{

  GladeWidget *gcontainer;      /* The container we are editing */

  /* Editor UI */

  GtkWidget *paned, *table, *treeview, *tip_label;

  GtkWidget *add_button, *delete_button, *help_button;

  GladeSignalEditor *signal_editor;

  GList *child_types;

  GtkTreeModel *model;

  GladeProject *project;

  /* Add button data */

  GType add_type;

  /* Temporal variables */

  GtkTreeIter iter;             /* used in idle functions */

  gint row;

  gboolean updating_treeview;

  guint properties_idle;

};

enum

{

  SIGNAL_CHILD_SELECTED,

  SIGNAL_CHANGE_TYPE,

  SIGNAL_GET_DISPLAY_NAME,

  SIGNAL_BUILD_CHILD,

  SIGNAL_DELETE_CHILD,

  SIGNAL_MOVE_CHILD,

  LAST_SIGNAL

};

enum

{

  PROP_0,

  PROP_CONTAINER,

  N_PROPERTIES

};

G_DEFINE_TYPE_WITH_PRIVATE (GladeBaseEditor, glade_base_editor, GTK_TYPE_BOX)

static GParamSpec *properties[N_PROPERTIES];

static guint glade_base_editor_signals[LAST_SIGNAL] = { 0 };

static void glade_base_editor_set_container (GladeBaseEditor *editor,

                                             GObject         *container);

static void glade_base_editor_block_callbacks (GladeBaseEditor *editor,

                                               gboolean         block);

static void

reset_child_types (GladeBaseEditor *editor)

{

  GList *l;

  ChildTypeTab *tab;

  for (l = editor->priv->child_types; l; l = l->next)

    {

      tab = l->data;

      g_object_unref (tab->children);

      g_free (tab);

    }

  g_list_free (editor->priv->child_types);

  editor->priv->child_types = NULL;

}

static gint

sort_type_by_hierarchy (ChildTypeTab *a, ChildTypeTab *b)

{

  if (g_type_is_a (a->parent_type, b->parent_type))

    return -1;

  return 1;

}

static GtkTreeModel *

get_children_model_for_type (GladeBaseEditor *editor, GType type)

{

  GList *l;

  for (l = editor->priv->child_types; l; l = l->next)

    {

      ChildTypeTab *tab = l->data;

      if (g_type_is_a (type, tab->parent_type))

        return tab->children;

    }

  return NULL;

}

static GtkTreeModel *

get_children_model_for_child_type (GladeBaseEditor *editor, GType type)

{

  GList *l;

  GtkTreeModel *model = NULL;

  /* Get deep derived classes first and work up the sorted heirarchy */

  for (l = g_list_last (editor->priv->child_types); model == NULL && l;

       l = l->prev)

    {

      ChildTypeTab *tab = l->data;

      GtkTreeIter iter;

      GType iter_type;

      if (!gtk_tree_model_get_iter_first (tab->children, &iter))

        continue;

      do

        {

          gtk_tree_model_get (tab->children, &iter,

                              GLADE_BASE_EDITOR_GTYPE, &iter_type, -1);

          /* Find exact match types in this case */

          if (iter_type == type)

            model = tab->children;

        }

      while (model == NULL && gtk_tree_model_iter_next (tab->children, &iter));

    }

  return model;

}

static gboolean

glade_base_editor_get_type_info (GladeBaseEditor *e,

                                 GtkTreeIter     *retiter,

                                 GType            child_type,

                                 ...)

{

  GtkTreeModel *model;

  GtkTreeIter iter;

  GType type;

  model = get_children_model_for_child_type (e, child_type);

  if (!model || gtk_tree_model_get_iter_first (model, &iter) == FALSE)

    return FALSE;

  do

    {

      gtk_tree_model_get (model, &iter, GLADE_BASE_EDITOR_GTYPE, &type, -1);

      if (child_type == type)

        {

          va_list args;

          va_start (args, child_type);

          gtk_tree_model_get_valist (model, &iter, args);

          va_end (args);

          if (retiter)

            *retiter = iter;

          return TRUE;

        }

    }

  while (gtk_tree_model_iter_next (model, &iter));

  return FALSE;

}

static gchar *

glade_base_editor_get_display_name (GladeBaseEditor *editor,

                                    GladeWidget     *gchild)

{

  gchar *retval;

  g_signal_emit (editor,

                 glade_base_editor_signals[SIGNAL_GET_DISPLAY_NAME],

                 0, gchild, &retval);

  return retval;

}

static void

glade_base_editor_fill_store_real (GladeBaseEditor *e,

                                   GladeWidget     *gwidget,

                                   GtkTreeIter     *parent)

{

  GList *children, *l;

  GtkTreeIter iter;

  children = glade_widget_get_children (gwidget);

  for (l = children; l; l = l->next)

    {

      GladeWidget *gchild;

      GObject     *child = l->data;

      gchar       *type_name = NULL, *name;

      gchild = glade_widget_get_from_gobject (child);

      /* Have to check parents here for compatibility (could be the parenting menuitem of this menu

       * supports a menuitem...) */

      if (glade_base_editor_get_type_info (e, NULL,

                                           G_OBJECT_TYPE (child),

                                           GLADE_BASE_EDITOR_CLASS_NAME,

                                           &type_name, -1))

        {

          gtk_tree_store_append (GTK_TREE_STORE (e->priv->model), &iter, parent);

          name = glade_base_editor_get_display_name (e, gchild);

          gtk_tree_store_set (GTK_TREE_STORE (e->priv->model), &iter,

                              GLADE_BASE_EDITOR_GWIDGET, gchild,

                              GLADE_BASE_EDITOR_OBJECT, child,

                              GLADE_BASE_EDITOR_TYPE_NAME, type_name,

                              GLADE_BASE_EDITOR_NAME, name,

                              GLADE_BASE_EDITOR_CHILD_TYPES,

                              get_children_model_for_child_type (e, G_OBJECT_TYPE (child)),

                              -1);

          glade_base_editor_fill_store_real (e, gchild, &iter);

          g_free (name);

          g_free (type_name);

      }

      else

        glade_base_editor_fill_store_real (e, gchild, parent);

    }

  g_list_free (children);

}

static void

glade_base_editor_fill_store (GladeBaseEditor *e)

{

  gtk_tree_store_clear (GTK_TREE_STORE (e->priv->model));

  gtk_tree_view_set_model (GTK_TREE_VIEW (e->priv->treeview), NULL);

  glade_base_editor_fill_store_real (e, e->priv->gcontainer, NULL);

  gtk_tree_view_set_model (GTK_TREE_VIEW (e->priv->treeview), e->priv->model);

  gtk_tree_view_expand_all (GTK_TREE_VIEW (e->priv->treeview));

}

static gboolean

glade_base_editor_get_child_selected (GladeBaseEditor *e, GtkTreeIter *iter)

{

  GtkTreeSelection *sel =

    gtk_tree_view_get_selection (GTK_TREE_VIEW (e->priv->treeview));

  return (sel) ? gtk_tree_selection_get_selected (sel, NULL, iter) : FALSE;

}

/* Forward declaration for glade_base_editor_project_widget_name_changed */

static void

glade_base_editor_project_widget_name_changed (GladeProject *project,

                                               GladeWidget *widget,

                                               GladeBaseEditor *editor);

static GladeWidget *

glade_base_editor_delegate_build_child (GladeBaseEditor *editor,

                                        GladeWidget     *parent,

                                        GType            type)

{

  GladeWidget *child = NULL;

  g_signal_emit (editor, glade_base_editor_signals[SIGNAL_BUILD_CHILD],

                 0, parent, type, &child);

  return child;

}

static gboolean

glade_base_editor_delegate_delete_child (GladeBaseEditor *editor,

                                         GladeWidget     *parent,

                                         GladeWidget     *child)

{

  gboolean retval;

  g_signal_emit (editor, glade_base_editor_signals[SIGNAL_DELETE_CHILD],

                 0, parent, child, &retval);

  return retval;

}

static void

glade_base_editor_name_activate (GtkEntry *entry, GladeWidget *gchild)

{

  const gchar *text = gtk_entry_get_text (GTK_ENTRY (entry));

  GladeBaseEditor *editor = g_object_get_data (G_OBJECT (entry), "editor");

  gchar *new_name = NULL;

  if (text == NULL || text[0] == '\0')

    {

      /* If we are explicitly trying to set the widget name to be empty,

       * then we must not allow it there are any active references to

       * the widget which would otherwise break.

       */

      if (!glade_widget_has_prop_refs (gchild))

        new_name = glade_project_new_widget_name (editor->priv->project, NULL, GLADE_UNNAMED_PREFIX);

    }

  else

    new_name = g_strdup (text);

  if (new_name && new_name[0])

    {

      g_signal_handlers_block_by_func (editor->priv->project,

                                       glade_base_editor_project_widget_name_changed, editor);

      glade_command_set_name (gchild, new_name);

      g_signal_handlers_unblock_by_func (editor->priv->project,

                                         glade_base_editor_project_widget_name_changed, editor);

    }

  g_free (new_name);

}

static void

glade_base_editor_table_attach (GladeBaseEditor *e,

                                GtkWidget *child1,

                                GtkWidget *child2)

{

  GtkGrid *table = GTK_GRID (e->priv->table);

  gint row = e->priv->row;

  if (child1)

    {

      gtk_grid_attach (table, child1, 0, row, 1, 1);

      gtk_widget_set_hexpand (child1, TRUE);

      gtk_widget_show (child1);

    }

  if (child2)

    {

      gtk_grid_attach (table, child2, 1, row, 1, 1);

      gtk_widget_show (child2);

    }

  e->priv->row++;

}

static void

glade_base_editor_clear (GladeBaseEditor *editor)

{

  GladeBaseEditorPrivate *e = editor->priv;

  gtk_widget_show (e->tip_label);

  gtk_container_foreach (GTK_CONTAINER (e->table),

                         (GtkCallback)gtk_widget_destroy, NULL);

  e->row = 0;

  gtk_widget_set_sensitive (e->delete_button, FALSE);

  glade_signal_editor_load_widget (e->signal_editor, NULL);

}

static void

glade_base_editor_treeview_cursor_changed (GtkTreeView     *treeview,

                                           GladeBaseEditor *editor)

{

  GladeBaseEditorPrivate *e = editor->priv;

  GtkTreeIter iter;

  GObject *child;

  GladeWidget *gchild;

  g_return_if_fail (GTK_IS_TREE_VIEW (treeview));

  if (!glade_base_editor_get_child_selected (editor, &iter))

    return;

  glade_base_editor_clear (editor);

  gtk_widget_set_sensitive (e->delete_button, TRUE);

  gtk_tree_model_get (e->model, &iter,

                      GLADE_BASE_EDITOR_GWIDGET, &gchild,

                      GLADE_BASE_EDITOR_OBJECT, &child, -1);

  g_object_unref (gchild);

  g_object_unref (child);

  /* Emit child-selected signal and let the user add the properties */

  g_signal_emit (editor, glade_base_editor_signals[SIGNAL_CHILD_SELECTED],

                 0, gchild);

  /* Update Signal Editor */

  glade_signal_editor_load_widget (e->signal_editor, gchild);

}

static gboolean

glade_base_editor_update_properties_idle (gpointer data)

{

  GladeBaseEditor *editor = (GladeBaseEditor *) data;

  glade_base_editor_treeview_cursor_changed

      (GTK_TREE_VIEW (editor->priv->treeview), editor);

  editor->priv->properties_idle = 0;

  return FALSE;

}

/* XXX Can we make it crisper by removing this idle ?? */

static void

glade_base_editor_update_properties (GladeBaseEditor *editor)

{

  g_return_if_fail (GLADE_IS_BASE_EDITOR (editor));

  if (!editor->priv->properties_idle)

    editor->priv->properties_idle =

        g_idle_add (glade_base_editor_update_properties_idle, editor);

}

static void

glade_base_editor_set_cursor (GladeBaseEditor *e, GtkTreeIter *iter)

{

  GtkTreePath *path;

  GtkTreeIter real_iter;

  if (iter == NULL && glade_base_editor_get_child_selected (e, &real_iter))

    iter = &real_iter;

  if (iter && (path = gtk_tree_model_get_path (e->priv->model, iter)))

    {

      gtk_tree_view_set_cursor (GTK_TREE_VIEW (e->priv->treeview), path, NULL,

                                FALSE);

      gtk_tree_path_free (path);

    }

}

static gboolean

glade_base_editor_find_child_real (GladeBaseEditor *e,

                                   GladeWidget     *gchild,

                                   GtkTreeIter     *iter)

{

  GtkTreeModel *model = e->priv->model;

  GtkTreeIter child_iter;

  GladeWidget *child;

  do

    {

      gtk_tree_model_get (model, iter, GLADE_BASE_EDITOR_GWIDGET, &child, -1);

      g_object_unref (child);

      if (child == gchild)

        return TRUE;

      if (gtk_tree_model_iter_children (model, &child_iter, iter))

        if (glade_base_editor_find_child_real (e, gchild, &child_iter))

          {

            *iter = child_iter;

            return TRUE;

          }

    }

  while (gtk_tree_model_iter_next (model, iter));

  return FALSE;

}

static gboolean

glade_base_editor_find_child (GladeBaseEditor *e,

                              GladeWidget     *child,

                              GtkTreeIter     *iter)

{

  if (gtk_tree_model_get_iter_first (e->priv->model, iter))

    return glade_base_editor_find_child_real (e, child, iter);

  return FALSE;

}

static void

glade_base_editor_select_child (GladeBaseEditor *e, GladeWidget *child)

{

  GtkTreeIter iter;

  if (glade_base_editor_find_child (e, child, &iter))

    glade_base_editor_set_cursor (e, &iter);

}

static void

glade_base_editor_child_change_type (GladeBaseEditor *editor,

                                     GtkTreeIter     *iter,

                                     GType            type)

{

  GladeWidget *gchild;

  GObject *child;

  gchar *class_name;

  gboolean retval;

  glade_base_editor_block_callbacks (editor, TRUE);

  /* Get old widget data */

  gtk_tree_model_get (editor->priv->model, iter,

                      GLADE_BASE_EDITOR_GWIDGET, &gchild,

                      GLADE_BASE_EDITOR_OBJECT, &child, -1);

  g_object_unref (gchild);

  g_object_unref (child);

  if (type == G_OBJECT_TYPE (child) || 

      !gchild || !glade_widget_get_parent (gchild))

    {

      glade_base_editor_block_callbacks (editor, FALSE);

      return;

    }

  /* Start of glade-command */

  if (glade_base_editor_get_type_info (editor, NULL,

                                       type,

                                       GLADE_BASE_EDITOR_CLASS_NAME,

                                       &class_name, -1))

    {

      glade_command_push_group (_("Setting object type on %s to %s"),

                                glade_widget_get_name (gchild), class_name);

      g_free (class_name);

    }

  else

    {

      glade_base_editor_block_callbacks (editor, FALSE);

      return;

    }

  g_signal_emit (editor,

                 glade_base_editor_signals[SIGNAL_CHANGE_TYPE],

                 0, gchild, type, &retval);

  /* End of glade-command */

  glade_command_pop_group ();

  /* Update properties */

  glade_base_editor_update_properties (editor);

  glade_base_editor_block_callbacks (editor, FALSE);

}

static void

glade_base_editor_type_changed (GtkComboBox *widget, GladeBaseEditor *e)

{

  GtkTreeIter iter, combo_iter;

  GType type;

  if (!glade_base_editor_get_child_selected (e, &iter))

    return;

  gtk_combo_box_get_active_iter (widget, &combo_iter);

  gtk_tree_model_get (gtk_combo_box_get_model (widget), &combo_iter,

                      GLADE_BASE_EDITOR_GTYPE, &type, -1);

  glade_base_editor_child_change_type (e, &iter, type);

}

static void

glade_base_editor_child_type_edited (GtkCellRendererText *cell,

                                     const gchar         *path_string,

                                     const gchar         *new_text,

                                     GladeBaseEditor     *editor)

{

  GladeBaseEditorPrivate *e = editor->priv;

  GtkTreeModel *child_class;

  GtkTreePath *path;

  GtkTreeIter iter, combo_iter;

  GType type;

  gchar *type_name = NULL;

  path = gtk_tree_path_new_from_string (path_string);

  gtk_tree_model_get_iter (e->model, &iter, path);

  gtk_tree_path_free (path);

  gtk_tree_model_get (e->model, &iter,

                      GLADE_BASE_EDITOR_TYPE_NAME, &type_name,

                      GLADE_BASE_EDITOR_CHILD_TYPES, &child_class, -1);

  if (g_strcmp0 (type_name, new_text) == 0)

    {

      g_free (type_name);

      g_object_unref (child_class);

      return;

    }

  /* Lookup GType */

  if (!gtk_tree_model_get_iter_first (child_class, &combo_iter))

    {

      g_free (type_name);

      g_object_unref (child_class);

      return;

    }

  g_free (type_name);

  do

    {

      gtk_tree_model_get (child_class, &combo_iter,

                          GLADE_BASE_EDITOR_GTYPE, &type,

                          GLADE_BASE_EDITOR_CLASS_NAME, &type_name, -1);

      if (strcmp (type_name, new_text) == 0)

        {

          g_free (type_name);

          break;

        }

      g_free (type_name);

    }

  while (gtk_tree_model_iter_next (child_class, &combo_iter));

  glade_base_editor_child_change_type (editor, &iter, type);

}

static void

glade_base_editor_reorder_children (GladeBaseEditor *editor,

                                    GtkTreeIter     *child)

{

  GtkTreeModel *model = editor->priv->model;

  GladeWidget *gchild;

  GladeProperty *property;

  GtkTreeIter parent, iter;

  gint position = 0;

  if (gtk_tree_model_iter_parent (model, &parent, child))

    gtk_tree_model_iter_children (model, &iter, &parent);

  else

    gtk_tree_model_get_iter_first (model, &iter);

  do

    {

      gtk_tree_model_get (model, &iter, GLADE_BASE_EDITOR_GWIDGET, &gchild, -1);

      g_object_unref (gchild);

      if ((property = glade_widget_get_property (gchild, "position")) != NULL)

        glade_command_set_property (property, position);

      position++;

    }

  while (gtk_tree_model_iter_next (model, &iter));

}

static void

glade_base_editor_add_child (GladeBaseEditor       *editor,

                             GType                  type, 

                             GladeBaseEditorAddMode add_mode)

{

  GladeBaseEditorPrivate *e = editor->priv;

  GtkTreeIter iter, new_iter;

  GladeWidget *gparent, *gchild_new;

  gchar *name, *class_name;

  gboolean selected_iter = FALSE;

  glade_base_editor_block_callbacks (editor, TRUE);

  gparent = e->gcontainer;

  if (add_mode != ADD_ROOT &&

      (selected_iter = glade_base_editor_get_child_selected (editor, &iter)))

    {

      if (add_mode == ADD_CHILD)

        {

          gtk_tree_model_get (e->model, &iter,

                              GLADE_BASE_EDITOR_GWIDGET, &gparent, -1);

          g_object_unref (gparent);

        }

      else if (add_mode == ADD_SIBLING &&

               gtk_tree_model_iter_parent (e->model, &new_iter, &iter))

        {

          gtk_tree_model_get (e->model, &new_iter,

                              GLADE_BASE_EDITOR_GWIDGET, &gparent, -1);

          g_object_unref (gparent);

        }

    }

  if (!glade_base_editor_get_type_info (editor, NULL, type,

                                        GLADE_BASE_EDITOR_CLASS_NAME,

                                        &class_name, -1))

    return;

  glade_command_push_group (_("Add a %s to %s"), class_name,

                            glade_widget_get_name (gparent));

  /* Build Child */

  gchild_new = glade_base_editor_delegate_build_child (editor, gparent, type);

  if (gchild_new == NULL)

    {

      glade_command_pop_group ();

      return;

    }

  if (selected_iter)

    {

      if (add_mode == ADD_CHILD)

        gtk_tree_store_append (GTK_TREE_STORE (editor->priv->model), &new_iter,

                               &iter);

      else

        gtk_tree_store_insert_after (GTK_TREE_STORE (editor->priv->model),

                                     &new_iter, NULL, &iter);

    }

  else

    gtk_tree_store_append (GTK_TREE_STORE (editor->priv->model), &new_iter,

                           NULL);

  name = glade_base_editor_get_display_name (editor, gchild_new);

  gtk_tree_store_set (GTK_TREE_STORE (editor->priv->model), &new_iter,

                      GLADE_BASE_EDITOR_GWIDGET, gchild_new,

                      GLADE_BASE_EDITOR_OBJECT,

                      glade_widget_get_object (gchild_new),

                      GLADE_BASE_EDITOR_TYPE_NAME, class_name,

                      GLADE_BASE_EDITOR_NAME, name,

                      GLADE_BASE_EDITOR_CHILD_TYPES,

                      get_children_model_for_type (editor,

                                                   G_OBJECT_TYPE (glade_widget_get_object (gparent))),

                      -1);

  glade_base_editor_reorder_children (editor, &new_iter);

  gtk_tree_view_expand_all (GTK_TREE_VIEW (e->treeview));

  glade_base_editor_set_cursor (editor, &new_iter);

  glade_command_pop_group ();

  glade_base_editor_block_callbacks (editor, FALSE);

  g_free (name);

  g_free (class_name);

}

static void

glade_base_editor_add_item_activate (GtkMenuItem     *menuitem,

                                     GladeBaseEditor *e)

{

  GObject *item = G_OBJECT (menuitem);

  GType type = GPOINTER_TO_SIZE (g_object_get_data (item, "object_type"));

  GladeBaseEditorAddMode add_mode =

      GPOINTER_TO_INT (g_object_get_data (item, "object_add_mode"));

  glade_base_editor_add_child (e, type, add_mode);

}

static GtkWidget *

glade_base_editor_popup (GladeBaseEditor *editor, GladeWidget *widget)

{

  GtkWidget *popup, *item;

  GtkTreeModel *model;

  GtkTreeIter iter;

  GType iter_type;

  gchar *label;

  gchar *class_name;

  if ((model =

       get_children_model_for_child_type (editor,

                                          G_OBJECT_TYPE (glade_widget_get_object (widget)))) == NULL)

    model =

      get_children_model_for_type (editor,

                                   G_OBJECT_TYPE (glade_widget_get_object (editor->priv->gcontainer)));

  g_assert (model);

  popup = gtk_menu_new ();

  if (gtk_tree_model_get_iter_first (model, &iter))

    do

      {

        gtk_tree_model_get (model, &iter,

                            GLADE_BASE_EDITOR_GTYPE, &iter_type,

                            GLADE_BASE_EDITOR_CLASS_NAME, &class_name, -1);

        label = g_strdup_printf (_("Add %s"), class_name);

        item = gtk_menu_item_new_with_label (label);

        gtk_widget_show (item);

        g_object_set_data (G_OBJECT (item), "object_type",

                           GSIZE_TO_POINTER (iter_type));

        g_object_set_data (G_OBJECT (item), "object_add_mode",

                           GINT_TO_POINTER (ADD_SIBLING));

        g_signal_connect (item, "activate",

                          G_CALLBACK (glade_base_editor_add_item_activate),

                          editor);

        gtk_menu_shell_append (GTK_MENU_SHELL (popup), item);

        g_free (label);

        g_free (class_name);

      }

    while (gtk_tree_model_iter_next (model, &iter));

  if ((model =

       get_children_model_for_type (editor, G_OBJECT_TYPE (glade_widget_get_object (widget)))) &&

      gtk_tree_model_get_iter_first (model, &iter))

    do

      {

        gtk_tree_model_get (model, &iter,

                            GLADE_BASE_EDITOR_GTYPE, &iter_type,

                            GLADE_BASE_EDITOR_CLASS_NAME, &class_name, -1);

        label = g_strdup_printf (_("Add child %s"), class_name);

        item = gtk_menu_item_new_with_label (label);

        gtk_widget_show (item);

        g_object_set_data (G_OBJECT (item), "object_type",

                           GSIZE_TO_POINTER (iter_type));

        g_object_set_data (G_OBJECT (item), "object_add_mode",

                           GINT_TO_POINTER (ADD_CHILD));

        g_signal_connect (item, "activate",

                          G_CALLBACK (glade_base_editor_add_item_activate),

                          editor);

        gtk_menu_shell_append (GTK_MENU_SHELL (popup), item);

        g_free (label);

        g_free (class_name);

      }

    while (gtk_tree_model_iter_next (model, &iter));

  return popup;

}

static gint

glade_base_editor_popup_handler (GtkWidget       *treeview,