path: root/e-util/e-name-selector-entry.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

/* e-name-selector-entry.c - Single-line text entry widget for EDestinations.
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 * This program 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.
 *
 * This program 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 General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Authors: Hans Petter Jansson <hpj@novell.com>
 */

#include <config.h>
#include <string.h>
#include <glib/gi18n-lib.h>

#include <camel/camel.h>
#include <libebackend/libebackend.h>

#include "e-name-selector-entry.h"

#define E_NAME_SELECTOR_ENTRY_GET_PRIVATE(obj) \
    (G_TYPE_INSTANCE_GET_PRIVATE \
    ((obj), E_TYPE_NAME_SELECTOR_ENTRY, ENameSelectorEntryPrivate))

struct _ENameSelectorEntryPrivate {
    EClientCache *client_cache;
    gint minimum_query_length;
    gboolean show_address;

    PangoAttrList *attr_list;
    EContactStore *contact_store;
    ETreeModelGenerator *email_generator;
    EDestinationStore *destination_store;
    GtkEntryCompletion *entry_completion;

    guint type_ahead_complete_cb_id;
    guint update_completions_cb_id;

    EDestination *popup_destination;

    gpointer    (*contact_editor_func)  (EBookClient *,
                         EContact *,
                         gboolean,
                         gboolean);
    gpointer    (*contact_list_editor_func)
                        (EBookClient *,
                         EContact *,
                         gboolean,
                         gboolean);

    gboolean is_completing;
    GSList *user_query_fields;

    /* For asynchronous operations. */
    GQueue cancellables;
};

enum {
    PROP_0,
    PROP_CLIENT_CACHE,
    PROP_MINIMUM_QUERY_LENGTH,
    PROP_SHOW_ADDRESS
};

enum {
    UPDATED,
    LAST_SIGNAL
};

static guint signals[LAST_SIGNAL] = { 0 };
#define ENS_DEBUG(x)

G_DEFINE_TYPE_WITH_CODE (
    ENameSelectorEntry,
    e_name_selector_entry,
    GTK_TYPE_ENTRY,
    G_IMPLEMENT_INTERFACE (
        E_TYPE_EXTENSIBLE, NULL))

/* 1/3 of the second to wait until invoking autocomplete lookup */
#define AUTOCOMPLETE_TIMEOUT 333

/* 1/20 of a second to wait until show the completion results */
#define SHOW_RESULT_TIMEOUT 50

#define re_set_timeout(id,func,ptr,tout) G_STMT_START { \
    if (id) \
        g_source_remove (id); \
    id = e_named_timeout_add (tout, func, ptr); \
    } G_STMT_END

static void destination_row_inserted (ENameSelectorEntry *name_selector_entry, GtkTreePath *path, GtkTreeIter *iter);
static void destination_row_changed  (ENameSelectorEntry *name_selector_entry, GtkTreePath *path, GtkTreeIter *iter);
static void destination_row_deleted  (ENameSelectorEntry *name_selector_entry, GtkTreePath *path);

static void user_insert_text (ENameSelectorEntry *name_selector_entry, gchar *new_text, gint new_text_length, gint *position, gpointer user_data);
static void user_delete_text (ENameSelectorEntry *name_selector_entry, gint start_pos, gint end_pos, gpointer user_data);

static void setup_default_contact_store (ENameSelectorEntry *name_selector_entry);
static void deep_free_list (GList *list);

static void
name_selector_entry_set_property (GObject *object,
                                  guint property_id,
                                  const GValue *value,
                                  GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_CLIENT_CACHE:
            e_name_selector_entry_set_client_cache (
                E_NAME_SELECTOR_ENTRY (object),
                g_value_get_object (value));
            return;

        case PROP_MINIMUM_QUERY_LENGTH:
            e_name_selector_entry_set_minimum_query_length (
                E_NAME_SELECTOR_ENTRY (object),
                g_value_get_int (value));
            return;

        case PROP_SHOW_ADDRESS:
            e_name_selector_entry_set_show_address (
                E_NAME_SELECTOR_ENTRY (object),
                g_value_get_boolean (value));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
name_selector_entry_get_property (GObject *object,
                                  guint property_id,
                                  GValue *value,
                                  GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_CLIENT_CACHE:
            g_value_take_object (
                value,
                e_name_selector_entry_ref_client_cache (
                E_NAME_SELECTOR_ENTRY (object)));
            return;

        case PROP_MINIMUM_QUERY_LENGTH:
            g_value_set_int (
                value,
                e_name_selector_entry_get_minimum_query_length (
                E_NAME_SELECTOR_ENTRY (object)));
            return;

        case PROP_SHOW_ADDRESS:
            g_value_set_boolean (
                value,
                e_name_selector_entry_get_show_address (
                E_NAME_SELECTOR_ENTRY (object)));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
name_selector_entry_dispose (GObject *object)
{
    ENameSelectorEntryPrivate *priv;

    priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (object);

    if (priv->client_cache != NULL) {
        g_object_unref (priv->client_cache);
        priv->client_cache = NULL;
    }

    if (priv->attr_list != NULL) {
        pango_attr_list_unref (priv->attr_list);
        priv->attr_list = NULL;
    }

    if (priv->entry_completion) {
        g_object_unref (priv->entry_completion);
        priv->entry_completion = NULL;
    }

    if (priv->destination_store) {
        g_object_unref (priv->destination_store);
        priv->destination_store = NULL;
    }

    if (priv->email_generator) {
        g_object_unref (priv->email_generator);
        priv->email_generator = NULL;
    }

    if (priv->contact_store) {
        g_object_unref (priv->contact_store);
        priv->contact_store = NULL;
    }

    g_slist_foreach (priv->user_query_fields, (GFunc) g_free, NULL);
    g_slist_free (priv->user_query_fields);
    priv->user_query_fields = NULL;

    /* Cancel any stuck book loading operations. */
    while (!g_queue_is_empty (&priv->cancellables)) {
        GCancellable *cancellable;

        cancellable = g_queue_pop_head (&priv->cancellables);
        g_cancellable_cancel (cancellable);
        g_object_unref (cancellable);
    }

    /* Chain up to parent's dispose() method. */
    G_OBJECT_CLASS (e_name_selector_entry_parent_class)->dispose (object);
}

static void
name_selector_entry_constructed (GObject *object)
{
    /* Chain up to parent's constructed() method. */
    G_OBJECT_CLASS (e_name_selector_entry_parent_class)->
        constructed (object);

    e_extensible_load_extensions (E_EXTENSIBLE (object));
}

static void
name_selector_entry_realize (GtkWidget *widget)
{
    ENameSelectorEntryPrivate *priv;

    priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (widget);

    /* Chain up to parent's realize() method. */
    GTK_WIDGET_CLASS (e_name_selector_entry_parent_class)->realize (widget);

    if (priv->contact_store == NULL)
        setup_default_contact_store (E_NAME_SELECTOR_ENTRY (widget));
}

static void
name_selector_entry_drag_data_received (GtkWidget *widget,
                                        GdkDragContext *context,
                                        gint x,
                                        gint y,
                                        GtkSelectionData *selection_data,
                                        guint info,
                                        guint time)
{
    CamelInternetAddress *address;
    gint n_addresses = 0;
    gchar *text;

    address = camel_internet_address_new ();
    text = (gchar *) gtk_selection_data_get_text (selection_data);

    /* See if Camel can parse a valid email address from the text. */
    if (text != NULL && *text != '\0') {
        camel_url_decode (text);
        if (g_ascii_strncasecmp (text, "mailto:", 7) == 0)
            n_addresses = camel_address_decode (
                CAMEL_ADDRESS (address), text + 7);
        else
            n_addresses = camel_address_decode (
                CAMEL_ADDRESS (address), text);
    }

    if (n_addresses > 0) {
        GtkEditable *editable;
        GdkDragAction action;
        gboolean delete;
        gint position;

        editable = GTK_EDITABLE (widget);
        gtk_editable_set_position (editable, -1);
        position = gtk_editable_get_position (editable);

        g_free (text);

        text = camel_address_format (CAMEL_ADDRESS (address));
        gtk_editable_insert_text (editable, text, -1, &position);

        action = gdk_drag_context_get_selected_action (context);
        delete = (action == GDK_ACTION_MOVE);
        gtk_drag_finish (context, TRUE, delete, time);
    }

    g_object_unref (address);
    g_free (text);

    if (n_addresses <= 0)
        /* Chain up to parent's drag_data_received() method. */
        GTK_WIDGET_CLASS (e_name_selector_entry_parent_class)->
            drag_data_received (
                widget, context, x, y,
                selection_data, info, time);
}

static void
e_name_selector_entry_class_init (ENameSelectorEntryClass *class)
{
    GObjectClass *object_class;
    GtkWidgetClass *widget_class;

    g_type_class_add_private (class, sizeof (ENameSelectorEntryPrivate));

    object_class = G_OBJECT_CLASS (class);
    object_class->set_property = name_selector_entry_set_property;
    object_class->get_property = name_selector_entry_get_property;
    object_class->dispose = name_selector_entry_dispose;
    object_class->constructed = name_selector_entry_constructed;

    widget_class = GTK_WIDGET_CLASS (class);
    widget_class->realize = name_selector_entry_realize;
    widget_class->drag_data_received = name_selector_entry_drag_data_received;

    /**
     * ENameSelectorEntry:client-cache:
     *
     * Cache of shared #EClient instances.
     **/
    g_object_class_install_property (
        object_class,
        PROP_CLIENT_CACHE,
        g_param_spec_object (
            "client-cache",
            "Client Cache",
            "Cache of shared EClient instances",
            E_TYPE_CLIENT_CACHE,
            G_PARAM_READWRITE |
            G_PARAM_CONSTRUCT |
            G_PARAM_STATIC_STRINGS));

    g_object_class_install_property (
        object_class,
        PROP_MINIMUM_QUERY_LENGTH,
        g_param_spec_int (
            "minimum-query-length",
            "Minimum Query Length",
            NULL,
            1, G_MAXINT,
            3,
            G_PARAM_READWRITE |
            G_PARAM_STATIC_STRINGS));

    g_object_class_install_property (
        object_class,
        PROP_SHOW_ADDRESS,
        g_param_spec_boolean (
            "show-address",
            "Show Address",
            NULL,
            FALSE,
            G_PARAM_READWRITE |
            G_PARAM_STATIC_STRINGS));

    signals[UPDATED] = g_signal_new (
        "updated",
        E_TYPE_NAME_SELECTOR_ENTRY,
        G_SIGNAL_RUN_FIRST,
        G_STRUCT_OFFSET (ENameSelectorEntryClass, updated),
        NULL, NULL,
        g_cclosure_marshal_VOID__POINTER,
        G_TYPE_NONE, 1, G_TYPE_POINTER);
}

/* Remove unquoted commas and control characters from string */
static gchar *
sanitize_string (const gchar *string)
{
    GString     *gstring;
    gboolean     quoted = FALSE;
    const gchar *p;

    gstring = g_string_new ("");

    if (!string)
        return g_string_free (gstring, FALSE);

    for (p = string; *p; p = g_utf8_next_char (p)) {
        gunichar c = g_utf8_get_char (p);

        if (c == '"')
            quoted = ~quoted;
        else if (c == ',' && !quoted)
            continue;
        else if (c == '\t' || c == '\n')
            continue;

        g_string_append_unichar (gstring, c);
    }

    return g_string_free (gstring, FALSE);
}

/* Called for each list store entry whenever the user types (but not on cut/paste) */
static gboolean
completion_match_cb (GtkEntryCompletion *completion,
                     const gchar *key,
                     GtkTreeIter *iter,
                     gpointer user_data)
{
    ENS_DEBUG (g_print ("completion_match_cb, key=%s\n", key));

    return TRUE;
}

/* Gets context of n_unichars total (n_unicars / 2, before and after position)
 * and places them in array. If any positions would be outside the string, the
 * corresponding unichars are set to zero. */
static void
get_utf8_string_context (const gchar *string,
                         gint position,
                         gunichar *unichars,
                         gint n_unichars)
{
    gchar *p = NULL;
    gint   len;
    gint   gap;
    gint   i;

    /* n_unichars must be even */
    g_assert (n_unichars % 2 == 0);

    len = g_utf8_strlen (string, -1);
    gap = n_unichars / 2;

    for (i = 0; i < n_unichars; i++) {
        gint char_pos = position - gap + i;

        if (char_pos < 0 || char_pos >= len) {
            unichars[i] = '\0';
            continue;
        }

        if (p)
            p = g_utf8_next_char (p);
        else
            p = g_utf8_offset_to_pointer (string, char_pos);

        unichars[i] = g_utf8_get_char (p);
    }
}

static gboolean
get_range_at_position (const gchar *string,
                       gint pos,
                       gint *start_pos,
                       gint *end_pos)
{
    const gchar *p;
    gboolean     quoted = FALSE;
    gint         local_start_pos = 0;
    gint         local_end_pos = 0;
    gint         i;

    if (!string || !*string)
        return FALSE;

    for (p = string, i = 0; *p; p = g_utf8_next_char (p), i++) {
        gunichar c = g_utf8_get_char (p);

        if (c == '"') {
            quoted = ~quoted;
        } else if (c == ',' && !quoted) {
            if (i < pos) {
                /* Start right after comma */
                local_start_pos = i + 1;
            } else {
                /* Stop right before comma */
                local_end_pos = i;
                break;
            }
        } else if (c == ' ' && local_start_pos == i) {
            /* Adjust start to skip space after first comma */
            local_start_pos++;
        }
    }

    /* If we didn't hit a comma, we must've hit NULL, and ours was the last element. */
    if (!local_end_pos)
        local_end_pos = i;

    if (start_pos)
        *start_pos = local_start_pos;
    if (end_pos)
        *end_pos   = local_end_pos;

    return TRUE;
}

static gboolean
is_quoted_at (const gchar *string,
              gint pos)
{
    const gchar *p;
    gboolean     quoted = FALSE;
    gint         i;

    for (p = string, i = 0; *p && i < pos; p = g_utf8_next_char (p), i++) {
        gunichar c = g_utf8_get_char (p);

        if (c == '"')
            quoted = ~quoted;
    }

    return quoted ? TRUE : FALSE;
}

static gint
get_index_at_position (const gchar *string,
                       gint pos)
{
    const gchar *p;
    gboolean     quoted = FALSE;
    gint         n = 0;
    gint         i;

    for (p = string, i = 0; *p && i < pos; p = g_utf8_next_char (p), i++) {
        gunichar c = g_utf8_get_char (p);

        if (c == '"')
            quoted = ~quoted;
        else if (c == ',' && !quoted)
            n++;
    }

    return n;
}

static gboolean
get_range_by_index (const gchar *string,
                    gint index,
                    gint *start_pos,
                    gint *end_pos)
{
    const gchar *p;
    gboolean     quoted = FALSE;
    gint         i;
    gint         n = 0;

    for (p = string, i = 0; *p && n < index; p = g_utf8_next_char (p), i++) {
        gunichar c = g_utf8_get_char (p);

        if (c == '"')
            quoted = ~quoted;
        if (c == ',' && !quoted)
            n++;
    }

    if (n < index)
        return FALSE;

    return get_range_at_position (string, i, start_pos, end_pos);
}

static gchar *
get_address_at_position (const gchar *string,
                         gint pos)
{
    gint         start_pos;
    gint         end_pos;
    const gchar *start_p;
    const gchar *end_p;

    if (!get_range_at_position (string, pos, &start_pos, &end_pos))
        return NULL;

    start_p = g_utf8_offset_to_pointer (string, start_pos);
    end_p = g_utf8_offset_to_pointer (string, end_pos);

    return g_strndup (start_p, end_p - start_p);
}

/* Finds the destination in model */
static EDestination *
find_destination_by_index (ENameSelectorEntry *name_selector_entry,
                           gint index)
{
    GtkTreePath  *path;
    GtkTreeIter   iter;

    path = gtk_tree_path_new_from_indices (index, -1);
    if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (name_selector_entry->priv->destination_store),
                      &iter, path)) {
        /* If we have zero destinations, getting a NULL destination at index 0
         * is valid. */
        if (index > 0)
            g_warning ("ENameSelectorEntry is out of sync with model!");
        gtk_tree_path_free (path);
        return NULL;
    }
    gtk_tree_path_free (path);

    return e_destination_store_get_destination (name_selector_entry->priv->destination_store, &iter);
}

/* Finds the destination in model */
static EDestination *
find_destination_at_position (ENameSelectorEntry *name_selector_entry,
                              gint pos)
{
    const gchar  *text;
    gint          index;

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    index = get_index_at_position (text, pos);

    return find_destination_by_index (name_selector_entry, index);
}

/* Builds destination from our text */
static EDestination *
build_destination_at_position (const gchar *string,
                               gint pos)
{
    EDestination *destination;
    gchar        *address;

    address = get_address_at_position (string, pos);
    if (!address)
        return NULL;

    destination = e_destination_new ();
    e_destination_set_raw (destination, address);

    g_free (address);
    return destination;
}

static gchar *
name_style_query (const gchar *field,
                  const gchar *value)
{
    gchar   *spaced_str;
    gchar   *comma_str;
    GString *out = g_string_new ("");
    gchar  **strv;
    gchar   *query;

    spaced_str = sanitize_string (value);
    g_strstrip (spaced_str);

    strv = g_strsplit (spaced_str, " ", 0);

    if (strv[0] && strv[1]) {
        g_string_append (out, "(or ");
        comma_str = g_strjoinv (", ", strv);
    } else {
        comma_str = NULL;
    }

    g_string_append (out, " (beginswith ");
    e_sexp_encode_string (out, field);
    e_sexp_encode_string (out, spaced_str);
    g_string_append (out, ")");

    if (comma_str) {
        g_string_append (out, " (beginswith ");

        e_sexp_encode_string (out, field);
        g_strstrip (comma_str);
        e_sexp_encode_string (out, comma_str);
        g_string_append (out, "))");
    }

    query = g_string_free (out, FALSE);

    g_free (spaced_str);
    g_free (comma_str);
    g_strfreev (strv);

    return query;
}

static gchar *
escape_sexp_string (const gchar *string)
{
    GString *gstring;
    gchar   *encoded_string;

    gstring = g_string_new ("");
    e_sexp_encode_string (gstring, string);

    encoded_string = gstring->str;
    g_string_free (gstring, FALSE);

    return encoded_string;
}

/**
 * ens_util_populate_user_query_fields:
 *
 * Populates list of user query fields to string usable in query string.
 * Returned pointer is either newly allocated string, supposed to be freed with g_free,
 * or NULL if no fields defined.
 *
 * Since: 2.24
 **/
gchar *
ens_util_populate_user_query_fields (GSList *user_query_fields,
                                     const gchar *cue_str,
                                     const gchar *encoded_cue_str)
{
    GString *user_fields;
    GSList *s;

    g_return_val_if_fail (cue_str != NULL, NULL);
    g_return_val_if_fail (encoded_cue_str != NULL, NULL);

    user_fields = g_string_new ("");

    for (s = user_query_fields; s; s = s->next) {
        const gchar *field = s->data;

        if (!field || !*field)
            continue;

        if (*field == '$') {
            g_string_append_printf (user_fields, " (beginswith \"%s\" %s) ", field + 1, encoded_cue_str);
        } else if (*field == '@') {
            g_string_append_printf (user_fields, " (is \"%s\" %s) ", field + 1, encoded_cue_str);
        } else {
            gchar *tmp = name_style_query (field, cue_str);

            g_string_append (user_fields, " ");
            g_string_append (user_fields, tmp);
            g_string_append (user_fields, " ");
            g_free (tmp);
        }
    }

    return g_string_free (user_fields, !user_fields->str || !*user_fields->str);
}

static void
set_completion_query (ENameSelectorEntry *name_selector_entry,
                      const gchar *cue_str)
{
    ENameSelectorEntryPrivate *priv;
    EBookQuery *book_query;
    gchar      *query_str;
    gchar      *encoded_cue_str;
    gchar      *full_name_query_str;
    gchar      *file_as_query_str;
    gchar      *user_fields_str;

    priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (name_selector_entry);

    if (!name_selector_entry->priv->contact_store)
        return;

    if (!cue_str) {
        /* Clear the store */
        e_contact_store_set_query (name_selector_entry->priv->contact_store, NULL);
        return;
    }

    encoded_cue_str = escape_sexp_string (cue_str);
    full_name_query_str = name_style_query ("full_name", cue_str);
    file_as_query_str = name_style_query ("file_as",   cue_str);
    user_fields_str = ens_util_populate_user_query_fields (priv->user_query_fields, cue_str, encoded_cue_str);

    query_str = g_strdup_printf (
        "(or "
        " (beginswith \"nickname\"  %s) "
        " (beginswith \"email\"     %s) "
        " %s "
        " %s "
        " %s "
        ")",
        encoded_cue_str, encoded_cue_str,
        full_name_query_str, file_as_query_str,
        user_fields_str ? user_fields_str : "");

    g_free (user_fields_str);
    g_free (file_as_query_str);
    g_free (full_name_query_str);
    g_free (encoded_cue_str);

    ENS_DEBUG (g_print ("%s\n", query_str));

    book_query = e_book_query_from_string (query_str);
    e_contact_store_set_query (name_selector_entry->priv->contact_store, book_query);
    e_book_query_unref (book_query);

    g_free (query_str);
}

static gchar *
get_entry_substring (ENameSelectorEntry *name_selector_entry,
                     gint range_start,
                     gint range_end)
{
    const gchar *entry_text;
    gchar       *p0, *p1;

    entry_text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));

    p0 = g_utf8_offset_to_pointer (entry_text, range_start);
    p1 = g_utf8_offset_to_pointer (entry_text, range_end);

    return g_strndup (p0, p1 - p0);
}

static gint
utf8_casefold_collate_len (const gchar *str1,
                           const gchar *str2,
                           gint len)
{
    gchar *s1 = g_utf8_casefold (str1, len);
    gchar *s2 = g_utf8_casefold (str2, len);
    gint rv;

    rv = g_utf8_collate (s1, s2);

    g_free (s1);
    g_free (s2);

    return rv;
}

static gchar *
build_textrep_for_contact (EContact *contact,
                           EContactField cue_field)
{
    gchar *name = NULL;
    gchar *email = NULL;
    gchar *textrep;

    switch (cue_field) {
        case E_CONTACT_FULL_NAME:
        case E_CONTACT_NICKNAME:
        case E_CONTACT_FILE_AS:
            name = e_contact_get (contact, cue_field);
            email = e_contact_get (contact, E_CONTACT_EMAIL_1);
            break;

        case E_CONTACT_EMAIL_1:
        case E_CONTACT_EMAIL_2:
        case E_CONTACT_EMAIL_3:
        case E_CONTACT_EMAIL_4:
            name = NULL;
            email = e_contact_get (contact, cue_field);
            break;

        default:
            g_assert_not_reached ();
            break;
    }

    g_assert (email);
    g_assert (strlen (email) > 0);

    if (name)
        textrep = g_strdup_printf ("%s <%s>", name, email);
    else
        textrep = g_strdup_printf ("%s", email);

    g_free (name);
    g_free (email);
    return textrep;
}

static gboolean
contact_match_cue (ENameSelectorEntry *name_selector_entry,
                   EContact *contact,
                   const gchar *cue_str,
                   EContactField *matched_field,
                   gint *matched_field_rank)
{
    EContactField  fields[] = { E_CONTACT_FULL_NAME, E_CONTACT_NICKNAME, E_CONTACT_FILE_AS,
                     E_CONTACT_EMAIL_1, E_CONTACT_EMAIL_2, E_CONTACT_EMAIL_3,
                     E_CONTACT_EMAIL_4 };
    gchar         *email;
    gboolean       result = FALSE;
    gint           cue_len;
    gint           i;

    g_assert (contact);
    g_assert (cue_str);

    if (g_utf8_strlen (cue_str, -1) < name_selector_entry->priv->minimum_query_length)
        return FALSE;

    cue_len = strlen (cue_str);

    /* Make sure contact has an email address */
    email = e_contact_get (contact, E_CONTACT_EMAIL_1);
    if (!email || !*email) {
        g_free (email);
        return FALSE;
    }
    g_free (email);

    for (i = 0; i < G_N_ELEMENTS (fields); i++) {
        gchar *value;
        gchar *value_sane;

        /* Don't match e-mail addresses in contact lists */
        if (e_contact_get (contact, E_CONTACT_IS_LIST) &&
            fields[i] >= E_CONTACT_FIRST_EMAIL_ID &&
            fields[i] <= E_CONTACT_LAST_EMAIL_ID)
            continue;

        value = e_contact_get (contact, fields[i]);
        if (!value)
            continue;

        value_sane = sanitize_string (value);
        g_free (value);

        ENS_DEBUG (g_print ("Comparing '%s' to '%s'\n", value, cue_str));

        if (!utf8_casefold_collate_len (value_sane, cue_str, cue_len)) {
            if (matched_field)
                *matched_field = fields [i];
            if (matched_field_rank)
                *matched_field_rank = i;

            result = TRUE;
            g_free (value_sane);
            break;
        }
        g_free (value_sane);
    }

    return result;
}

static gboolean
find_existing_completion (ENameSelectorEntry *name_selector_entry,
                          const gchar *cue_str,
                          EContact **contact,
                          gchar **text,
                          EContactField *matched_field,
                          EBookClient **book_client)
{
    GtkTreeIter    iter;
    EContact      *best_contact = NULL;
    gint           best_field_rank = G_MAXINT;
    EContactField  best_field = 0;
    EBookClient   *best_book_client = NULL;

    g_assert (cue_str);

    if (!name_selector_entry->priv->contact_store)
        return FALSE;

    ENS_DEBUG (g_print ("Completing '%s'\n", cue_str));

    if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (name_selector_entry->priv->contact_store), &iter))
        return FALSE;

    do {
        EContact      *current_contact;
        gint           current_field_rank;
        EContactField  current_field;
        gboolean       matches;

        current_contact = e_contact_store_get_contact (name_selector_entry->priv->contact_store, &iter);
        if (!current_contact)
            continue;

        matches = contact_match_cue (name_selector_entry, current_contact, cue_str, &current_field, &current_field_rank);
        if (matches && current_field_rank < best_field_rank) {
            best_contact = current_contact;
            best_field_rank = current_field_rank;
            best_field = current_field;
            best_book_client = e_contact_store_get_client (name_selector_entry->priv->contact_store, &iter);
        }
    } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (name_selector_entry->priv->contact_store), &iter));

    if (!best_contact)
        return FALSE;

    if (contact)
        *contact = best_contact;
    if (text)
        *text = build_textrep_for_contact (best_contact, best_field);
    if (matched_field)
        *matched_field = best_field;
    if (book_client)
        *book_client = best_book_client;

    return TRUE;
}

static void
generate_attribute_list (ENameSelectorEntry *name_selector_entry)
{
    PangoLayout    *layout;
    PangoAttrList  *attr_list;
    const gchar    *text;
    gint            i;

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    layout = gtk_entry_get_layout (GTK_ENTRY (name_selector_entry));

    /* Set up the attribute list */

    attr_list = pango_attr_list_new ();

    if (name_selector_entry->priv->attr_list)
        pango_attr_list_unref (name_selector_entry->priv->attr_list);

    name_selector_entry->priv->attr_list = attr_list;

    /* Parse the entry's text and apply attributes to real contacts */

    for (i = 0; ; i++) {
        EDestination   *destination;
        PangoAttribute *attr;
        gint            start_pos;
        gint            end_pos;

        if (!get_range_by_index (text, i, &start_pos, &end_pos))
            break;

        destination = find_destination_at_position (name_selector_entry, start_pos);

        /* Destination will be NULL if we have no entries */
        if (!destination || !e_destination_get_contact (destination))
            continue;

        attr = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
        attr->start_index = g_utf8_offset_to_pointer (text, start_pos) - text;
        attr->end_index = g_utf8_offset_to_pointer (text, end_pos) - text;
        pango_attr_list_insert (attr_list, attr);
    }

    pango_layout_set_attributes (layout, attr_list);
}

static gboolean
draw_event (ENameSelectorEntry *name_selector_entry)
{
    PangoLayout *layout;

    layout = gtk_entry_get_layout (GTK_ENTRY (name_selector_entry));
    pango_layout_set_attributes (layout, name_selector_entry->priv->attr_list);

    return FALSE;
}

static void
type_ahead_complete (ENameSelectorEntry *name_selector_entry)
{
    EContact      *contact;
    EBookClient   *book_client = NULL;
    EContactField  matched_field;
    EDestination  *destination;
    gint           cursor_pos;
    gint           range_start = 0;
    gint           range_end = 0;
    gint           pos = 0;
    gchar         *textrep;
    gint           textrep_len;
    gint           range_len;
    const gchar   *text;
    gchar         *cue_str;
    gchar         *temp_str;
    ENameSelectorEntryPrivate *priv;

    priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (name_selector_entry);

    cursor_pos = gtk_editable_get_position (GTK_EDITABLE (name_selector_entry));
    if (cursor_pos < 0)
        return;

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    get_range_at_position (text, cursor_pos, &range_start, &range_end);
    range_len = range_end - range_start;
    if (range_len < priv->minimum_query_length)
        return;

    destination = find_destination_at_position (name_selector_entry, cursor_pos);

    cue_str = get_entry_substring (name_selector_entry, range_start, range_end);
    if (!find_existing_completion (name_selector_entry, cue_str, &contact,
                       &textrep, &matched_field, &book_client)) {
        g_free (cue_str);
        return;
    }

    temp_str = sanitize_string (textrep);
    g_free (textrep);
    textrep = temp_str;

    textrep_len = g_utf8_strlen (textrep, -1);
    pos = range_start;

    g_signal_handlers_block_by_func (
        name_selector_entry,
        user_insert_text, name_selector_entry);
    g_signal_handlers_block_by_func (
        name_selector_entry,
        user_delete_text, name_selector_entry);
    g_signal_handlers_block_by_func (
        name_selector_entry->priv->destination_store,
        destination_row_changed, name_selector_entry);

    if (textrep_len > range_len) {
        gint i;

        /* keep character's case as user types */
        for (i = 0; textrep[i] && cue_str[i]; i++)
            textrep[i] = cue_str[i];

        gtk_editable_delete_text (
            GTK_EDITABLE (name_selector_entry),
            range_start, range_end);
        gtk_editable_insert_text (
            GTK_EDITABLE (name_selector_entry),
            textrep, -1, &pos);
        gtk_editable_select_region (
            GTK_EDITABLE (name_selector_entry),
            range_end, range_start + textrep_len);
        priv->is_completing = TRUE;
    }
    g_free (cue_str);

    if (contact && destination) {
        gint email_n = 0;

        if (matched_field >= E_CONTACT_FIRST_EMAIL_ID && matched_field <= E_CONTACT_LAST_EMAIL_ID)
            email_n = matched_field - E_CONTACT_FIRST_EMAIL_ID;

        e_destination_set_contact (destination, contact, email_n);
        if (book_client)
            e_destination_set_client (destination, book_client);
        generate_attribute_list (name_selector_entry);
    }

    g_signal_handlers_unblock_by_func (
        name_selector_entry->priv->destination_store,
        destination_row_changed, name_selector_entry);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_insert_text, name_selector_entry);

    g_free (textrep);
}

static void
clear_completion_model (ENameSelectorEntry *name_selector_entry)
{
    ENameSelectorEntryPrivate *priv;

    priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (name_selector_entry);

    if (!name_selector_entry->priv->contact_store)
        return;

    e_contact_store_set_query (name_selector_entry->priv->contact_store, NULL);
    priv->is_completing = FALSE;
}

static void
update_completion_model (ENameSelectorEntry *name_selector_entry)
{
    const gchar *text;
    gint         cursor_pos;
    gint         range_start = 0;
    gint         range_end = 0;

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    cursor_pos = gtk_editable_get_position (GTK_EDITABLE (name_selector_entry));

    if (cursor_pos >= 0)
        get_range_at_position (text, cursor_pos, &range_start, &range_end);

    if (range_end - range_start >= name_selector_entry->priv->minimum_query_length && cursor_pos == range_end) {
        gchar *cue_str;

        cue_str = get_entry_substring (name_selector_entry, range_start, range_end);
        set_completion_query (name_selector_entry, cue_str);
        g_free (cue_str);
    } else {
        /* N/A; Clear completion model */
        clear_completion_model (name_selector_entry);
    }
}

static gboolean
type_ahead_complete_on_timeout_cb (gpointer user_data)
{
    ENameSelectorEntry *name_selector_entry;

    name_selector_entry = E_NAME_SELECTOR_ENTRY (user_data);
    type_ahead_complete (name_selector_entry);
    name_selector_entry->priv->type_ahead_complete_cb_id = 0;

    return FALSE;
}

static gboolean
update_completions_on_timeout_cb (gpointer user_data)
{
    ENameSelectorEntry *name_selector_entry;

    name_selector_entry = E_NAME_SELECTOR_ENTRY (user_data);
    update_completion_model (name_selector_entry);
    name_selector_entry->priv->update_completions_cb_id = 0;

    return FALSE;
}

static void
insert_destination_at_position (ENameSelectorEntry *name_selector_entry,
                                gint pos)
{
    EDestination *destination;
    const gchar  *text;
    gint          index;

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    index = get_index_at_position (text, pos);

    destination = build_destination_at_position (text, pos);
    g_assert (destination);

    g_signal_handlers_block_by_func (
        name_selector_entry->priv->destination_store,
        destination_row_inserted, name_selector_entry);
    e_destination_store_insert_destination (
        name_selector_entry->priv->destination_store,
                        index, destination);
    g_signal_handlers_unblock_by_func (
        name_selector_entry->priv->destination_store,
        destination_row_inserted, name_selector_entry);
    g_object_unref (destination);
}

static void
modify_destination_at_position (ENameSelectorEntry *name_selector_entry,
                                gint pos)
{
    EDestination *destination;
    const gchar  *text;
    gchar        *raw_address;
    gboolean      rebuild_attributes = FALSE;

    destination = find_destination_at_position (name_selector_entry, pos);
    if (!destination)
        return;

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    raw_address = get_address_at_position (text, pos);
    g_assert (raw_address);

    if (e_destination_get_contact (destination))
        rebuild_attributes = TRUE;

    g_signal_handlers_block_by_func (
        name_selector_entry->priv->destination_store,
        destination_row_changed, name_selector_entry);
    e_destination_set_raw (destination, raw_address);
    g_signal_handlers_unblock_by_func (
        name_selector_entry->priv->destination_store,
        destination_row_changed, name_selector_entry);

    g_free (raw_address);

    if (rebuild_attributes)
        generate_attribute_list (name_selector_entry);
}

static gchar *
get_destination_textrep (ENameSelectorEntry *name_selector_entry,
                         EDestination *destination)
{
    gboolean show_email = e_name_selector_entry_get_show_address (name_selector_entry);
    EContact *contact;

    g_return_val_if_fail (destination != NULL, NULL);

    contact = e_destination_get_contact (destination);

    if (!show_email) {
        if (contact && !e_contact_get (contact, E_CONTACT_IS_LIST)) {
            GList *email_list;

            email_list = e_contact_get (contact, E_CONTACT_EMAIL);
            show_email = g_list_length (email_list) > 1;
            deep_free_list (email_list);
        }
    }

    /* do not show emails for contact lists even user forces it */
    if (show_email && contact && e_contact_get (contact, E_CONTACT_IS_LIST))
        show_email = FALSE;

    return sanitize_string (e_destination_get_textrep (destination, show_email));
}

static void
sync_destination_at_position (ENameSelectorEntry *name_selector_entry,
                              gint range_pos,
                              gint *cursor_pos)
{
    EDestination *destination;
    const gchar  *text;
    gchar        *address;
    gint          address_len;
    gint          range_start, range_end;

    /* Get the destination we're looking at. Note that the entry may be empty, and so
     * there may not be one. */
    destination = find_destination_at_position (name_selector_entry, range_pos);
    if (!destination)
        return;

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    if (!get_range_at_position (text, range_pos, &range_start, &range_end)) {
        g_warning ("ENameSelectorEntry is out of sync with model!");
        return;
    }

    address = get_destination_textrep (name_selector_entry, destination);
    address_len = g_utf8_strlen (address, -1);

    if (cursor_pos) {
        /* Update cursor placement */
        if (*cursor_pos >= range_end)
            *cursor_pos += address_len - (range_end - range_start);
        else if (*cursor_pos > range_start)
            *cursor_pos = range_start + address_len;
    }

    g_signal_handlers_block_by_func (name_selector_entry, user_insert_text, name_selector_entry);
    g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);

    gtk_editable_delete_text (GTK_EDITABLE (name_selector_entry), range_start, range_end);
    gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), address, -1, &range_start);

    g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_insert_text, name_selector_entry);

    generate_attribute_list (name_selector_entry);
    g_free (address);
}

static void
remove_destination_by_index (ENameSelectorEntry *name_selector_entry,
                             gint index)
{
    EDestination *destination;

    destination = find_destination_by_index (name_selector_entry, index);
    if (destination) {
        g_signal_handlers_block_by_func (
            name_selector_entry->priv->destination_store,
            destination_row_deleted, name_selector_entry);
        e_destination_store_remove_destination (
            name_selector_entry->priv->destination_store,
                        destination);
        g_signal_handlers_unblock_by_func (
            name_selector_entry->priv->destination_store,
            destination_row_deleted, name_selector_entry);
    }
}

static void
post_insert_update (ENameSelectorEntry *name_selector_entry,
                    gint position)
{
    const gchar *text;
    glong length;

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    length = g_utf8_strlen (text, -1);
    text = g_utf8_next_char (text);

    if (*text == '\0') {
        /* First and only character, create initial destination. */
        insert_destination_at_position (name_selector_entry, 0);
    } else {
        /* Modified an existing destination. */
        modify_destination_at_position (name_selector_entry, position);
    }

    /* If editing within the string, regenerate attributes. */
    if (position < length)
        generate_attribute_list (name_selector_entry);
}

/* Returns the number of characters inserted */
static gint
insert_unichar (ENameSelectorEntry *name_selector_entry,
                gint *pos,
                gunichar c)
{
    const gchar *text;
    gunichar     str_context[4];
    gchar        buf[7];
    gint         len;

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    get_utf8_string_context (text, *pos, str_context, 4);

    /* Space is not allowed:
     * - Before or after another space.
     * - At start of string. */

    if (c == ' ' && (str_context[1] == ' ' || str_context[1] == '\0' || str_context[2] == ' '))
        return 0;

    /* Comma is not allowed:
     * - After another comma.
     * - At start of string. */

    if (c == ',' && !is_quoted_at (text, *pos)) {
        gint         start_pos;
        gint         end_pos;
        gboolean     at_start = FALSE;
        gboolean     at_end = FALSE;

        if (str_context[1] == ',' || str_context[1] == '\0')
            return 0;

        /* We do this so we can avoid disturbing destinations with completed contacts
         * either before or after the destination being inserted. */
        get_range_at_position (text, *pos, &start_pos, &end_pos);
        if (*pos <= start_pos)
            at_start = TRUE;
        if (*pos >= end_pos)
            at_end = TRUE;

        /* Must insert comma first, so modify_destination_at_position can do its job
         * correctly, splitting up the contact if necessary. */
        gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), ", ", -1, pos);

        /* Update model */
        g_assert (*pos >= 2);

        /* If we inserted the comma at the end of, or in the middle of, an existing
         * address, add a new destination for what appears after comma. Else, we
         * have to add a destination for what appears before comma (a blank one). */
        if (at_end) {
            /* End: Add last, sync first */
            insert_destination_at_position (name_selector_entry, *pos);
            sync_destination_at_position (name_selector_entry, *pos - 2, pos);
            /* Sync generates the attributes list */
        } else if (at_start) {
            /* Start: Add first */
            insert_destination_at_position (name_selector_entry, *pos - 2);
            generate_attribute_list (name_selector_entry);
        } else {
            /* Middle: */
            insert_destination_at_position (name_selector_entry, *pos);
            modify_destination_at_position (name_selector_entry, *pos - 2);
            generate_attribute_list (name_selector_entry);
        }

        return 2;
    }

    /* Generic case. Allowed spaces also end up here. */

    len = g_unichar_to_utf8 (c, buf);
    buf[len] = '\0';

    gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), buf, -1, pos);

    post_insert_update (name_selector_entry, *pos);

    return 1;
}

static void
user_insert_text (ENameSelectorEntry *name_selector_entry,
                  gchar *new_text,
                  gint new_text_length,
                  gint *position,
                  gpointer user_data)
{
    gint chars_inserted = 0;
    gboolean fast_insert;

    g_signal_handlers_block_by_func (name_selector_entry, user_insert_text, name_selector_entry);
    g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);

    fast_insert =
        (g_utf8_strchr (new_text, new_text_length, ' ') == NULL) &&
        (g_utf8_strchr (new_text, new_text_length, ',') == NULL);

    /* If the text to insert does not contain spaces or commas,
     * insert all of it at once.  This avoids confusing on-going
     * input method behavior. */
    if (fast_insert) {
        gint old_position = *position;

        gtk_editable_insert_text (
            GTK_EDITABLE (name_selector_entry),
            new_text, new_text_length, position);

        chars_inserted = *position - old_position;
        if (chars_inserted > 0)
            post_insert_update (name_selector_entry, *position);

    /* Otherwise, apply some rules as to where spaces and commas
     * can be inserted, and insert a trailing space after comma. */
    } else {
        const gchar *cp;

        for (cp = new_text; *cp; cp = g_utf8_next_char (cp)) {
            gunichar uc = g_utf8_get_char (cp);
            insert_unichar (name_selector_entry, position, uc);
            chars_inserted++;
        }
    }

    if (chars_inserted >= 1) {
        /* If the user inserted one character, kick off completion */
        re_set_timeout (
            name_selector_entry->priv->update_completions_cb_id,
            update_completions_on_timeout_cb,  name_selector_entry,
            AUTOCOMPLETE_TIMEOUT);
        re_set_timeout (
            name_selector_entry->priv->type_ahead_complete_cb_id,
            type_ahead_complete_on_timeout_cb, name_selector_entry,
            AUTOCOMPLETE_TIMEOUT);
    }

    g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_insert_text, name_selector_entry);

    g_signal_stop_emission_by_name (name_selector_entry, "insert_text");
}

static void
user_delete_text (ENameSelectorEntry *name_selector_entry,
                  gint start_pos,
                  gint end_pos,
                  gpointer user_data)
{
    const gchar *text;
    gint         index_start, index_end;
    gint         selection_start, selection_end;
    gunichar     str_context[2], str_b_context[2];
    gint         len;
    gint         i;
    gboolean     del_space = FALSE, del_comma = FALSE;

    if (start_pos == end_pos)
        return;

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    len = g_utf8_strlen (text, -1);

    if (end_pos == -1)
        end_pos = len;

    gtk_editable_get_selection_bounds (
        GTK_EDITABLE (name_selector_entry),
        &selection_start, &selection_end);

    get_utf8_string_context (text, start_pos, str_context, 2);
    get_utf8_string_context (text, end_pos, str_b_context, 2);

    g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);

    if (end_pos - start_pos == 1) {
        /* Might be backspace; update completion model so dropdown is accurate */
        re_set_timeout (
            name_selector_entry->priv->update_completions_cb_id,
            update_completions_on_timeout_cb, name_selector_entry,
            AUTOCOMPLETE_TIMEOUT);
    }

    index_start = get_index_at_position (text, start_pos);
    index_end = get_index_at_position (text, end_pos);

    g_signal_stop_emission_by_name (name_selector_entry, "delete_text");

    /* If the deletion touches more than one destination, the first one is changed
     * and the rest are removed. If the last destination wasn't completely deleted,
     * it becomes part of the first one, since the separator between them was
     * removed.
     *
     * Here, we let the model know about removals. */
    for (i = index_end; i > index_start; i--) {
        EDestination *destination = find_destination_by_index (name_selector_entry, i);
        gint range_start, range_end;
        gchar *ttext;
        const gchar *email = NULL;
        gboolean sel = FALSE;

        if (destination)
            email = e_destination_get_textrep (destination, TRUE);

        if (!email || !*email)
            continue;

        if (!get_range_by_index (text, i, &range_start, &range_end)) {
            g_warning ("ENameSelectorEntry is out of sync with model!");
            return;
        }

        if ((selection_start < range_start && selection_end > range_start) ||
            (selection_end > range_start && selection_end < range_end))
            sel = TRUE;

        if (!sel) {
            g_signal_handlers_block_by_func (name_selector_entry, user_insert_text, name_selector_entry);
            g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);

            gtk_editable_delete_text (GTK_EDITABLE (name_selector_entry), range_start, range_end);

            ttext = sanitize_string (email);
            gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), ttext, -1, &range_start);
            g_free (ttext);

            g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);
            g_signal_handlers_unblock_by_func (name_selector_entry, user_insert_text, name_selector_entry);

        }

        remove_destination_by_index (name_selector_entry, i);
    }

    /* Do the actual deletion */

    if (end_pos == start_pos +1 && index_end == index_start) {
        /* We could be just deleting the empty text */
        gchar *c;

        /* Get the actual deleted text */
        c = gtk_editable_get_chars (GTK_EDITABLE (name_selector_entry), start_pos, start_pos + 1);

        if ( c[0] == ' ') {
            /* If we are at the beginning or removing junk space, let us ignore it */
            del_space = TRUE;
        }
        g_free (c);
    } else  if (end_pos == start_pos +1 && index_end == index_start + 1) {
        /* We could be just deleting the empty text */
        gchar *c;

        /* Get the actual deleted text */
        c = gtk_editable_get_chars (GTK_EDITABLE (name_selector_entry), start_pos, start_pos + 1);

        if ( c[0] == ',' && !is_quoted_at (text, start_pos)) {
            /* If we are at the beginning or removing junk space, let us ignore it */
            del_comma = TRUE;
        }
        g_free (c);
    }

    if (del_comma) {
        gint range_start=-1, range_end;
        EDestination *dest = find_destination_by_index (name_selector_entry, index_end);
        /* If we have deleted the last comma, let us autocomplete normally
         */

        if (dest && len - end_pos != 0) {

            EDestination *destination1 = find_destination_by_index (name_selector_entry, index_start);
            gchar *ttext;
            const gchar *email = NULL;

            if (destination1)
                email = e_destination_get_textrep (destination1, TRUE);

            if (email && *email) {

                if (!get_range_by_index (text, i, &range_start, &range_end)) {
                    g_warning ("ENameSelectorEntry is out of sync with model!");
                    return;
                }

                g_signal_handlers_block_by_func (name_selector_entry, user_insert_text, name_selector_entry);
                g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);

                gtk_editable_delete_text (GTK_EDITABLE (name_selector_entry), range_start, range_end);

                ttext = sanitize_string (email);
                gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), ttext, -1, &range_start);
                g_free (ttext);

                g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);
                g_signal_handlers_unblock_by_func (name_selector_entry, user_insert_text, name_selector_entry);
            }

            if (range_start != -1) {
                start_pos = range_start;
                end_pos = start_pos + 1;
                gtk_editable_set_position (GTK_EDITABLE (name_selector_entry),start_pos);
            }
        }
    }
    gtk_editable_delete_text (
        GTK_EDITABLE (name_selector_entry),
        start_pos, end_pos);

    /*If the user is deleting a '"' new destinations have to be created for ',' between the quoted text
     Like "fd,ty,uy" is a one entity, but if you remove the quotes it has to be broken doan into 3 seperate
     addresses.
    */

    if (str_b_context[1] == '"') {
        const gchar *p;
        gint j;
        p = text + end_pos;
        for (p = text + (end_pos - 1), j = end_pos - 1; *p && *p != '"' ; p = g_utf8_next_char (p), j++) {
            gunichar c = g_utf8_get_char (p);
            if (c == ',') {
                insert_destination_at_position (name_selector_entry, j + 1);
            }
        }

    }

    /* Let model know about changes */
    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    if (!*text || strlen (text) <= 0) {
        /* If the entry was completely cleared, remove the initial destination too */
        remove_destination_by_index (name_selector_entry, 0);
        generate_attribute_list (name_selector_entry);
    } else  if (!del_space) {
        modify_destination_at_position (name_selector_entry, start_pos);
    }

    /* If editing within the string, we need to regenerate attributes */
    if (end_pos < len)
        generate_attribute_list (name_selector_entry);

    /* Prevent type-ahead completion */
    if (name_selector_entry->priv->type_ahead_complete_cb_id) {
        g_source_remove (name_selector_entry->priv->type_ahead_complete_cb_id);
        name_selector_entry->priv->type_ahead_complete_cb_id = 0;
    }

    g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);
}

static gboolean
completion_match_selected (ENameSelectorEntry *name_selector_entry,
                           ETreeModelGenerator *email_generator_model,
                           GtkTreeIter *generator_iter)
{
    EContact      *contact;
    EBookClient   *book_client;
    EDestination  *destination;
    gint           cursor_pos;
    GtkTreeIter    contact_iter;
    gint           email_n;

    if (!name_selector_entry->priv->contact_store)
        return FALSE;

    g_return_val_if_fail (name_selector_entry->priv->email_generator == email_generator_model, FALSE);

    e_tree_model_generator_convert_iter_to_child_iter (
        email_generator_model,
        &contact_iter, &email_n,
        generator_iter);

    contact = e_contact_store_get_contact (name_selector_entry->priv->contact_store, &contact_iter);
    book_client = e_contact_store_get_client (name_selector_entry->priv->contact_store, &contact_iter);
    cursor_pos = gtk_editable_get_position (GTK_EDITABLE (name_selector_entry));

    /* Set the contact in the model's destination */

    destination = find_destination_at_position (name_selector_entry, cursor_pos);
    e_destination_set_contact (destination, contact, email_n);
    if (book_client)
        e_destination_set_client (destination, book_client);
    sync_destination_at_position (name_selector_entry, cursor_pos, &cursor_pos);

    g_signal_handlers_block_by_func (name_selector_entry, user_insert_text, name_selector_entry);
    gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), ", ", -1, &cursor_pos);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_insert_text, name_selector_entry);

    /*Add destination at end for next entry*/
    insert_destination_at_position (name_selector_entry, cursor_pos);
    /* Place cursor at end of address */

    gtk_editable_set_position (GTK_EDITABLE (name_selector_entry), cursor_pos);
    g_signal_emit (name_selector_entry, signals[UPDATED], 0, destination, NULL);
    return TRUE;
}

static void
entry_activate (ENameSelectorEntry *name_selector_entry)
{
    gint         cursor_pos;
    gint         range_start, range_end;
    ENameSelectorEntryPrivate *priv;
    EDestination  *destination;
    gint           range_len;
    const gchar   *text;
    gchar         *cue_str;

    cursor_pos = gtk_editable_get_position (GTK_EDITABLE (name_selector_entry));
    if (cursor_pos < 0)
        return;

    priv = E_NAME_SELECTOR_ENTRY_GET_PRIVATE (name_selector_entry);

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    if (!get_range_at_position (text, cursor_pos, &range_start, &range_end))
        return;

    range_len = range_end - range_start;
    if (range_len < priv->minimum_query_length)
        return;

    destination = find_destination_at_position (name_selector_entry, cursor_pos);
    if (!destination)
        return;

    cue_str = get_entry_substring (name_selector_entry, range_start, range_end);
#if 0
    if (!find_existing_completion (name_selector_entry, cue_str, &contact,
                       &textrep, &matched_field)) {
        g_free (cue_str);
        return;
    }
#endif
    g_free (cue_str);
    sync_destination_at_position (name_selector_entry, cursor_pos, &cursor_pos);

    /* Place cursor at end of address */
    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    get_range_at_position (text, cursor_pos, &range_start, &range_end);

    if (priv->is_completing) {
        gchar *str_context = NULL;

        str_context = gtk_editable_get_chars (GTK_EDITABLE (name_selector_entry), range_end, range_end + 1);

        if (str_context[0] != ',') {
            /* At the end*/
            gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), ", ", -1, &range_end);
        } else {
            /* In the middle */
            gint newpos = strlen (text);

                        /* Doing this we can make sure that It wont ask for completion again. */
            gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), ", ", -1, &newpos);
            g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);
            gtk_editable_delete_text (GTK_EDITABLE (name_selector_entry), newpos - 2, newpos);
            g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);

            /* Move it close to next destination*/
            range_end = range_end + 2;

        }
        g_free (str_context);
    }

    gtk_editable_set_position (GTK_EDITABLE (name_selector_entry), range_end);
    g_signal_emit (name_selector_entry, signals[UPDATED], 0, destination, NULL);

    if (priv->is_completing)
        clear_completion_model (name_selector_entry);
}

static void
update_text (ENameSelectorEntry *name_selector_entry,
             const gchar *text)
{
    gint start = 0, end = 0;
    gboolean has_selection;

    has_selection = gtk_editable_get_selection_bounds (GTK_EDITABLE (name_selector_entry), &start, &end);

    gtk_entry_set_text (GTK_ENTRY (name_selector_entry), text);

    if (has_selection)
        gtk_editable_select_region (GTK_EDITABLE (name_selector_entry), start, end);
}

static void
sanitize_entry (ENameSelectorEntry *name_selector_entry)
{
    gint n;
    GList *l, *known, *del = NULL;
    GString *str = g_string_new ("");

    g_signal_handlers_block_matched (name_selector_entry, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, name_selector_entry);
    g_signal_handlers_block_matched (name_selector_entry->priv->destination_store, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, name_selector_entry);

    known = e_destination_store_list_destinations (name_selector_entry->priv->destination_store);
    for (l = known, n = 0; l != NULL; l = l->next, n++) {
        EDestination *dest = l->data;

        if (!dest || !e_destination_get_address (dest))
            del = g_list_prepend (del, GINT_TO_POINTER (n));
        else {
            gchar *text;

            text = get_destination_textrep (name_selector_entry, dest);
            if (text) {
                if (str->str && str->str[0])
                    g_string_append (str, ", ");

                g_string_append (str, text);
            }
            g_free (text);
        }
    }
    g_list_free (known);

    for (l = del; l != NULL; l = l->next) {
        e_destination_store_remove_destination_nth (name_selector_entry->priv->destination_store, GPOINTER_TO_INT (l->data));
    }
    g_list_free (del);

    update_text (name_selector_entry, str->str);

    g_string_free (str, TRUE);

    g_signal_handlers_unblock_matched (name_selector_entry->priv->destination_store, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, name_selector_entry);
    g_signal_handlers_unblock_matched (name_selector_entry, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, name_selector_entry);

    generate_attribute_list (name_selector_entry);
}

static gboolean
user_focus_in (ENameSelectorEntry *name_selector_entry,
               GdkEventFocus *event_focus)
{
    gint n;
    GList *l, *known;
    GString *str = g_string_new ("");
    EDestination *dest_dummy = e_destination_new ();

    g_signal_handlers_block_matched (name_selector_entry, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, name_selector_entry);
    g_signal_handlers_block_matched (name_selector_entry->priv->destination_store, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, name_selector_entry);

    known = e_destination_store_list_destinations (name_selector_entry->priv->destination_store);
    for (l = known, n = 0; l != NULL; l = l->next, n++) {
        EDestination *dest = l->data;

        if (dest) {
            gchar *text;

            text = get_destination_textrep (name_selector_entry, dest);
            if (text) {
                if (str->str && str->str[0])
                    g_string_append (str, ", ");

                g_string_append (str, text);
            }
            g_free (text);
        }
    }
    g_list_free (known);

    /* Add a blank destination */
    e_destination_store_append_destination (name_selector_entry->priv->destination_store, dest_dummy);
    if (str->str && str->str[0])
        g_string_append (str, ", ");

    gtk_entry_set_text (GTK_ENTRY (name_selector_entry), str->str);

    g_string_free (str, TRUE);

    g_signal_handlers_unblock_matched (name_selector_entry->priv->destination_store, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, name_selector_entry);
    g_signal_handlers_unblock_matched (name_selector_entry, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, name_selector_entry);

    generate_attribute_list (name_selector_entry);

    return FALSE;
}

static gboolean
user_focus_out (ENameSelectorEntry *name_selector_entry,
                GdkEventFocus *event_focus)
{
    if (!event_focus->in) {
        entry_activate (name_selector_entry);
    }

    if (name_selector_entry->priv->type_ahead_complete_cb_id) {
        g_source_remove (name_selector_entry->priv->type_ahead_complete_cb_id);
        name_selector_entry->priv->type_ahead_complete_cb_id = 0;
    }

    if (name_selector_entry->priv->update_completions_cb_id) {
        g_source_remove (name_selector_entry->priv->update_completions_cb_id);
        name_selector_entry->priv->update_completions_cb_id = 0;
    }

    clear_completion_model (name_selector_entry);

    if (!event_focus->in) {
        sanitize_entry (name_selector_entry);
    }

    return FALSE;
}

static void
deep_free_list (GList *list)
{
    GList *l;

    for (l = list; l; l = g_list_next (l))
        g_free (l->data);

    g_list_free (list);
}

/* Given a widget, determines the height that text will normally be drawn. */
static guint
entry_height (GtkWidget *widget)
{
    PangoLayout *layout;
    gint bound;

    g_return_val_if_fail (widget != NULL, 0);

    layout = gtk_widget_create_pango_layout (widget, NULL);

    pango_layout_get_pixel_size (layout, NULL, &bound);

    return bound;
}

static void
contact_layout_pixbuffer (GtkCellLayout *cell_layout,
                          GtkCellRenderer *cell,
                          GtkTreeModel *model,
                          GtkTreeIter *iter,
                          ENameSelectorEntry *name_selector_entry)
{
    EContact      *contact;
    GtkTreeIter    generator_iter;
    GtkTreeIter    contact_store_iter;
    gint           email_n;
    EContactPhoto *photo;
    GdkPixbuf *pixbuf = NULL;

    if (!name_selector_entry->priv->contact_store)
        return;

    gtk_tree_model_filter_convert_iter_to_child_iter (
        GTK_TREE_MODEL_FILTER (model),
        &generator_iter, iter);
    e_tree_model_generator_convert_iter_to_child_iter (
        name_selector_entry->priv->email_generator,
        &contact_store_iter, &email_n,
        &generator_iter);

    contact = e_contact_store_get_contact (name_selector_entry->priv->contact_store, &contact_store_iter);
    if (!contact) {
        g_object_set (cell, "pixbuf", pixbuf, NULL);
        return;
    }

    photo = e_contact_get (contact, E_CONTACT_PHOTO);
    if (photo && photo->type == E_CONTACT_PHOTO_TYPE_INLINED) {
        guint max_height = entry_height (GTK_WIDGET (name_selector_entry));
        GdkPixbufLoader *loader;

        loader = gdk_pixbuf_loader_new ();
        if (gdk_pixbuf_loader_write (loader, (guchar *) photo->data.inlined.data, photo->data.inlined.length, NULL) &&
            gdk_pixbuf_loader_close (loader, NULL)) {
            pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
            if (pixbuf)
                g_object_ref (pixbuf);
        }
        g_object_unref (loader);

        if (pixbuf) {
            gint w, h;
            gdouble scale = 1.0;

            w = gdk_pixbuf_get_width (pixbuf);
            h = gdk_pixbuf_get_height (pixbuf);

            if (h > w)
                scale = max_height / (double) h;
            else
                scale = max_height / (double) w;

            if (scale < 1.0) {
                GdkPixbuf *tmp;

                tmp = gdk_pixbuf_scale_simple (pixbuf, w * scale, h * scale, GDK_INTERP_BILINEAR);
                g_object_unref (pixbuf);
                pixbuf = tmp;
            }

        }
    }

    e_contact_photo_free (photo);

    g_object_set (cell, "pixbuf", pixbuf, NULL);

    if (pixbuf)
        g_object_unref (pixbuf);
}

static void
contact_layout_formatter (GtkCellLayout *cell_layout,
                          GtkCellRenderer *cell,
                          GtkTreeModel *model,
                          GtkTreeIter *iter,
                          ENameSelectorEntry *name_selector_entry)
{
    EContact      *contact;
    GtkTreeIter    generator_iter;
    GtkTreeIter    contact_store_iter;
    GList         *email_list;
    gchar         *string;
    gchar         *file_as_str;
    gchar         *email_str;
    gint           email_n;

    if (!name_selector_entry->priv->contact_store)
        return;

    gtk_tree_model_filter_convert_iter_to_child_iter (
        GTK_TREE_MODEL_FILTER (model),
        &generator_iter, iter);
    e_tree_model_generator_convert_iter_to_child_iter (
        name_selector_entry->priv->email_generator,
        &contact_store_iter, &email_n,
        &generator_iter);

    contact = e_contact_store_get_contact (name_selector_entry->priv->contact_store, &contact_store_iter);
    email_list = e_contact_get (contact, E_CONTACT_EMAIL);
    email_str = g_list_nth_data (email_list, email_n);
    file_as_str = e_contact_get (contact, E_CONTACT_FILE_AS);

    if (e_contact_get (contact, E_CONTACT_IS_LIST)) {
        string = g_strdup_printf ("%s", file_as_str ? file_as_str : "?");
    } else {
        string = g_strdup_printf (
            "%s%s<%s>", file_as_str ? file_as_str : "",
            file_as_str ? " " : "",
            email_str ? email_str : "");
    }

    g_free (file_as_str);
    deep_free_list (email_list);

    g_object_set (cell, "text", string, NULL);
    g_free (string);
}

static gint
generate_contact_rows (EContactStore *contact_store,
                       GtkTreeIter *iter,
                       ENameSelectorEntry *name_selector_entry)
{
    EContact    *contact;
    const gchar *contact_uid;
    GList       *email_list;
    gint         n_rows;

    contact = e_contact_store_get_contact (contact_store, iter);
    g_assert (contact != NULL);

    contact_uid = e_contact_get_const (contact, E_CONTACT_UID);
    if (!contact_uid)
        return 0;  /* Can happen with broken databases */

    if (e_contact_get (contact, E_CONTACT_IS_LIST))
        return 1;

    email_list = e_contact_get (contact, E_CONTACT_EMAIL);
    n_rows = g_list_length (email_list);
    deep_free_list (email_list);

    return n_rows;
}

static void
ensure_type_ahead_complete_on_timeout (ENameSelectorEntry *name_selector_entry)
{
    /* this is called whenever a new item is added to the model,
     * thus, to not starve when there are many matches, do not
     * postpone on each add, but show results as soon as possible */
    if (!name_selector_entry->priv->type_ahead_complete_cb_id) {
        re_set_timeout (
            name_selector_entry->priv->type_ahead_complete_cb_id,
            type_ahead_complete_on_timeout_cb, name_selector_entry,
            SHOW_RESULT_TIMEOUT);
    }
}

static void
setup_contact_store (ENameSelectorEntry *name_selector_entry)
{
    if (name_selector_entry->priv->email_generator) {
        g_object_unref (name_selector_entry->priv->email_generator);
        name_selector_entry->priv->email_generator = NULL;
    }

    if (name_selector_entry->priv->contact_store) {
        name_selector_entry->priv->email_generator =
            e_tree_model_generator_new (
                GTK_TREE_MODEL (
                name_selector_entry->priv->contact_store));

        e_tree_model_generator_set_generate_func (
            name_selector_entry->priv->email_generator,
            (ETreeModelGeneratorGenerateFunc) generate_contact_rows,
            name_selector_entry, NULL);

        /* Assign the store to the entry completion */

        gtk_entry_completion_set_model (
            name_selector_entry->priv->entry_completion,
            GTK_TREE_MODEL (
            name_selector_entry->priv->email_generator));

        /* Set up callback for incoming matches */
        g_signal_connect_swapped (
            name_selector_entry->priv->contact_store, "row-inserted",
            G_CALLBACK (ensure_type_ahead_complete_on_timeout), name_selector_entry);
    } else {
        /* Remove the store from the entry completion */

        gtk_entry_completion_set_model (name_selector_entry->priv->entry_completion, NULL);
    }
}

static void
name_selector_entry_get_client_cb (GObject *source_object,
                                   GAsyncResult *result,
                                   gpointer user_data)
{
    EContactStore *contact_store = user_data;
    EBookClient *book_client;
    EClient *client;
    GError *error = NULL;

    client = e_client_cache_get_client_finish (
        E_CLIENT_CACHE (source_object), result, &error);

    /* Sanity check. */
    g_return_if_fail (
        ((client != NULL) && (error == NULL)) ||
        ((client == NULL) && (error != NULL)));

    if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
        g_error_free (error);
        goto exit;
    }

    if (error != NULL) {
        g_warning ("%s: %s", G_STRFUNC, error->message);
        g_error_free (error);
        goto exit;
    }

    book_client = E_BOOK_CLIENT (client);

    g_return_if_fail (E_IS_BOOK_CLIENT (book_client));
    e_contact_store_add_client (contact_store, book_client);
    g_object_unref (book_client);

 exit:
    g_object_unref (contact_store);
}

static void
setup_default_contact_store (ENameSelectorEntry *name_selector_entry)
{
    EClientCache *client_cache;
    ESourceRegistry *registry;
    EContactStore *contact_store;
    GList *list, *iter;
    const gchar *extension_name;

    g_return_if_fail (name_selector_entry->priv->contact_store == NULL);

    /* Create a book for each completion source, and assign them to the contact store */

    contact_store = e_contact_store_new ();
    name_selector_entry->priv->contact_store = contact_store;

    extension_name = E_SOURCE_EXTENSION_ADDRESS_BOOK;
    client_cache = e_name_selector_entry_ref_client_cache (name_selector_entry);
    registry = e_client_cache_ref_registry (client_cache);

    list = e_source_registry_list_enabled (registry, extension_name);

    for (iter = list; iter != NULL; iter = g_list_next (iter)) {
        ESource *source = E_SOURCE (iter->data);
        ESourceAutocomplete *extension;
        GCancellable *cancellable;
        const gchar *extension_name;

        extension_name = E_SOURCE_EXTENSION_AUTOCOMPLETE;
        extension = e_source_get_extension (source, extension_name);

        /* Skip non-completion address books. */
        if (!e_source_autocomplete_get_include_me (extension))
            continue;

        cancellable = g_cancellable_new ();

        g_queue_push_tail (
            &name_selector_entry->priv->cancellables,
            cancellable);

        e_client_cache_get_client (
            client_cache, source,
            E_SOURCE_EXTENSION_ADDRESS_BOOK,
            cancellable,
            name_selector_entry_get_client_cb,
            g_object_ref (contact_store));
    }

    g_list_free_full (list, (GDestroyNotify) g_object_unref);

    g_object_unref (registry);
    g_object_unref (client_cache);

    setup_contact_store (name_selector_entry);
}

static void
destination_row_changed (ENameSelectorEntry *name_selector_entry,
                         GtkTreePath *path,
                         GtkTreeIter *iter)
{
    EDestination *destination;
    const gchar  *entry_text;
    gchar        *text;
    gint          range_start, range_end;
    gint          n;

    n = gtk_tree_path_get_indices (path)[0];
    destination = e_destination_store_get_destination (name_selector_entry->priv->destination_store, iter);

    if (!destination)
        return;

    g_assert (n >= 0);

    entry_text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    if (!get_range_by_index (entry_text, n, &range_start, &range_end)) {
        g_warning ("ENameSelectorEntry is out of sync with model!");
        return;
    }

    g_signal_handlers_block_by_func (name_selector_entry, user_insert_text, name_selector_entry);
    g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);

    gtk_editable_delete_text (GTK_EDITABLE (name_selector_entry), range_start, range_end);

    text = get_destination_textrep (name_selector_entry, destination);
    gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), text, -1, &range_start);
    g_free (text);

    g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_insert_text, name_selector_entry);

    clear_completion_model (name_selector_entry);
    generate_attribute_list (name_selector_entry);
}

static void
destination_row_inserted (ENameSelectorEntry *name_selector_entry,
                          GtkTreePath *path,
                          GtkTreeIter *iter)
{
    EDestination *destination;
    const gchar  *entry_text;
    gchar        *text;
    gboolean      comma_before = FALSE;
    gboolean      comma_after = FALSE;
    gint          range_start, range_end;
    gint          insert_pos;
    gint          n;

    n = gtk_tree_path_get_indices (path)[0];
    destination = e_destination_store_get_destination (name_selector_entry->priv->destination_store, iter);

    g_assert (n >= 0);
    g_assert (destination != NULL);

    entry_text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));

    if (get_range_by_index (entry_text, n, &range_start, &range_end) && range_start != range_end) {
        /* Another destination comes after us */
        insert_pos = range_start;
        comma_after = TRUE;
    } else if (n > 0 && get_range_by_index (entry_text, n - 1, &range_start, &range_end)) {
        /* Another destination comes before us */
        insert_pos = range_end;
        comma_before = TRUE;
    } else if (n == 0) {
        /* We're the sole destination */
        insert_pos = 0;
    } else {
        g_warning ("ENameSelectorEntry is out of sync with model!");
        return;
    }

    g_signal_handlers_block_by_func (name_selector_entry, user_insert_text, name_selector_entry);

    if (comma_before)
        gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), ", ", -1, &insert_pos);

    text = get_destination_textrep (name_selector_entry, destination);
    gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), text, -1, &insert_pos);
    g_free (text);

    if (comma_after)
        gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), ", ", -1, &insert_pos);

    g_signal_handlers_unblock_by_func (name_selector_entry, user_insert_text, name_selector_entry);

    clear_completion_model (name_selector_entry);
    generate_attribute_list (name_selector_entry);
}

static void
destination_row_deleted (ENameSelectorEntry *name_selector_entry,
                         GtkTreePath *path)
{
    const gchar *text;
    gboolean     deleted_comma = FALSE;
    gint         range_start, range_end;
    gchar       *p0;
    gint         n;

    n = gtk_tree_path_get_indices (path)[0];
    g_assert (n >= 0);

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));

    if (!get_range_by_index (text, n, &range_start, &range_end)) {
        g_warning ("ENameSelectorEntry is out of sync with model!");
        return;
    }

    /* Expand range for deletion forwards */
    for (p0 = g_utf8_offset_to_pointer (text, range_end); *p0;
         p0 = g_utf8_next_char (p0), range_end++) {
        gunichar c = g_utf8_get_char (p0);

        /* Gobble spaces directly after comma */
        if (c != ' ' && deleted_comma) {
            range_end--;
            break;
        }

        if (c == ',') {
            deleted_comma = TRUE;
            range_end++;
        }
    }

    /* Expand range for deletion backwards */
    for (p0 = g_utf8_offset_to_pointer (text, range_start); range_start > 0;
         p0 = g_utf8_prev_char (p0), range_start--) {
        gunichar c = g_utf8_get_char (p0);

        if (c == ',') {
            if (!deleted_comma) {
                deleted_comma = TRUE;
                break;
            }

            range_start++;

            /* Leave a space in front; we deleted the comma and spaces before the
             * following destination */
            p0 = g_utf8_next_char (p0);
            c = g_utf8_get_char (p0);
            if (c == ' ')
                range_start++;

            break;
        }
    }

    g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);
    gtk_editable_delete_text (GTK_EDITABLE (name_selector_entry), range_start, range_end);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);

    clear_completion_model (name_selector_entry);
    generate_attribute_list (name_selector_entry);
}

static void
setup_destination_store (ENameSelectorEntry *name_selector_entry)
{
    GtkTreeIter  iter;

    g_signal_connect_swapped (
        name_selector_entry->priv->destination_store, "row-changed",
        G_CALLBACK (destination_row_changed), name_selector_entry);
    g_signal_connect_swapped (
        name_selector_entry->priv->destination_store, "row-deleted",
        G_CALLBACK (destination_row_deleted), name_selector_entry);
    g_signal_connect_swapped (
        name_selector_entry->priv->destination_store, "row-inserted",
        G_CALLBACK (destination_row_inserted), name_selector_entry);

    if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (name_selector_entry->priv->destination_store), &iter))
        return;

    do {
        GtkTreePath *path;

        path = gtk_tree_model_get_path (GTK_TREE_MODEL (name_selector_entry->priv->destination_store), &iter);
        g_assert (path);

        destination_row_inserted (name_selector_entry, path, &iter);
    } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (name_selector_entry->priv->destination_store), &iter));
}

static gboolean
prepare_popup_destination (ENameSelectorEntry *name_selector_entry,
                           GdkEventButton *event_button)
{
    EDestination *destination;
    PangoLayout  *layout;
    gint          layout_offset_x;
    gint          layout_offset_y;
    gint          x, y;
    gint          index;

    if (event_button->type != GDK_BUTTON_PRESS)
        return FALSE;

    if (event_button->button != 3)
        return FALSE;

    if (name_selector_entry->priv->popup_destination) {
        g_object_unref (name_selector_entry->priv->popup_destination);
        name_selector_entry->priv->popup_destination = NULL;
    }

    gtk_entry_get_layout_offsets (
        GTK_ENTRY (name_selector_entry),
        &layout_offset_x, &layout_offset_y);
    x = (event_button->x + 0.5) - layout_offset_x;
    y = (event_button->y + 0.5) - layout_offset_y;

    if (x < 0 || y < 0)
        return FALSE;

    layout = gtk_entry_get_layout (GTK_ENTRY (name_selector_entry));
    if (!pango_layout_xy_to_index (layout, x * PANGO_SCALE, y * PANGO_SCALE, &index, NULL))
        return FALSE;

    index = gtk_entry_layout_index_to_text_index (GTK_ENTRY (name_selector_entry), index);
    destination = find_destination_at_position (name_selector_entry, index);
    /* FIXME: Add this to a private variable, in ENameSelectorEntry Class*/
    g_object_set_data ((GObject *) name_selector_entry, "index", GINT_TO_POINTER (index));

    if (!destination || !e_destination_get_contact (destination))
        return FALSE;

    /* TODO: Unref destination when we finalize */
    name_selector_entry->priv->popup_destination = g_object_ref (destination);
    return FALSE;
}

static EBookClient *
find_client_by_contact (GSList *clients,
                        const gchar *contact_uid,
                        const gchar *source_uid)
{
    GSList *l;

    if (source_uid && *source_uid) {
        /* this is much quicket than asking each client for an existence */
        for (l = clients; l; l = g_slist_next (l)) {
            EBookClient *client = l->data;
            ESource *source = e_client_get_source (E_CLIENT (client));

            if (!source)
                continue;

            if (g_strcmp0 (source_uid, e_source_get_uid (source)) == 0)
                return client;
        }
    }

    for (l = clients; l; l = g_slist_next (l)) {
        EBookClient *client = l->data;
        EContact *contact = NULL;
        gboolean  result;

        result = e_book_client_get_contact_sync (client, contact_uid, &contact, NULL, NULL);
        if (contact)
            g_object_unref (contact);

        if (result)
            return client;
    }

    return NULL;
}

static void
editor_closed_cb (GtkWidget *editor,
                  gpointer data)
{
    EContact *contact;
    gchar *contact_uid;
    EDestination *destination;
    GSList *clients;
    EBookClient *book_client;
    gint email_num;
    ENameSelectorEntry *name_selector_entry = E_NAME_SELECTOR_ENTRY (data);

    destination = name_selector_entry->priv->popup_destination;
    contact = e_destination_get_contact (destination);
    if (!contact) {
        g_object_unref (name_selector_entry);
        return;
    }

    contact_uid = e_contact_get (contact, E_CONTACT_UID);
    if (!contact_uid) {
        g_object_unref (contact);
        g_object_unref (name_selector_entry);
        return;
    }

    if (name_selector_entry->priv->contact_store) {
        clients = e_contact_store_get_clients (name_selector_entry->priv->contact_store);
        book_client = find_client_by_contact (clients, contact_uid, e_destination_get_source_uid (destination));
        g_slist_free (clients);
    } else {
        book_client = NULL;
    }

    if (book_client) {
        contact = NULL;

        g_warn_if_fail (e_book_client_get_contact_sync (book_client, contact_uid, &contact, NULL, NULL));
        email_num = e_destination_get_email_num (destination);
        e_destination_set_contact (destination, contact, email_num);
        e_destination_set_client (destination, book_client);
    } else {
        contact = NULL;
    }

    g_free (contact_uid);
    if (contact)
        g_object_unref (contact);
    g_object_unref (name_selector_entry);
}

/* To parse something like...
 * =?UTF-8?Q?=E0=A4=95=E0=A4=95=E0=A4=AC=E0=A5=82=E0=A5=8B=E0=A5=87?=\t\n=?UTF-8?Q?=E0=A4=B0?=\t\n<aa@aa.ccom>
 * and return the decoded representation of name & email parts.
 * */
static gboolean
eab_parse_qp_email (const gchar *string,
                    gchar **name,
                    gchar **email)
{
    struct _camel_header_address *address;
    gboolean res = FALSE;

    address = camel_header_address_decode (string, "UTF-8");

    if (!address)
        return FALSE;

        /* report success only when we have filled both name and email address */
    if (address->type == CAMEL_HEADER_ADDRESS_NAME && address->name && *address->name && address->v.addr && *address->v.addr) {
                *name = g_strdup (address->name);
                *email = g_strdup (address->v.addr);
        res = TRUE;
    }

    camel_header_address_unref (address);

    return res;
}

static void
popup_activate_inline_expand (ENameSelectorEntry *name_selector_entry,
                              GtkWidget *menu_item)
{
    const gchar *text;
    GString *sanitized_text = g_string_new ("");
    EDestination *destination = name_selector_entry->priv->popup_destination;
    gint position, start, end;
    const GList *dests;

    position = GPOINTER_TO_INT (g_object_get_data ((GObject *) name_selector_entry, "index"));

    for (dests = e_destination_list_get_dests (destination); dests; dests = dests->next) {
        const EDestination *dest = dests->data;
        gchar *sanitized;
        gchar *name = NULL, *email = NULL, *tofree = NULL;

        if (!dest)
            continue;

        text = e_destination_get_textrep (dest, TRUE);

        if (!text || !*text)
            continue;

        if (eab_parse_qp_email (text, &name, &email)) {
            tofree = g_strdup_printf ("%s <%s>", name, email);
            text = tofree;
            g_free (name);
            g_free (email);
        }

        sanitized = sanitize_string (text);
        g_free (tofree);
        if (!sanitized)
            continue;

        if (*sanitized) {
            if (*sanitized_text->str)
                g_string_append (sanitized_text, ", ");

            g_string_append (sanitized_text, sanitized);
        }

        g_free (sanitized);
    }

    text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
    get_range_at_position (text, position, &start, &end);
    gtk_editable_delete_text (GTK_EDITABLE (name_selector_entry), start, end);
    gtk_editable_insert_text (GTK_EDITABLE (name_selector_entry), sanitized_text->str, -1, &start);
    g_string_free (sanitized_text, TRUE);

    clear_completion_model (name_selector_entry);
    generate_attribute_list (name_selector_entry);
}

static void
popup_activate_contact (ENameSelectorEntry *name_selector_entry,
                        GtkWidget *menu_item)
{
    EBookClient  *book_client;
    GSList       *clients;
    EDestination *destination;
    EContact     *contact;
    gchar        *contact_uid;

    destination = name_selector_entry->priv->popup_destination;
    if (!destination)
        return;

    contact = e_destination_get_contact (destination);
    if (!contact)
        return;

    contact_uid = e_contact_get (contact, E_CONTACT_UID);
    if (!contact_uid)
        return;

    if (name_selector_entry->priv->contact_store) {
        clients = e_contact_store_get_clients (name_selector_entry->priv->contact_store);
        book_client = find_client_by_contact (clients, contact_uid, e_destination_get_source_uid (destination));
        g_slist_free (clients);
        g_free (contact_uid);
    } else {
        book_client = NULL;
    }

    if (!book_client)
        return;

    if (e_destination_is_evolution_list (destination)) {
        GtkWidget *contact_list_editor;

        if (!name_selector_entry->priv->contact_list_editor_func)
            return;

        contact_list_editor = (*name_selector_entry->priv->contact_list_editor_func) (book_client, contact, FALSE, TRUE);
        g_object_ref (name_selector_entry);
        g_signal_connect (
            contact_list_editor, "editor_closed",
            G_CALLBACK (editor_closed_cb), name_selector_entry);
    } else {
        GtkWidget *contact_editor;

        if (!name_selector_entry->priv->contact_editor_func)
            return;

        contact_editor = (*name_selector_entry->priv->contact_editor_func) (book_client, contact, FALSE, TRUE);
        g_object_ref (name_selector_entry);
        g_signal_connect (
            contact_editor, "editor_closed",
            G_CALLBACK (editor_closed_cb), name_selector_entry);
    }
}

static void
popup_activate_email (ENameSelectorEntry *name_selector_entry,
                      GtkWidget *menu_item)
{
    EDestination *destination;
    EContact     *contact;
    gint          email_num;

    destination = name_selector_entry->priv->popup_destination;
    if (!destination)
        return;

    contact = e_destination_get_contact (destination);
    if (!contact)
        return;

    email_num = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item), "order"));
    e_destination_set_contact (destination, contact, email_num);
}

static void
popup_activate_list (EDestination *destination,
                     GtkWidget *item)
{
    gboolean status = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (item));

    e_destination_set_ignored (destination, !status);
}

static void
popup_activate_cut (ENameSelectorEntry *name_selector_entry,
                    GtkWidget *menu_item)
{
    EDestination *destination;
    const gchar *contact_email;
    gchar *pemail = NULL;
    GtkClipboard *clipboard;

    destination = name_selector_entry->priv->popup_destination;
    contact_email =e_destination_get_textrep (destination, TRUE);

    g_signal_handlers_block_by_func (name_selector_entry, user_insert_text, name_selector_entry);
    g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);

    clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
    pemail = g_strconcat (contact_email, ",", NULL);
    gtk_clipboard_set_text (clipboard, pemail, strlen (pemail));

    clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
    gtk_clipboard_set_text (clipboard, pemail, strlen (pemail));

    gtk_editable_delete_text (GTK_EDITABLE (name_selector_entry), 0, 0);
    e_destination_store_remove_destination (name_selector_entry->priv->destination_store, destination);

    g_free (pemail);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_insert_text, name_selector_entry);
}

static void
popup_activate_copy (ENameSelectorEntry *name_selector_entry,
                     GtkWidget *menu_item)
{
    EDestination *destination;
    const gchar *contact_email;
    gchar *pemail;
    GtkClipboard *clipboard;

    destination = name_selector_entry->priv->popup_destination;
    contact_email = e_destination_get_textrep (destination, TRUE);

    g_signal_handlers_block_by_func (name_selector_entry, user_insert_text, name_selector_entry);
    g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);

    clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
    pemail = g_strconcat (contact_email, ",", NULL);
    gtk_clipboard_set_text (clipboard, pemail, strlen (pemail));

    clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
    gtk_clipboard_set_text (clipboard, pemail, strlen (pemail));
    g_free (pemail);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_delete_text, name_selector_entry);
    g_signal_handlers_unblock_by_func (name_selector_entry, user_insert_text, name_selector_entry);
}

static void
destination_set_list (GtkWidget *item,
                      EDestination *destination)
{
    EContact *contact;
    gboolean status = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (item));

    contact = e_destination_get_contact (destination);
    if (!contact)
        return;

    e_destination_set_ignored (destination, !status);
}

static void
destination_set_email (GtkWidget *item,
                       EDestination *destination)
{
    gint email_num;
    EContact *contact;

    if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (item)))
        return;
    contact = e_destination_get_contact (destination);
    if (!contact)
        return;

    email_num = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "order"));
    e_destination_set_contact (destination, contact, email_num);
}

static void
populate_popup (ENameSelectorEntry *name_selector_entry,
                GtkMenu *menu)
{
    EDestination *destination;
    EContact     *contact;
    GtkWidget    *menu_item;
    GList        *email_list = NULL;
    GList        *l;
    gint          i;
    gchar        *edit_label;
    gchar        *cut_label;
    gchar         *copy_label;
    gint          email_num, len;
    GSList       *group = NULL;
    gboolean      is_list;
    gboolean      show_menu = FALSE;

    destination = name_selector_entry->priv->popup_destination;
    if (!destination)
        return;

    contact = e_destination_get_contact (destination);
    if (!contact)
        return;

    /* Prepend the menu items, backwards */

    /* Separator */

    menu_item = gtk_separator_menu_item_new ();
    gtk_widget_show (menu_item);
    gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
    email_num = e_destination_get_email_num (destination);

    /* Addresses */
    is_list = e_contact_get (contact, E_CONTACT_IS_LIST) ? TRUE : FALSE;
    if (is_list) {
        const GList *dests = e_destination_list_get_dests (destination);
        GList *iter;
        gint length = g_list_length ((GList *) dests);

        for (iter = (GList *) dests; iter; iter = iter->next) {
            EDestination *dest = (EDestination *) iter->data;
            const gchar *email = e_destination_get_email (dest);

            if (!email || *email == '\0')
                continue;

            if (length > 1) {
                menu_item = gtk_check_menu_item_new_with_label (email);
                g_signal_connect (
                    menu_item, "toggled",
                    G_CALLBACK (destination_set_list), dest);
            } else {
                menu_item = gtk_menu_item_new_with_label (email);
            }

            gtk_widget_show (menu_item);
            gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
            show_menu = TRUE;

            if (length > 1) {
                gtk_check_menu_item_set_active (
                    GTK_CHECK_MENU_ITEM (menu_item),
                    !e_destination_is_ignored (dest));
                g_signal_connect_swapped (
                    menu_item, "activate",
                    G_CALLBACK (popup_activate_list), dest);
            }
        }

    } else {
        email_list = e_contact_get (contact, E_CONTACT_EMAIL);
        len = g_list_length (email_list);

        for (l = email_list, i = 0; l; l = g_list_next (l), i++) {
            gchar *email = l->data;

            if (!email || *email == '\0')
                continue;

            if (len > 1) {
                menu_item = gtk_radio_menu_item_new_with_label (group, email);
                group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menu_item));
                g_signal_connect (menu_item, "toggled", G_CALLBACK (destination_set_email), destination);
            } else {
                menu_item = gtk_menu_item_new_with_label (email);
            }

            gtk_widget_show (menu_item);
            gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
            show_menu = TRUE;
            g_object_set_data (G_OBJECT (menu_item), "order", GINT_TO_POINTER (i));

            if (i == email_num && len > 1) {
                gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), TRUE);
                g_signal_connect_swapped (
                    menu_item, "activate",
                    G_CALLBACK (popup_activate_email),
                    name_selector_entry);
            }
        }
    }

    /* Separator */

    if (show_menu) {
        menu_item = gtk_separator_menu_item_new ();
        gtk_widget_show (menu_item);
        gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
    }

    /* Expand a list inline */
    if (is_list) {
        /* To Translators: This would be similiar to "Expand MyList Inline" where MyList is a Contact List*/
        edit_label = g_strdup_printf (_("E_xpand %s Inline"), (gchar *) e_contact_get_const (contact, E_CONTACT_FILE_AS));
        menu_item = gtk_menu_item_new_with_mnemonic (edit_label);
        g_free (edit_label);
        gtk_widget_show (menu_item);
        gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
        g_signal_connect_swapped (
            menu_item, "activate", G_CALLBACK (popup_activate_inline_expand),
            name_selector_entry);

        /* Separator */
        menu_item = gtk_separator_menu_item_new ();
        gtk_widget_show (menu_item);
        gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
    }

    /* Copy Contact Item */
    copy_label = g_strdup_printf (_("Cop_y %s"), (gchar *) e_contact_get_const (contact, E_CONTACT_FILE_AS));
    menu_item = gtk_menu_item_new_with_mnemonic (copy_label);
    g_free (copy_label);
    gtk_widget_show (menu_item);
    gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);

    g_signal_connect_swapped (
        menu_item, "activate", G_CALLBACK (popup_activate_copy),
        name_selector_entry);

    /* Cut Contact Item */
    cut_label = g_strdup_printf (_("C_ut %s"), (gchar *) e_contact_get_const (contact, E_CONTACT_FILE_AS));
    menu_item = gtk_menu_item_new_with_mnemonic (cut_label);
    g_free (cut_label);
    gtk_widget_show (menu_item);
    gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);

    g_signal_connect_swapped (
        menu_item, "activate", G_CALLBACK (popup_activate_cut),
        name_selector_entry);

    if (show_menu) {
        menu_item = gtk_separator_menu_item_new ();
        gtk_widget_show (menu_item);
        gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
    }

    /* Edit Contact item */

    edit_label = g_strdup_printf (_("_Edit %s"), (gchar *) e_contact_get_const (contact, E_CONTACT_FILE_AS));
    menu_item = gtk_menu_item_new_with_mnemonic (edit_label);
    g_free (edit_label);
    gtk_widget_show (menu_item);
    gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);

    g_signal_connect_swapped (
        menu_item, "activate", G_CALLBACK (popup_activate_contact),
        name_selector_entry);

    deep_free_list (email_list);
}

static gint
compare_gint_ptr_cb (gconstpointer a,
                     gconstpointer b)
{
    return GPOINTER_TO_INT (a) - GPOINTER_TO_INT (b);
}

static void
copy_or_cut_clipboard (ENameSelectorEntry *name_selector_entry,
                       gboolean is_cut)
{
    GtkClipboard *clipboard;
    GtkEditable *editable;
    const gchar *text, *cp;
    GHashTable *hash;
    GHashTableIter iter;
    gpointer key, value;
    GSList *sorted, *siter;
    GString *addresses;
    gint ii, start, end, ostart, oend;
    gunichar uc;

    editable = GTK_EDITABLE (name_selector_entry);
    text = gtk_entry_get_text (GTK_ENTRY (editable));

    if (!gtk_editable_get_selection_bounds (editable, &start, &end))
        return;

    g_return_if_fail (end > start);

    hash = g_hash_table_new (g_direct_hash, g_direct_equal);

    /* convert from character indexes to pointer indexes */
    ostart = g_utf8_offset_to_pointer (text, start) - text;
    oend = g_utf8_offset_to_pointer (text, end) - text;

    ii = end;
    cp = g_utf8_offset_to_pointer (text, end);
    uc = g_utf8_get_char (cp);

    /* Exclude trailing whitespace and commas. */
    while (ii >= start && (uc == ',' || g_unichar_isspace (uc))) {
        cp = g_utf8_prev_char (cp);
        uc = g_utf8_get_char (cp);
        ii--;
    }

    /* Determine the index of each remaining character. */
    while (ii >= start) {
        gint index = get_index_at_position (text, ii--);
        g_hash_table_insert (hash, GINT_TO_POINTER (index), NULL);
    }

    sorted = NULL;
    g_hash_table_iter_init (&iter, hash);
    while (g_hash_table_iter_next (&iter, &key, &value)) {
        sorted = g_slist_prepend (sorted, key);
    }

    sorted = g_slist_sort (sorted, compare_gint_ptr_cb);
    addresses = g_string_new ("");

    for (siter = sorted; siter != NULL; siter = g_slist_next (siter)) {
        gint index = GPOINTER_TO_INT (siter->data);
        EDestination *dest;
        gint rstart, rend;

        if (!get_range_by_index (text, index, &rstart, &rend))
            continue;

        /* convert from character indexes to pointer indexes */
        rstart = g_utf8_offset_to_pointer (text, rstart) - text;
        rend = g_utf8_offset_to_pointer (text, rend) - text;

        if (rstart < ostart) {
            if (addresses->str && *addresses->str)
                g_string_append (addresses, ", ");

            g_string_append_len (addresses, text + ostart, MIN (oend - ostart, rend - ostart));
        } else if (rend > oend) {
            if (addresses->str && *addresses->str)
                g_string_append (addresses, ", ");

            g_string_append_len (addresses, text + rstart, oend - rstart);
        } else {
            /* the contact is whole selected */
            dest = find_destination_by_index (name_selector_entry, index);
            if (dest && e_destination_get_textrep (dest, TRUE)) {
                if (addresses->str && *addresses->str)
                    g_string_append (addresses, ", ");

                g_string_append (addresses, e_destination_get_textrep (dest, TRUE));
            } else
                g_string_append_len (addresses, text + rstart, rend - rstart);
        }
    }

    g_slist_free (sorted);

    if (is_cut)
        gtk_editable_delete_text (editable, start, end);

    g_hash_table_unref (hash);

    clipboard = gtk_widget_get_clipboard (
        GTK_WIDGET (name_selector_entry), GDK_SELECTION_CLIPBOARD);
    gtk_clipboard_set_text (clipboard, addresses->str, -1);

    g_string_free (addresses, TRUE);
}

static void
copy_clipboard (GtkEntry *entry,
                ENameSelectorEntry *name_selector_entry)
{
    copy_or_cut_clipboard (name_selector_entry, FALSE);
    g_signal_stop_emission_by_name (entry, "copy-clipboard");
}

static void
cut_clipboard (GtkEntry *entry,
               ENameSelectorEntry *name_selector_entry)
{
    copy_or_cut_clipboard (name_selector_entry, TRUE);
    g_signal_stop_emission_by_name (entry, "cut-clipboard");
}

static void
e_name_selector_entry_init (ENameSelectorEntry *name_selector_entry)
{
    GtkCellRenderer *renderer;

    name_selector_entry->priv =
        E_NAME_SELECTOR_ENTRY_GET_PRIVATE (name_selector_entry);

    g_queue_init (&name_selector_entry->priv->cancellables);

    name_selector_entry->priv->minimum_query_length = 3;
    name_selector_entry->priv->show_address = FALSE;

    /* Edit signals */

    g_signal_connect (
        name_selector_entry, "insert-text",
        G_CALLBACK (user_insert_text), name_selector_entry);
    g_signal_connect (
        name_selector_entry, "delete-text",
        G_CALLBACK (user_delete_text), name_selector_entry);
    g_signal_connect (
        name_selector_entry, "focus-out-event",
        G_CALLBACK (user_focus_out), name_selector_entry);
    g_signal_connect_after (
        name_selector_entry, "focus-in-event",
        G_CALLBACK (user_focus_in), name_selector_entry);

    /* Drawing */

    g_signal_connect (
        name_selector_entry, "draw",
        G_CALLBACK (draw_event), name_selector_entry);

    /* Activation: Complete current entry if possible */

    g_signal_connect (
        name_selector_entry, "activate",
        G_CALLBACK (entry_activate), name_selector_entry);

    /* Pop-up menu */

    g_signal_connect (
        name_selector_entry, "button-press-event",
        G_CALLBACK (prepare_popup_destination), name_selector_entry);
    g_signal_connect (
        name_selector_entry, "populate-popup",
        G_CALLBACK (populate_popup), name_selector_entry);

    /* Clipboard signals */
    g_signal_connect (
        name_selector_entry, "copy-clipboard",
        G_CALLBACK (copy_clipboard), name_selector_entry);
    g_signal_connect (
        name_selector_entry, "cut-clipboard",
        G_CALLBACK (cut_clipboard), name_selector_entry);

    /* Completion */

    name_selector_entry->priv->email_generator = NULL;

    name_selector_entry->priv->entry_completion = gtk_entry_completion_new ();
    gtk_entry_completion_set_match_func (
        name_selector_entry->priv->entry_completion,
        (GtkEntryCompletionMatchFunc) completion_match_cb, NULL, NULL);
    g_signal_connect_swapped (
        name_selector_entry->priv->entry_completion, "match-selected",
        G_CALLBACK (completion_match_selected), name_selector_entry);

    gtk_entry_set_completion (
        GTK_ENTRY (name_selector_entry),
        name_selector_entry->priv->entry_completion);

    renderer = gtk_cell_renderer_pixbuf_new ();
    gtk_cell_layout_pack_start (
        GTK_CELL_LAYOUT (name_selector_entry->priv->entry_completion),
        renderer, FALSE);
    gtk_cell_layout_set_cell_data_func (
        GTK_CELL_LAYOUT (name_selector_entry->priv->entry_completion),
        GTK_CELL_RENDERER (renderer),
        (GtkCellLayoutDataFunc) contact_layout_pixbuffer,
        name_selector_entry, NULL);

    /* Completion list name renderer */
    renderer = gtk_cell_renderer_text_new ();
    gtk_cell_layout_pack_start (
        GTK_CELL_LAYOUT (name_selector_entry->priv->entry_completion),
        renderer, TRUE);
    gtk_cell_layout_set_cell_data_func (
        GTK_CELL_LAYOUT (name_selector_entry->priv->entry_completion),
        GTK_CELL_RENDERER (renderer),
        (GtkCellLayoutDataFunc) contact_layout_formatter,
        name_selector_entry, NULL);

    /* Destination store */

    name_selector_entry->priv->destination_store = e_destination_store_new ();
    setup_destination_store (name_selector_entry);
    name_selector_entry->priv->is_completing = FALSE;
}

/**
 * e_name_selector_entry_new:
 * @client_cache: an #EClientCache
 *
 * Creates a new #ENameSelectorEntry.
 *
 * Returns: A new #ENameSelectorEntry.
 **/
GtkWidget *
e_name_selector_entry_new (EClientCache *client_cache)
{
    g_return_val_if_fail (E_IS_CLIENT_CACHE (client_cache), NULL);

    return g_object_new (
        E_TYPE_NAME_SELECTOR_ENTRY,
        "client-cache", client_cache, NULL);
}

/**
 * e_name_selector_entry_ref_client_cache:
 * @name_selector_entry: an #ENameSelectorEntry
 *
 * Returns the #EClientCache passed to e_name_selector_entry_new().
 *
 * The returned #EClientCache is referenced for thread-safety and must be
 * unreferenced with g_object_unref() when finished with it.
 *
 * Returns: an #EClientCache
 *
 * Since: 3.8
 **/
EClientCache *
e_name_selector_entry_ref_client_cache (ENameSelectorEntry *name_selector_entry)
{
    g_return_val_if_fail (
        E_IS_NAME_SELECTOR_ENTRY (name_selector_entry), NULL);

    if (name_selector_entry->priv->client_cache == NULL)
        return NULL;

    return g_object_ref (name_selector_entry->priv->client_cache);
}

/**
 * e_name_selector_entry_set_client_cache:
 * @name_selector_entry: an #ENameSelectorEntry
 * @client_cache: an #EClientCache
 *
 * Sets the #EClientCache used to query address books.
 *
 * This function is intended for cases where @name_selector_entry is
 * instantiated by a #GtkBuilder and has to be given an #EClientCache
 * after it is fully constructed.
 *
 * Since: 3.6
 **/
void
e_name_selector_entry_set_client_cache (ENameSelectorEntry *name_selector_entry,
                                        EClientCache *client_cache)
{
    g_return_if_fail (E_IS_NAME_SELECTOR_ENTRY (name_selector_entry));

    if (client_cache == name_selector_entry->priv->client_cache)
        return;

    if (client_cache != NULL) {
        g_return_if_fail (E_IS_CLIENT_CACHE (client_cache));
        g_object_ref (client_cache);
    }

    if (name_selector_entry->priv->client_cache != NULL)
        g_object_unref (name_selector_entry->priv->client_cache);

    name_selector_entry->priv->client_cache = client_cache;

    g_object_notify (G_OBJECT (name_selector_entry), "client-cache");
}

/**
 * e_name_selector_entry_get_minimum_query_length:
 * @name_selector_entry: an #ENameSelectorEntry
 *
 * Returns: Minimum length of query before completion starts
 *
 * Since: 3.6
 **/
gint
e_name_selector_entry_get_minimum_query_length (ENameSelectorEntry *name_selector_entry)
{
    g_return_val_if_fail (E_IS_NAME_SELECTOR_ENTRY (name_selector_entry), -1);

    return name_selector_entry->priv->minimum_query_length;
}

/**
 * e_name_selector_entry_set_minimum_query_length:
 * @name_selector_entry: an #ENameSelectorEntry
 * @length: minimum query length
 *
 * Sets minimum length of query before completion starts.
 *
 * Since: 3.6
 **/
void
e_name_selector_entry_set_minimum_query_length (ENameSelectorEntry *name_selector_entry,
                                                gint length)
{
    g_return_if_fail (E_IS_NAME_SELECTOR_ENTRY (name_selector_entry));
    g_return_if_fail (length > 0);

    if (name_selector_entry->priv->minimum_query_length == length)
        return;

    name_selector_entry->priv->minimum_query_length = length;

    g_object_notify (G_OBJECT (name_selector_entry), "minimum-query-length");
}

/**
 * e_name_selector_entry_get_show_address:
 * @name_selector_entry: an #ENameSelectorEntry
 *
 * Returns: Whether always show email address for an auto-completed contact.
 *
 * Since: 3.6
 **/
gboolean
e_name_selector_entry_get_show_address (ENameSelectorEntry *name_selector_entry)
{
    g_return_val_if_fail (E_IS_NAME_SELECTOR_ENTRY (name_selector_entry), FALSE);

    return name_selector_entry->priv->show_address;
}

/**
 * e_name_selector_entry_set_show_address:
 * @name_selector_entry: an #ENameSelectorEntry
 * @show: new value to set
 *
 * Sets whether always show email address for an auto-completed contact.
 *
 * Since: 3.6
 **/
void
e_name_selector_entry_set_show_address (ENameSelectorEntry *name_selector_entry,
                                        gboolean show)
{
    g_return_if_fail (E_IS_NAME_SELECTOR_ENTRY (name_selector_entry));

    if ((name_selector_entry->priv->show_address ? 1 : 0) == (show ? 1 : 0))
        return;

    name_selector_entry->priv->show_address = show;

    sanitize_entry (name_selector_entry);

    g_object_notify (G_OBJECT (name_selector_entry), "show-address");
}

/**
 * e_name_selector_entry_peek_contact_store:
 * @name_selector_entry: an #ENameSelectorEntry
 *
 * Gets the #EContactStore being used by @name_selector_entry.
 *
 * Returns: An #EContactStore.
 **/
EContactStore *
e_name_selector_entry_peek_contact_store (ENameSelectorEntry *name_selector_entry)
{
    g_return_val_if_fail (E_IS_NAME_SELECTOR_ENTRY (name_selector_entry), NULL);

    return name_selector_entry->priv->contact_store;
}

/**
 * e_name_selector_entry_set_contact_store:
 * @name_selector_entry: an #ENameSelectorEntry
 * @contact_store: an #EContactStore to use
 *
 * Sets the #EContactStore being used by @name_selector_entry to @contact_store.
 **/
void
e_name_selector_entry_set_contact_store (ENameSelectorEntry *name_selector_entry,
                                         EContactStore *contact_store)
{
    g_return_if_fail (E_IS_NAME_SELECTOR_ENTRY (name_selector_entry));
    g_return_if_fail (contact_store == NULL || E_IS_CONTACT_STORE (contact_store));

    if (contact_store == name_selector_entry->priv->contact_store)
        return;

    if (name_selector_entry->priv->contact_store)
        g_object_unref (name_selector_entry->priv->contact_store);
    name_selector_entry->priv->contact_store = contact_store;
    if (name_selector_entry->priv->contact_store)
        g_object_ref (name_selector_entry->priv->contact_store);

    setup_contact_store (name_selector_entry);
}

/**
 * e_name_selector_entry_peek_destination_store:
 * @name_selector_entry: an #ENameSelectorEntry
 *
 * Gets the #EDestinationStore being used to store @name_selector_entry's destinations.
 *
 * Returns: An #EDestinationStore.
 **/
EDestinationStore *
e_name_selector_entry_peek_destination_store (ENameSelectorEntry *name_selector_entry)
{
    g_return_val_if_fail (E_IS_NAME_SELECTOR_ENTRY (name_selector_entry), NULL);

    return name_selector_entry->priv->destination_store;
}

/**
 * e_name_selector_entry_set_destination_store:
 * @name_selector_entry: an #ENameSelectorEntry
 * @destination_store: an #EDestinationStore to use
 *
 * Sets @destination_store as the #EDestinationStore to be used to store
 * destinations for @name_selector_entry.
 **/
void
e_name_selector_entry_set_destination_store (ENameSelectorEntry *name_selector_entry,
                                             EDestinationStore *destination_store)
{
    g_return_if_fail (E_IS_NAME_SELECTOR_ENTRY (name_selector_entry));
    g_return_if_fail (E_IS_DESTINATION_STORE (destination_store));

    if (destination_store == name_selector_entry->priv->destination_store)
        return;

    g_object_unref (name_selector_entry->priv->destination_store);
    name_selector_entry->priv->destination_store = g_object_ref (destination_store);

    setup_destination_store (name_selector_entry);
}

/**
 * e_name_selector_entry_get_popup_destination:
 *
 * Since: 2.32
 **/
EDestination *
e_name_selector_entry_get_popup_destination (ENameSelectorEntry *name_selector_entry)
{
    g_return_val_if_fail (E_IS_NAME_SELECTOR_ENTRY (name_selector_entry), NULL);

    return name_selector_entry->priv->popup_destination;
}

/**
 * e_name_selector_entry_set_contact_editor_func:
 *
 * DO NOT USE.
 **/
void
e_name_selector_entry_set_contact_editor_func (ENameSelectorEntry *name_selector_entry,
                                               gpointer func)
{
    name_selector_entry->priv->contact_editor_func = func;
}

/**
 * e_name_selector_entry_set_contact_list_editor_func:
 *
 * DO NOT USE.
 **/
void
e_name_selector_entry_set_contact_list_editor_func (ENameSelectorEntry *name_selector_entry,
                                                    gpointer func)
{
    name_selector_entry->priv->contact_list_editor_func = func;
}