/*

 * This file is a part of hildon

 *

 * Copyright (C) 2005, 2008 Nokia Corporation.

 *

 * 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 of the License, or (at your option) any later version. 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 library; if not, write to the Free

 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

/**

 * SECTION:hildon-touch-selector

 * @short_description: A selector widget with several columns.

 *

 * #HildonTouchSelector is a selector widget, that allows users to

 * select items from one to many predefined lists. It is very similar

 * to #GtkComboBox, but with several individual pannable

 * columns. #HildonTouchSelector does not need to be placed in a

 * #HildonPannableArea (in fact, doing so will prevent panning).

 *

 * Normally, you would use #HildonTouchSelector together with a

 * #HildonPickerDialog activated from a button. For the most common

 * cases, you should use #HildonPickerButton.

 *

 * The contents of each #HildonTouchSelector column are stored in a

 * #GtkTreeModel. To add a new column to a #HildonTouchSelector, use

 * hildon_touch_selector_append_column(). If you want to add a

 * text-only column, without special attributes, use

 * hildon_touch_selector_append_text_column().

 *

 * It is highly recommended that you use only one column

 * #HildonTouchSelector<!-- -->s.

 * If you only need a text only, one column selector, you can create it with

 * hildon_touch_selector_new_text() and populate with

 * hildon_touch_selector_append_text(), hildon_touch_selector_prepend_text(),

 * and hildon_touch_selector_insert_text().

 *

 * If you need a selector widget that also accepts user inputs, you

 * can use #HildonTouchSelectorEntry.

 *

 * The current selection has a string representation. In the most common cases,

 * each column model will contain a text column. You can configure

 * which column in particular using the #HildonTouchSelectorColumn property

 * #HildonTouchSelectorColumn:text-column

 *

 * You can get this string representation using

 * hildon_touch_selector_get_current_text().

 * You can configure how the selection is printed with

 * hildon_touch_selector_set_print_func(), that sets the current hildon touch

 * selector print function. The widget has a default print function, that

 * uses the #HildonTouchSelectorColumn:text-column property on each

 * #HildonTouchSelectorColumn to compose the final representation.

 *

 * If you create the selector using hildon_touch_selector_new_text() you

 * don't need to take care of this property, as the model is created internally.

 * If you create the selector using hildon_touch_selector_new(), you

 * need to specify properly the property for your custom model in order to get a

 * non-empty string representation, or define your custom print function.

 *

 * <example>

 * <title>Creating a HildonTouchSelector</title>

 * <programlisting>

 * void

 * selection_changed (HildonTouchSelector *selector,

 *                    gint                 column,

 *                    gpointer             user_data)

 * {

 *   gchar *current_selection = NULL;

 * <!-- -->

 *   current_selection = hildon_touch_selector_get_current_text (selector);

 *   g_debug ("Current selection : %s", current_selection);

 * }

 * <!-- -->

 * static GtkWidget *

 * create_customized_selector ()

 * {

 *   GtkWidget *selector = NULL;

 *   GSList *icon_list = NULL;

 *   GtkListStore *store_icons = NULL;

 *   GSList *item = NULL;

 *   GtkCellRenderer *renderer = NULL;

 *   HildonTouchSelectorColumn *column = NULL;

 * <!-- -->

 *   selector = hildon_touch_selector_new ();

 * <!-- -->

 *   icon_list = gtk_stock_list_ids ();

 * <!-- -->

 *   store_icons = gtk_list_store_new (1, G_TYPE_STRING);

 *   for (item = icon_list; item; item = g_slist_next (item)) {

 *     GtkTreeIter iter;

 *     gchar *label = item->data;

 * <!-- -->

 *     gtk_list_store_append (store_icons, &iter);

 *     gtk_list_store_set (store_icons, &iter, 0, label, -1);

 *     g_free (label);

 *   }

 *   g_slist_free (icon_list);

 * <!-- -->

 *   renderer = gtk_cell_renderer_pixbuf_new ();

 *   gtk_cell_renderer_set_fixed_size (renderer, -1, 100);

 * <!-- -->

 *   column = hildon_touch_selector_append_column (HILDON_TOUCH_SELECTOR (selector),

 *                                                 GTK_TREE_MODEL (store_icons),

 *                                                 renderer, "stock-id", 0, NULL);

 * <!-- -->

 *   hildon_touch_selector_column_set_text_column (column, 0);

 * <!-- -->

 *   g_object_unref (store_icons);

 * <!-- -->

 *   hildon_touch_selector_set_column_selection_mode (HILDON_TOUCH_SELECTOR (selector),

 *                                                    HILDON_TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE);

 * <!-- -->

 *   g_signal_connect (G_OBJECT (selector), "changed",

 *                     G_CALLBACK (selection_changed), NULL);

 * <!-- -->

 *   return selector;

 * }

 * <!-- -->

 * static GtkWidget *

 * create_simple_selector ()

 * {

 *   GtkWidget *selector = NULL;

 *   gint i;

 * <!-- -->

 *   selector = hildon_touch_selector_new_text ();

 *   hildon_touch_selector_set_column_selection_mode (HILDON_TOUCH_SELECTOR (selector),

 *                                                    HILDON_TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE);

 * <!-- -->

 *   g_signal_connect (G_OBJECT (selector), "changed",

 *                     G_CALLBACK (selection_changed), NULL);

 * <!-- -->

 *   for (i = 1; i <= 10 ; i++) {

 *     gchar *label = g_strdup_printf ("Item %d", i);

 * <!-- -->

 *     hildon_touch_selector_append_text (HILDON_TOUCH_SELECTOR (selector),

 *                                        label);

 * <!-- -->

 *     g_free (label);

 *   }

 * <!-- -->

 *   return selector;

 * }

 * </programlisting>

 * </example>

 */

/**

 * SECTION:hildon-touch-selector-column

 * @short_description: A visible column in a #HildonTouchSelector

 * @see_also: #HildonTouchSelector

 *

 * A #HildonTouchSelectorColumn is a column in a

 * #HildonTouchSelector. This class implements the #GtkCellLayout interface, allowing

 * a flexible management of the cellrenderers in each #HildonTouchSelector column.

 */

#undef HILDON_DISABLE_DEPRECATED

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <string.h>

#include <stdlib.h>

#include <glib.h>

#include "hildon-gtk.h"

#include "hildon-pannable-area.h"

#include "hildon-touch-selector.h"

#include "hildon-touch-selector-private.h"

#include "hildon-live-search.h"

#include "hildon-helper.h"

#define HILDON_TOUCH_SELECTOR_GET_PRIVATE(obj)                          \

  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), HILDON_TYPE_TOUCH_SELECTOR, HildonTouchSelectorPrivate))

G_DEFINE_TYPE (HildonTouchSelector, hildon_touch_selector, GTK_TYPE_VBOX)

/*

 * IMPLEMENTATION NOTES:

 * Struct to maintain the data of each column. The columns are the elements

 * of the widget that belongs properly to the selection behaviour. Although

 * internally the columns are arranged in a private #GtkHBox, as the selector

 * itself is a #GtkVBox, you can add more widgets, like buttons etc., so

 * you finally could have a widget with more elements that the columns, but

 * this doesn't belongs to the selection logic

 */

struct _HildonTouchSelectorColumnPrivate

{

  HildonTouchSelector *parent;    /* the selector that contains this column */

  GtkTreeModel *model;

  gint text_column;

  GtkTreeView *tree_view;

  gulong realize_handler;

  GtkTreePath *initial_path;

  GtkTreeModel *filter;

  GtkWidget *livesearch;

  GtkWidget *panarea;           /* the pannable widget */

  GtkWidget *vbox;

  GtkTreeRowReference *last_activated;

};

struct _HildonTouchSelectorPrivate

{

  GSList *columns;              /* the selection columns */

  GtkWidget *hbox;              /* the container for the selector's columns */

  gboolean initial_scroll;      /* whether initial fancy scrolling to selection */

  gboolean has_live_search;

  GSList *norm_tokens;

  gboolean changed_blocked;

  HildonTouchSelectorPrintFunc print_func;

  gpointer print_user_data;

  GDestroyNotify print_destroy_func;

  HildonUIMode hildon_ui_mode;

};

enum

{

  PROP_HAS_MULTIPLE_SELECTION = 1,

  PROP_INITIAL_SCROLL,

  PROP_HILDON_UI_MODE,

  PROP_LIVE_SEARCH

};

enum

{

  CHANGED,

  COLUMNS_CHANGED,

  LAST_SIGNAL

};

static gint hildon_touch_selector_signals[LAST_SIGNAL] = { 0 };

static void

hildon_touch_selector_dispose                   (GObject * object);

static void

hildon_touch_selector_get_property              (GObject * object,

                                                 guint prop_id,

                                                 GValue * value,

                                                 GParamSpec * pspec);

static void

hildon_touch_selector_set_property              (GObject *object,

                                                 guint prop_id,

                                                 const GValue *value,

                                                 GParamSpec *pspec);

/* gtkwidget */

/* gtkcontainer */

static void hildon_touch_selector_remove        (GtkContainer * container,

                                                 GtkWidget * widget);

/* private functions */

static void _row_tapped_cb                      (GtkTreeView * tree_view,

                                                 GtkTreePath * path,

                                                 gpointer user_data);

static void

hildon_touch_selector_row_activated_cb          (GtkTreeView       *tree_view,

                                                 GtkTreePath       *path,

                                                 GtkTreeViewColumn *column,

                                                 gpointer           user_data);

static gchar *_default_print_func               (HildonTouchSelector * selector,

                                                 gpointer user_data);

static HildonTouchSelectorColumn *_create_new_column (HildonTouchSelector * selector,

                                                 GtkTreeModel * model,

                                                 gboolean *emit_changed,

                                                 GtkCellRenderer * renderer,

                                                 va_list args);

static gboolean

on_realize_cb                                  (GtkWidget *widget,

                                                gpointer data);

static void

on_row_changed                                 (GtkTreeModel *model,

                                                GtkTreePath *path,

                                                GtkTreeIter *iter,

                                                gpointer userdata);

static void

on_row_deleted                                 (GtkTreeModel *model,

                                                GtkTreePath *path,

                                                gpointer userdata);

static void

hildon_touch_selector_scroll_to (HildonTouchSelectorColumn *column,

                                 GtkTreeView *tv,

                                 GtkTreePath *path);

static gboolean

_hildon_touch_selector_center_on_selected_items (HildonTouchSelector *selector,

                                                 HildonTouchSelectorColumn *column);

static void

_hildon_touch_selector_set_model                (HildonTouchSelector * selector,

                                                 gint num_column,

                                                 GtkTreeModel * model);

static gboolean

_hildon_touch_selector_has_multiple_selection   (HildonTouchSelector * selector);

static void

hildon_touch_selector_emit_value_changed        (HildonTouchSelector *selector,

                                                 gint column);

/* GtkCellLayout implementation (HildonTouchSelectorColumn)*/

static void hildon_touch_selector_column_cell_layout_init         (GtkCellLayoutIface      *iface);

static void hildon_touch_selector_column_cell_layout_pack_start   (GtkCellLayout         *cell_layout,

                                                                   GtkCellRenderer       *cell,

                                                                   gboolean               expand);

static void hildon_touch_selector_column_cell_layout_pack_end     (GtkCellLayout         *cell_layout,

                                                                   GtkCellRenderer       *cell,

                                                                   gboolean               expand);

static void hildon_touch_selector_column_cell_layout_clear        (GtkCellLayout         *cell_layout);

static void hildon_touch_selector_column_cell_layout_add_attribute(GtkCellLayout         *cell_layout,

                                                                   GtkCellRenderer       *cell,

                                                                   const gchar           *attribute,

                                                                   gint                   column);

static void hildon_touch_selector_column_cell_layout_set_cell_data_func (GtkCellLayout         *cell_layout,

                                                                         GtkCellRenderer       *cell,

                                                                         GtkCellLayoutDataFunc  func,

                                                                         gpointer               func_data,

                                                                         GDestroyNotify         destroy);

static void hildon_touch_selector_column_cell_layout_clear_attributes   (GtkCellLayout         *cell_layout,

                                                                         GtkCellRenderer       *cell);

static void hildon_touch_selector_column_cell_layout_reorder       (GtkCellLayout         *cell_layout,

                                                                    GtkCellRenderer       *cell,

                                                                    gint                   position);

static GList *hildon_touch_selector_column_cell_layout_get_cells   (GtkCellLayout         *cell_layout);

static void

hildon_touch_selector_check_ui_mode_coherence   (HildonTouchSelector *selector);

static void

hildon_touch_selector_class_init (HildonTouchSelectorClass * class)

{

  GObjectClass *gobject_class;

  GtkObjectClass *object_class;

  GtkContainerClass *container_class;

  gobject_class = G_OBJECT_CLASS (class);

  object_class = GTK_OBJECT_CLASS (class);

  container_class = GTK_CONTAINER_CLASS (class);

  /* GObject */

  gobject_class->dispose = hildon_touch_selector_dispose;

  gobject_class->get_property = hildon_touch_selector_get_property;

  gobject_class->set_property = hildon_touch_selector_set_property;

  /* GtkWidget */

  /* GtkContainer */

  container_class->remove = hildon_touch_selector_remove;

  /* HildonTouchSelector */

  class->changed = NULL;

  class->set_model = _hildon_touch_selector_set_model;

  class->has_multiple_selection = _hildon_touch_selector_has_multiple_selection;

  /* signals */

  /**

   * HildonTouchSelector::changed:

   * @widget: the object which received the signal

   * @column: the number of the column that has changed

   *

   * The "changed" signal is emitted when the active item on any column is changed.

   * This can be due to the user selecting a different item from the list, or

   * due to a call to hildon_touch_selector_select_iter() on one of the columns.

   *

   * Since: 2.2

   */

  hildon_touch_selector_signals[CHANGED] =

    g_signal_new ("changed",

                  G_OBJECT_CLASS_TYPE (class),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (HildonTouchSelectorClass, changed),

                  NULL, NULL,

                  g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);

  /**

   * HildonTouchSelector::columns-changed:

   * @selector: the object which received the signal

   *

   * The "columns-changed" signal is emitted when the number

   * of columns in the #HildonTouchSelector change.

   *

   * Since: 2.2

   */

  hildon_touch_selector_signals[COLUMNS_CHANGED] =

    g_signal_new ("columns-changed",

                  G_OBJECT_CLASS_TYPE (class),

                  G_SIGNAL_RUN_LAST, 0,

                  NULL, NULL,

                  g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);

  /* properties */

  g_object_class_install_property (gobject_class, PROP_HAS_MULTIPLE_SELECTION,

                                   g_param_spec_boolean ("has-multiple-selection",

                                                         "has multiple selection",

                                                         "Whether the widget has multiple "

                                                         "selection (like multiple columns, "

                                                         "multiselection mode, or multiple "

                                                         "internal widgets) and therefore "

                                                         "it may need a confirmation button, "

                                                         "for instance.",

                                                         FALSE,

                                                         G_PARAM_READABLE));

  g_object_class_install_property (G_OBJECT_CLASS (gobject_class),

                                   PROP_INITIAL_SCROLL,

                                   g_param_spec_boolean ("initial-scroll",

                                                         "Initial scroll",

                                                         "Whether to scroll to the"

                                                         "current selection when"

                                                         "the selector is first"

                                                         "shown",

                                                         TRUE,

                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

    /**

     * HildonTouchSelector:hildon-ui-mode:

     *

     * Specifies which UI mode to use in the internal treeviews.  A setting

     * of %HILDON_UI_MODE_NORMAL will cause these tree view to disable selections

     * and emit row-activated as soon as a row is pressed (unless it is pressed

     * to drag the pannable area where the treeview is). You can use the

     * method hildon_touch_selector_get_last_activated_row() to get it. When

     * %HILDON_UI_MODE_EDIT is set, selections can be made according to the

     * setting of the mode on GtkTreeSelection.

     *

     * Toggling this property will cause the tree view to select an

     * appropriate selection mode if not already done.

     *

     * Since: Hildon 2.2

     */

  g_object_class_install_property (gobject_class,

                                   PROP_HILDON_UI_MODE,

                                   g_param_spec_enum ("hildon-ui-mode",

                                                      "Hildon UI Mode",

                                                      "The Hildon UI mode according "

                                                      "to which the touch selector "

                                                      "should behave",

                                                      HILDON_TYPE_UI_MODE,

                                                      HILDON_UI_MODE_EDIT,

                                                      G_PARAM_READWRITE));

  g_object_class_install_property (G_OBJECT_CLASS (gobject_class),

                                   PROP_LIVE_SEARCH,

                                   g_param_spec_boolean ("live-search",

                                                         "Live search",

                                                         "Whether the widget should have built-in"

                                                         "live search capabilities",

                                                         TRUE,

                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  /* style properties */

  /* We need to ensure fremantle mode for the treeview in order to work

     properly. This is not about the appearance, this is about behaviour */

  gtk_rc_parse_string ("style \"fremantle-htst\" {\n"

                       "  GtkWidget::hildon-mode = 1\n"

                       "} widget \"*.fremantle-htst\" style \"fremantle-htst\""

                       "widget_class \"*<HildonPannableArea>.GtkTreeView\" style :highest \"fremantle-htst\"");

  g_type_class_add_private (object_class, sizeof (HildonTouchSelectorPrivate));

}

static void

hildon_touch_selector_get_property (GObject * object,

                                    guint prop_id,

                                    GValue * value, GParamSpec * pspec)

{

  HildonTouchSelectorPrivate *priv = HILDON_TOUCH_SELECTOR (object)->priv;

  switch (prop_id) {

  case PROP_HAS_MULTIPLE_SELECTION:

    g_value_set_boolean (value,

                         hildon_touch_selector_has_multiple_selection (HILDON_TOUCH_SELECTOR (object)));

    break;

  case PROP_INITIAL_SCROLL:

    g_value_set_boolean (value, priv->initial_scroll);

    break;

  case PROP_HILDON_UI_MODE:

    g_value_set_enum (value, priv->hildon_ui_mode);

    break;

  case PROP_LIVE_SEARCH:

    g_value_set_boolean (value,

                         hildon_touch_selector_get_live_search (HILDON_TOUCH_SELECTOR (object)));

    break;

  default:

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

    break;

  }

}

static void

hildon_touch_selector_set_property (GObject *object, guint prop_id,

                                    const GValue *value, GParamSpec *pspec)

{

  HildonTouchSelectorPrivate *priv = HILDON_TOUCH_SELECTOR (object)->priv;

  switch (prop_id) {

  case PROP_INITIAL_SCROLL:

    priv->initial_scroll = g_value_get_boolean (value);

    break;

  case PROP_HILDON_UI_MODE:

    hildon_touch_selector_set_hildon_ui_mode (HILDON_TOUCH_SELECTOR (object),

                                              g_value_get_enum (value));

    break;

  case PROP_LIVE_SEARCH:

    hildon_touch_selector_set_live_search (HILDON_TOUCH_SELECTOR (object),

                                           g_value_get_boolean (value));

    break;

  default:

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

    break;

  }

}

static void

hildon_touch_selector_init (HildonTouchSelector * selector)

{

  selector->priv = HILDON_TOUCH_SELECTOR_GET_PRIVATE (selector);

  GTK_WIDGET_SET_FLAGS (GTK_WIDGET (selector), GTK_NO_WINDOW);

  gtk_widget_set_redraw_on_allocate (GTK_WIDGET (selector), FALSE);

  selector->priv->columns = NULL;

  selector->priv->norm_tokens = NULL;

  selector->priv->print_func = NULL;

  selector->priv->print_user_data = NULL;

  selector->priv->print_destroy_func = NULL;

  selector->priv->initial_scroll = TRUE;

  selector->priv->hbox = gtk_hbox_new (FALSE, 0);

  selector->priv->changed_blocked = FALSE;

  selector->priv->hildon_ui_mode = HILDON_UI_MODE_EDIT;

  gtk_box_pack_end (GTK_BOX (selector), selector->priv->hbox,

                    TRUE, TRUE, 0);

  gtk_widget_show (selector->priv->hbox);

}

static void

hildon_touch_selector_dispose (GObject * object)

{

  GObjectClass *gobject_class;

  HildonTouchSelector *selector = HILDON_TOUCH_SELECTOR (object);

  hildon_touch_selector_set_print_func_full (selector,

                                             NULL, NULL, NULL);

  if (selector->priv->norm_tokens != NULL) {

      g_slist_foreach (selector->priv->norm_tokens, (GFunc) g_free, NULL);

      g_slist_free (selector->priv->norm_tokens);

      selector->priv->norm_tokens = NULL;

  }

  gobject_class = G_OBJECT_CLASS (hildon_touch_selector_parent_class);

  if (gobject_class->dispose)

    (* gobject_class->dispose) (object);

}

static void

clean_column                                    (HildonTouchSelectorColumn *col,

                                                 HildonTouchSelector *selector)

{

  g_signal_handlers_disconnect_by_func (col->priv->model,

                                        on_row_changed, selector);

  g_signal_handlers_disconnect_by_func (col->priv->model,

                                        on_row_deleted, selector);

  if (col->priv->last_activated != NULL) {

    gtk_tree_row_reference_free (col->priv->last_activated);

    col->priv->last_activated = NULL;

  }

}

/*

 * IMPLEMENTATION NOTES:

 * Some people sent questions regarding the fact that the dispose/finalize functions

 * doesn't clean the internal widgets that could lead to leak memory, so we will

 * clarify this topic.

 *

 * This is not required as #HildonTouchSelector extends #GtkContainer. When the

 * widget is freed, the #GtkContainer freeing memory functions are called. This

 * process includes remove each widget individually, so all the widgets are

 * properly freed.

 *

 * In the same way, this widget redefines gtk_container->remove function, in

 * order to free the column related information if it is required.

 *

 * Please take a look to hildon_touch_selector_remove for more information.

 */

/*------------------------------ GtkContainer ------------------------------ */

/*

 * Required in order to free the column at the columns list

 */

static void

hildon_touch_selector_remove (GtkContainer * container, GtkWidget * widget)

{

  HildonTouchSelector *selector = NULL;

  g_return_if_fail (HILDON_IS_TOUCH_SELECTOR (container));

  selector = HILDON_TOUCH_SELECTOR (container);

  /* Remove the extra data related to the columns, if required. */

  if (widget == selector->priv->hbox) {

    g_slist_foreach (selector->priv->columns, (GFunc) clean_column, selector);

    g_slist_foreach (selector->priv->columns, (GFunc) g_object_unref, NULL);

    g_slist_free (selector->priv->columns);

    selector->priv->columns = NULL;

  }

  /* Now remove the widget itself from the container */

  GTK_CONTAINER_CLASS (hildon_touch_selector_parent_class)->remove (container, widget);

}

/* ------------------------------ PRIVATE METHODS ---------------------------- */

void

hildon_touch_selector_block_changed             (HildonTouchSelector *selector)

{

  selector->priv->changed_blocked = TRUE;

}

void

hildon_touch_selector_unblock_changed           (HildonTouchSelector *selector)

{

  selector->priv->changed_blocked = FALSE;

}

static void

hildon_touch_selector_emit_value_changed        (HildonTouchSelector *selector,

                                                 gint column)

{

  /* FIXME: it could be good to emit too the GtkTreePath of the element

     selected, as now it is required to connect to the signal and then ask

     for the element selected. We can't do this API change, in order to avoid

     and ABI break */

  if (!selector->priv->changed_blocked) {

    if (hildon_touch_selector_get_column_selection_mode (selector) == HILDON_TOUCH_SELECTOR_SELECTION_MODE_SINGLE &&

        selector->priv->columns) {

      HildonTouchSelectorColumn *col;

      col = (HildonTouchSelectorColumn *) selector->priv->columns->data;

      if (col->priv->livesearch) {

        hildon_live_search_clean_selection_map (HILDON_LIVE_SEARCH (col->priv->livesearch));

      }

    }

    g_signal_emit (selector, hildon_touch_selector_signals[CHANGED], 0, column);

  }

}

static void

hildon_touch_selector_check_ui_mode_coherence   (HildonTouchSelector *selector)

{

  g_return_if_fail (HILDON_IS_TOUCH_SELECTOR (selector));

  if (hildon_touch_selector_get_num_columns (selector) > 1) {

    hildon_touch_selector_set_hildon_ui_mode (selector, HILDON_UI_MODE_EDIT);

  }

}

/**

 * default_print_func:

 * @selector: a #HildonTouchSelector

 *

 * Default print function

 *

 * Returns: a new string that represents the selected items

 *

 * Since: 2.2

 **/

static gchar *

_default_print_func (HildonTouchSelector * selector, gpointer user_data)

{

  gchar *result = NULL;

  gchar *aux = NULL;

  gint num_columns = 0;

  GtkTreeIter iter;

  GtkTreeModel *model = NULL;

  gchar *current_string = NULL;

  gint i;

  HildonTouchSelectorSelectionMode mode;

  GList *item = NULL;

  GtkTreePath *current_path = NULL;

  GList *selected_rows = NULL;

  gint initial_value = 0;

  gint text_column = -1;

  HildonTouchSelectorColumn *column = NULL;

  num_columns = hildon_touch_selector_get_num_columns (selector);

  mode = hildon_touch_selector_get_column_selection_mode (selector);

  if ((mode == HILDON_TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

      && (num_columns > 0)) {

    /* In this case we get the first column first */

    selected_rows = hildon_touch_selector_get_selected_rows (selector, 0);

    model = hildon_touch_selector_get_model (selector, 0);

    column = hildon_touch_selector_get_column (selector, 0);

    text_column = hildon_touch_selector_column_get_text_column (column);

    result = g_strdup_printf ("(");

    i = 0;

    for (item = selected_rows; item; item = g_list_next (item)) {

      current_path = item->data;

      gtk_tree_model_get_iter (model, &iter, current_path);

      if (text_column != -1) {

        gtk_tree_model_get (model, &iter, text_column, &current_string, -1);

      }

      if (i < g_list_length (selected_rows) - 1) {

        aux = g_strconcat (result, current_string, ",", NULL);

        g_free (result);

        result = aux;

      } else {

        aux = g_strconcat (result, current_string, NULL);

        g_free (result);

        result = aux;

      }

      if (current_string) {

        g_free (current_string);

        current_string = NULL;

      }

      i++;

    }

    aux = g_strconcat (result, ")", NULL);

    g_free (result);

    result = aux;

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

    g_list_free (selected_rows);

    initial_value = 1;

  } else {

    initial_value = 0;

  }

  for (i = initial_value; i < num_columns; i++) {

    model = hildon_touch_selector_get_model (selector, i);

    column = hildon_touch_selector_get_column (selector, i);

    text_column = hildon_touch_selector_column_get_text_column (column);

    if (hildon_touch_selector_get_selected (selector, i, &iter)) {

      if (text_column == -1 ) {

        g_warning ("Trying to use the default print function in HildonTouchSelector, but "

                   "\"text-column\" property is not set for HildonTouchSelectorColumn %p.", column);

        current_string = NULL;

      } else {

        gtk_tree_model_get (model, &iter, text_column, &current_string, -1);

      }

      if (i == 0) {

        result = current_string;

      } else {

        aux = g_strconcat (result, ":", current_string, NULL);

        g_free (result);

        g_free (current_string);

        current_string = NULL;

        result = aux;

      }

    }

  }

  return result;

}

static void

hildon_touch_selector_row_activated_cb          (GtkTreeView       *tree_view,

                                                 GtkTreePath       *path,

                                                 GtkTreeViewColumn *column,

                                                 gpointer           user_data)

{

  HildonTouchSelectorColumn *selector_column = NULL;

  GtkTreePath *child_path;

  g_return_if_fail (HILDON_IS_TOUCH_SELECTOR_COLUMN (user_data));

  selector_column = HILDON_TOUCH_SELECTOR_COLUMN (user_data);

  if (selector_column->priv->last_activated != NULL) {

    gtk_tree_row_reference_free (selector_column->priv->last_activated);

  }

  child_path = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER (selector_column->priv->filter),

                                                                 path);

  selector_column->priv->last_activated = gtk_tree_row_reference_new (selector_column->priv->model,

                                                                      child_path);

  gtk_tree_path_free (child_path);

}

static void

_row_tapped_cb (GtkTreeView * tree_view, GtkTreePath * path, gpointer user_data)

{

  HildonTouchSelector *selector = NULL;

  HildonTouchSelectorColumn *column = NULL;

  gint num_column = -1;

  column = HILDON_TOUCH_SELECTOR_COLUMN (user_data);

  g_return_if_fail (HILDON_IS_TOUCH_SELECTOR (column->priv->parent));

  selector = column->priv->parent;

  num_column = g_slist_index (selector->priv->columns, column);

  hildon_touch_selector_emit_value_changed (selector, num_column);

}

static HildonTouchSelectorColumn *

_create_new_column (HildonTouchSelector * selector,

                    GtkTreeModel * model,

                    gboolean *emit_changed,

                    GtkCellRenderer * renderer, va_list args)

{

  HildonTouchSelectorColumn *new_column = NULL;

  GtkTreeViewColumn *tree_column = NULL;

  GtkTreeView *tv = NULL;

  GtkTreeModel *filter;

  GtkWidget *panarea = NULL;

  GtkTreeSelection *selection = NULL;

  GtkTreeIter iter;

  gchar *attribute;

  gint value;

  tree_column = gtk_tree_view_column_new ();

  if (renderer != NULL) {

    gtk_tree_view_column_pack_start (tree_column, renderer, TRUE);

    attribute = va_arg (args, gchar *);

    while (attribute != NULL) {

      value = va_arg (args, gint);

      gtk_tree_view_column_add_attribute (tree_column, renderer, attribute,

                                          value);

      attribute = va_arg (args, gchar *);

    }

  }

#ifdef MAEMO_GTK

  tv = GTK_TREE_VIEW (hildon_gtk_tree_view_new (selector->priv->hildon_ui_mode));

#else

  tv = GTK_TREE_VIEW (gtk_tree_view_new ());

#endif /* MAEMO_GTK */

  gtk_tree_view_set_enable_search (tv, FALSE);

  if (!selector->priv->has_live_search) {

    GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (tv), GTK_CAN_FOCUS);

  }

  filter = gtk_tree_model_filter_new (model, NULL);

  gtk_tree_view_set_model (tv, filter);

  g_signal_connect (model, "row-changed",

                    G_CALLBACK (on_row_changed), selector);

  g_signal_connect_after (model, "row-deleted",

                          G_CALLBACK (on_row_deleted), selector);

  gtk_tree_view_set_rules_hint (tv, TRUE);

  gtk_tree_view_append_column (GTK_TREE_VIEW (tv), tree_column);

  new_column = g_object_new (HILDON_TYPE_TOUCH_SELECTOR_COLUMN, NULL);

  new_column->priv->parent = selector;

  panarea = hildon_pannable_area_new ();

  gtk_container_add (GTK_CONTAINER (panarea), GTK_WIDGET (tv));

  new_column->priv->model = g_object_ref (model);

  new_column->priv->tree_view = tv;

  new_column->priv->panarea = panarea;

  new_column->priv->filter = filter;

  new_column->priv->livesearch = NULL;

  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv));

  gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);

  /* select the first item */

  *emit_changed = FALSE;

  if ((gtk_tree_model_get_iter_first (filter, &iter))&&

      (selector->priv->hildon_ui_mode == HILDON_UI_MODE_EDIT)) {

    gtk_tree_selection_select_iter (selection, &iter);

    *emit_changed = TRUE;

  }

  /* connect to the hildon-row-tapped signal connection */

  g_signal_connect (G_OBJECT (tv), "hildon-row-tapped",

                    G_CALLBACK (_row_tapped_cb), new_column);

  g_signal_connect (G_OBJECT (tv), "row-activated",

                    G_CALLBACK (hildon_touch_selector_row_activated_cb), new_column);

  return new_column;

}

/* ------------------------ HildonTouchSelectorColumn implementation ---------------------- */

G_DEFINE_TYPE_WITH_CODE (HildonTouchSelectorColumn, hildon_touch_selector_column, G_TYPE_OBJECT,

                         G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,

                                                hildon_touch_selector_column_cell_layout_init))

enum

{

  PROP_TEXT_COLUMN = 1

};

static void

hildon_touch_selector_column_class_init (HildonTouchSelectorColumnClass *klass);

static void

hildon_touch_selector_column_get_property (GObject *object, guint property_id,

                                           GValue *value, GParamSpec *pspec);

static void

hildon_touch_selector_column_set_property  (GObject *object, guint property_id,

                                            const GValue *value, GParamSpec *pspec);

static void

hildon_touch_selector_column_dispose       (GObject *object);

static void

hildon_touch_selector_column_finalize      (GObject *object);

static void

hildon_touch_selector_column_class_init (HildonTouchSelectorColumnClass *klass)

{

  GObjectClass *gobject_class = NULL;

  gobject_class = G_OBJECT_CLASS (klass);

  g_type_class_add_private (gobject_class, sizeof (HildonTouchSelectorColumnPrivate));

  /* GObject */

  gobject_class->get_property = hildon_touch_selector_column_get_property;

  gobject_class->set_property = hildon_touch_selector_column_set_property;

  gobject_class->dispose      = hildon_touch_selector_column_dispose;

  gobject_class->finalize     = hildon_touch_selector_column_finalize;

  /**

   * HildonTouchSelectorColumn:text-column:

   *

   * A column in the data source model to get the strings from.

   *

   * Since: maemo 2.2

   **/

  g_object_class_install_property (G_OBJECT_CLASS(klass),

                                   PROP_TEXT_COLUMN,

                                   g_param_spec_int ("text-column",

                                                     "Text Column",

                                                     "A column in the data source model to get the strings from.",

                                                     -1,

                                                     G_MAXINT,

                                                     -1,

                                                     G_PARAM_READWRITE));

}

static void

hildon_touch_selector_column_init (HildonTouchSelectorColumn *column)

{

  column->priv = G_TYPE_INSTANCE_GET_PRIVATE (column, HILDON_TYPE_TOUCH_SELECTOR_COLUMN,

                                              HildonTouchSelectorColumnPrivate);

  column->priv->text_column = -1;

  column->priv->last_activated = NULL;

  column->priv->realize_handler = 0;

  column->priv->initial_path = NULL;

}

static gboolean

hildon_live_search_visible_func (GtkTreeModel *model,

                                 GtkTreeIter *iter,

                                 gchar *prefix,

                                 gpointer userdata)

{

  gboolean visible = TRUE;

  gchar *string, *string_ascii;

  GSList *list_iter;

  HildonTouchSelectorColumn *col;

  HildonTouchSelector *selector;

  col = HILDON_TOUCH_SELECTOR_COLUMN (userdata);

  selector = col->priv->parent;

  gint text_column = GPOINTER_TO_INT (col->priv->text_column);

  gtk_tree_model_get (model, iter, text_column, &string, -1);

  string_ascii = hildon_helper_normalize_string (string);

  list_iter = selector->priv->norm_tokens;

  while (visible && list_iter) {

    visible = (string_ascii != NULL &&

               hildon_helper_smart_match (string_ascii,

                                          (const gchar *)list_iter->data));

    list_iter = list_iter->next;

  }

  g_free (string);

  g_free (string_ascii);

  return visible;

}

static gboolean

on_live_search_refilter (HildonLiveSearch *livesearch,

                         gpointer userdata)

{

    HildonTouchSelector *selector = HILDON_TOUCH_SELECTOR (userdata);

    gchar **tokens = g_strsplit (hildon_live_search_get_text (livesearch), " ", -1);

    gchar *token;

    gint i;

    if (selector->priv->norm_tokens != NULL) {

        g_slist_foreach (selector->priv->norm_tokens, (GFunc) g_free, NULL);

        g_slist_free (selector->priv->norm_tokens);

        selector->priv->norm_tokens = NULL;

    }

    for (i = 0; tokens [i] != NULL; i++) {

        token = hildon_helper_normalize_string (tokens[i]);

        if (token != NULL)

            selector->priv->norm_tokens = g_slist_prepend (selector->priv->norm_tokens,

                                                           token);

    }

    g_strfreev (tokens);

    return FALSE;

}

/**

 * hildon_touch_selector_column_set_text_column:

 * @column: A #HildonTouchSelectorColumn

 * @text_column: the index of a model column in the model for @column.

 *

 * Sets the model column to be displayed in @column. @text_column must point to a

 * column in the model used with type %G_TYPE_STRING. Initially, this property

 * is unset. You should set it before using the #HildonTouchSelector that uses

 * @column.

 *

 * Since: 2.2

 **/

void

hildon_touch_selector_column_set_text_column (HildonTouchSelectorColumn *column,

                                              gint text_column)

{

  g_return_if_fail (HILDON_IS_TOUCH_SELECTOR_COLUMN (column));

  g_return_if_fail (text_column >= -1);

  column->priv->text_column = text_column;

  if (column->priv->livesearch) {

    hildon_live_search_set_visible_func (HILDON_LIVE_SEARCH (column->priv->livesearch),

                                         hildon_live_search_visible_func,

                                         column,

                                         NULL);

  }

  g_object_notify (G_OBJECT (column), "text-column");

}

/**

 * hildon_touch_selector_column_get_text_column:

 * @column: a #HildonTouchSelectorColumn

 *

 * Gets the model column set as the text source for @column.

 *

 * Returns: the index of the text column for @column, or -1 if unset.

 *

 * Since: 2.2

 **/

gint

hildon_touch_selector_column_get_text_column (HildonTouchSelectorColumn *column)

{

  g_return_val_if_fail (HILDON_IS_TOUCH_SELECTOR_COLUMN (column), -1);

  return column->priv->text_column;

}

static void

hildon_touch_selector_column_get_property (GObject *object, guint property_id,

                                           GValue *value, GParamSpec *pspec)

{

  switch (property_id) {

  case PROP_TEXT_COLUMN:

    g_value_set_int (value,

                     hildon_touch_selector_column_get_text_column (HILDON_TOUCH_SELECTOR_COLUMN (object)));

    break;

  default:

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

  }

}

static void

hildon_touch_selector_column_set_property (GObject *object, guint property_id,

                                           const GValue *value, GParamSpec *pspec)

{

  switch (property_id) {

  case PROP_TEXT_COLUMN:

    hildon_touch_selector_column_set_text_column (HILDON_TOUCH_SELECTOR_COLUMN (object),

                                                  g_value_get_int (value));

    break;

  default:

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

  }

}

static void

hildon_touch_selector_column_dispose      (GObject *object)

{

  HildonTouchSelectorColumnPrivate *priv =

      HILDON_TOUCH_SELECTOR_COLUMN (object)->priv;

  if (priv->model != NULL) {

      g_object_unref (priv->model);

      priv->model = NULL;

  }

  if (priv->filter != NULL) {

      g_object_unref (priv->filter);

      priv->filter = NULL;

  }

  G_OBJECT_CLASS (hildon_touch_selector_column_parent_class)->dispose (object);

}

static void

hildon_touch_selector_column_finalize     (GObject *object)

{

  HildonTouchSelectorColumnPrivate *priv = HILDON_TOUCH_SELECTOR_COLUMN (object)->priv;

  if (priv->initial_path) {

    gtk_tree_path_free (priv->initial_path);

  }

  G_OBJECT_CLASS (hildon_touch_selector_column_parent_class)->finalize (object);

}

/* ------------------------ GtkCellLayout implementation -------------------- */

static void

hildon_touch_selector_column_cell_layout_init (GtkCellLayoutIface      *iface)

{

  iface->pack_start         = hildon_touch_selector_column_cell_layout_pack_start;

  iface->pack_end           = hildon_touch_selector_column_cell_layout_pack_end;

  iface->clear              = hildon_touch_selector_column_cell_layout_clear;

  iface->add_attribute      = hildon_touch_selector_column_cell_layout_add_attribute;

  iface->set_cell_data_func = hildon_touch_selector_column_cell_layout_set_cell_data_func;

  iface->clear_attributes   = hildon_touch_selector_column_cell_layout_clear_attributes;

  iface->reorder            = hildon_touch_selector_column_cell_layout_reorder;

  iface->get_cells          = hildon_touch_selector_column_cell_layout_get_cells;

}

static void

hildon_touch_selector_column_cell_layout_pack_start (GtkCellLayout         *cell_layout,

                                               GtkCellRenderer       *cell,

                                               gboolean               expand)

{

  HildonTouchSelectorColumn *sel_column = NULL;

  GtkTreeViewColumn *view_column = NULL;

  g_return_if_fail (HILDON_IS_TOUCH_SELECTOR_COLUMN (cell_layout));

  sel_column = HILDON_TOUCH_SELECTOR_COLUMN (cell_layout);

  view_column = gtk_tree_view_get_column (sel_column->priv->tree_view, 0);

  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(view_column), cell, expand);

}

static void

hildon_touch_selector_column_cell_layout_pack_end (GtkCellLayout         *cell_layout,

                                             GtkCellRenderer       *cell,

                                             gboolean               expand)

{