/* gtkentrycompletion.c

 * Copyright (C) 2003  Kristian Rietveld  <kris@gtk.org>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include "gtkentrycompletion.h"

#include "gtkentryprivate.h"

#include "gtkcelllayout.h"

#include "gtkintl.h"

#include "gtkcellrenderertext.h"

#include "gtkframe.h"

#include "gtktreeselection.h"

#include "gtktreeview.h"

#include "gtkscrolledwindow.h"

#include "gtkvbox.h"

#include "gtkwindow.h"

#include "gtkentry.h"

#include "gtkmain.h"

#include "gtkmarshalers.h"

#include "gtkprivate.h"

#include "gtkalias.h"

#include <string.h>

/* signals */

enum

{

  INSERT_PREFIX,

  MATCH_SELECTED,

  ACTION_ACTIVATED,

  CURSOR_ON_MATCH,

  LAST_SIGNAL

};

/* properties */

enum

{

  PROP_0,

  PROP_MODEL,

  PROP_MINIMUM_KEY_LENGTH,

  PROP_TEXT_COLUMN,

  PROP_INLINE_COMPLETION,

  PROP_POPUP_COMPLETION,

  PROP_POPUP_SET_WIDTH,

  PROP_POPUP_SINGLE_MATCH,

  PROP_INLINE_SELECTION

};

#define GTK_ENTRY_COMPLETION_GET_PRIVATE(obj)(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_ENTRY_COMPLETION, GtkEntryCompletionPrivate))

static void                                                             gtk_entry_completion_cell_layout_init    (GtkCellLayoutIface      *iface);

static void     gtk_entry_completion_set_property        (GObject      *object,

                                                          guint         prop_id,

                                                          const GValue *value,

                                                          GParamSpec   *pspec);

static void     gtk_entry_completion_get_property        (GObject      *object,

                                                          guint         prop_id,

                                                          GValue       *value,

                                                          GParamSpec   *pspec);

static void                                                             gtk_entry_completion_finalize            (GObject                 *object);

static void     gtk_entry_completion_pack_start          (GtkCellLayout         *cell_layout,

                                                          GtkCellRenderer       *cell,

                                                          gboolean               expand);

static void     gtk_entry_completion_pack_end            (GtkCellLayout         *cell_layout,

                                                          GtkCellRenderer       *cell,

                                                          gboolean               expand);

static void                                                                      gtk_entry_completion_clear               (GtkCellLayout           *cell_layout);

static void     gtk_entry_completion_add_attribute       (GtkCellLayout         *cell_layout,

                                                          GtkCellRenderer       *cell,

                                                          const char            *attribute,

                                                          gint                   column);

static void     gtk_entry_completion_set_cell_data_func  (GtkCellLayout         *cell_layout,

                                                          GtkCellRenderer       *cell,

                                                          GtkCellLayoutDataFunc  func,

                                                          gpointer               func_data,

                                                          GDestroyNotify         destroy);

static void     gtk_entry_completion_clear_attributes    (GtkCellLayout         *cell_layout,

                                                          GtkCellRenderer       *cell);

static void     gtk_entry_completion_reorder             (GtkCellLayout         *cell_layout,

                                                          GtkCellRenderer       *cell,

                                                          gint                   position);

static GList *  gtk_entry_completion_get_cells           (GtkCellLayout         *cell_layout);

static gboolean gtk_entry_completion_visible_func        (GtkTreeModel       *model,

                                                          GtkTreeIter        *iter,

                                                          gpointer            data);

static gboolean gtk_entry_completion_popup_key_event     (GtkWidget          *widget,

                                                          GdkEventKey        *event,

                                                          gpointer            user_data);

static gboolean gtk_entry_completion_popup_button_press  (GtkWidget          *widget,

                                                          GdkEventButton     *event,

                                                          gpointer            user_data);

static gboolean gtk_entry_completion_list_button_press   (GtkWidget          *widget,

                                                          GdkEventButton     *event,

                                                          gpointer            user_data);

static gboolean gtk_entry_completion_action_button_press (GtkWidget          *widget,

                                                          GdkEventButton     *event,

                                                          gpointer            user_data);

static void     gtk_entry_completion_selection_changed   (GtkTreeSelection   *selection,

                                                          gpointer            data);

static gboolean	gtk_entry_completion_list_enter_notify	 (GtkWidget          *widget,

							  GdkEventCrossing   *event,

							  gpointer            data);

static gboolean gtk_entry_completion_list_motion_notify	 (GtkWidget	     *widget,

							  GdkEventMotion     *event,

							  gpointer 	      data);

static void     gtk_entry_completion_insert_action       (GtkEntryCompletion *completion,

                                                          gint                index,

                                                          const gchar        *string,

                                                          gboolean            markup);

static void     gtk_entry_completion_action_data_func    (GtkTreeViewColumn  *tree_column,

                                                          GtkCellRenderer    *cell,

                                                          GtkTreeModel       *model,

                                                          GtkTreeIter        *iter,

                                                          gpointer            data);

static gboolean gtk_entry_completion_match_selected      (GtkEntryCompletion *completion,

							  GtkTreeModel       *model,

							  GtkTreeIter        *iter);

static gboolean gtk_entry_completion_real_insert_prefix  (GtkEntryCompletion *completion,

							  const gchar        *prefix);

static gboolean gtk_entry_completion_cursor_on_match     (GtkEntryCompletion *completion,

							  GtkTreeModel       *model,

							  GtkTreeIter        *iter);

static gboolean gtk_entry_completion_insert_completion   (GtkEntryCompletion *completion,

                                                          GtkTreeModel       *model,

                                                          GtkTreeIter        *iter);

static void     gtk_entry_completion_insert_completion_text (GtkEntryCompletion *completion,

                                                             const gchar *text);

static guint entry_completion_signals[LAST_SIGNAL] = { 0 };

/* GtkBuildable */

static void     gtk_entry_completion_buildable_init      (GtkBuildableIface  *iface);

G_DEFINE_TYPE_WITH_CODE (GtkEntryCompletion, gtk_entry_completion, G_TYPE_OBJECT,

			 G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,

						gtk_entry_completion_cell_layout_init)

			 G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,

						gtk_entry_completion_buildable_init))

static void

gtk_entry_completion_class_init (GtkEntryCompletionClass *klass)

{

  GObjectClass *object_class;

  object_class = (GObjectClass *)klass;

  object_class->set_property = gtk_entry_completion_set_property;

  object_class->get_property = gtk_entry_completion_get_property;

  object_class->finalize = gtk_entry_completion_finalize;

  klass->match_selected = gtk_entry_completion_match_selected;

  klass->insert_prefix = gtk_entry_completion_real_insert_prefix;

  klass->cursor_on_match = gtk_entry_completion_cursor_on_match;

  /**

   * GtkEntryCompletion::insert-prefix:

   * @widget: the object which received the signal

   * @prefix: the common prefix of all possible completions

   *

   * Gets emitted when the inline autocompletion is triggered.

   * The default behaviour is to make the entry display the

   * whole prefix and select the newly inserted part.

   *

   * Applications may connect to this signal in order to insert only a

   * smaller part of the @prefix into the entry - e.g. the entry used in

   * the #GtkFileChooser inserts only the part of the prefix up to the

   * next '/'.

   *

   * Return value: %TRUE if the signal has been handled

   *

   * Since: 2.6

   */

  entry_completion_signals[INSERT_PREFIX] =

    g_signal_new (I_("insert-prefix"),

                  G_TYPE_FROM_CLASS (klass),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkEntryCompletionClass, insert_prefix),

                  _gtk_boolean_handled_accumulator, NULL,

                  _gtk_marshal_BOOLEAN__STRING,

                  G_TYPE_BOOLEAN, 1,

                  G_TYPE_STRING);

  /**

   * GtkEntryCompletion::match-selected:

   * @widget: the object which received the signal

   * @model: the #GtkTreeModel containing the matches

   * @iter: a #GtkTreeIter positioned at the selected match

   *

   * Gets emitted when a match from the list is selected.

   * The default behaviour is to replace the contents of the

   * entry with the contents of the text column in the row

   * pointed to by @iter.

   *

   * Return value: %TRUE if the signal has been handled

   *

   * Since: 2.4

   */

  entry_completion_signals[MATCH_SELECTED] =

    g_signal_new (I_("match-selected"),

                  G_TYPE_FROM_CLASS (klass),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkEntryCompletionClass, match_selected),

                  _gtk_boolean_handled_accumulator, NULL,

                  _gtk_marshal_BOOLEAN__OBJECT_BOXED,

                  G_TYPE_BOOLEAN, 2,

                  GTK_TYPE_TREE_MODEL,

                  GTK_TYPE_TREE_ITER);

  /**

   * GtkEntryCompletion::cursor-on-match:

   * @widget: the object which received the signal

   * @model: the #GtkTreeModel containing the matches

   * @iter: a #GtkTreeIter positioned at the selected match

   *

   * Gets emitted when a match from the cursor is on a match

   * of the list. The default behaviour is to replace the contents

   * of the entry with the contents of the text column in the row

   * pointed to by @iter.

   *

   * Return value: %TRUE if the signal has been handled

   *

   * Since: 2.12

   */

  entry_completion_signals[CURSOR_ON_MATCH] =

    g_signal_new (I_("cursor-on-match"),

		  G_TYPE_FROM_CLASS (klass),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkEntryCompletionClass, cursor_on_match),

		  _gtk_boolean_handled_accumulator, NULL,

		  _gtk_marshal_BOOLEAN__OBJECT_BOXED,

		  G_TYPE_BOOLEAN, 2,

		  GTK_TYPE_TREE_MODEL,

		  GTK_TYPE_TREE_ITER);

  /**

   * GtkEntryCompletion::action-activated:

   * @widget: the object which received the signal

   * @index: the index of the activated action

   *

   * Gets emitted when an action is activated.

   * 

   * Since: 2.4

   */

  entry_completion_signals[ACTION_ACTIVATED] =

    g_signal_new (I_("action-activated"),

                  G_TYPE_FROM_CLASS (klass),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkEntryCompletionClass, action_activated),

                  NULL, NULL,

                  _gtk_marshal_VOID__INT,

                  G_TYPE_NONE, 1,

                  G_TYPE_INT);

  g_object_class_install_property (object_class,

                                   PROP_MODEL,

                                   g_param_spec_object ("model",

                                                        P_("Completion Model"),

                                                        P_("The model to find matches in"),

                                                        GTK_TYPE_TREE_MODEL,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (object_class,

                                   PROP_MINIMUM_KEY_LENGTH,

                                   g_param_spec_int ("minimum-key-length",

                                                     P_("Minimum Key Length"),

                                                     P_("Minimum length of the search key in order to look up matches"),

                                                     0,

                                                     G_MAXINT,

                                                     1,

                                                     GTK_PARAM_READWRITE));

  /**

   * GtkEntryCompletion:text-column:

   *

   * The column of the model containing the strings.

   * Note that the strings must be UTF-8.

   *

   * Since: 2.6

   */

  g_object_class_install_property (object_class,

                                   PROP_TEXT_COLUMN,

                                   g_param_spec_int ("text-column",

                                                     P_("Text column"),

                                                     P_("The column of the model containing the strings."),

                                                     -1,

                                                     G_MAXINT,

                                                     -1,

                                                     GTK_PARAM_READWRITE));

  /**

   * GtkEntryCompletion:inline-completion:

   * 

   * Determines whether the common prefix of the possible completions 

   * should be inserted automatically in the entry. Note that this

   * requires text-column to be set, even if you are using a custom

   * match function.

   *

   * Since: 2.6

   **/

  g_object_class_install_property (object_class,

				   PROP_INLINE_COMPLETION,

				   g_param_spec_boolean ("inline-completion",

 							 P_("Inline completion"),

 							 P_("Whether the common prefix should be inserted automatically"),

 							 FALSE,

 							 GTK_PARAM_READWRITE));

  /**

   * GtkEntryCompletion:popup-completion:

   * 

   * Determines whether the possible completions should be 

   * shown in a popup window. 

   *

   * Since: 2.6

   **/

  g_object_class_install_property (object_class,

				   PROP_POPUP_COMPLETION,

				   g_param_spec_boolean ("popup-completion",

 							 P_("Popup completion"),

 							 P_("Whether the completions should be shown in a popup window"),

 							 TRUE,

 							 GTK_PARAM_READWRITE));

  /**

   * GtkEntryCompletion:popup-set-width:

   * 

   * Determines whether the completions popup window will be

   * resized to the width of the entry.

   *

   * Since: 2.8

   */

  g_object_class_install_property (object_class,

				   PROP_POPUP_SET_WIDTH,

				   g_param_spec_boolean ("popup-set-width",

 							 P_("Popup set width"),

 							 P_("If TRUE, the popup window will have the same size as the entry"),

 							 TRUE,

 							 GTK_PARAM_READWRITE));

  /**

   * GtkEntryCompletion:popup-single-match:

   * 

   * Determines whether the completions popup window will shown

   * for a single possible completion. You probably want to set

   * this to %FALSE if you are using 

   * <link linkend="GtkEntryCompletion--inline-completion">inline 

   * completion</link>.

   *

   * Since: 2.8

   */

  g_object_class_install_property (object_class,

				   PROP_POPUP_SINGLE_MATCH,

				   g_param_spec_boolean ("popup-single-match",

 							 P_("Popup single match"),

 							 P_("If TRUE, the popup window will appear for a single match."),

 							 TRUE,

 							 GTK_PARAM_READWRITE));

  /**

   * GtkEntryCompletion:inline-selection:

   * 

   * Determines whether the possible completions on the popup

   * will appear in the entry as you navigate through them.

   * Since: 2.12

   */

  g_object_class_install_property (object_class,

				   PROP_INLINE_SELECTION,

				   g_param_spec_boolean ("inline-selection",

							 P_("Inline selection"),

							 P_("Your description here"),

							 FALSE,

							 GTK_PARAM_READWRITE));

  g_type_class_add_private (object_class, sizeof (GtkEntryCompletionPrivate));

}

static void

gtk_entry_completion_buildable_init (GtkBuildableIface *iface)

{

  iface->add_child = _gtk_cell_layout_buildable_add_child;

  iface->custom_tag_start = _gtk_cell_layout_buildable_custom_tag_start;

  iface->custom_tag_end = _gtk_cell_layout_buildable_custom_tag_end;

}

static void

gtk_entry_completion_cell_layout_init (GtkCellLayoutIface *iface)

{

  iface->pack_start = gtk_entry_completion_pack_start;

  iface->pack_end = gtk_entry_completion_pack_end;

  iface->clear = gtk_entry_completion_clear;

  iface->add_attribute = gtk_entry_completion_add_attribute;

  iface->set_cell_data_func = gtk_entry_completion_set_cell_data_func;

  iface->clear_attributes = gtk_entry_completion_clear_attributes;

  iface->reorder = gtk_entry_completion_reorder;

  iface->get_cells = gtk_entry_completion_get_cells;

}

static void

gtk_entry_completion_init (GtkEntryCompletion *completion)

{

  GtkCellRenderer *cell;

  GtkTreeSelection *sel;

  GtkEntryCompletionPrivate *priv;

  GtkWidget *popup_frame;

  /* yes, also priv, need to keep the code readable */

  priv = completion->priv = GTK_ENTRY_COMPLETION_GET_PRIVATE (completion);

  priv->minimum_key_length = 1;

  priv->text_column = -1;

  priv->has_completion = FALSE;

  priv->inline_completion = FALSE;

  priv->popup_completion = TRUE;

  priv->popup_set_width = TRUE;

  priv->popup_single_match = TRUE;

  priv->inline_selection = FALSE;

  /* completions */

  priv->filter_model = NULL;

  priv->tree_view = gtk_tree_view_new ();

  g_signal_connect (priv->tree_view, "button-press-event",

                    G_CALLBACK (gtk_entry_completion_list_button_press),

                    completion);

  g_signal_connect (priv->tree_view, "enter-notify-event",

		    G_CALLBACK (gtk_entry_completion_list_enter_notify),

		    completion);

  g_signal_connect (priv->tree_view, "motion-notify-event",

		    G_CALLBACK (gtk_entry_completion_list_motion_notify),

		    completion);

  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view), FALSE);

  gtk_tree_view_set_hover_selection (GTK_TREE_VIEW (priv->tree_view), TRUE);

  sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view));

  gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE);

  gtk_tree_selection_unselect_all (sel);

  g_signal_connect (sel, "changed",

                    G_CALLBACK (gtk_entry_completion_selection_changed),

                    completion);

  priv->first_sel_changed = TRUE;

  priv->column = gtk_tree_view_column_new ();

  gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), priv->column);

  priv->scrolled_window = gtk_scrolled_window_new (NULL, NULL);

  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),

                                  GTK_POLICY_NEVER,

                                  GTK_POLICY_AUTOMATIC);

  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->scrolled_window),

                                       GTK_SHADOW_NONE);

  /* a nasty hack to get the completions treeview to size nicely */

  gtk_widget_set_size_request (GTK_SCROLLED_WINDOW (priv->scrolled_window)->vscrollbar, -1, 0);

  /* actions */

  priv->actions = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);

  priv->action_view =

    gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->actions));

  g_object_ref_sink (priv->action_view);

  g_signal_connect (priv->action_view, "button-press-event",

                    G_CALLBACK (gtk_entry_completion_action_button_press),

                    completion);

  g_signal_connect (priv->action_view, "enter-notify-event",

		    G_CALLBACK (gtk_entry_completion_list_enter_notify),

		    completion);

  g_signal_connect (priv->action_view, "motion-notify-event",

		    G_CALLBACK (gtk_entry_completion_list_motion_notify),

		    completion);

  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->action_view), FALSE);

  gtk_tree_view_set_hover_selection (GTK_TREE_VIEW (priv->action_view), TRUE);

  sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->action_view));

  gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE);

  gtk_tree_selection_unselect_all (sel);

  cell = gtk_cell_renderer_text_new ();

  gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW (priv->action_view),

                                              0, "",

                                              cell,

                                              gtk_entry_completion_action_data_func,

                                              NULL,

                                              NULL);

  /* pack it all */

  priv->popup_window = gtk_window_new (GTK_WINDOW_POPUP);

  gtk_window_set_resizable (GTK_WINDOW (priv->popup_window), FALSE);

  gtk_window_set_type_hint (GTK_WINDOW(priv->popup_window),

                            GDK_WINDOW_TYPE_HINT_COMBO);

  g_signal_connect (priv->popup_window, "key-press-event",

                    G_CALLBACK (gtk_entry_completion_popup_key_event),

                    completion);

  g_signal_connect (priv->popup_window, "key-release-event",

                    G_CALLBACK (gtk_entry_completion_popup_key_event),

                    completion);

  g_signal_connect (priv->popup_window, "button-press-event",

                    G_CALLBACK (gtk_entry_completion_popup_button_press),

                    completion);

  popup_frame = gtk_frame_new (NULL);

  gtk_frame_set_shadow_type (GTK_FRAME (popup_frame),

			     GTK_SHADOW_ETCHED_IN);

  gtk_widget_show (popup_frame);

  gtk_container_add (GTK_CONTAINER (priv->popup_window), popup_frame);

  priv->vbox = gtk_vbox_new (FALSE, 0);

  gtk_container_add (GTK_CONTAINER (popup_frame), priv->vbox);

  gtk_container_add (GTK_CONTAINER (priv->scrolled_window), priv->tree_view);

  gtk_box_pack_start (GTK_BOX (priv->vbox), priv->scrolled_window,

                      TRUE, TRUE, 0);

  /* we don't want to see the action treeview when no actions have

   * been inserted, so we pack the action treeview after the first

   * action has been added

   */

}

static void

gtk_entry_completion_set_property (GObject      *object,

                                   guint         prop_id,

                                   const GValue *value,

                                   GParamSpec   *pspec)

{

  GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (object);

  GtkEntryCompletionPrivate *priv = completion->priv;

  switch (prop_id)

    {

      case PROP_MODEL:

        gtk_entry_completion_set_model (completion,

                                        g_value_get_object (value));

        break;

      case PROP_MINIMUM_KEY_LENGTH:

        gtk_entry_completion_set_minimum_key_length (completion,

                                                     g_value_get_int (value));

        break;

      case PROP_TEXT_COLUMN:

	priv->text_column = g_value_get_int (value);

        break;

      case PROP_INLINE_COMPLETION:

	priv->inline_completion = g_value_get_boolean (value);

        break;

      case PROP_POPUP_COMPLETION:

	priv->popup_completion = g_value_get_boolean (value);

        break;

      case PROP_POPUP_SET_WIDTH:

	priv->popup_set_width = g_value_get_boolean (value);

        break;

      case PROP_POPUP_SINGLE_MATCH:

	priv->popup_single_match = g_value_get_boolean (value);

        break;

      case PROP_INLINE_SELECTION:

        priv->inline_selection = g_value_get_boolean (value);

        break;

      default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

        break;

    }

}

static void

gtk_entry_completion_get_property (GObject    *object,

                                   guint       prop_id,

                                   GValue     *value,

                                   GParamSpec *pspec)

{

  GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (object);

  switch (prop_id)

    {

      case PROP_MODEL:

        g_value_set_object (value,

                            gtk_entry_completion_get_model (completion));

        break;

      case PROP_MINIMUM_KEY_LENGTH:

        g_value_set_int (value, gtk_entry_completion_get_minimum_key_length (completion));

        break;

      case PROP_TEXT_COLUMN:

        g_value_set_int (value, gtk_entry_completion_get_text_column (completion));

        break;

      case PROP_INLINE_COMPLETION:

        g_value_set_boolean (value, gtk_entry_completion_get_inline_completion (completion));

        break;

      case PROP_POPUP_COMPLETION:

        g_value_set_boolean (value, gtk_entry_completion_get_popup_completion (completion));

        break;

      case PROP_POPUP_SET_WIDTH:

        g_value_set_boolean (value, gtk_entry_completion_get_popup_set_width (completion));

        break;

      case PROP_POPUP_SINGLE_MATCH:

        g_value_set_boolean (value, gtk_entry_completion_get_popup_single_match (completion));

        break;

      case PROP_INLINE_SELECTION:

        g_value_set_boolean (value, gtk_entry_completion_get_inline_selection (completion));

        break;

      default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

        break;

    }

}

static void

gtk_entry_completion_finalize (GObject *object)

{

  GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (object);

  GtkEntryCompletionPrivate *priv = completion->priv;

  if (priv->tree_view)

    gtk_widget_destroy (priv->tree_view);

  if (priv->entry)

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

  if (priv->actions)

    g_object_unref (priv->actions);

  if (priv->action_view)

    g_object_unref (priv->action_view);

  g_free (priv->case_normalized_key);

  g_free (priv->completion_prefix);

  if (priv->popup_window)

    gtk_widget_destroy (priv->popup_window);

  if (priv->match_notify)

    (* priv->match_notify) (priv->match_data);

  G_OBJECT_CLASS (gtk_entry_completion_parent_class)->finalize (object);

}

/* implement cell layout interface */

static void

gtk_entry_completion_pack_start (GtkCellLayout   *cell_layout,

                                 GtkCellRenderer *cell,

                                 gboolean         expand)

{

  GtkEntryCompletionPrivate *priv;

  priv = GTK_ENTRY_COMPLETION_GET_PRIVATE (cell_layout);

  gtk_tree_view_column_pack_start (priv->column, cell, expand);

}

static void

gtk_entry_completion_pack_end (GtkCellLayout   *cell_layout,

                               GtkCellRenderer *cell,

                               gboolean         expand)

{

  GtkEntryCompletionPrivate *priv;

  priv = GTK_ENTRY_COMPLETION_GET_PRIVATE (cell_layout);

  gtk_tree_view_column_pack_end (priv->column, cell, expand);

}

static void

gtk_entry_completion_clear (GtkCellLayout *cell_layout)

{

  GtkEntryCompletionPrivate *priv;

  priv = GTK_ENTRY_COMPLETION_GET_PRIVATE (cell_layout);

  gtk_tree_view_column_clear (priv->column);

}

static void

gtk_entry_completion_add_attribute (GtkCellLayout   *cell_layout,

                                    GtkCellRenderer *cell,

                                    const gchar     *attribute,

                                    gint             column)

{

  GtkEntryCompletionPrivate *priv;

  priv = GTK_ENTRY_COMPLETION_GET_PRIVATE (cell_layout);

  gtk_tree_view_column_add_attribute (priv->column, cell, attribute, column);

}

static void

gtk_entry_completion_set_cell_data_func (GtkCellLayout          *cell_layout,

                                         GtkCellRenderer        *cell,

                                         GtkCellLayoutDataFunc   func,

                                         gpointer                func_data,

                                         GDestroyNotify          destroy)

{

  GtkEntryCompletionPrivate *priv;

  priv = GTK_ENTRY_COMPLETION_GET_PRIVATE (cell_layout);

  gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (priv->column),

                                      cell, func, func_data, destroy);

}

static void

gtk_entry_completion_clear_attributes (GtkCellLayout   *cell_layout,

                                       GtkCellRenderer *cell)

{

  GtkEntryCompletionPrivate *priv;

  priv = GTK_ENTRY_COMPLETION_GET_PRIVATE (cell_layout);

  gtk_tree_view_column_clear_attributes (priv->column, cell);

}

static void

gtk_entry_completion_reorder (GtkCellLayout   *cell_layout,

                              GtkCellRenderer *cell,

                              gint             position)

{

  GtkEntryCompletionPrivate *priv;

  priv = GTK_ENTRY_COMPLETION_GET_PRIVATE (cell_layout);

  gtk_cell_layout_reorder (GTK_CELL_LAYOUT (priv->column), cell, position);

}

static GList *

gtk_entry_completion_get_cells (GtkCellLayout *cell_layout)

{

  GtkEntryCompletionPrivate *priv;

  priv = GTK_ENTRY_COMPLETION_GET_PRIVATE (cell_layout);

  return gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (priv->column));

}

/* all those callbacks */

static gboolean

gtk_entry_completion_default_completion_func (GtkEntryCompletion *completion,

                                              const gchar        *key,

                                              GtkTreeIter        *iter,

                                              gpointer            user_data)

{

  gchar *item = NULL;

  gchar *normalized_string;

  gchar *case_normalized_string;

  gboolean ret = FALSE;

  GtkTreeModel *model;

  model = gtk_tree_model_filter_get_model (completion->priv->filter_model);

  g_return_val_if_fail (gtk_tree_model_get_column_type (model, completion->priv->text_column) == G_TYPE_STRING, 

			FALSE);

  gtk_tree_model_get (model, iter,

                      completion->priv->text_column, &item,

                      -1);

  if (item != NULL)

    {

      normalized_string = g_utf8_normalize (item, -1, G_NORMALIZE_ALL);

      if (normalized_string != NULL)

        {

          case_normalized_string = g_utf8_casefold (normalized_string, -1);

          if (!strncmp (key, case_normalized_string, strlen (key)))

	    ret = TRUE;

          g_free (case_normalized_string);

        }

      g_free (normalized_string);

    }

  g_free (item);

  return ret;

}

static gboolean

gtk_entry_completion_visible_func (GtkTreeModel *model,

                                   GtkTreeIter  *iter,

                                   gpointer      data)

{

  gboolean ret = FALSE;

  GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (data);

  if (!completion->priv->case_normalized_key)

    return ret;

  if (completion->priv->match_func)

    ret = (* completion->priv->match_func) (completion,

                                            completion->priv->case_normalized_key,

                                            iter,

                                            completion->priv->match_data);

  else if (completion->priv->text_column >= 0)

    ret = gtk_entry_completion_default_completion_func (completion,

                                                        completion->priv->case_normalized_key,

                                                        iter,

                                                        NULL);

  return ret;

}

static gboolean

gtk_entry_completion_popup_key_event (GtkWidget   *widget,

                                      GdkEventKey *event,

                                      gpointer     user_data)

{

  GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (user_data);

  if (!gtk_widget_get_mapped (completion->priv->popup_window))

    return FALSE;

  /* propagate event to the entry */

  gtk_widget_event (completion->priv->entry, (GdkEvent *)event);

  return TRUE;

}

static gboolean

gtk_entry_completion_popup_button_press (GtkWidget      *widget,

                                         GdkEventButton *event,

                                         gpointer        user_data)

{

  GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (user_data);

  if (!gtk_widget_get_mapped (completion->priv->popup_window))

    return FALSE;

  /* if we come here, it's usually time to popdown */

  _gtk_entry_completion_popdown (completion);

  return TRUE;

}

static gboolean

gtk_entry_completion_list_button_press (GtkWidget      *widget,

                                        GdkEventButton *event,

                                        gpointer        user_data)

{

  GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (user_data);

  GtkTreePath *path = NULL;

  if (!gtk_widget_get_mapped (completion->priv->popup_window))

    return FALSE;

  if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),

                                     event->x, event->y,

                                     &path, NULL, NULL, NULL))

    {