From 0b3cbf57875fd692e4ba0b336fefa4bee1ed00dc Mon Sep 17 00:00:00 2001 From: Simeon Simeonov Date: Mon, 26 Feb 2018 11:23:00 +0100 Subject: Initial commit for sylpheed 3.7.0 --- src/addr_compl.c | 1142 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1142 insertions(+) create mode 100644 src/addr_compl.c (limited to 'src/addr_compl.c') diff --git a/src/addr_compl.c b/src/addr_compl.c new file mode 100644 index 0000000..1fcc513 --- /dev/null +++ b/src/addr_compl.c @@ -0,0 +1,1142 @@ +/* + * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client + * + * Copyright (C) 2000-2005 by Alfons Hoogervorst & The Sylpheed Claws Team. + * Copyright (C) 1999-2014 Hiroyuki Yamamoto + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * 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 General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif +#include "defs.h" + +#include +#include +#include +#include + +#include +#include + +#include "xml.h" +#include "addr_compl.h" +#include "utils.h" +#include "addressbook.h" +#include "main.h" +#include "prefs_common.h" + +/* How it works: + * + * The address book is read into memory. We set up an address list + * containing all address book entries. Next we make the completion + * list, which contains all the completable strings, and store a + * reference to the address entry it belongs to. + * After calling the g_completion_complete(), we get a reference + * to a valid email address. + * + * Completion is very simplified. We never complete on another prefix, + * i.e. we neglect the next smallest possible prefix for the current + * completion cache. This is simply done so we might break up the + * addresses a little more (e.g. break up alfons@proteus.demon.nl into + * something like alfons, proteus, demon, nl; and then completing on + * any of those words). + */ + +/* address_entry - structure which refers to the original address entry in the + * address book + */ +typedef struct +{ + gchar *name; + gchar *address; +} address_entry; + +/* completion_entry - structure used to complete addresses, with a reference + * the the real address information. + */ +typedef struct +{ + gchar *string; /* string to complete */ + address_entry *ref; /* address the string belongs to */ +} completion_entry; + +/*******************************************************************************/ + +static gint ref_count; /* list ref count */ +static GList *completion_list; /* list of strings to be checked */ +static GList *address_list; /* address storage */ +static GCompletion *completion; /* completion object */ + +/* To allow for continuing completion we have to keep track of the state + * using the following variables. No need to create a context object. */ + +static gint completion_count; /* nr of addresses incl. the prefix */ +static gint completion_next; /* next prev address */ +static GSList *completion_addresses; /* unique addresses found in the + completion cache. */ +static gchar *completion_prefix; /* last prefix. (this is cached here + * because the prefix passed to g_completion + * is g_strdown()'ed */ + +/*******************************************************************************/ + + +static void address_completion_entry_changed (GtkEditable *editable, + gpointer data); + + +/* completion_func() - used by GTK to find the string data to be used for + * completion + */ +static gchar *completion_func(gpointer data) +{ + g_return_val_if_fail(data != NULL, NULL); + + return ((completion_entry *)data)->string; +} + +static void init_all(void) +{ + completion = g_completion_new(completion_func); + g_return_if_fail(completion != NULL); +} + +static void free_all(void) +{ + GList *walk; + + walk = g_list_first(completion_list); + for (; walk != NULL; walk = g_list_next(walk)) { + completion_entry *ce = (completion_entry *) walk->data; + g_free(ce->string); + g_free(ce); + } + g_list_free(completion_list); + completion_list = NULL; + + walk = address_list; + for (; walk != NULL; walk = g_list_next(walk)) { + address_entry *ae = (address_entry *) walk->data; + g_free(ae->name); + g_free(ae->address); + g_free(ae); + } + g_list_free(address_list); + address_list = NULL; + + g_completion_free(completion); + completion = NULL; +} + +static gint address_entry_find_func(gconstpointer a, gconstpointer b) +{ + const address_entry *ae1 = a; + const address_entry *ae2 = b; + gint val; + + if (!a || !b) + return -1; + + val = strcmp(ae1->name, ae2->name); + if (val != 0) + return val; + val = strcmp(ae1->address, ae2->address); + if (val != 0) + return val; + + return 0; +} + +static void add_completion_entry(const gchar *str, address_entry *ae) +{ + completion_entry *ce; + + if (!str || *str == '\0') + return; + if (!ae) + return; + + ce = g_new0(completion_entry, 1); + /* GCompletion list is case sensitive */ + ce->string = g_utf8_strdown(str, -1); + ce->ref = ae; + completion_list = g_list_append(completion_list, ce); +} + +/* add_address() - adds address to the completion list. this function looks + * complicated, but it's only allocation checks. + */ +static gint add_address(const gchar *name, const gchar *firstname, const gchar *lastname, const gchar *nickname, const gchar *address) +{ + address_entry *ae; + GList *found; + + if (!address || *address == '\0') + return -1; + + /* debugg_print("add_address: [%s] [%s] [%s] [%s] [%s]\n", name, firstname, lastname, nickname, address); */ + + ae = g_new0(address_entry, 1); + ae->name = g_strdup(name ? name : ""); + ae->address = g_strdup(address); + if ((found = g_list_find_custom(address_list, ae, + address_entry_find_func))) { + g_free(ae->name); + g_free(ae->address); + g_free(ae); + ae = (address_entry *)found->data; + } else + address_list = g_list_append(address_list, ae); + + if (name) { + const gchar *p = name; + + while (*p != '\0') { + add_completion_entry(p, ae); + while (*p && *p != '-' && *p != '.' && !g_ascii_isspace(*p)) + p++; + while (*p == '-' || *p == '.' || g_ascii_isspace(*p)) + p++; + } + } + add_completion_entry(firstname, ae); + add_completion_entry(lastname, ae); + add_completion_entry(nickname, ae); + add_completion_entry(address, ae); + + return 0; +} + +/* read_address_book() + */ +static void read_address_book(void) { + addressbook_load_completion_full( add_address ); +} + +/* start_address_completion() - returns the number of addresses + * that should be matched for completion. + */ +gint start_address_completion(void) +{ + clear_completion_cache(); + if (!ref_count) { + init_all(); + /* open the address book */ + read_address_book(); + /* merge the completion entry list into g_completion */ + if (completion_list) + g_completion_add_items(completion, completion_list); + } + ref_count++; + debug_print("start_address_completion ref count %d\n", ref_count); + + return g_list_length(completion_list); +} + +/* get_address_from_edit() - returns a possible address (or a part) + * from an entry box. To make life easier, we only look at the last valid address + * component; address completion only works at the last string component in + * the entry box. + */ +gchar *get_address_from_edit(GtkEntry *entry, gint *start_pos) +{ + const gchar *edit_text, *p; + gint cur_pos; + gboolean in_quote = FALSE; + gboolean in_bracket = FALSE; + gchar *str; + + edit_text = gtk_entry_get_text(entry); + if (edit_text == NULL) return NULL; + + cur_pos = gtk_editable_get_position(GTK_EDITABLE(entry)); + + /* scan for a separator. doesn't matter if walk points at null byte. */ + for (p = g_utf8_offset_to_pointer(edit_text, cur_pos); + p > edit_text; + p = g_utf8_prev_char(p)) { + if (*p == '"') + in_quote ^= TRUE; + else if (!in_quote) { + if (!in_bracket && *p == ',') + break; + else if (*p == '>') + in_bracket = TRUE; + else if (*p == '<') + in_bracket = FALSE; + } + } + + /* have something valid */ + if (g_utf8_strlen(p, -1) == 0) + return NULL; + + /* now scan back until we hit a valid character */ + for (; *p && (*p == ',' || g_ascii_isspace(*p)); + p = g_utf8_next_char(p)) + ; + + if (g_utf8_strlen(p, -1) == 0) + return NULL; + + if (start_pos) *start_pos = g_utf8_pointer_to_offset(edit_text, p); + + str = g_strdup(p); + + return str; +} + +/* replace_address_in_edit() - replaces an incompleted address with a completed one. + */ +void replace_address_in_edit(GtkEntry *entry, const gchar *newtext, + gint start_pos) +{ + gchar *origtext; + + if (!newtext) return; + + debug_print("replace_address_in_edit: %s\n", newtext); + + origtext = gtk_editable_get_chars(GTK_EDITABLE(entry), start_pos, -1); + if (!strcmp(origtext, newtext)) { + g_free(origtext); + return; + } + g_free(origtext); + + g_signal_handlers_block_by_func + (entry, address_completion_entry_changed, NULL); + gtk_editable_delete_text(GTK_EDITABLE(entry), start_pos, -1); + gtk_editable_insert_text(GTK_EDITABLE(entry), newtext, strlen(newtext), + &start_pos); + gtk_editable_set_position(GTK_EDITABLE(entry), -1); + g_signal_handlers_unblock_by_func + (entry, address_completion_entry_changed, NULL); +} + +#if 0 +static gint insert_address_func(gconstpointer a, gconstpointer b) +{ + const address_entry *ae1 = a; + const address_entry *ae2 = b; + gchar *s1, *s2; + gint val; + + if (!a || !b) + return -1; + + s1 = g_utf8_casefold(ae1->address, -1); + s2 = g_utf8_casefold(ae2->address, -1); + val = g_utf8_collate(s1, s2); + g_free(s2); + g_free(s1); + if (val != 0) + return val; + s1 = g_utf8_casefold(ae1->name, -1); + s2 = g_utf8_casefold(ae2->name, -1); + val = g_utf8_collate(s1, s2); + g_free(s2); + g_free(s1); + if (val != 0) + return val; + + return 0; +} +#endif + +/* complete_address() - tries to complete an addres, and returns the + * number of addresses found. use get_complete_address() to get one. + * returns zero if no match was found, otherwise the number of addresses, + * with the original prefix at index 0. + */ +guint complete_address(const gchar *str) +{ + GList *result; + gchar *d; + guint count, cpl; + completion_entry *ce; + + g_return_val_if_fail(str != NULL, 0); + + clear_completion_cache(); + completion_prefix = g_strdup(str); + + /* g_completion is case sensitive */ + d = g_utf8_strdown(str, -1); + result = g_completion_complete(completion, d, NULL); + + count = g_list_length(result); + if (count) { + /* create list with unique addresses */ + for (cpl = 0, result = g_list_first(result); + result != NULL; + result = g_list_next(result)) { + ce = (completion_entry *)(result->data); + if (NULL == g_slist_find(completion_addresses, + ce->ref)) { + cpl++; + completion_addresses = + g_slist_append(completion_addresses, + ce->ref); +#if 0 + g_slist_insert_sorted + (completion_addresses, ce->ref, + insert_address_func); +#endif + } + } + count = cpl + 1; /* index 0 is the original prefix */ + completion_next = 1; /* we start at the first completed one */ + } else { + g_free(completion_prefix); + completion_prefix = NULL; + } + + completion_count = count; + + g_free(d); + + return count; +} + +/* get_complete_address() - returns a complete address. the returned + * string should be freed + */ +gchar *get_complete_address(gint index) +{ + const address_entry *p; + gchar *address = NULL; + + if (index < completion_count) { + if (index == 0) + address = g_strdup(completion_prefix); + else { + /* get something from the unique addresses */ + p = (address_entry *)g_slist_nth_data + (completion_addresses, index - 1); + if (p != NULL) { + if (!p->name || p->name[0] == '\0') + address = g_strdup(p->address); + else if (p->name[0] != '"' && + strpbrk(p->name, "(),.:;<>@[]") != NULL) + address = g_strdup_printf + ("\"%s\" <%s>", p->name, p->address); + else + address = g_strdup_printf + ("%s <%s>", p->name, p->address); + } + } + } + + return address; +} + +gchar *get_next_complete_address(void) +{ + if (is_completion_pending()) { + gchar *res; + + res = get_complete_address(completion_next); + completion_next += 1; + if (completion_next >= completion_count) + completion_next = 0; + + return res; + } else + return NULL; +} + +gchar *get_prev_complete_address(void) +{ + if (is_completion_pending()) { + int n = completion_next - 2; + + /* real previous */ + n = (n + (completion_count * 5)) % completion_count; + + /* real next */ + completion_next = n + 1; + if (completion_next >= completion_count) + completion_next = 0; + return get_complete_address(n); + } else + return NULL; +} + +guint get_completion_count(void) +{ + if (is_completion_pending()) + return completion_count; + else + return 0; +} + +/* should clear up anything after complete_address() */ +void clear_completion_cache(void) +{ + if (is_completion_pending()) { + if (completion_prefix) + g_free(completion_prefix); + + if (completion_addresses) { + g_slist_free(completion_addresses); + completion_addresses = NULL; + } + + completion_count = completion_next = 0; + } +} + +gboolean is_completion_pending(void) +{ + /* check if completion pending, i.e. we might satisfy a request for the next + * or previous address */ + return completion_count; +} + +/* invalidate_address_completion() - should be called if address book + * changed; + */ +gint invalidate_address_completion(void) +{ + if (ref_count) { + /* simply the same as start_address_completion() */ + debug_print("Invalidation request for address completion\n"); + free_all(); + init_all(); + read_address_book(); + if (completion_list) + g_completion_add_items(completion, completion_list); + clear_completion_cache(); + } + + return g_list_length(completion_list); +} + +gint end_address_completion(void) +{ + clear_completion_cache(); + + if (0 == --ref_count) + free_all(); + + debug_print("end_address_completion ref count %d\n", ref_count); + + return ref_count; +} + + +/* address completion entry ui. the ui (completion list was inspired by galeon's + * auto completion list). remaining things powered by sylpheed's completion engine. + */ + +#define ENTRY_DATA_TAB_HOOK "tab_hook" /* used to lookup entry */ +#define WINDOW_DATA_COMPL_ENTRY "compl_entry" /* used to store entry for compl. window */ +#define WINDOW_DATA_COMPL_CLIST "compl_clist" /* used to store clist for compl. window */ + +static void address_completion_mainwindow_set_focus (GtkWindow *window, + GtkWidget *widget, + gpointer data); +static gboolean address_completion_entry_key_pressed (GtkEntry *entry, + GdkEventKey *ev, + gpointer data); +static gboolean address_completion_complete_address_in_entry + (GtkEntry *entry, + gboolean next); +static void address_completion_create_completion_window (GtkEntry *entry, + gboolean select_next); + +static void completion_window_select_row(GtkCList *clist, + gint row, + gint col, + GdkEvent *event, + GtkWidget **window); +static gboolean completion_window_button_press + (GtkWidget *widget, + GdkEventButton *event, + GtkWidget **window); +static gboolean completion_window_key_press + (GtkWidget *widget, + GdkEventKey *event, + GtkWidget **window); + + +static void completion_window_advance_to_row(GtkCList *clist, gint row) +{ + g_return_if_fail(row < completion_count); + gtk_clist_select_row(clist, row, 0); +} + +static void completion_window_advance_selection(GtkCList *clist, gboolean forward) +{ + int row; + + g_return_if_fail(clist != NULL); + g_return_if_fail(clist->selection != NULL); + + row = GPOINTER_TO_INT(clist->selection->data); + + row = forward ? (row + 1) % completion_count : + (row - 1) < 0 ? completion_count - 1 : row - 1; + + gtk_clist_freeze(clist); + completion_window_advance_to_row(clist, row); + gtk_clist_thaw(clist); + +#ifdef __APPLE__ + /* workaround for a draw bug in OS X */ + gtk_widget_queue_draw(GTK_WIDGET(clist)); +#endif +} + +#if 0 +/* completion_window_accept_selection() - accepts the current selection in the + * clist, and destroys the window */ +static void completion_window_accept_selection(GtkWidget **window, + GtkCList *clist, + GtkEntry *entry) +{ + gchar *address = NULL, *text = NULL; + gint cursor_pos, row; + + g_return_if_fail(window != NULL); + g_return_if_fail(*window != NULL); + g_return_if_fail(clist != NULL); + g_return_if_fail(entry != NULL); + g_return_if_fail(clist->selection != NULL); + + /* FIXME: I believe it's acceptable to access the selection member directly */ + row = GPOINTER_TO_INT(clist->selection->data); + + /* we just need the cursor position */ + address = get_address_from_edit(entry, &cursor_pos); + g_free(address); + gtk_clist_get_text(clist, row, 0, &text); + replace_address_in_edit(entry, text, cursor_pos); + + clear_completion_cache(); + gtk_widget_destroy(*window); + *window = NULL; +} +#endif + +/* completion_window_apply_selection() - apply the current selection in the + * clist */ +static void completion_window_apply_selection(GtkCList *clist, GtkEntry *entry) +{ + gchar *address = NULL, *text = NULL; + gint cursor_pos, row; + + g_return_if_fail(clist != NULL); + g_return_if_fail(entry != NULL); + g_return_if_fail(clist->selection != NULL); + + row = GPOINTER_TO_INT(clist->selection->data); + + address = get_address_from_edit(entry, &cursor_pos); + g_free(address); + gtk_clist_get_text(clist, row, 0, &text); + replace_address_in_edit(entry, text, cursor_pos); +} + +static void completion_window_apply_selection_address_only(GtkCList *clist, GtkEntry *entry) +{ + gchar *address = NULL; + address_entry *ae; + gint cursor_pos, row; + + g_return_if_fail(clist != NULL); + g_return_if_fail(entry != NULL); + g_return_if_fail(clist->selection != NULL); + + row = GPOINTER_TO_INT(clist->selection->data); + + ae = (address_entry *)g_slist_nth_data(completion_addresses, row - 1); + if (ae && ae->address) { + address = get_address_from_edit(entry, &cursor_pos); + g_free(address); + replace_address_in_edit(entry, ae->address, cursor_pos); + } +} + +/* should be called when creating the main window containing address + * completion entries */ +void address_completion_start(GtkWidget *mainwindow) +{ + start_address_completion(); + + /* register focus change hook */ + g_signal_connect(G_OBJECT(mainwindow), "set_focus", + G_CALLBACK(address_completion_mainwindow_set_focus), + mainwindow); +} + +/* Need unique data to make unregistering signal handler possible for the auto + * completed entry */ +#define COMPLETION_UNIQUE_DATA (GINT_TO_POINTER(0xfeefaa)) + +void address_completion_register_entry(GtkEntry *entry) +{ + g_return_if_fail(entry != NULL); + g_return_if_fail(GTK_IS_ENTRY(entry)); + + /* add hooked property */ + g_object_set_data(G_OBJECT(entry), ENTRY_DATA_TAB_HOOK, entry); + + /* add keypress event */ + g_signal_connect_closure + (G_OBJECT(entry), "key_press_event", + g_cclosure_new + (G_CALLBACK(address_completion_entry_key_pressed), + COMPLETION_UNIQUE_DATA, NULL), + FALSE); + g_signal_connect(G_OBJECT(entry), "changed", + G_CALLBACK(address_completion_entry_changed), + NULL); +} + +void address_completion_unregister_entry(GtkEntry *entry) +{ + GObject *entry_obj; + + g_return_if_fail(entry != NULL); + g_return_if_fail(GTK_IS_ENTRY(entry)); + + entry_obj = g_object_get_data(G_OBJECT(entry), ENTRY_DATA_TAB_HOOK); + g_return_if_fail(entry_obj); + g_return_if_fail(entry_obj == G_OBJECT(entry)); + + /* has the hooked property? */ + g_object_set_data(G_OBJECT(entry), ENTRY_DATA_TAB_HOOK, NULL); + + /* remove the hook */ + g_signal_handlers_disconnect_by_func + (G_OBJECT(entry), + G_CALLBACK(address_completion_entry_key_pressed), + COMPLETION_UNIQUE_DATA); +} + +/* should be called when main window with address completion entries + * terminates. + * NOTE: this function assumes that it is called upon destruction of + * the window */ +void address_completion_end(GtkWidget *mainwindow) +{ + /* if address_completion_end() is really called on closing the window, + * we don't need to unregister the set_focus_cb */ + end_address_completion(); +} + +/* if focus changes to another entry, then clear completion cache */ +static void address_completion_mainwindow_set_focus(GtkWindow *window, + GtkWidget *widget, + gpointer data) +{ + if (widget && GTK_IS_ENTRY(widget) && + g_object_get_data(G_OBJECT(widget), ENTRY_DATA_TAB_HOOK)) { + clear_completion_cache(); + } +} + +static GtkWidget *completion_window; + +/* watch for tabs in one of the address entries. if no tab then clear the + * completion cache */ +static gboolean address_completion_entry_key_pressed(GtkEntry *entry, + GdkEventKey *ev, + gpointer data) +{ + if (!prefs_common.fullauto_completion_mode && ev->keyval == GDK_Tab && + !completion_window) { + if (address_completion_complete_address_in_entry(entry, TRUE)) { + address_completion_create_completion_window(entry, TRUE); + /* route a void character to the default handler */ + /* this is a dirty hack; we're actually changing a key + * reported by the system. */ + ev->keyval = GDK_AudibleBell_Enable; + ev->state &= ~GDK_SHIFT_MASK; + return TRUE; + } + } + + if (!completion_window) + return FALSE; + + if ( ev->keyval == GDK_Up + || ev->keyval == GDK_Down + || ev->keyval == GDK_Page_Up + || ev->keyval == GDK_Page_Down + || ev->keyval == GDK_Return + || ev->keyval == GDK_Escape + || ev->keyval == GDK_Tab + || ev->keyval == GDK_ISO_Left_Tab) { + completion_window_key_press(completion_window, ev, &completion_window); + return TRUE; + } else if (ev->keyval == GDK_Shift_L + || ev->keyval == GDK_Shift_R + || ev->keyval == GDK_Control_L + || ev->keyval == GDK_Control_R + || ev->keyval == GDK_Caps_Lock + || ev->keyval == GDK_Shift_Lock + || ev->keyval == GDK_Meta_L + || ev->keyval == GDK_Meta_R + || ev->keyval == GDK_Alt_L + || ev->keyval == GDK_Alt_R) { + /* these buttons should not clear the cache... */ + } else { + clear_completion_cache(); + gtk_widget_destroy(completion_window); + completion_window = NULL; + } + + return FALSE; +} + +static void address_completion_entry_changed(GtkEditable *editable, + gpointer data) +{ + GtkEntry *entry = GTK_ENTRY(editable); + + if (!prefs_common.fullauto_completion_mode) + return; + + g_signal_handlers_block_by_func + (editable, address_completion_entry_changed, data); + if (address_completion_complete_address_in_entry(entry, TRUE)) { + address_completion_create_completion_window(entry, FALSE); + } else { + clear_completion_cache(); + if (completion_window) { + gtk_widget_destroy(completion_window); + completion_window = NULL; + } + } + g_signal_handlers_unblock_by_func + (editable, address_completion_entry_changed, data); +} + +/* initialize the completion cache and put first completed string + * in entry. this function used to do back cycling but this is not + * currently used. since the address completion behaviour has been + * changed regularly, we keep the feature in case someone changes + * his / her mind again. :) */ +static gboolean address_completion_complete_address_in_entry(GtkEntry *entry, + gboolean next) +{ + gint ncount = 0, cursor_pos; + gchar *address, *new = NULL; + gboolean completed = FALSE; + + g_return_val_if_fail(entry != NULL, FALSE); + + if (!GTK_WIDGET_HAS_FOCUS(entry)) return FALSE; + + /* get an address component from the cursor */ + address = get_address_from_edit(entry, &cursor_pos); + if (!address) return FALSE; + + /* still something in the cache */ + if (is_completion_pending()) { + new = next ? get_next_complete_address() : + get_prev_complete_address(); + } else { + if (0 < (ncount = complete_address(address))) + new = get_next_complete_address(); + } + + if (new) { + /* prevent "change" signal */ + /* replace_address_in_edit(entry, new, cursor_pos); */ + + /* don't complete if entry equals to the completed address */ + if (ncount == 2 && !strcmp(address, new)) + completed = FALSE; + else + completed = TRUE; + g_free(new); + } + + g_free(address); + + return completed; +} + +static void address_completion_create_completion_window(GtkEntry *entry_, + gboolean select_next) +{ + gint x, y, width; + GtkWidget *scroll, *clist; + GtkRequisition r; + guint count = 0; + GtkWidget *entry = GTK_WIDGET(entry_); + + debug_print("address_completion_create_completion_window\n"); + + if (completion_window) { + gtk_widget_destroy(completion_window); + completion_window = NULL; + } + + scroll = gtk_scrolled_window_new(NULL, NULL); + clist = gtk_clist_new(1); + gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_SINGLE); + + completion_window = gtk_window_new(GTK_WINDOW_POPUP); + + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + gtk_container_add(GTK_CONTAINER(completion_window), scroll); + gtk_container_add(GTK_CONTAINER(scroll), clist); + + /* set the unique data so we can always get back the entry and + * clist window to which this completion window has been attached */ + g_object_set_data(G_OBJECT(completion_window), + WINDOW_DATA_COMPL_ENTRY, entry_); + g_object_set_data(G_OBJECT(completion_window), + WINDOW_DATA_COMPL_CLIST, clist); + + g_signal_connect(G_OBJECT(clist), "select_row", + G_CALLBACK(completion_window_select_row), + &completion_window); + + for (count = 0; count < get_completion_count(); count++) { + gchar *text[] = {NULL, NULL}; + + text[0] = get_complete_address(count); + gtk_clist_append(GTK_CLIST(clist), text); + g_free(text[0]); + } + + gdk_window_get_origin(entry->window, &x, &y); + gtk_widget_size_request(entry, &r); + width = entry->allocation.width; + y += r.height; + gtk_window_move(GTK_WINDOW(completion_window), x, y); + + gtk_widget_size_request(clist, &r); + gtk_widget_set_size_request(completion_window, width, r.height); + gtk_widget_show_all(completion_window); + gtk_widget_size_request(clist, &r); + + if ((y + r.height) > gdk_screen_height()) { + gtk_window_set_policy(GTK_WINDOW(completion_window), + TRUE, FALSE, FALSE); + gtk_widget_set_size_request(completion_window, width, + gdk_screen_height () - y); + } + + g_signal_connect(G_OBJECT(completion_window), + "button-press-event", + G_CALLBACK(completion_window_button_press), + &completion_window); + g_signal_connect(G_OBJECT(completion_window), + "key-press-event", + G_CALLBACK(completion_window_key_press), + &completion_window); + gdk_pointer_grab(completion_window->window, TRUE, + GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK, + NULL, NULL, GDK_CURRENT_TIME); + gtk_grab_add(completion_window); + + /* this gets rid of the irritating focus rectangle that doesn't + * follow the selection */ + GTK_WIDGET_UNSET_FLAGS(clist, GTK_CAN_FOCUS); + gtk_clist_select_row(GTK_CLIST(clist), select_next ? 1 : 0, 0); + + debug_print("address_completion_create_completion_window done\n"); +} + + +/* row selection sends completed address to entry. + * note: event is NULL if selected by anything else than a mouse button. */ +static void completion_window_select_row(GtkCList *clist, gint row, gint col, + GdkEvent *event, + GtkWidget **window) +{ + GtkEntry *entry; + + g_return_if_fail(window != NULL); + g_return_if_fail(*window != NULL); + + entry = GTK_ENTRY(g_object_get_data(G_OBJECT(*window), + WINDOW_DATA_COMPL_ENTRY)); + g_return_if_fail(entry != NULL); + + completion_window_apply_selection(clist, entry); + + if (!event || event->type != GDK_BUTTON_RELEASE) + return; + + clear_completion_cache(); + gtk_widget_destroy(*window); + *window = NULL; +} + +/* completion_window_button_press() - check is mouse click is anywhere + * else (not in the completion window). in that case the completion + * window is destroyed, and the original prefix is restored */ +static gboolean completion_window_button_press(GtkWidget *widget, + GdkEventButton *event, + GtkWidget **window) +{ + GtkWidget *event_widget, *entry; + gchar *prefix; + gint cursor_pos; + gboolean restore = TRUE; + + g_return_val_if_fail(window != NULL, FALSE); + g_return_val_if_fail(*window != NULL, FALSE); + + entry = GTK_WIDGET(g_object_get_data(G_OBJECT(*window), + WINDOW_DATA_COMPL_ENTRY)); + g_return_val_if_fail(entry != NULL, FALSE); + + event_widget = gtk_get_event_widget((GdkEvent *)event); + if (event_widget != widget) { + while (event_widget) { + if (event_widget == widget) + return FALSE; + else if (event_widget == entry) { + restore = FALSE; + break; + } + event_widget = event_widget->parent; + } + } + + if (restore) { + prefix = get_complete_address(0); + g_free(get_address_from_edit(GTK_ENTRY(entry), &cursor_pos)); + replace_address_in_edit(GTK_ENTRY(entry), prefix, cursor_pos); + g_free(prefix); + } + + clear_completion_cache(); + gtk_widget_destroy(*window); + *window = NULL; + + return TRUE; +} + +static gboolean completion_window_key_press(GtkWidget *widget, + GdkEventKey *event, + GtkWidget **window) +{ + GtkWidget *entry; + gchar *prefix; + gint cursor_pos; + GtkWidget *clist; + + g_return_val_if_fail(window != NULL, FALSE); + g_return_val_if_fail(*window != NULL, FALSE); + + if (!is_completion_pending()) + g_warning("completion is not pending!\n"); + + entry = GTK_WIDGET(g_object_get_data(G_OBJECT(*window), + WINDOW_DATA_COMPL_ENTRY)); + clist = GTK_WIDGET(g_object_get_data(G_OBJECT(*window), + WINDOW_DATA_COMPL_CLIST)); + g_return_val_if_fail(entry != NULL, FALSE); + + /* allow keyboard navigation in the alternatives clist */ + if (event->keyval == GDK_Up || event->keyval == GDK_Down || + event->keyval == GDK_Page_Up || event->keyval == GDK_Page_Down) { + completion_window_advance_selection + (GTK_CLIST(clist), + event->keyval == GDK_Down || + event->keyval == GDK_Page_Down ? TRUE : FALSE); + return FALSE; + } + + /* also make tab / shift tab go to next previous completion entry. we're + * changing the key value */ + if (event->keyval == GDK_Tab || event->keyval == GDK_ISO_Left_Tab) { + event->keyval = (event->state & GDK_SHIFT_MASK) + ? GDK_Up : GDK_Down; + /* need to reset shift state if going up */ + if (event->state & GDK_SHIFT_MASK) + event->state &= ~GDK_SHIFT_MASK; + completion_window_advance_selection(GTK_CLIST(clist), + event->keyval == GDK_Down ? TRUE : FALSE); + return FALSE; + } + + /* look for presses that accept the selection */ + if (event->keyval == GDK_Return || + (!prefs_common.fullauto_completion_mode && + event->keyval == GDK_space)) { + /* insert address only if shift or control is pressed */ + if (event->state & (GDK_SHIFT_MASK|GDK_CONTROL_MASK) || + prefs_common.always_add_address_only) { + completion_window_apply_selection_address_only + (GTK_CLIST(clist), GTK_ENTRY(entry)); + } + clear_completion_cache(); + gtk_widget_destroy(*window); + *window = NULL; + return FALSE; + } + + /* key state keys should never be handled */ + if (event->keyval == GDK_Shift_L + || event->keyval == GDK_Shift_R + || event->keyval == GDK_Control_L + || event->keyval == GDK_Control_R + || event->keyval == GDK_Caps_Lock + || event->keyval == GDK_Shift_Lock + || event->keyval == GDK_Meta_L + || event->keyval == GDK_Meta_R + || event->keyval == GDK_Alt_L + || event->keyval == GDK_Alt_R) { + return FALSE; + } + + /* other key, let's restore the prefix (orignal text) */ + if (!prefs_common.fullauto_completion_mode || + event->keyval == GDK_Escape) { + prefix = get_complete_address(0); + g_free(get_address_from_edit(GTK_ENTRY(entry), &cursor_pos)); + replace_address_in_edit(GTK_ENTRY(entry), prefix, cursor_pos); + g_free(prefix); + } + + /* make sure anything we typed comes in the edit box */ + if ((!prefs_common.fullauto_completion_mode && event->length > 0 && + event->keyval != GDK_Escape) || + (prefs_common.fullauto_completion_mode && + event->keyval != GDK_Escape)) { + GtkWidget *pwin = entry; + + while ((pwin = gtk_widget_get_parent(pwin)) != NULL) { + if (GTK_WIDGET_TOPLEVEL(pwin)) { + gtk_window_propagate_key_event + (GTK_WINDOW(pwin), event); + if (prefs_common.fullauto_completion_mode) + return TRUE; + } + } + } + + /* and close the completion window */ + clear_completion_cache(); + gtk_widget_destroy(*window); + *window = NULL; + + return TRUE; +} -- cgit v1.3