/*

 * Copyright (C) 2008 Tristan Van Berkom.

 *

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

 *   Tristan Van Berkom <tvb@gnome.org>

 */

#include <config.h>

#include <gladeui/glade.h>

#include <gtk/gtk.h>

#include <gdk/gdkkeysyms.h>

#include <glib/gi18n-lib.h>

#include <string.h>

#include "glade-model-data.h"

#include "glade-column-types.h"

GladeModelData *

glade_model_data_new (GType type, const gchar * column_name)

{

  GladeModelData *data = g_slice_new0 (GladeModelData);

  if (type != 0)

    g_value_init (&data->value, type);

  if (type == G_TYPE_STRING)

    data->i18n_translatable = TRUE;

  data->name = g_strdup (column_name);

  return data;

}

GladeModelData *

glade_model_data_copy (GladeModelData * data)

{

  GladeModelData *dup;

  if (!data)

    return NULL;

  dup = g_slice_new0 (GladeModelData);

  if (G_VALUE_TYPE (&data->value) != 0)

    {

      g_value_init (&dup->value, G_VALUE_TYPE (&data->value));

      g_value_copy (&data->value, &dup->value);

    }

  dup->name = g_strdup (data->name);

  dup->i18n_translatable = data->i18n_translatable;

  dup->i18n_context = g_strdup (data->i18n_context);

  dup->i18n_comment = g_strdup (data->i18n_comment);

  return dup;

}

void

glade_model_data_free (GladeModelData * data)

{

  if (data)

    {

      if (G_VALUE_TYPE (&data->value) != 0)

        g_value_unset (&data->value);

      g_free (data->name);

      g_free (data->i18n_context);

      g_free (data->i18n_comment);

      g_slice_free (GladeModelData, data);

    }

}

GNode *

glade_model_data_tree_copy (GNode * node)

{

  return g_node_copy_deep (node, (GCopyFunc) glade_model_data_copy, NULL);

}

static gboolean

model_data_traverse_free (GNode * node, gpointer data)

{

  glade_model_data_free ((GladeModelData *) node->data);

  return FALSE;

}

void

glade_model_data_tree_free (GNode * node)

{

  if (node)

    {

      g_node_traverse (node, G_IN_ORDER, G_TRAVERSE_ALL, -1,

                       (GNodeTraverseFunc) model_data_traverse_free, NULL);

      g_node_destroy (node);

    }

}

GladeModelData *

glade_model_data_tree_get_data (GNode * data_tree, gint row, gint colnum)

{

  GNode *node;

  g_return_val_if_fail (data_tree != NULL, NULL);

  if ((node = g_node_nth_child (data_tree, row)) != NULL)

    if ((node = g_node_nth_child (node, colnum)) != NULL)

      return (GladeModelData *) node->data;

  return NULL;

}

void

glade_model_data_insert_column (GNode * node,

                                GType type, const gchar * column_name, gint nth)

{

  GNode *row, *item;

  GladeModelData *data;

  g_return_if_fail (node != NULL);

  for (row = node->children; row; row = row->next)

    {

      g_return_if_fail (nth >= 0 && nth <= g_node_n_children (row));

      data = glade_model_data_new (type, column_name);

      item = g_node_new (data);

      g_node_insert (row, nth, item);

    }

}

void

glade_model_data_remove_column (GNode * node, gint nth)

{

  GNode *row, *item;

  GladeModelData *data;

  g_return_if_fail (node != NULL);

  for (row = node->children; row; row = row->next)

    {

      g_return_if_fail (nth >= 0 && nth < g_node_n_children (row));

      item = g_node_nth_child (row, nth);

      data = item->data;

      glade_model_data_free (data);

      g_node_destroy (item);

    }

}

void

glade_model_data_reorder_column (GNode * node, gint column, gint nth)

{

  GNode *row, *item;

  g_return_if_fail (node != NULL);

  for (row = node->children; row; row = row->next)

    {

      g_return_if_fail (nth >= 0 && nth < g_node_n_children (row));

      item = g_node_nth_child (row, column);

      g_node_unlink (item);

      g_node_insert (row, nth, item);

    }

}

gint

glade_model_data_column_index (GNode * node, const gchar * column_name)

{

  gint i;

  GNode *item;

  GladeModelData *data;

  g_return_val_if_fail (node != NULL, -1);

  for (i = 0, item = node->children->children; item; i++, item = item->next)

    {

      data = item->data;

      if (strcmp (data->name, column_name) == 0)

        return i;

    }

  return -1;

}

void

glade_model_data_column_rename (GNode * node,

                                const gchar * column_name,

                                const gchar * new_name)

{

  gint idx;

  GNode *row, *iter;

  GladeModelData *data;

  g_return_if_fail (node != NULL);

  if ((idx = glade_model_data_column_index (node, column_name)) < 0)

    return;

  for (row = node->children; row; row = row->next)

    {

      iter = g_node_nth_child (row, idx);

      data = iter->data;

      g_free (data->name);

      data->name = g_strdup (new_name);

    }

}

GType

glade_model_data_tree_get_type (void)

{

  static GType type_id = 0;

  if (!type_id)

    type_id = g_boxed_type_register_static

        ("GladeModelDataTree",

         (GBoxedCopyFunc) glade_model_data_tree_copy,

         (GBoxedFreeFunc) glade_model_data_tree_free);

  return type_id;

}

/**************************** GladeEditorProperty *****************************/

enum

{

  COLUMN_ROW = 0,               /* row number */

  NUM_COLUMNS

};

typedef struct

{

  GladeEditorProperty parent_instance;

  GtkTreeView *view;

  GtkListStore *store;

  GtkTreeSelection *selection;

  GNode *pending_data_tree;

  /* Used for setting focus on newly added rows */

  gboolean adding_row;

  gboolean want_focus;

  gboolean setting_focus;

  gint editing_row;

  gint editing_column;

} GladeEPropModelData;

GLADE_MAKE_EPROP (GladeEPropModelData, glade_eprop_model_data)

#define GLADE_EPROP_MODEL_DATA(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GLADE_TYPE_EPROP_MODEL_DATA, GladeEPropModelData))

#define GLADE_EPROP_MODEL_DATA_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GLADE_TYPE_EPROP_MODEL_DATA, GladeEPropModelDataClass))

#define GLADE_IS_EPROP_MODEL_DATA(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GLADE_TYPE_EPROP_MODEL_DATA))

#define GLADE_IS_EPROP_MODEL_DATA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GLADE_TYPE_EPROP_MODEL_DATA))

#define GLADE_EPROP_MODEL_DATA_GET_CLASS(o)    (G_TYPE_INSTANCE_GET_CLASS ((o), GLADE_EPROP_MODEL_DATA, GladeEPropModelDataClass))

static void eprop_data_focus_editing_cell (GladeEPropModelData *eprop_data);

static void append_row (GNode * node, GList * columns)

{

  GladeModelData *data;

  GladeColumnType *column;

  GNode *row;

  GList *list;

  g_assert (node && columns);

  row = g_node_new (NULL);

  g_node_append (node, row);

  for (list = columns; list; list = list->next)

    {

      column = list->data;

      data =

          glade_model_data_new (g_type_from_name (column->type_name),

                                column->column_name);

      g_node_append_data (row, data);

    }

}

static void

clear_view (GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  GtkTreeViewColumn *column;

  /* Clear columns ... */

  while ((column = gtk_tree_view_get_column (eprop_data->view, 0)) != NULL)

    gtk_tree_view_remove_column (eprop_data->view, column);

  /* Clear store ... (this will unref the old store) */

  gtk_tree_view_set_model (eprop_data->view, NULL);

}

static gboolean

update_data_tree_idle (GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  GladeProperty       *property = glade_editor_property_get_property (eprop);

  GValue value = { 0, };

  g_value_init (&value, GLADE_TYPE_MODEL_DATA_TREE);

  g_value_take_boxed (&value, eprop_data->pending_data_tree);

  /* Only commit the value if it changed, otherwise this

   * can trigger a load.. which we dont handle well in this

   * editor 

   */

  if (!glade_property_equals_value (property, &value))

    glade_editor_property_commit (eprop, &value);

  g_value_unset (&value);

  eprop_data->pending_data_tree = NULL;

  return FALSE;

}

static gboolean

update_and_focus_data_tree_idle (GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  GladeProperty       *property = glade_editor_property_get_property (eprop);

  eprop_data->want_focus = TRUE;

  update_data_tree_idle (eprop);

  /* XXX Have to load it regardless if it changed, this is a slow and redundant way... */

  glade_editor_property_load (eprop, property);

  eprop_data->want_focus = FALSE;

  return FALSE;

}

static gboolean

focus_data_tree_idle (GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  eprop_data->want_focus = TRUE;

  eprop_data_focus_editing_cell (eprop_data);

  eprop_data->want_focus = FALSE;

  return FALSE;

}

static void

glade_eprop_model_data_add_row (GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  GValue value = { 0, };

  GNode *node = NULL;

  GList *columns = NULL;

  GladeProperty *property = glade_editor_property_get_property (eprop);

  glade_property_get (property, &node);

  glade_widget_property_get (glade_property_get_widget (property), "columns", &columns);

  if (!columns)

    return;

  clear_view (eprop);

  if (!node)

    node = g_node_new (NULL);

  else

    node = glade_model_data_tree_copy (node);

  append_row (node, columns);

  eprop_data->adding_row = TRUE;

  g_value_init (&value, GLADE_TYPE_MODEL_DATA_TREE);

  g_value_take_boxed (&value, node);

  glade_editor_property_commit (eprop, &value);

  g_value_unset (&value);

  eprop_data->adding_row = FALSE;

}

static void

glade_eprop_model_data_delete_selected (GladeEditorProperty * eprop)

{

  GtkTreeIter iter;

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  GladeProperty *property = glade_editor_property_get_property (eprop);

  GNode *data_tree = NULL, *row;

  gint rownum = -1;

  /* NOTE: This will trigger row-deleted below... */

  if (!gtk_tree_selection_get_selected (eprop_data->selection, NULL, &iter))

    return;

  gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,

                      COLUMN_ROW, &rownum, -1);

  g_assert (rownum >= 0);

  /* if theres a sected row, theres data... */

  glade_property_get (property, &data_tree);

  g_assert (data_tree);

  data_tree = glade_model_data_tree_copy (data_tree);

  row = g_node_nth_child (data_tree, rownum);

  g_node_unlink (row);

  glade_model_data_tree_free (row);

  if (eprop_data->pending_data_tree)

    glade_model_data_tree_free (eprop_data->pending_data_tree);

  eprop_data->pending_data_tree = data_tree;

  g_idle_add ((GSourceFunc) update_data_tree_idle, eprop);

}

static void

glade_eprop_model_data_add_clicked (GtkWidget * button,

                                    GladeEditorProperty * eprop)

{

  glade_eprop_model_data_add_row (eprop);

}

static void

glade_eprop_model_data_delete_clicked (GtkWidget * button,

                                       GladeEditorProperty * eprop)

{

  glade_eprop_model_data_delete_selected (eprop);

}

static gboolean

eprop_treeview_key_press (GtkWidget * treeview,

                          GdkEventKey * event, GladeEditorProperty * eprop)

{

  if (event->keyval == GDK_KEY_Delete)

    {

      glade_eprop_model_data_delete_selected (eprop);

      return TRUE;

    }

  else if ((event->state & GDK_CONTROL_MASK) != 0 &&

           (event->keyval == GDK_KEY_n || event->keyval == GDK_KEY_N))

    {

      glade_eprop_model_data_add_row (eprop);

      return TRUE;

    }

  return FALSE;

}

static gboolean

data_changed_idle (GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  GladeProperty *property = glade_editor_property_get_property (eprop);

  GNode *data_tree = NULL, *new_tree, *row;

  GtkTreeIter iter;

  gint rownum;

  glade_property_get (property, &data_tree);

  g_assert (data_tree);

  new_tree = g_node_new (NULL);

  if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (eprop_data->store), &iter))

    {

      do

        {

          gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,

                              COLUMN_ROW, &rownum, -1);

          if ((row = g_node_nth_child (data_tree, rownum)) != NULL)

            {

              /* Make a new tree by copying row by row... */

              row = glade_model_data_tree_copy (row);

              g_node_append (new_tree, row);

            }

        }

      while (gtk_tree_model_iter_next

             (GTK_TREE_MODEL (eprop_data->store), &iter));

    }

  /* Were already in an idle, no need to idle from here...  */

  if (eprop_data->pending_data_tree)

    glade_model_data_tree_free (eprop_data->pending_data_tree);

  eprop_data->pending_data_tree = new_tree;

  update_data_tree_idle (eprop);

  return FALSE;

}

static void

eprop_treeview_row_deleted (GtkTreeModel * tree_model,

                            GtkTreePath * path, GladeEditorProperty * eprop)

{

  if (glade_editor_property_loading (eprop))

    return;

  g_idle_add ((GSourceFunc) data_changed_idle, eprop);

}

static void

glade_eprop_model_data_finalize (GObject * object)

{

  /* Chain up */

  GObjectClass *parent_class =

      g_type_class_peek_parent (G_OBJECT_GET_CLASS (object));

  //GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (object);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static GtkListStore *

eprop_model_data_generate_store (GladeEditorProperty * eprop)

{

  GtkListStore *store = NULL;

  GladeModelData *iter_data;

  GNode *data_tree = NULL, *iter_node, *row_node;

  GArray *gtypes = g_array_new (FALSE, TRUE, sizeof (GType));

  GtkTreeIter iter;

  gint column_num, row_num;

  GType index_type = G_TYPE_INT, string_type = G_TYPE_STRING, pointer_type = G_TYPE_POINTER;

  GladeProperty *property = glade_editor_property_get_property (eprop);

  glade_property_get (property, &data_tree);

  if (!data_tree || !data_tree->children || !data_tree->children->children)

    return NULL;

  /* Generate store with tailored column types */

  g_array_append_val (gtypes, index_type);

  for (iter_node = data_tree->children->children; iter_node;

       iter_node = iter_node->next)

    {

      iter_data = iter_node->data;

      if (G_VALUE_TYPE (&iter_data->value) == 0)

        g_array_append_val (gtypes, pointer_type);

      else if (G_VALUE_TYPE (&iter_data->value) == GDK_TYPE_PIXBUF)

        g_array_append_val (gtypes, string_type);

      else

        g_array_append_val (gtypes, G_VALUE_TYPE (&iter_data->value));

    }

  store = gtk_list_store_newv (gtypes->len, (GType *) gtypes->data);

  g_array_free (gtypes, TRUE);

  /* Now populate the store with data */

  for (row_num = 0, row_node = data_tree->children; row_node;

       row_num++, row_node = row_node->next)

    {

      gtk_list_store_append (store, &iter);

      gtk_list_store_set (store, &iter, COLUMN_ROW, row_num, -1);

      for (column_num = NUM_COLUMNS, iter_node = row_node->children; iter_node;

           column_num++, iter_node = iter_node->next)

        {

          iter_data = iter_node->data;

          if (G_VALUE_TYPE (&iter_data->value) == 0)

            continue;

          /* Special case, show the filename in the cellrenderertext */

          if (G_VALUE_TYPE (&iter_data->value) == GDK_TYPE_PIXBUF)

            {

              GObject *object = g_value_get_object (&iter_data->value);

              gchar *filename = NULL;

              if (object)

                filename = g_object_get_data (object, "GladeFileName");

              gtk_list_store_set (store, &iter, column_num, filename, -1);

            }

          else

            gtk_list_store_set_value (store, &iter, column_num,

                                      &iter_data->value);

        }

    }

  return store;

}

static void

value_toggled (GtkCellRendererToggle * cell,

               gchar * path, GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  GtkTreeIter iter;

  gint colnum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number"));

  gint row;

  GNode *data_tree = NULL;

  GladeModelData *data;

  gboolean active;

  GladeProperty *property = glade_editor_property_get_property (eprop);

  if (!gtk_tree_model_get_iter_from_string

      (GTK_TREE_MODEL (eprop_data->store), &iter, path))

    return;

  gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,

                      COLUMN_ROW, &row, NUM_COLUMNS + colnum, &active, -1);

  glade_property_get (property, &data_tree);

  /* if we are editing, then there is data in the datatree */

  g_assert (data_tree);

  data_tree = glade_model_data_tree_copy (data_tree);

  data = glade_model_data_tree_get_data (data_tree, row, colnum);

  g_value_set_boolean (&data->value, !active);

  eprop_data->editing_row = row;

  eprop_data->editing_column = colnum;

  if (eprop_data->pending_data_tree)

    glade_model_data_tree_free (eprop_data->pending_data_tree);

  eprop_data->pending_data_tree = data_tree;

  g_idle_add ((GSourceFunc) update_and_focus_data_tree_idle, eprop);

}

static void

value_i18n_activate (GladeCellRendererIcon * cell,

                     const gchar * path, GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  GtkTreeIter iter;

  gint colnum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number"));

  gint row;

  GNode *data_tree = NULL;

  GladeModelData *data;

  gchar *new_text;

  GladeProperty *property = glade_editor_property_get_property (eprop);

  if (!gtk_tree_model_get_iter_from_string

      (GTK_TREE_MODEL (eprop_data->store), &iter, path))

    return;

  gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,

                      COLUMN_ROW, &row, -1);

  glade_property_get (property, &data_tree);

  /* if we are editing, then there is data in the datatree */

  g_assert (data_tree);

  data_tree = glade_model_data_tree_copy (data_tree);

  data = glade_model_data_tree_get_data (data_tree, row, colnum);

  g_assert (G_VALUE_TYPE (&data->value) == G_TYPE_STRING);

  new_text = g_value_dup_string (&data->value);

  if (glade_editor_property_show_i18n_dialog (NULL,

                                              &new_text,

                                              &data->i18n_context,

                                              &data->i18n_comment,

                                              &data->i18n_translatable))

    {

      g_value_set_string (&data->value, new_text);

      eprop_data->editing_row = row;

      eprop_data->editing_column = colnum;

      if (eprop_data->pending_data_tree)

        glade_model_data_tree_free (eprop_data->pending_data_tree);

      eprop_data->pending_data_tree = data_tree;

      g_idle_add ((GSourceFunc) update_and_focus_data_tree_idle, eprop);

    }

  else

    glade_model_data_tree_free (data_tree);

  g_free (new_text);

}

static void

value_text_edited (GtkCellRendererText * cell,

                   const gchar * path,

                   const gchar * new_text, GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  GtkTreeIter iter;

  gint colnum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number"));

  gint row;

  GNode *data_tree = NULL;

  GladeModelData *data;

  GValue *value;

  GladeProperty *property = glade_editor_property_get_property (eprop);

  if (!gtk_tree_model_get_iter_from_string

      (GTK_TREE_MODEL (eprop_data->store), &iter, path))

    return;

  gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,

                      COLUMN_ROW, &row, -1);

  glade_property_get (property, &data_tree);

  /* if we are editing, then there is data in the datatree */

  g_assert (data_tree);

  data_tree = glade_model_data_tree_copy (data_tree);

  data = glade_model_data_tree_get_data (data_tree, row, colnum);

  /* Untranslate string and update value in tree. */

  if (G_VALUE_HOLDS_ENUM (&data->value) || G_VALUE_HOLDS_FLAGS (&data->value))

    value = glade_utils_value_from_string (G_VALUE_TYPE (&data->value),

                                           glade_get_value_from_displayable

                                           (G_VALUE_TYPE (&data->value),

                                            new_text),

                                           glade_widget_get_project (glade_property_get_widget (property)));

  else

    value =

        glade_utils_value_from_string (G_VALUE_TYPE (&data->value), new_text,

                                       glade_widget_get_project (glade_property_get_widget (property)));

  g_value_copy (value, &data->value);

  g_value_unset (value);

  g_free (value);

  eprop_data->editing_row = row;

  eprop_data->editing_column = colnum;

  if (eprop_data->pending_data_tree)

    glade_model_data_tree_free (eprop_data->pending_data_tree);

  eprop_data->pending_data_tree = data_tree;

  g_idle_add ((GSourceFunc) update_and_focus_data_tree_idle, eprop);

}

static void

enum_flags_format_cell_data (GtkCellLayout * cell_layout,

                             GtkCellRenderer * cell,

                             GtkTreeModel * tree_model,

                             GtkTreeIter * iter, gpointer data)

{

  gint colnum =

      GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number"));

  GValue value = { 0, };

  gchar *string;

  gtk_tree_model_get_value (tree_model, iter, NUM_COLUMNS + colnum, &value);

  string = glade_utils_string_from_value (&value);

  g_object_set (cell, "text", string && string[0] ?

                glade_get_displayable_value (G_VALUE_TYPE (&value),

                                             string) : "", NULL);

  g_free (string);

  g_value_unset (&value);

}

static void

data_editing_started (GtkCellRenderer * cell,

                      GtkCellEditable * editable,

                      gchar * path, GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  gint colnum =

      GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number"));

  gint row;

  GtkTreeIter iter;

  if (!gtk_tree_model_get_iter_from_string

      (GTK_TREE_MODEL (eprop_data->store), &iter, path))

    return;

  gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,

                      COLUMN_ROW, &row, -1);

  eprop_data->editing_row = row;

  eprop_data->editing_column = colnum;

}

static void

data_editing_canceled (GtkCellRenderer * renderer, GladeEditorProperty * eprop)

{

  GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);

  if (eprop_data->setting_focus)

    return;

  g_idle_add ((GSourceFunc) focus_data_tree_idle, eprop);

}

static GtkTreeViewColumn *

eprop_model_generate_column (GladeEditorProperty * eprop,

                             gint colnum, GladeModelData * data)

{

  GtkTreeViewColumn *column = gtk_tree_view_column_new ();

  GtkCellRenderer *renderer = NULL;

  GtkAdjustment *adjustment;

  GtkListStore *store;

  GType type = G_TYPE_INVALID;

  gtk_tree_view_column_set_title (column, data->name);

  gtk_tree_view_column_set_resizable (column, TRUE);

  gtk_tree_view_column_set_expand (column, TRUE);

  type = G_VALUE_TYPE (&data->value);

  /* Support enum and flag types, and a hardcoded list of fundamental types */

  if (type == G_TYPE_CHAR ||

      type == G_TYPE_UCHAR || type == G_TYPE_STRING || type == GDK_TYPE_PIXBUF)

    {

      /* Text renderer */

      renderer = gtk_cell_renderer_text_new ();

      g_object_set (G_OBJECT (renderer),

                    "editable", TRUE,

                    "ellipsize", PANGO_ELLIPSIZE_END, "width", 90, NULL);

      gtk_tree_view_column_pack_start (column, renderer, FALSE);

      gtk_tree_view_column_set_attributes (column, renderer,

                                           "text", NUM_COLUMNS + colnum, NULL);

      if (type == G_TYPE_CHAR || type == G_TYPE_UCHAR)

        {

          /* XXX restrict to 1 char !! */

        }

      g_signal_connect (G_OBJECT (renderer), "edited",

                        G_CALLBACK (value_text_edited), eprop);

      /* Trigger i18n dialog from here */

      if (type == G_TYPE_STRING)

        {

          GtkCellRenderer *icon_renderer = glade_cell_renderer_icon_new ();

          g_object_set (G_OBJECT (icon_renderer),

                        "activatable", TRUE,

                        "icon-name", "gtk-edit",

                        NULL);

          gtk_tree_view_column_pack_start (column, icon_renderer, FALSE);

          g_object_set_data (G_OBJECT (icon_renderer), "column-number",

                             GINT_TO_POINTER (colnum));

          g_signal_connect (G_OBJECT (icon_renderer), "activate",

                            G_CALLBACK (value_i18n_activate), eprop);

        }

    }

  else if (type == G_TYPE_BOOLEAN)

    {

      /* Toggle renderer */

      renderer = gtk_cell_renderer_toggle_new ();

      g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);

      gtk_tree_view_column_pack_start (column, renderer, FALSE);

      gtk_tree_view_column_set_attributes (column, renderer,

                                           "active", NUM_COLUMNS + colnum,

                                           NULL);

      g_signal_connect (G_OBJECT (renderer), "toggled",

                        G_CALLBACK (value_toggled), eprop);

    }

  /* Check renderer */

  else if (type == G_TYPE_INT ||

           type == G_TYPE_UINT ||

           type == G_TYPE_LONG ||

           type == G_TYPE_ULONG ||

           type == G_TYPE_INT64 ||

           type == G_TYPE_UINT64 ||

           type == G_TYPE_FLOAT || type == G_TYPE_DOUBLE)