/*

 * glade-named-icon-chooser-widget.c - Named icon chooser widget

 *

 * Copyright (C) 2007 Vincent Geddes

 *

 * Author:  Vincent Geddes <vgeddes@gnome.org>

 *

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

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANNAMED_ICON_CHOOSERILITY 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, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 */

#include <config.h>

#include "glade-private.h"

#include "glade-named-icon-chooser-dialog.h"

#include "icon-naming-spec.c"

#include <gtk/gtk.h>

#include <glib/gi18n-lib.h>

#include <string.h>

#include <errno.h>

#define DEFAULT_SETTING_LIST_STANDARD_ONLY   TRUE

enum

{

  CONTEXTS_ID_COLUMN,

  CONTEXTS_NAME_COLUMN,

  CONTEXTS_TITLE_COLUMN,

  CONTEXTS_N_COLUMS

};

enum

{

  ICONS_CONTEXT_COLUMN,

  ICONS_STANDARD_COLUMN,

  ICONS_NAME_COLUMN,

  ICONS_N_COLUMNS

};

enum

{

  GLADE_NAMED_ICON

};

enum

{

  ICON_ACTIVATED,

  SELECTION_CHANGED,

  LAST_SIGNAL

};

struct _GladeNamedIconChooserDialogPrivate

{

  GtkWidget *icons_view;

  GtkTreeModel *filter_model;   /* filtering model  */

  GtkListStore *icons_store;    /* data store       */

  GtkTreeSelection *selection;

  GtkWidget *contexts_view;

  GtkListStore *contexts_store;

  GtkWidget *entry;

  GtkEntryCompletion *entry_completion;

  GtkWidget *button;            /* list-standard-only checkbutton */

  gint context_id;              /* current icon name context for icon filtering */

  gchar *pending_select_name;   /* an icon name for a pending treeview selection.

                                 * can only select name after model is loaded

                                 * and the widget is mapped */

  GtkIconTheme *icon_theme;     /* the current icon theme */

  guint load_id;                /* id of the idle function for loading data into model */

  gboolean settings_list_standard;      /* whether to list standard icon names only */

  GtkWidget *last_focus_widget;

  gboolean icons_loaded;        /* whether the icons have been loaded into the model */

};

static GHashTable *standard_icon_quarks = NULL;

static guint dialog_signals[LAST_SIGNAL] = { 0, };

gchar *

glade_named_icon_chooser_dialog_get_icon_name (GladeNamedIconChooserDialog *dialog);

void

glade_named_icon_chooser_dialog_set_icon_name (GladeNamedIconChooserDialog *dialog,

                                               const gchar                 *icon_name);

gboolean

glade_named_icon_chooser_dialog_set_context (GladeNamedIconChooserDialog *dialog,

                                             const gchar                 *context);

gchar *

glade_named_icon_chooser_dialog_get_context (GladeNamedIconChooserDialog *dialog);

static gboolean should_respond (GladeNamedIconChooserDialog *dialog);

static void filter_icons_model (GladeNamedIconChooserDialog *dialog);

static gboolean scan_for_name_func (GtkTreeModel *model,

                                    GtkTreePath  *path,

                                    GtkTreeIter  *iter,

                                    gpointer      data);

static gboolean scan_for_context_func (GtkTreeModel *model,

                                       GtkTreePath  *path,

                                       GtkTreeIter  *iter,

                                       gpointer      data);

static void settings_load (GladeNamedIconChooserDialog *dialog);

static void settings_save (GladeNamedIconChooserDialog *dialog);

G_DEFINE_TYPE_WITH_PRIVATE (GladeNamedIconChooserDialog,

                            glade_named_icon_chooser_dialog,

                            GTK_TYPE_DIALOG);

static void

entry_set_name (GladeNamedIconChooserDialog *dialog, const gchar *name)

{

  /* Must disable completion before setting text, in order to avoid

   * spurious warnings (possible GTK+ bug).

   */

  gtk_entry_set_completion (GTK_ENTRY (dialog->priv->entry), NULL);

  gtk_entry_set_text (GTK_ENTRY (dialog->priv->entry), name);

  gtk_entry_set_completion (GTK_ENTRY (dialog->priv->entry),

                            dialog->priv->entry_completion);

}

static GtkIconTheme *

get_icon_theme_for_widget (GtkWidget *widget)

{

  if (gtk_widget_has_screen (widget))

    return gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));

  return gtk_icon_theme_get_default ();

}

/* validates name according to the icon naming spec (en_US.US_ASCII [a-z1-9_-.])  */

static gboolean

is_well_formed (const gchar * name)

{

  gchar *c = (gchar *) name;

  for (; *c; c++)

    {

      if (g_ascii_isalnum (*c))

        {

          if (g_ascii_isalpha (*c) && !g_ascii_islower (*c))

            return FALSE;

        }

      else if (*c != '_' && *c != '-' && *c != '.')

        {

          return FALSE;

        }

    }

  return TRUE;

}

static void

check_entry_text (GladeNamedIconChooserDialog *dialog,

                  gchar                      **name_ret,

                  gboolean                    *is_wellformed_ret,

                  gboolean                    *is_empty_ret)

{

  if (strlen (gtk_entry_get_text (GTK_ENTRY (dialog->priv->entry))) == 0)

    {

      *name_ret = NULL;

      *is_wellformed_ret = TRUE;

      *is_empty_ret = TRUE;

      return;

    }

  *is_empty_ret = FALSE;

  *is_wellformed_ret =

      is_well_formed (gtk_entry_get_text (GTK_ENTRY (dialog->priv->entry)));

  if (*is_wellformed_ret)

    *name_ret = g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->priv->entry)));

  else

    *name_ret = NULL;

}

static void

changed_text_handler (GtkEditable                 *editable,

                      GladeNamedIconChooserDialog *dialog)

{

  g_signal_emit_by_name (dialog, "selection-changed", NULL);

}

/* ensure that only valid text can be inserted into entry */

static void

insert_text_handler (GtkEditable                 *editable,

                     const gchar                 *text,

                     gint                         length,

                     gint                        *position,

                     GladeNamedIconChooserDialog *dialog)

{

  if (is_well_formed (text))

    {

      g_signal_handlers_block_by_func (editable, (gpointer) insert_text_handler,

                                       dialog);

      gtk_editable_insert_text (editable, text, length, position);

      g_signal_handlers_unblock_by_func (editable,

                                         (gpointer) insert_text_handler,

                                         dialog);

    }

  else

    {

      gdk_display_beep (gtk_widget_get_display (GTK_WIDGET (dialog)));

    }

  g_signal_stop_emission_by_name (editable, "insert-text");

}

typedef struct

{

  gchar *name;                  /* the name of the icon or context */

  guint found:1;                /* whether an item matching `name' was found */

  guint do_select:1;            /* select the matched row */

  guint do_cursor:1;            /* put cursor at the matched row */

  guint do_activate:1;          /* activate the matched row */

  GladeNamedIconChooserDialog *dialog;

} ForEachFuncData;

void

glade_named_icon_chooser_dialog_set_icon_name (GladeNamedIconChooserDialog *dialog, 

                                               const gchar                 *name)

{

  ForEachFuncData *data;

  gboolean located_in_theme;

  g_return_if_fail (GLADE_IS_NAMED_ICON_CHOOSER_DIALOG (dialog));

  g_return_if_fail (gtk_widget_has_screen (GTK_WIDGET (dialog)));

  if (name == NULL)

    {

      gtk_tree_selection_unselect_all (dialog->priv->selection);

      entry_set_name (dialog, "");

      return;

    }

  located_in_theme =

      gtk_icon_theme_has_icon (get_icon_theme_for_widget (GTK_WIDGET (dialog)),

                               name);

  if (located_in_theme)

    {

      if (dialog->priv->icons_loaded && dialog->priv->filter_model)

        {

          data = g_slice_new0 (ForEachFuncData);

          data->name = g_strdup (name);

          data->found = FALSE;

          data->do_activate = FALSE;

          data->do_select = TRUE;

          data->do_cursor = TRUE;

          data->dialog = dialog;

          gtk_tree_model_foreach (dialog->priv->filter_model,

                                  scan_for_name_func, data);

          g_free (data->name);

          g_slice_free (ForEachFuncData, data);

        }

      else

        {

          dialog->priv->pending_select_name = g_strdup (name);

        }

      /* selecting a treeview row will set the entry text,

       * but we must have this here in case the row has been filtered out

       */

      entry_set_name (dialog, name);

    }

  else if (is_well_formed (name))

    {

      gtk_tree_selection_unselect_all (dialog->priv->selection);

      entry_set_name (dialog, name);

    }

  else

    {

      g_warning ("invalid icon name: '%s' is not well formed", name);

    }

}

gboolean

glade_named_icon_chooser_dialog_set_context (GladeNamedIconChooserDialog *dialog,

                                             const gchar                 *name)

{

  ForEachFuncData *data;

  g_return_val_if_fail (GLADE_IS_NAMED_ICON_CHOOSER_DIALOG (dialog), FALSE);

  data = g_slice_new0 (ForEachFuncData);

  if (name)

    data->name = g_strdup (name);

  else

    data->name = g_strdup ("All Contexts");

  data->found = FALSE;

  data->do_select = TRUE;

  data->do_activate = FALSE;

  data->do_cursor = FALSE;

  data->dialog = dialog;

  gtk_tree_model_foreach (GTK_TREE_MODEL (dialog->priv->contexts_store),

                          (GtkTreeModelForeachFunc) scan_for_context_func,

                          data);

  g_free (data->name);

  g_slice_free (ForEachFuncData, data);

  return TRUE;

}

gchar *

glade_named_icon_chooser_dialog_get_context (GladeNamedIconChooserDialog *dialog)

{

  GtkTreeSelection *sel;

  GtkTreeIter iter;

  gchar *context_name;

  g_return_val_if_fail (GLADE_IS_NAMED_ICON_CHOOSER_DIALOG (dialog), NULL);

  sel =

      gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->contexts_view));

  if (gtk_tree_selection_get_selected (sel, NULL, &iter))

    {

      gtk_tree_model_get (GTK_TREE_MODEL (dialog->priv->contexts_store), &iter,

                          CONTEXTS_NAME_COLUMN, &context_name, -1);

      /* if context_name is NULL, then it is the 'all categories' special context */

      return context_name;

    }

  else

    {

      return NULL;

    }

}

static gchar *

get_icon_name_from_selection (GladeNamedIconChooserDialog *dialog)

{

  GtkTreeIter iter;

  GtkTreeModel *model;

  gchar *name;

  if (!gtk_tree_selection_get_selected (dialog->priv->selection, &model, &iter))

    return NULL;

  gtk_tree_model_get (model, &iter, ICONS_NAME_COLUMN, &name, -1);

  return name;

}

gchar *

glade_named_icon_chooser_dialog_get_icon_name (GladeNamedIconChooserDialog *dialog)

{

  GtkWidget *current_focus;

  gchar *name;

  g_return_val_if_fail (GLADE_IS_NAMED_ICON_CHOOSER_DIALOG (dialog), NULL);

  current_focus = gtk_window_get_focus (GTK_WINDOW (dialog));

  if (current_focus == dialog->priv->icons_view)

    {

    view:

      name = get_icon_name_from_selection (dialog);

      if (name == NULL)

        goto entry;

    }

  else if (current_focus == dialog->priv->entry)

    {

      gboolean is_wellformed, is_empty;

    entry:

      check_entry_text (dialog, &name, &is_wellformed, &is_empty);

      if (!is_wellformed || is_empty)

        return NULL;

    }

  else if (dialog->priv->last_focus_widget == dialog->priv->icons_view)

    {

      goto view;

    }

  else if (dialog->priv->last_focus_widget == dialog->priv->entry)

    {

      goto entry;

    }

  else

    {

      goto view;

    }

  return name;

}

static void

set_busy_cursor (GladeNamedIconChooserDialog *dialog, gboolean busy)

{

  GdkDisplay *display;

  GdkCursor *cursor;

  if (!gtk_widget_get_realized (GTK_WIDGET (dialog)))

    return;

  display = gtk_widget_get_display (GTK_WIDGET (dialog));

  if (busy)

    cursor = gdk_cursor_new_for_display (display, GDK_WATCH);

  else

    cursor = NULL;

  gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (dialog)), cursor);

  gdk_display_flush (display);

  if (cursor)

    g_object_unref (cursor);

}

static GtkListStore *

populate_icon_contexts_model (void)

{

  GtkListStore *store;

  GtkTreeIter iter;

  guint i;

  store = gtk_list_store_new (CONTEXTS_N_COLUMS,

                              G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);

  gtk_list_store_append (store, &iter);

  gtk_list_store_set (store, &iter,

                      CONTEXTS_ID_COLUMN, -1,

                      CONTEXTS_NAME_COLUMN, "All Contexts",

                      CONTEXTS_TITLE_COLUMN, _("All Contexts"), -1);

  gtk_list_store_append (store, &iter);

  gtk_list_store_set (store, &iter,

                      CONTEXTS_ID_COLUMN, -1,

                      CONTEXTS_NAME_COLUMN, NULL,

                      CONTEXTS_TITLE_COLUMN, NULL, -1);

  for (i = 0; i < G_N_ELEMENTS (standard_contexts); i++)

    {

      gtk_list_store_append (store, &iter);

      gtk_list_store_set (store, &iter,

                          CONTEXTS_ID_COLUMN, i,

                          CONTEXTS_NAME_COLUMN, standard_contexts[i].name,

                          CONTEXTS_TITLE_COLUMN, _(standard_contexts[i].title),

                          -1);

    }

  return store;

}

static void

icons_row_activated_cb (GtkTreeView                 *view,

                        GtkTreePath                 *path,

                        GtkTreeViewColumn           *column,

                        GladeNamedIconChooserDialog *dialog)

{

  g_signal_emit_by_name (dialog, "icon-activated", NULL);

}

static void

icons_selection_changed_cb (GtkTreeSelection * selection,

                            GladeNamedIconChooserDialog * dialog)

{

  GtkTreeModel *model;

  GtkTreeIter iter;

  gchar *name;

  if (gtk_tree_selection_get_selected (selection, &model, &iter))

    {

      gtk_tree_model_get (model, &iter, ICONS_NAME_COLUMN, &name, -1);

      if (name)

        entry_set_name (dialog, name);

      g_free (name);

    }

  else

    {

      /* entry_set_name (dialog, ""); */

    }

  /* we emit "selection-changed" for chooser in insert_text_handler()

   * to avoid emitting the signal twice */

}

static void

contexts_row_activated_cb (GtkTreeView                 *view,

                           GtkTreePath                 *cpath,

                           GtkTreeViewColumn           *column,

                           GladeNamedIconChooserDialog *dialog)

{

  GtkTreeIter iter;

  GtkTreePath *path;

  if (gtk_tree_model_get_iter_first (dialog->priv->filter_model, &iter))

    {

      gtk_tree_selection_select_iter (dialog->priv->selection, &iter);

      path = gtk_tree_model_get_path (dialog->priv->filter_model, &iter);

      gtk_tree_selection_select_path (dialog->priv->selection, path);

      gtk_tree_view_scroll_to_point (GTK_TREE_VIEW (dialog->priv->icons_view),

                                     -1, 0);

      gtk_tree_path_free (path);

    }

  gtk_widget_grab_focus (dialog->priv->icons_view);

}

static void

contexts_selection_changed_cb (GtkTreeSelection            *selection,

                               GladeNamedIconChooserDialog *dialog)

{

  GtkTreeIter iter;

  GtkTreeModel *model;

  gboolean retval;

  gint context_id;

  retval = gtk_tree_selection_get_selected (selection, &model, &iter);

  if (retval)

    {

      gtk_tree_model_get (model, &iter, CONTEXTS_ID_COLUMN, &context_id, -1);

      dialog->priv->context_id = context_id;

      if (!dialog->priv->filter_model)

        return;

      filter_icons_model (dialog);

    }

  entry_set_name (dialog, "");

}

static gboolean

row_separator_func (GtkTreeModel *model, GtkTreeIter *iter, gpointer unused)

{

  gboolean retval;

  gchar *name, *title;

  gtk_tree_model_get (model, iter,

                      CONTEXTS_NAME_COLUMN, &name,

                      CONTEXTS_TITLE_COLUMN, &title, -1);

  retval = !name && !title;

  g_free (name);

  g_free (title);

  return retval;

}

static GtkWidget *

create_contexts_view (GladeNamedIconChooserDialog *dialog)

{

  GtkTreeView *view;

  GtkTreeViewColumn *column;

  GtkTreePath *path;

  dialog->priv->contexts_store = populate_icon_contexts_model ();

  view =

      GTK_TREE_VIEW (gtk_tree_view_new_with_model

                     (GTK_TREE_MODEL (dialog->priv->contexts_store)));

  column = gtk_tree_view_column_new_with_attributes (NULL,

                                                     gtk_cell_renderer_text_new

                                                     (), "text",

                                                     CONTEXTS_TITLE_COLUMN,

                                                     NULL);

  gtk_tree_view_append_column (view, column);

  gtk_tree_view_set_headers_visible (view, FALSE);

  gtk_tree_view_set_row_separator_func (view,

                                        (GtkTreeViewRowSeparatorFunc)

                                        row_separator_func, NULL, NULL);

  gtk_tree_selection_set_mode (gtk_tree_view_get_selection (view),

                               GTK_SELECTION_BROWSE);

  path = gtk_tree_path_new_from_indices (0, -1);

  gtk_tree_selection_select_path (gtk_tree_view_get_selection (view), path);

  gtk_tree_path_free (path);

  g_signal_connect (view, "row-activated",

                    G_CALLBACK (contexts_row_activated_cb), dialog);

  g_signal_connect (gtk_tree_view_get_selection (view), "changed",

                    G_CALLBACK (contexts_selection_changed_cb), dialog);

  gtk_widget_show (GTK_WIDGET (view));

  return GTK_WIDGET (view);

}

/* filters the icons model based on the current state */

static void

filter_icons_model (GladeNamedIconChooserDialog *dialog)

{

  set_busy_cursor (dialog, TRUE);

  g_object_ref (dialog->priv->filter_model);

  gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->icons_view), NULL);

  gtk_entry_completion_set_model (dialog->priv->entry_completion, NULL);

  gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER

                                  (dialog->priv->filter_model));

  gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->icons_view),

                           dialog->priv->filter_model);

  gtk_entry_completion_set_model (dialog->priv->entry_completion,

                                  GTK_TREE_MODEL (dialog->priv->icons_store));

  gtk_entry_completion_set_text_column (dialog->priv->entry_completion,

                                        ICONS_NAME_COLUMN);

  g_object_unref (dialog->priv->filter_model);

  set_busy_cursor (dialog, FALSE);

}

static gboolean

filter_visible_func (GtkTreeModel                *model,

                     GtkTreeIter                 *iter,

                     GladeNamedIconChooserDialog *dialog)

{

  gboolean standard;

  gint context_id;

  gtk_tree_model_get (model, iter,

                      ICONS_CONTEXT_COLUMN, &context_id,

                      ICONS_STANDARD_COLUMN, &standard, -1);

  if (dialog->priv->context_id == -1)

    return (dialog->priv->settings_list_standard) ? TRUE && standard : TRUE;

  if (context_id == dialog->priv->context_id)

    return (dialog->priv->settings_list_standard) ? TRUE && standard : TRUE;

  else

    return FALSE;

}

static gboolean

search_equal_func (GtkTreeModel                *model,

                   gint                         column,

                   const gchar                 *key,

                   GtkTreeIter                 *iter,

                   GladeNamedIconChooserDialog *dialog)

{

  gchar *name;

  gboolean retval;

  gtk_tree_model_get (model, iter, ICONS_NAME_COLUMN, &name, -1);

  retval = !g_str_has_prefix (name, key);

  g_free (name);

  return retval;

}

static gboolean

scan_for_context_func (GtkTreeModel *model,

                       GtkTreePath  *path,

                       GtkTreeIter  *iter,

                       gpointer      user_data)

{

  ForEachFuncData *data = (ForEachFuncData *) user_data;

  GtkTreeSelection *selection =

      gtk_tree_view_get_selection (GTK_TREE_VIEW

                                   (data->dialog->priv->contexts_view));

  gchar *name = NULL;

  gtk_tree_model_get (model, iter, CONTEXTS_NAME_COLUMN, &name, -1);

  if (!name)

    return FALSE;

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

    {

      data->found = TRUE;

      if (data->do_activate)

        gtk_tree_view_row_activated (GTK_TREE_VIEW

                                     (data->dialog->priv->contexts_view), path,

                                     gtk_tree_view_get_column (GTK_TREE_VIEW

                                                               (data->dialog->

                                                                priv->

                                                                contexts_view),

                                                               0));

      if (data->do_select)

        gtk_tree_selection_select_path (selection, path);

      else

        gtk_tree_selection_unselect_path (selection, path);

      if (data->do_cursor)

        gtk_tree_view_set_cursor (GTK_TREE_VIEW

                                  (data->dialog->priv->contexts_view), path,

                                  NULL, FALSE);

      g_free (name);

      return TRUE;

    }

  g_free (name);

  return FALSE;

}

gboolean

scan_for_name_func (GtkTreeModel *model,

                    GtkTreePath  *path,

                    GtkTreeIter  *iter,

                    gpointer      user_data)

{

  ForEachFuncData *data = (ForEachFuncData *) user_data;

  gchar *name = NULL;

  gtk_tree_model_get (model, iter, ICONS_NAME_COLUMN, &name, -1);

  if (!name)

    return FALSE;

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

    {

      data->found = TRUE;

      if (data->do_activate)

        gtk_tree_view_row_activated (GTK_TREE_VIEW

                                     (data->dialog->priv->icons_view), path,

                                     gtk_tree_view_get_column (GTK_TREE_VIEW

                                                               (data->dialog->

                                                                priv->

                                                                icons_view),

                                                               0));

      if (data->do_select)

        gtk_tree_selection_select_path (data->dialog->priv->selection, path);

      else

        gtk_tree_selection_unselect_path (data->dialog->priv->selection, path);

      if (data->do_cursor)

        gtk_tree_view_set_cursor (GTK_TREE_VIEW

                                  (data->dialog->priv->icons_view), path, NULL,

                                  FALSE);

      g_free (name);

      return TRUE;

    }

  g_free (name);

  return FALSE;

}

static void

centre_selected_row (GladeNamedIconChooserDialog *dialog)

{

  GList *l;

  g_assert (dialog->priv->icons_store != NULL);

  g_assert (dialog->priv->selection != NULL);

  l = gtk_tree_selection_get_selected_rows (dialog->priv->selection, NULL);

  if (l)

    {

      g_assert (gtk_widget_get_mapped (GTK_WIDGET (dialog)));

      g_assert (gtk_widget_get_visible (GTK_WIDGET (dialog)));

      gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->priv->icons_view),

                                    (GtkTreePath *) l->data,

                                    NULL, TRUE, 0.5, 0.0);

/*		gtk_tree_view_set_cursor (GTK_TREE_VIEW (dialog->priv->icons_view),

					 (GtkTreePath *) l->data,

					 0,

					 FALSE);

		gtk_widget_grab_focus (dialog->priv->icons_view);		

*/

      g_list_foreach (l, (GFunc) gtk_tree_path_free, NULL);

      g_list_free (l);

    }

}

static void

select_first_row (GladeNamedIconChooserDialog *dialog)

{

  GtkTreePath *path;

  if (!dialog->priv->filter_model)

    return;

  path = gtk_tree_path_new_from_indices (0, -1);

  gtk_tree_view_set_cursor (GTK_TREE_VIEW (dialog->priv->icons_view), path,

                            NULL, FALSE);

  gtk_tree_path_free (path);

}

static void

pending_select_name_process (GladeNamedIconChooserDialog *dialog)

{

  ForEachFuncData *data;

  g_assert (dialog->priv->icons_store != NULL);

  g_assert (dialog->priv->selection != NULL);

  if (dialog->priv->pending_select_name)

    {

      data = g_slice_new0 (ForEachFuncData);

      data->name = dialog->priv->pending_select_name;

      data->do_select = TRUE;

      data->do_activate = FALSE;

      data->dialog = dialog;