From 688df5327c0409fc607b038f17eb43216f9893bd Mon Sep 17 00:00:00 2001 From: Melvin Hadasht Date: Wed, 16 Jan 2002 06:56:38 +0000 Subject: [PATCH] New spell checker code --- ChangeLog.claws | 10 + README.claws | 38 +- configure.in | 2 +- src/compose.c | 73 +- src/gtkspell.c | 2409 +++++++++++++++++++++++++++-------------------- src/gtkspell.h | 145 ++- src/main.c | 9 +- 7 files changed, 1591 insertions(+), 1095 deletions(-) diff --git a/ChangeLog.claws b/ChangeLog.claws index 8c756395a..dbc2b451d 100644 --- a/ChangeLog.claws +++ b/ChangeLog.claws @@ -1,3 +1,13 @@ +2002-01-16 [melvin] 0.7.0claws5 + + * README.claws + * src/compose.c + * src/gtkspell.[ch] + * src/main.c + Heavily modified spell checker code to work around + ispell bug, to add keyboard shortcuts and for future + enhancements. See README.claws for usage information. + 2002-01-15 [alfons] 0.7.0claws4 * src/summaryview.c diff --git a/README.claws b/README.claws index 23e162274..bba0b37ad 100644 --- a/README.claws +++ b/README.claws @@ -181,6 +181,9 @@ are hardly noticable, but deserve mentioning: c. Usage -------- + NOTE: if you upgraded from 0.7.0claws, please reselect your default + dictionary in the preferences. + After successful compiling, you need to tell sylpheed where your dictionaries reside. First run 'pspell-config pkgdatadir' on the shell to get their path. @@ -194,16 +197,41 @@ are hardly noticable, but deserve mentioning: When composing, misspelled words are highlighted. Click on any highlighted word with the right mouse button to get a list of - suggestions. You can also accept the highlighted word to the - session dictionary (equivalent to an 'ignore' option of other spell - checker), or you can add it to you personal dictionary. + suggestions. The first entry of the menu just displays the unknown + word. Selecting "Accept in this session" (or hitting MOD1-Space, + where MOD1 is usually the ALT key), will ignore this word and accept + it in this message. Selecting the next entry "Add to dictionary", which + is bound to MOD1-Enter combination will add the unknown word to the + dictionary to learn it. The next entries are the suggested words. + The first 15 suggestions can be accessed typing one of the first letters + of latin alphabet (if this does not suit your language, please send + a mail to melvin.hadasht@free.fr). If you are using an aspell + dictionary, you can use its 'learn from mistake' feature, by pressing + the MOD1 key and selecting the suggestion (with the keyboard or with + the mouse). See pspell manual ยง4.7.1 for an explanation of this + feature. If you click with the right mouse button everywhere else, or if you shift-right-click even on a misspelled word, you get the configuration menu. 'Check all' highlights all misspelled words. With this menu, you can also change the dictionary while editing. - You can change the suggestion mode and toggle the learn from - misktakes 'feature' (useful only with aspell). + FInally, you can change the suggestion mode misktakes 'feature' + (useful only with aspell). + + Spell checking can also be done using keyboard shortcuts. In the + "Edit" menu of the compose window, there are two menus "Check backwards + misspelled word" and "Forward to next misspelled word". Add to them + appropriate keyboard shortcuts. "Check backwards misspelled word" + checks backwards from cursor position for the first misspelled word. + If it finds one, it displays the suggestions lists which can be handled + with the keyboard as described before. When the suggestion menu is + closed, the cursor returns to its original position to be able to + continue editing. The "Forward to next misspelled word" do the same + thing in the other direction but moves the cursor at the end of the + misspelled word. This way, you can spell check easily a whole message + starting from its beginning and using the "Forward to next misspelled + word" keyboard short cut. + d. Known problems ----------------- diff --git a/configure.in b/configure.in index b922ad547..b9197d5d4 100644 --- a/configure.in +++ b/configure.in @@ -8,7 +8,7 @@ MINOR_VERSION=7 MICRO_VERSION=0 INTERFACE_AGE=0 BINARY_AGE=0 -EXTRA_VERSION=claws4 +EXTRA_VERSION=claws5 VERSION=$MAJOR_VERSION.$MINOR_VERSION.$MICRO_VERSION$EXTRA_VERSION dnl diff --git a/src/compose.c b/src/compose.c index 9cda5edaf..0d88640a0 100644 --- a/src/compose.c +++ b/src/compose.c @@ -430,6 +430,12 @@ static void compose_show_first_last_header (Compose *compose, gboolean show_firs static void compose_ctl_enter_send_shortcut_cb(GtkWidget *w, Compose *compose); +static void compose_check_backwards(Compose *compose); + +static void compose_check_forwards_go(Compose *compose); + + + static GtkItemFactoryEntry compose_popup_entries[] = { {N_("/_Add..."), NULL, compose_attach_cb, 0, NULL}, @@ -456,6 +462,11 @@ static GtkItemFactoryEntry compose_entries[] = {N_("/_Edit/_Paste"), "V", compose_paste_cb, 0, NULL}, {N_("/_Edit/Select _all"), "A", compose_allsel_cb, 0, NULL}, {N_("/_Edit/---"), NULL, NULL, 0, ""}, +#if USE_PSPELL + {N_("/_Edit/Check backwards misspelled word"), ";", compose_check_backwards , 0, NULL}, + {N_("/_Edit/Forward to next misspelled word"), "!", compose_check_forwards_go, 0, NULL}, + {N_("/_Edit/---"), NULL, NULL, 0, ""}, +#endif {N_("/_Edit/_Wrap current paragraph"), "L", compose_wrap_line, 0, NULL}, {N_("/_Edit/Wrap all long _lines"), @@ -4365,19 +4376,6 @@ static Compose *compose_create(PrefsAccount *account, ComposeMode mode) gtk_signal_connect(GTK_OBJECT(text), "drag_data_received", GTK_SIGNAL_FUNC(compose_insert_drag_received_cb), compose); -#if USE_PSPELL - if (prefs_common.enable_pspell) { - gtkpspell = gtkpspell_new_with_config(gtkpspellconfig, - prefs_common.pspell_path, - prefs_common.dictionary, - prefs_common.pspell_sugmode, - conv_get_current_charset_str()); - if (gtkpspell == NULL) - prefs_common.enable_pspell = FALSE; - else - gtkpspell_attach(gtkpspell, GTK_STEXT(text)); - } -#endif gtk_widget_show_all(vbox); /* pane between attach clist and text */ @@ -4552,6 +4550,24 @@ static Compose *compose_create(PrefsAccount *account, ComposeMode mode) compose->bounce_filename = NULL; compose->undostruct = undostruct; +#if USE_PSPELL + menu_set_sensitive(ifactory, "/Edit/Check backwards misspelled word", FALSE); + menu_set_sensitive(ifactory, "/Edit/Forward to next misspelled word", FALSE); + if (prefs_common.enable_pspell) { + gtkpspell = gtkpspell_new((const gchar*)prefs_common.dictionary, + conv_get_current_charset_str(), + GTK_STEXT(text)); + if (!gtkpspell) { + alertpanel_error(_("Spell checker could not be started.\n%s"), gtkpspellcheckers->error_message); + gtkpspell_checkers_reset(); + } else { + + gtkpspell_set_sug_mode(gtkpspell, prefs_common.pspell_sugmode); + menu_set_sensitive(ifactory, "/Edit/Check backwards misspelled word", TRUE); + menu_set_sensitive(ifactory, "/Edit/Forward to next misspelled word", TRUE); + } + } +#endif compose_set_title(compose); @@ -5956,8 +5972,7 @@ static void compose_close_cb(gpointer data, guint action, GtkWidget *widget) } #if USE_PSPELL if (compose->gtkpspell) { - gtkpspell_detach(compose->gtkpspell); - compose->gtkpspell = gtkpspell_delete(compose->gtkpspell); + gtkpspell_delete(compose->gtkpspell); } #endif gtk_widget_destroy(compose->window); @@ -6441,4 +6456,30 @@ static void compose_ctl_enter_send_shortcut_cb(GtkWidget *w, Compose *compose) if (accel->accelerator_key == GDK_Return && accel->accelerator_mods == GDK_CONTROL_MASK) compose_send_cb(compose, 0, NULL); -} +} + +#if USE_PSPELL +static void compose_check_backwards(Compose *compose) +{ + if (compose->gtkpspell) + gtkpspell_check_backwards(compose->gtkpspell); + else { + GtkItemFactory *ifactory; + ifactory = gtk_item_factory_from_widget(compose->popupmenu); + menu_set_sensitive(ifactory, "/Edit/Check backwards misspelled word", FALSE); + menu_set_sensitive(ifactory, "/Edit/Forward to next misspelled word", FALSE); + } +} + +static void compose_check_forwards_go(Compose *compose) +{ + if (compose->gtkpspell) + gtkpspell_check_forwards_go(compose->gtkpspell); + else { + GtkItemFactory *ifactory; + ifactory = gtk_item_factory_from_widget(compose->popupmenu); + menu_set_sensitive(ifactory, "/Edit/Check backwards misspelled word", FALSE); + menu_set_sensitive(ifactory, "/Edit/Forward to next misspelled word", FALSE); + } +} +#endif diff --git a/src/gtkspell.c b/src/gtkspell.c index d4b1838b7..21b3b1d01 100644 --- a/src/gtkspell.c +++ b/src/gtkspell.c @@ -1,5 +1,6 @@ /* gtkpspell - a spell-checking addon for GtkText * Copyright (c) 2000 Evan Martin. + * Copyright (c) 2002 Melvin Hadasht. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,15 +13,14 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software + * License along with this library; If not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ - /* * Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev - * Adapted for Sylpheed (Claws) (c) 2001 by Hiroyuki Yamamoto & + * Adapted for Sylpheed (Claws) (c) 2001-2002 by Hiroyuki Yamamoto & * The Sylpheed Claws Team. - * Adapted for pspell (c) 2001 Melvin Hadasht + * Adapted for pspell (c) 2001-2002 Melvin Hadasht */ #if defined(HAVE_CONFIG_H) @@ -31,6 +31,7 @@ #include "intl.h" #include +#include #include #include #include @@ -52,8 +53,9 @@ #include #include #include +#include -#include "gtkxtext.h" +#include "gtkstext.h" #include "gtkspell.h" @@ -64,530 +66,713 @@ /* number of suggestions to display on each menu. */ #define MENUCOUNT 15 -/******************************************************************************/ - -/* Function called from menus */ +/* 'config' must be defined as a 'PspellConfig *' */ +#define RETURN_FALSE_IF_CONFIG_ERROR() \ + if (pspell_config_error_number(config) != 0) { \ + gtkpspellcheckers->error_message = g_strdup(pspell_config_error_message(config)); \ + return FALSE; \ + } -static void add_word_to_session (GtkWidget *w, GtkPspell *d); -static void add_word_to_personal (GtkWidget *w, GtkPspell *d); -static void set_sug_mode (GtkWidget *w, GtkPspell *gtkpspell); -static void set_learn_mode (GtkWidget *w, GtkPspell *gtkpspell); -static void check_all (GtkWidget *w, GtkPspell *gtkpspell); -static void menu_change_dict (GtkWidget *w, GtkPspell *gtkpspell); -static void entry_insert_cb (GtkXText *gtktext, gchar *newtext, - guint len, guint *ppos, - GtkPspell *gtkpspell); -static void entry_delete_cb (GtkXText *gtktext, gint start, gint end, - GtkPspell *gtkpspell); -static gint compare_dict (Dictionary *a, Dictionary *b); -guchar *convert_to_pspell_encoding (const guchar *encoding); +#define CONFIG_REPLACE_RETURN_FALSE_IF_FAIL(option, value) { \ + pspell_config_replace(config, option, value); \ + RETURN_FALSE_IF_CONFIG_ERROR(); \ + } -static void allocate_color(GtkPspell *gtkpspell); +/******************************************************************************/ +GtkPspellCheckers *gtkpspellcheckers; + +/* Error message storage */ +static void gtkpspell_checkers_error_message(gchar *message); + +/* Callbacks */ +static void entry_insert_cb (GtkSText *gtktext, + gchar *newtext, + guint len, + guint *ppos, + GtkPspell *gtkpspell); +static void entry_delete_cb (GtkSText *gtktext, + gint start, + gint end, + GtkPspell *gtkpspell); +static gint button_press_intercept_cb (GtkSText *gtktext, + GdkEvent *e, + GtkPspell *gtkpspell); + +/* Checker creation */ +static GtkPspeller * gtkpspeller_new (Dictionary *dict); +static GtkPspeller * gtkpspeller_real_new (Dictionary *dict); +static GtkPspeller * gtkpspeller_delete (GtkPspeller *gtkpspeller); +static GtkPspeller * gtkpspeller_real_delete (GtkPspeller *gtkpspeller); + +/* Checker configuration */ +static gint set_dictionary (PspellConfig *config, + Dictionary *dict); +static void set_sug_mode_cb (GtkWidget *w, + GtkPspell *gtkpspell); +static void set_real_sug_mode (GtkPspell *gtkpspell, + const char *themode); + +/* Checker actions */ +static gboolean check_at (GtkPspell *gtkpspell, + int from_pos); +static void check_next_prev (GtkPspell *gtkpspell, + gboolean forward); + +static GList* misspelled_suggest (GtkPspell *gtkpspell, + guchar *word); +static void add_word_to_session (GtkWidget *w, + GtkPspell *d); +static void add_word_to_personal (GtkWidget *w, + GtkPspell *d); +static void replace_word (GtkWidget *w, + GtkPspell *gtkpspell); +static void replace_real_word (GtkPspell *gtkpspell, + gchar *newword); +static void check_all_cb (GtkWidget *w, + GtkPspell *gtkpspell); + +/* Menu creation */ +static void popup_menu (GtkPspell *gtkpspell, + GdkEventButton *eb); +static GtkMenu* make_sug_menu (GtkPspell *gtkpspell); +static GtkMenu* make_config_menu (GtkPspell *gtkpspell); +static void set_menu_pos (GtkMenu *menu, + gint *x, + gint *y, + gpointer data); +/* Other menu callbacks */ +static gboolean deactivate_menu_cb (GtkWidget *w, + gpointer *data); +static void change_dict_cb (GtkWidget *w, + GtkPspell *gtkpspell); + +/* Misc. helper functions */ +static gboolean iswordsep (unsigned char c); +static guchar get_text_index_whar (GtkPspell *gtkpspell, + int pos); +static gboolean get_word_from_pos (GtkPspell *gtkpspell, + int pos, + unsigned char* buf, + int *pstart, int *pend); +static void allocate_color (GtkPspell *gtkpspell); +static void change_color (GtkPspell *gtkpspell, + int start, + int end, + GdkColor *color); +static guchar* convert_to_pspell_encoding (const guchar *encoding); +static gint compare_dict (Dictionary *a, + Dictionary *b); +static void dictionary_delete (Dictionary *dict); +static Dictionary * dictionary_dup (const Dictionary *dict); +static void free_suggestions_list (GtkPspell *gtkpspell); +static void reset_theword_data (GtkPspell *gtkpspell); +static void free_checkers (gpointer elt, + gpointer data); +static gint find_gtkpspeller (gconstpointer aa, + gconstpointer bb); +static void gtkpspell_alert_dialog (gchar *message); /* gtkspellconfig - only one config per session */ GtkPspellConfig * gtkpspellconfig; /******************************************************************************/ -/* gtkspell_init() - run the first pspell_config from which every - * new config is cloned - */ -GtkPspellConfig * gtkpspell_init() +GtkPspellCheckers * gtkpspell_checkers_new() { - return new_pspell_config(); -} + GtkPspellCheckers *gtkpspellcheckers; + + gtkpspellcheckers = g_new(GtkPspellCheckers, 1); + + gtkpspellcheckers->checkers = NULL; -/* gtkspell_finished() - Finish all. No more spelling. Called when the - * program ends - */ -void gtkpspell_finished(GtkPspellConfig *gtkpspellconfig) -{ - if (gtkpspellconfig) { - delete_pspell_config(gtkpspellconfig); - gtkpspellconfig = NULL; - } -} + gtkpspellcheckers->dictionary_list = NULL; -/* gtkspell_running - Test if there is a manager running - */ -int gtkpspell_running(GtkPspell * gtkpspell) -{ - return (gtkpspell->config!=NULL); + gtkpspellcheckers->error_message = NULL; + + return gtkpspellcheckers; } - -/* gtkspell_new() - creates a new session if a gtkpspellconfig exists. The - * settings are defaults. If no path/dict is set afterwards, the default - * one is used - */ -GtkPspell * gtkpspell_new(GtkPspellConfig *gtkpspellconfig) + +GtkPspellCheckers *gtkpspell_checkers_delete() { - GtkPspell *gtkpspell; + GSList *checkers; + GSList *dict_list; - if (gtkpspellconfig == NULL) { - gtkpspellconfig = gtkpspell_init(); - if (gtkpspellconfig == NULL) { - debug_print(_("Pspell could not be started.")); - prefs_common.enable_pspell=FALSE; - return NULL; - } - } + if (gtkpspellcheckers == NULL) return NULL; - gtkpspell = g_new(GtkPspell ,1); - gtkpspell->config = gtkpspellconfig; - gtkpspell->possible_err = new_pspell_manager(gtkpspell->config); - gtkpspell->checker = NULL; + if ((checkers = gtkpspellcheckers->checkers)) { + debug_print(_("Pspell: number of running checkers to delete %d\n"), + g_slist_length(checkers)); - if (pspell_error_number(gtkpspell->possible_err) != 0) { - debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err)); - delete_pspell_can_have_error( gtkpspell->possible_err ); + g_slist_foreach(checkers, free_checkers, NULL); + g_slist_free(checkers); } - else { - gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err); + + if ((dict_list = gtkpspellcheckers->dictionary_list)) { + debug_print(_("Pspell: number of dictionaries to delete %d\n"), + g_slist_length(dict_list)); + + gtkpspell_free_dictionary_list(dict_list); + gtkpspellcheckers->dictionary_list = NULL; } - - gtkpspell->dictionary_list = NULL; - gtkpspell->path = NULL; - gtkpspell->dict = NULL; - gtkpspell->mode = PSPELL_FASTMODE; - gtkpspell->learn = TRUE; - gtkpspell->gtktext = NULL; - return gtkpspell; + g_free(gtkpspellcheckers->error_message); + + return NULL; } -/* gtkspell_new_with_config() - Creates a new session and set path/dic - */ -GtkPspell *gtkpspell_new_with_config(GtkPspellConfig *gtkpspellconfig, - guchar *path, guchar *dict, - guint mode, const guchar *encoding) -{ - GtkPspell *gtkpspell; - - if (gtkpspellconfig == NULL) { - gtkpspellconfig=gtkpspell_init(); - if (gtkpspellconfig == NULL) { - debug_print(_("Pspell could not be started.")); - prefs_common.enable_pspell = FALSE; - return NULL; - } - } +static void gtkpspell_checkers_error_message (gchar *message) +{ + gchar *tmp; + if (gtkpspellcheckers->error_message) { + tmp = g_strdup_printf("%s\n%s", + gtkpspellcheckers->error_message, message); + g_free(message); + g_free(gtkpspellcheckers->error_message); + gtkpspellcheckers->error_message = tmp; + } else gtkpspellcheckers->error_message = message; +} - gtkpspell = g_new( GtkPspell ,1); - gtkpspell->path = NULL; - gtkpspell->dict = NULL; - gtkpspell->dictionary_list = NULL; - gtkpspell->gtktext = NULL; - - gtkpspell->config = pspell_config_clone(gtkpspellconfig); - gtkpspell->mode = mode; - gtkpspell->learn = TRUE; - - if (!set_path_and_dict(gtkpspell, gtkpspell->config, path, dict)) { - debug_print(_("Pspell could not be configured.")); - gtkpspell = gtkpspell_delete(gtkpspell); - return gtkpspell; - } +void gtkpspell_checkers_reset() +{ + g_return_if_fail(gtkpspellcheckers); - if (encoding) { - char *pspell_encoding; - pspell_encoding = convert_to_pspell_encoding (encoding); - debug_print(_("Pspell encoding: asked: %s changed to: %s\n"), encoding, pspell_encoding); - pspell_config_replace(gtkpspell->config, "encoding", (const char *)pspell_encoding); - if (pspell_config_error_number(gtkpspell->config) !=0 ) { - debug_print(_("Pspell encoding error: %s\nSwitching to iso8859-1 (sorry)\n"), - pspell_config_error_message(gtkpspell->config)); - pspell_config_replace(gtkpspell->config, "encoding", "iso8859-1"); - } - g_free(pspell_encoding); - } + g_free(gtkpspellcheckers->error_message); + + gtkpspellcheckers->error_message = NULL; +} - gtkpspell->possible_err = new_pspell_manager(gtkpspell->config); - gtkpspell->checker = NULL; +GtkPspell *gtkpspell_new(const gchar *dictionary, + const gchar *encoding, + GtkSText *gtktext) +{ + Dictionary *dict = g_new0(Dictionary, 1); + GtkPspell *gtkpspell; + GtkPspeller *gtkpspeller; - if (pspell_error_number(gtkpspell->possible_err) != 0) { - debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err)); - delete_pspell_can_have_error(gtkpspell->possible_err); - gtkpspell = gtkpspell_delete(gtkpspell); - } - else { - gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err ); - } + g_return_val_if_fail(gtktext, NULL); + + dict->fullname = g_strdup(dictionary); + dict->encoding = g_strdup(encoding); + gtkpspeller = gtkpspeller_new(dict); + dictionary_delete(dict); - return gtkpspell; -} + if (!gtkpspeller) + return NULL; + + gtkpspell = g_new(GtkPspell, 1); -/* gtkspell_delete() - Finishes a session - */ -GtkPspell *gtkpspell_delete( GtkPspell *gtkpspell ) -{ - if ( gtkpspell->checker ) { - /* First save all word lists */ - pspell_manager_save_all_word_lists(gtkpspell->checker); - delete_pspell_manager(gtkpspell->checker); - gtkpspell->checker = NULL; - gtkpspell->possible_err = NULL; /* checker is a cast from possible_err */ - } + gtkpspell->gtkpspeller = gtkpspeller; + gtkpspell->theword[0] = 0x00; + gtkpspell->start_pos = 0; + gtkpspell->end_pos = 0; + gtkpspell->orig_pos = -1; - if (gtkpspell->dictionary_list) - gtkpspell_free_dictionary_list(gtkpspell->dictionary_list); + gtkpspell->gtktext = gtktext; - g_free(gtkpspell->path); - g_free(gtkpspell->dict); - gtkpspell->path = NULL; - gtkpspell->dict = NULL; + gtkpspell->default_sug_mode = PSPELL_FASTMODE; + gtkpspell->max_sug = -1; + gtkpspell->suggestions_list = NULL; - g_free(gtkpspell); - return NULL; -} - -int set_path_and_dict(GtkPspell *gtkpspell, PspellConfig *config, - guchar *path, guchar * dict) -{ - guchar *module = NULL; - guchar *language = NULL; - guchar *spelling = NULL; - guchar *jargon = NULL; - guchar buf[BUFSIZE]; - guchar *end; - guchar *temppath; - guchar *tempdict; - - /* Change nothing if any of path/dict/config is NULL */ - g_return_val_if_fail(path, 0); - g_return_val_if_fail(dict, 0); - g_return_val_if_fail(config, 0); - - /* This is done, so we can free gtkpspell->path, even if it was - * given as an argument of the function */ - temppath = g_strdup(path); - g_free(gtkpspell->path); - - /* pspell dict name format : */ - /* [[-[-]]-.pwli */ - /* Strip off path */ + gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text", + GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); + + gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text", + GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); - if (!strrchr(dict,G_DIR_SEPARATOR)) { - /* plain dict name */ - strncpy(buf,dict,BUFSIZE-1); - } - else { - /* strip path */ - strncpy(buf, strrchr(dict, G_DIR_SEPARATOR)+1, BUFSIZE-1); - } + gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event", + GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); - g_free(gtkpspell->dict); + allocate_color(gtkpspell); + + return gtkpspell; +} - /* Ensure no buffers overflows if the dict is to long */ - buf[BUFSIZE-1] = 0x00; +void gtkpspell_delete(GtkPspell * gtkpspell) +{ + GtkSText * gtktext; + + gtktext = gtkpspell->gtktext; - language = buf; - if ((module = strrchr(buf, '-')) != NULL) { - module++; - if ((end = strrchr(module, '.')) != NULL) - end[0] = 0x00; - } + gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), + GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); + gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), + GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); + gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), + GTK_SIGNAL_FUNC(button_press_intercept_cb), + gtkpspell); - /* In tempdict, we have only the dict name, without path nor - extension. Useful in the popup menus */ + gtkpspell_uncheck_all(gtkpspell); + + gtkpspeller_delete(gtkpspell->gtkpspeller); - tempdict = g_strdup(buf); + g_free(gtkpspell); + gtkpspell = NULL; +} - /* Probably I am too paranoied... */ - if (!(language[0] != 0x00 && language[1] != 0x00)) - language = NULL; - else { - spelling = strchr(language, '-'); - if (spelling != NULL) { - spelling[0] = 0x00; - spelling++; - } - if (spelling != module) { - if ((end = strchr(spelling, '-')) != NULL) { - end[0] = 0x00; - jargon = end + 1; - if (jargon != module) - if ((end = strchr(jargon, '-')) != NULL) - end[0] = 0x00; - else - jargon = NULL; - else - jargon = NULL; - } - else - spelling = NULL; +static void entry_insert_cb(GtkSText *gtktext, gchar *newtext, + guint len, guint *ppos, + GtkPspell * gtkpspell) +{ + g_return_if_fail(gtkpspell->gtkpspeller->checker); + + /* We must insert ourself the character to impose the */ + /* color of the inserted character to be default */ + /* Never mess with set_insertion when frozen */ + gtk_stext_freeze(gtktext); + gtk_stext_backward_delete(GTK_STEXT(gtktext), len); + gtk_stext_insert(GTK_STEXT(gtktext), NULL, NULL, NULL, newtext, len); + *ppos = gtk_stext_get_point(GTK_STEXT(gtktext)); + + if (iswordsep(newtext[0])) { + /* did we just end a word? */ + if (*ppos >= 2) + check_at(gtkpspell, *ppos - 2); + + /* did we just split a word? */ + if (*ppos < gtk_stext_get_length(gtktext)) + check_at(gtkpspell, *ppos + 1); + } else { + /* check as they type, *except* if they're typing at the end (the most + * common case. + */ + if (*ppos < gtk_stext_get_length(gtktext) + && !iswordsep(get_text_index_whar(gtkpspell, *ppos))) + check_at(gtkpspell, *ppos - 1); } - else - spelling = NULL; - } + gtk_stext_thaw(gtktext); + gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos); +} - debug_print(_("Language : %s\nSpelling: %s\nJargon: %s\nModule: %s\n"), - language, spelling, jargon, module); - - if (temppath[strlen(temppath)-1] == G_DIR_SEPARATOR) - temppath[strlen(temppath)-1]= 0; - if (temppath) { - pspell_config_replace(config, "add-word-list-path", temppath); - debug_print(_("Pspell config: added path %s\n"), pspell_config_retrieve(config, "word-list-path")); - if (pspell_config_error_number(config)) - debug_print(_("Pspell config: %s\n"), pspell_config_error_message(config)); - } - if (language) - pspell_config_replace(config, "language-tag", language); - if (spelling) - pspell_config_replace(config, "spelling", spelling); - if (jargon) - pspell_config_replace(config, "jargon", jargon); - if (module) - pspell_config_replace(config, "module", module); - - switch(gtkpspell->mode) { - case PSPELL_FASTMODE: - pspell_config_replace(config, "sug-mode", "fast"); - break; - case PSPELL_NORMALMODE: - pspell_config_replace(config, "sug-mode", "normal"); - break; - case PSPELL_BADSPELLERMODE: - pspell_config_replace(config, "sug-mode", "bad-spellers"); - break; +static void entry_delete_cb(GtkSText *gtktext, gint start, gint end, + GtkPspell *gtkpspell) +{ + int origpos; + + g_return_if_fail(gtkpspell->gtkpspeller->checker); + + origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); + if (start) { + check_at(gtkpspell, start - 1); + check_at(gtkpspell, start); } - - gtkpspell->path = g_strdup(temppath); - gtkpspell->dict = g_strdup(tempdict); - g_free(temppath); - g_free(tempdict); - return TRUE; + gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); + gtk_stext_set_point(gtktext, origpos); + gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); + /* this is to *UNDO* the selection, in case they were holding shift + * while hitting backspace. */ } - -/* gtkpspell_set_path_and_dict() - Set path and dict. The session is - * resetted. - * FALSE on error, TRUE on success */ -int gtkpspell_set_path_and_dict(GtkPspell * gtkpspell, guchar * path, - guchar * dict) +/* ok, this is pretty wacky: + * we need to let the right-mouse-click go through, so it moves the cursor, + * but we *can't* let it go through, because GtkText interprets rightclicks as + * weird selection modifiers. + * + * so what do we do? forge rightclicks as leftclicks, then popup the menu. + * HACK HACK HACK. + */ +static gint button_press_intercept_cb(GtkSText *gtktext, GdkEvent *e, GtkPspell *gtkpspell) { - PspellConfig * config2; - - /* It seems changing an already running config is not the way to go - */ - - config2 = pspell_config_clone(gtkpspell->config); + GdkEventButton *eb; + gboolean retval; - if (gtkpspell->checker) { - pspell_manager_save_all_word_lists(gtkpspell->checker); - delete_pspell_manager(gtkpspell->checker); - } - - gtkpspell->checker = NULL; - gtkpspell->possible_err = NULL; + g_return_val_if_fail(gtkpspell->gtkpspeller->checker, FALSE); - if (set_path_and_dict(gtkpspell,config2,path,dict) == 0) { - debug_print(_("Pspell set_path_and_dict error.")); + if (e->type != GDK_BUTTON_PRESS) return FALSE; - } - - gtkpspell->possible_err = new_pspell_manager(config2); - - delete_pspell_config(config2); - config2 = NULL; + eb = (GdkEventButton*) e; - if (pspell_error_number(gtkpspell->possible_err) != 0) { - debug_print(_("Pspell path & dict. error %s\n"), - pspell_error_message(gtkpspell->possible_err)); - delete_pspell_can_have_error(gtkpspell->possible_err); - gtkpspell->possible_err = NULL; + if (eb->button != 3) return FALSE; - } - gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err); + /* forge the leftclick */ + eb->button = 1; + gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), + GTK_SIGNAL_FUNC(button_press_intercept_cb), + gtkpspell); + gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event", + e, &retval); + gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), + GTK_SIGNAL_FUNC(button_press_intercept_cb), + gtkpspell); + gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event"); + + /* now do the menu wackiness */ + popup_menu(gtkpspell, eb); + gtk_grab_remove(GTK_WIDGET(gtktext)); return TRUE; } - -/* gtkpspell_get_dict() - What dict are we using ? language-spelling-jargon-module format */ -/* Actually, this function is not used and hence not tested. */ -/* Returns an allocated string */ -guchar *gtkpspell_get_dict(GtkPspell *gtkpspell) + +/*****************************************************************************/ +/* Checker creation */ +static GtkPspeller *gtkpspeller_new(Dictionary *dictionary) { -/* Number of dashes in a dictionary name + 1 (for trailing null) - * needed when rebuilding dictionary name - */ -#define DASHES_IN_DICTNAME 3+1 + GSList *checkers, *exist; + GtkPspeller *gtkpspeller = NULL; + GtkPspeller *g = g_new(GtkPspeller, 1); + Dictionary *dict; + gint ispell; + gboolean free_dict = TRUE; + + g_return_val_if_fail(gtkpspellcheckers, NULL); - guchar *dict; - guchar *language; - guchar *spelling; - guchar *jargon; - guint len; + g_return_val_if_fail(dictionary, NULL); - g_return_val_if_fail(gtkpspell->config, NULL); - - language = g_strdup(pspell_config_retrieve(gtkpspell->config, "language")); - spelling = g_strdup(pspell_config_retrieve(gtkpspell->config, "spelling")); - jargon = g_strdup(pspell_config_retrieve(gtkpspell->config, "jargon" )); - len = strlen(language) + strlen(spelling) + strlen(jargon); - - if (len + DASHES_IN_DICTNAME < BUFSIZE) { - dict = g_new(char,len + DASHES_IN_DICTNAME); - strcpy(dict, language); - if (spelling) { - strcat(dict, "-"); - strcat(dict, spelling); - if (jargon) { - strcat(dict, "-"); - strcat(dict,jargon); - } - } - } - g_free(language); - g_free(spelling); - g_free(jargon); - - return dict; -} - -/* gtkpspell_get_path() - Return the dict path as an allocated string */ -/* Not used = not tested */ -guchar *gtkpspell_get_path(GtkPspell *gtkpspell) -{ - guchar * path; + if (dictionary->fullname == NULL) + gtkpspell_checkers_error_message(g_strdup(_("No dictionary selected."))); + + g_return_val_if_fail(dictionary->fullname, NULL); + + if (dictionary->dictname == NULL) { + gchar *tmp; + tmp = strrchr(dictionary->fullname, G_DIR_SEPARATOR); - g_return_val_if_fail(gtkpspell->config, NULL); + if (tmp == NULL) + dictionary->dictname = dictionary->fullname; + else + dictionary->dictname = tmp + 1; + } - path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path")); + dict = dictionary_dup(dictionary); - return path; -} + ispell = (strstr2(dict->dictname, "-ispell") != NULL); -/* menu_change_dict() - Menu callback : change dict */ -static void menu_change_dict(GtkWidget *w, GtkPspell *gtkpspell) -{ - guchar *thedict, - *thelabel; - - /* Dict is simply the menu label */ + g->dictionary = dict; - gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &thelabel); + checkers = gtkpspellcheckers->checkers; - if (!strcmp2(thelabel, _("None"))) - return; + exist = g_slist_find_custom(checkers, g, find_gtkpspeller); + + g_free(g); - thedict = g_strdup(thelabel); + if (exist) + gtkpspeller = (GtkPspeller *) exist->data; - /* Set path, dict, (and sug_mode ?) */ - if(!gtkpspell_set_path_and_dict(gtkpspell, gtkpspell->path, thedict)) { - /* FIXME : try to handle this very special case */ - debug_print("Pspell: Attempt to change to a non existant dict. I will crash after closing compose window.\n"); - gtkpspell_detach(gtkpspell); - gtkpspell = gtkpspell_delete(gtkpspell); + if (exist && ispell) + debug_print(_("Pspell: Using existing ispell checker %0x\n"), + (gint) gtkpspeller); + else { + if ((gtkpspeller = gtkpspeller_real_new(dict)) != NULL) { + checkers = g_slist_append(checkers, gtkpspeller); + + debug_print(_("Pspell: Created a new gtkpspeller %0x\n"), + (gint) gtkpspeller); + + free_dict = FALSE; + } else + debug_print(_("Pspell: Could not create spell checker.\n")); } - g_free(thedict); -} -/* set_sug_mode() - Menu callback : Set the suggestion mode */ -static void set_sug_mode(GtkWidget *w, GtkPspell *gtkpspell) -{ - unsigned char *themode; + debug_print(_("Pspell: number of existing checkers %d\n"), + g_slist_length(checkers)); - gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode); + if (free_dict) + dictionary_delete(dict); - if (!strcmp(themode, _("Fast Mode"))) { - gtkpspell_set_sug_mode(gtkpspell, "fast"); - gtkpspell->mode = PSPELL_FASTMODE; - } - if (!strcmp(themode,_("Normal Mode"))) { - gtkpspell_set_sug_mode(gtkpspell, "normal"); - gtkpspell->mode = PSPELL_NORMALMODE; - } - if (!strcmp( themode,_("Bad Spellers Mode"))) { - gtkpspell_set_sug_mode(gtkpspell, "bad-spellers"); - gtkpspell->mode = PSPELL_BADSPELLERMODE; - } + gtkpspellcheckers->checkers = checkers; + + return gtkpspeller; } - -/* gtkpspell_set_sug_mode() - Set the suggestion mode */ -/* Actually, the session is resetted and everything is reset. */ -/* We take the used path/dict pair and create a new config with them */ -int gtkpspell_set_sug_mode(GtkPspell *gtkpspell, gchar *themode) + +static GtkPspeller *gtkpspeller_real_new(Dictionary *dict) { - PspellConfig *config2; - guchar *path; - guchar *dict; + GtkPspeller *gtkpspeller; + PspellConfig *config; + PspellCanHaveError *ret; + + g_return_val_if_fail(gtkpspellcheckers, NULL); + g_return_val_if_fail(dict, NULL); - pspell_manager_save_all_word_lists(gtkpspell->checker); - delete_pspell_manager(gtkpspell->checker); + gtkpspeller = g_new(GtkPspeller, 1); + + gtkpspeller->dictionary = dict; + gtkpspeller->sug_mode = PSPELL_FASTMODE; - gtkpspell->checker = NULL; + config = new_pspell_config(); - config2 = pspell_config_clone(gtkpspell->config); + if (!set_dictionary(config, dict)) + return NULL; + + ret = new_pspell_manager(config); + delete_pspell_config(config); - if (!set_path_and_dict(gtkpspell, config2, gtkpspell->path, gtkpspell->dict)) { - debug_print(_("Pspell set_sug_mod could not reset path & dict\n")); - return FALSE; + if (pspell_error_number(ret) != 0) { + gtkpspellcheckers->error_message = g_strdup(pspell_error_message(ret)); + + delete_pspell_can_have_error(ret); + + return NULL; } - pspell_config_replace(config2, "sug-mode", themode); + gtkpspeller->checker = to_pspell_manager(ret); + gtkpspeller->config = pspell_manager_config(gtkpspeller->checker); + gtkpspeller->ispell = (strstr2(dict->fullname, "-ispell") != NULL); - gtkpspell->possible_err = new_pspell_manager(config2); - delete_pspell_config(config2); - config2 = NULL; - - if (pspell_error_number(gtkpspell->possible_err) != 0) { - debug_print(_("Pspell set sug-mode error %s\n"), - pspell_error_message(gtkpspell->possible_err)); - delete_pspell_can_have_error(gtkpspell->possible_err); - gtkpspell->possible_err = NULL; - return FALSE; - } - gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err); - return TRUE; + return gtkpspeller; } -/* set_learn_mode() - menu callback to toggle learn mode */ -static void set_learn_mode (GtkWidget *w, GtkPspell *gtkpspell) -{ - gtkpspell->learn = gtkpspell->learn == FALSE ; -} - -/* misspelled_suggest() - Create a suggestion list for word */ -static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word) +static GtkPspeller *gtkpspeller_delete(GtkPspeller *gtkpspeller) { - const guchar *newword; - GList *list = NULL; - int count; - const PspellWordList *suggestions; - PspellStringEmulation *elements; + GSList *checkers; - g_return_val_if_fail(word, NULL); + g_return_val_if_fail(gtkpspellcheckers, NULL); + + checkers = gtkpspellcheckers->checkers; + + if (gtkpspeller->ispell) + debug_print(_("Pspell: Won't remove existing ispell checker %0x.\n"), + (gint) gtkpspeller); + else { + checkers = g_slist_remove(checkers, gtkpspeller); - if (!pspell_manager_check(gtkpspell->checker, word, -1)) { - suggestions = pspell_manager_suggest(gtkpspell->checker, (const char *)word, -1); - elements = pspell_word_list_elements(suggestions); - /* First one must be the misspelled (why this ?) */ - list = g_list_append(list, g_strdup(word)); + gtkpspellcheckers->checkers = checkers; - while ((newword = pspell_string_emulation_next(elements)) != NULL) - list = g_list_append(list, g_strdup(newword)); - return list; + debug_print(_("Pspell: Deleting gtkpspeller %0x.\n"), + (gint) gtkpspeller); + + gtkpspeller_real_delete(gtkpspeller); } - return NULL; + + debug_print(_("Pspell: number of existing checkers %d\n"), + g_slist_length(checkers)); + + return gtkpspeller; } -/* misspelled_test() - Just test if word is correctly spelled */ -static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word) +static GtkPspeller *gtkpspeller_real_delete(GtkPspeller *gtkpspeller) { - return pspell_manager_check(gtkpspell->checker, word, -1) ? 0 : 1; -} + g_return_val_if_fail(gtkpspeller, NULL); + g_return_val_if_fail(gtkpspeller->checker, NULL); + pspell_manager_save_all_word_lists(gtkpspeller->checker); -static gboolean iswordsep(unsigned char c) -{ - return !isalpha(c) && c != '\''; + delete_pspell_manager(gtkpspeller->checker); + + dictionary_delete(gtkpspeller->dictionary); + + g_free(gtkpspeller); + + return NULL; } -static guchar get_text_index_whar(GtkPspell *gtkpspell, int pos) +/*****************************************************************************/ +/* Checker configuration */ + +static gboolean set_dictionary(PspellConfig *config, Dictionary *dict) +{ + gchar *language = NULL; + gchar *spelling = NULL; + gchar *jargon = NULL; + gchar *module = NULL; + gchar *end = NULL; + gchar buf[BUFSIZE]; + + g_return_val_if_fail(config, FALSE); + g_return_val_if_fail(dict, FALSE); + + strncpy(buf, dict->fullname, BUFSIZE-1); + buf[BUFSIZE-1] = 0x00; + + buf[dict->dictname - dict->fullname] = 0x00; + + CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("rem-all-word-list-path", ""); + debug_print(_("Pspell: removing all paths.\n")); + + CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("add-word-list-path", buf); + debug_print(_("Pspell: adding path (%s).\n"), buf); + + strncpy(buf, dict->dictname, BUFSIZE-1); + language = buf; + + if ((module = strrchr(buf, '-')) != NULL) { + module++; + } + if ((spelling = strchr(language, '-')) != NULL) + *spelling++ = 0x00; + if (spelling != module) { + if ((end = strchr(spelling, '-')) != NULL) { + *end++ = 0x00; + jargon = end; + if (jargon != module) + if ((end = strchr(jargon, '-')) != NULL) + *end = 0x00; + else + jargon = NULL; + else + jargon = NULL; + } + else + spelling = NULL; + } + else + spelling = NULL; + + debug_print(_("Pspell: Language: %s, spelling: %s, jargon: %s, module: %s\n"), + language, spelling, jargon, module); + + if (language) + CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("language-tag", language); + + if (spelling) + CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("spelling", spelling); + + if (jargon) + CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("jargon", jargon); + + if (module) { + CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("rem-all-module-search-order", ""); + CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("add-module-search-order", module); + } + + if (dict->encoding) { + gchar *pspell_enc; + + pspell_enc = convert_to_pspell_encoding (dict->encoding); + pspell_config_replace(config, "encoding", (const char *) pspell_enc); + g_free(pspell_enc); + + RETURN_FALSE_IF_CONFIG_ERROR(); + } + + return TRUE; +} + +guchar *gtkpspell_get_dict(GtkPspell *gtkpspell) +{ + + g_return_val_if_fail(gtkpspell->gtkpspeller->config, NULL); + g_return_val_if_fail(gtkpspell->gtkpspeller->dictionary, NULL); + + return g_strdup(gtkpspell->gtkpspeller->dictionary->dictname); +} + +guchar *gtkpspell_get_path(GtkPspell *gtkpspell) +{ + guchar *path; + Dictionary *dict; + + g_return_val_if_fail(gtkpspell->gtkpspeller->config, NULL); + g_return_val_if_fail(gtkpspell->gtkpspeller->dictionary, NULL); + + dict = gtkpspell->gtkpspeller->dictionary; + path = g_strndup(dict->fullname, dict->dictname - dict->fullname); + + return path; +} + +/* set_sug_mode_cb() - Menu callback : Set the suggestion mode */ +static void set_sug_mode_cb(GtkWidget *w, GtkPspell *gtkpspell) +{ + unsigned char *themode; + + if (gtkpspell->gtkpspeller->ispell) return; + + gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode); + + set_real_sug_mode(gtkpspell, themode); + +} +static void set_real_sug_mode(GtkPspell *gtkpspell, const char *themode) +{ + gint result; + g_return_if_fail(gtkpspell); + g_return_if_fail(gtkpspell->gtkpspeller); + g_return_if_fail(themode); + + if (!strcmp(themode, _("Fast Mode"))) { + result = gtkpspell_set_sug_mode(gtkpspell, PSPELL_FASTMODE); + } else if (!strcmp(themode,_("Normal Mode"))) { + result = gtkpspell_set_sug_mode(gtkpspell, PSPELL_NORMALMODE); + } else if (!strcmp( themode,_("Bad Spellers Mode"))) { + result = gtkpspell_set_sug_mode(gtkpspell, PSPELL_BADSPELLERMODE); + } + + if(!result) { + debug_print(_("Pspell: error while changing suggestion mode:%s\n"), + gtkpspellcheckers->error_message); + gtkpspell_checkers_reset(); + } +} + +/* gtkpspell_set_sug_mode() - Set the suggestion mode */ +gboolean gtkpspell_set_sug_mode(GtkPspell *gtkpspell, gint themode) +{ + PspellConfig *config; + g_return_val_if_fail(gtkpspell, FALSE); + g_return_val_if_fail(gtkpspell->gtkpspeller, FALSE); + g_return_val_if_fail(gtkpspell->gtkpspeller->config, FALSE); + + config = gtkpspell->gtkpspeller->config; + switch (themode) { + case PSPELL_FASTMODE: + CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "fast"); + break; + case PSPELL_NORMALMODE: + CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "normal"); + break; + case PSPELL_BADSPELLERMODE: + CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", + "bad-spellers"); + break; + default: + gtkpspellcheckers->error_message = + g_strdup(_("Unknown suggestion mode.")); + return FALSE; + } + + gtkpspell->gtkpspeller->sug_mode = themode; + gtkpspell->default_sug_mode = themode; + + return TRUE; +} + +/* misspelled_suggest() - Create a suggestion list for word */ +static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word) +{ + const guchar *newword; + GList *list = NULL; + const PspellWordList *suggestions; + PspellStringEmulation *elements; + + g_return_val_if_fail(word, NULL); + + if (!pspell_manager_check(gtkpspell->gtkpspeller->checker, word, -1)) { + free_suggestions_list(gtkpspell); + + suggestions = pspell_manager_suggest(gtkpspell->gtkpspeller->checker, + (const char *)word, -1); + elements = pspell_word_list_elements(suggestions); + list = g_list_append(list, g_strdup(word)); + + while ((newword = pspell_string_emulation_next(elements)) != NULL) + list = g_list_append(list, g_strdup(newword)); + + gtkpspell->max_sug = g_list_length(list) - 1; + gtkpspell->suggestions_list = list; + + return list; + } + + free_suggestions_list(gtkpspell); + + return NULL; +} + +/* misspelled_test() - Just test if word is correctly spelled */ +static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word) +{ + return pspell_manager_check(gtkpspell->gtkpspeller->checker, word, -1) ? 0 : 1; +} + + +static gboolean iswordsep(unsigned char c) +{ + return !isalpha(c) && c != '\''; +} + +static guchar get_text_index_whar(GtkPspell *gtkpspell, int pos) { guchar a; gchar *text; @@ -609,13 +794,13 @@ static gboolean get_word_from_pos(GtkPspell *gtkpspell, int pos, /* TODO : when correcting a word into quotes, change the color of */ /* the quotes too, as may be they were highlighted before. To do */ - /* so, we can use two others pointers that points to the whole */ + /* this, we can use two others pointers that points to the whole */ /* word including quotes. */ gint start, end; guchar c; - GtkXText *gtktext; + GtkSText *gtktext; gtktext = gtkpspell->gtktext; if (iswordsep(get_text_index_whar(gtkpspell, pos))) @@ -646,10 +831,10 @@ static gboolean get_word_from_pos(GtkPspell *gtkpspell, int pos, } start++; - for (end = pos; end < gtk_xtext_get_length(gtktext); end++) { + for (end = pos; end < gtk_stext_get_length(gtktext); end++) { c = get_text_index_whar(gtkpspell, end); if (c == '\'') { - if (end < gtk_xtext_get_length(gtktext)) { + if (end < gtk_stext_get_length(gtktext)) { if (!isalpha(get_text_index_whar(gtkpspell, end + 1))) { /* end_quote = TRUE; */ break; @@ -679,41 +864,11 @@ static gboolean get_word_from_pos(GtkPspell *gtkpspell, int pos, return TRUE; } -static gboolean get_curword(GtkPspell *gtkpspell, unsigned char* buf, - int *pstart, int *pend) -{ - int pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext)); - return get_word_from_pos(gtkpspell, pos, buf, pstart, pend); -} - -static void change_color(GtkPspell * gtkpspell, - int start, int end, - GdkColor *color) -{ - char *newtext; - GtkXText *gtktext; - - g_return_if_fail(start < end); - - gtktext = gtkpspell->gtktext; - - gtk_xtext_freeze(gtktext); - newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end); - if (newtext) { - gtk_xtext_set_point(gtktext, start); - gtk_xtext_forward_delete(gtktext, end - start); - - gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start); - g_free(newtext); - } - gtk_xtext_thaw(gtktext); -} - static gboolean check_at(GtkPspell *gtkpspell, int from_pos) { int start, end; unsigned char buf[BUFSIZE]; - GtkXText *gtktext; + GtkSText *gtktext; g_return_val_if_fail(from_pos >= 0, FALSE); @@ -722,11 +877,17 @@ static gboolean check_at(GtkPspell *gtkpspell, int from_pos) if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end)) return FALSE; - strncpy(gtkpspell->theword, buf, BUFSIZE - 1); - gtkpspell->theword[BUFSIZE - 1] = 0; if (misspelled_test(gtkpspell, buf)) { - change_color(gtkpspell, start, end, &(gtkpspell->highlight)); + strncpy(gtkpspell->theword, buf, GTKPSPELLWORDSIZE - 1); + gtkpspell->theword[GTKPSPELLWORDSIZE - 1] = 0; + gtkpspell->start_pos = start; + gtkpspell->end_pos = end; + gtkpspell->newword[0] = 0; + free_suggestions_list(gtkpspell); + + change_color(gtkpspell, start, end, &(gtkpspell->highlight)); + return TRUE; } else { change_color(gtkpspell, start, end, NULL); @@ -734,29 +895,27 @@ static gboolean check_at(GtkPspell *gtkpspell, int from_pos) } } - -static void check_all(GtkWidget *w, GtkPspell *gtkpspell) +static void check_all_cb(GtkWidget *w, GtkPspell *gtkpspell) { gtkpspell_check_all(gtkpspell); } - void gtkpspell_check_all(GtkPspell *gtkpspell) { guint origpos; guint pos = 0; guint len; float adj_value; - GtkXText *gtktext; + GtkSText *gtktext; + + g_return_if_fail(gtkpspell->gtkpspeller->checker); - - if (!gtkpspell_running(gtkpspell)) return ; gtktext = gtkpspell->gtktext; - len = gtk_xtext_get_length(gtktext); + len = gtk_stext_get_length(gtktext); adj_value = gtktext->vadj->value; - gtk_xtext_freeze(gtktext); + gtk_stext_freeze(gtktext); origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); gtk_editable_set_position(GTK_EDITABLE(gtktext),0); while (pos < len) { @@ -767,144 +926,157 @@ void gtkpspell_check_all(GtkPspell *gtkpspell) if (pos > 0) check_at(gtkpspell, pos - 1); } - gtk_xtext_thaw(gtktext); + gtk_stext_thaw(gtktext); gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); } -static void entry_insert_cb(GtkXText *gtktext, gchar *newtext, - guint len, guint *ppos, - GtkPspell * gtkpspell) +static void check_next_prev(GtkPspell *gtkpspell, gboolean forward) { - guint origpos; - if (!gtkpspell_running(gtkpspell)) - return; + gint pos; + gint minpos; + gint maxpos; + gint direc = -1; + gboolean misspelled; + GdkEvent *event= (GdkEvent *) gtk_get_current_event(); + + minpos = 0; + maxpos = gtk_stext_get_length(gtkpspell->gtktext); - /* We must insert ourself the character to impose the */ - /* color of the inserted character to be default */ - /* Never mess with set_insertion when frozen */ - gtk_xtext_freeze(gtktext); - gtk_xtext_backward_delete(GTK_XTEXT(gtktext), len); - gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newtext, len); - *ppos = gtk_xtext_get_point(GTK_XTEXT(gtktext)); - - if (iswordsep(newtext[0])) { - /* did we just end a word? */ - if (*ppos >= 2) - check_at(gtkpspell, *ppos - 2); + if (forward) { + minpos = -1; + direc = -direc; + maxpos--; + } - /* did we just split a word? */ - if (*ppos < gtk_xtext_get_length(gtktext)) - check_at(gtkpspell, *ppos + 1); + + pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext)); + gtkpspell->orig_pos = pos; + while (iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos) + pos += direc; + while (!(misspelled = check_at(gtkpspell, pos)) && pos > minpos && pos <= maxpos) + { + while (!iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos) + pos += direc; + + while (iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos) + pos += direc; + } + if (misspelled) { + misspelled_suggest(gtkpspell, gtkpspell->theword); + if (forward) + gtkpspell->orig_pos = gtkpspell->end_pos; + gtk_stext_set_point(GTK_STEXT(gtkpspell->gtktext), + gtkpspell->end_pos); + gtk_editable_set_position(GTK_EDITABLE(gtkpspell->gtktext), + gtkpspell->end_pos); + gtk_menu_popup(make_sug_menu(gtkpspell), NULL, NULL, + set_menu_pos, gtkpspell, 0, gdk_event_get_time(event)); } else { - /* check as they type, *except* if they're typing at the end (the most - * common case. - */ - if (*ppos < gtk_xtext_get_length(gtktext) - && !iswordsep(get_text_index_whar(gtkpspell, *ppos))) - check_at(gtkpspell, *ppos - 1); - } - gtk_xtext_thaw(gtktext); - gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos); + reset_theword_data(gtkpspell); + + gtk_stext_set_point(GTK_STEXT(gtkpspell->gtktext), gtkpspell->orig_pos); + gtk_editable_set_position(GTK_EDITABLE(gtkpspell->gtktext), gtkpspell->orig_pos); + } } -static void entry_delete_cb(GtkXText *gtktext, gint start, gint end, - GtkPspell *gtkpspell) +void gtkpspell_check_backwards(GtkPspell *gtkpspell) { - int origpos; - - if (!gtkpspell_running(gtkpspell)) - return; - - origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - if (start) { - check_at(gtkpspell, start - 1); - check_at(gtkpspell, start); - } + check_next_prev(gtkpspell, FALSE); +} - gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); - gtk_xtext_set_point(gtktext, origpos); - gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); - /* this is to *UNDO* the selection, in case they were holding shift - * while hitting backspace. */ +void gtkpspell_check_forwards_go(GtkPspell *gtkpspell) +{ + check_next_prev(gtkpspell, TRUE); } + static void replace_word(GtkWidget *w, GtkPspell *gtkpspell) { - int start, end,oldlen, newlen; - guint origpos; - unsigned char *newword; - unsigned char buf[BUFSIZE]; - guint pos; - GtkXText *gtktext; + unsigned char *newword; + GdkEvent *e= (GdkEvent *) gtk_get_current_event(); + + gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword); + replace_real_word(gtkpspell, newword); + if ((e->type == GDK_KEY_PRESS && ((GdkEventKey *) e)->state & GDK_MOD1_MASK) || + (e->type == GDK_BUTTON_RELEASE && ((GdkEventButton *) e)->state & GDK_MOD1_MASK)) { + pspell_manager_store_replacement(gtkpspell->gtkpspeller->checker, + gtkpspell->theword, -1, + newword, -1); + } + gtkpspell->newword[0] = 0x00; + gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent)); +} + +static void replace_real_word(GtkPspell *gtkpspell, gchar *newword) +{ + int oldlen, newlen, wordlen; + gint origpos; + gint pos; + gint start = gtkpspell->start_pos; + GtkSText *gtktext; + if (!newword) return; + gtktext = gtkpspell->gtktext; - gtk_xtext_freeze(GTK_XTEXT(gtktext)); + gtk_stext_freeze(GTK_STEXT(gtktext)); origpos = gtkpspell->orig_pos; pos = origpos; + oldlen = gtkpspell->end_pos - gtkpspell->start_pos; + wordlen = strlen(gtkpspell->theword); - gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword); - newlen = strlen(newword); - - get_curword(gtkpspell, buf, &start, &end); - oldlen = end - start; + strncpy(gtkpspell->newword, newword, GTKPSPELLWORDSIZE - 1); + gtkpspell->newword[GTKPSPELLWORDSIZE-1] = 0x00; + newlen = strlen(newword); /* FIXME: multybyte characters? */ - gtk_xtext_set_point(GTK_XTEXT(gtktext), end); gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); - gtk_xtext_set_point(gtktext, start); - gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "delete-text", start, end); - gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "insert-text", newword, strlen(newword), &start); - + gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "delete-text", + gtkpspell->start_pos, gtkpspell->end_pos); + gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "insert-text", + newword, newlen, &start); + gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); - if (end-start > 0 && gtkpspell->learn) { - /* Just be sure the buffer ends somewhere... */ - buf[end-start] = 0; - /* Learn from common misspellings */ - pspell_manager_store_replacement(gtkpspell->checker, buf, - end-start, newword, - strlen(newword)); - } - + /* Put the point and the position where we clicked with the mouse */ /* It seems to be a hack, as I must thaw,freeze,thaw the widget */ /* to let it update correctly the word insertion and then the */ /* point & position position. If not, SEGV after the first replacement */ /* If the new word ends before point, put the point at its end*/ - if (origpos-start <= oldlen && origpos-start >= 0) { + if (origpos - gtkpspell->start_pos < oldlen && origpos - gtkpspell->start_pos >= 0) { /* Original point was in the word. */ - /* Put the insertion point in the same location */ - /* with respect to the new length */ - /* If the original position is still within the word, */ - /* then keep the original position. If not, move to the */ - /* end of the word */ - if (origpos-start > newlen) - pos = start + newlen; + /* Let it there unless point is going to be outside of the word */ + if (origpos - gtkpspell->start_pos >= newlen) { + pos = gtkpspell->start_pos + newlen; + } } - else if (origpos > end) { + else if (origpos >= gtkpspell->end_pos) { /* move the position according to the change of length */ pos = origpos + newlen - oldlen; } - gtk_xtext_thaw(GTK_XTEXT(gtktext)); - gtk_xtext_freeze(GTK_XTEXT(gtktext)); - if (GTK_XTEXT(gtktext)->text_len < pos) - pos = gtk_xtext_get_length(GTK_XTEXT(gtktext)); + + gtkpspell->end_pos = gtkpspell->start_pos + strlen(newword); /* FIXME: multibyte characters? */ + + gtk_stext_thaw(GTK_STEXT(gtktext)); + gtk_stext_freeze(GTK_STEXT(gtktext)); + if (GTK_STEXT(gtktext)->text_len < pos) + pos = gtk_stext_get_length(GTK_STEXT(gtktext)); gtkpspell->orig_pos = pos; gtk_editable_set_position(GTK_EDITABLE(gtktext), gtkpspell->orig_pos); - gtk_xtext_set_point(GTK_XTEXT(gtktext), + gtk_stext_set_point(GTK_STEXT(gtktext), gtk_editable_get_position(GTK_EDITABLE(gtktext))); - gtk_xtext_thaw(GTK_XTEXT(gtktext)); + gtk_stext_thaw(GTK_STEXT(gtktext)); } /* Accept this word for this session */ @@ -912,395 +1084,105 @@ static void replace_word(GtkWidget *w, GtkPspell *gtkpspell) static void add_word_to_session(GtkWidget *w, GtkPspell *gtkpspell) { guint pos; - GtkXText *gtkxtext; + GtkSText *gtktext; - gtkxtext = gtkpspell->gtktext; - gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); - pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext)); + gtktext = gtkpspell->gtktext; + + gtk_stext_freeze(GTK_STEXT(gtktext)); + + pos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - pspell_manager_add_to_session(gtkpspell->checker,gtkpspell->theword, strlen(gtkpspell->theword)); + pspell_manager_add_to_session(gtkpspell->gtkpspeller->checker,gtkpspell->theword, strlen(gtkpspell->theword)); - check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); + check_at(gtkpspell, gtkpspell->start_pos); - gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); - gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); - gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos); - gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); - gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); + gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent)); } /* add_word_to_personal() - add word to personal dict. */ - static void add_word_to_personal(GtkWidget *w, GtkPspell *gtkpspell) { - guint pos; - GtkXText *gtkxtext; + GtkSText *gtktext; - gtkxtext = gtkpspell->gtktext; + gtktext = gtkpspell->gtktext; - gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); - pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext)); + gtk_stext_freeze(GTK_STEXT(gtktext)); - pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword)); + pspell_manager_add_to_personal(gtkpspell->gtkpspeller->checker,gtkpspell->theword, strlen(gtkpspell->theword)); - check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); - gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); - gtk_xtext_freeze(GTK_XTEXT(gtkxtext)); - gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos); - gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext))); - gtk_xtext_thaw(GTK_XTEXT(gtkxtext)); + check_at(gtkpspell, gtkpspell->start_pos); + + gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent)); } - -static GtkMenu *make_menu_config(GtkPspell *gtkpspell) +void gtkpspell_uncheck_all(GtkPspell * gtkpspell) { - GtkWidget *menu, *item, *submenu; + int origpos; + unsigned char *text; + float adj_value; + GtkSText *gtktext; + + gtktext=gtkpspell->gtktext; - - menu = gtk_menu_new(); + adj_value = gtktext->vadj->value; + gtk_stext_freeze(gtktext); + origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); + text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1); + gtk_stext_set_point(gtktext, 0); + gtk_stext_forward_delete(gtktext, gtk_stext_get_length(gtktext)); + gtk_stext_insert(gtktext, NULL, NULL, NULL, text, strlen(text)); + gtk_stext_thaw(gtktext); - item = gtk_menu_item_new_with_label(_("Spell check all")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); - gtk_signal_connect(GTK_OBJECT(item),"activate", - GTK_SIGNAL_FUNC(check_all), - gtkpspell); + g_free(text); + gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); + gtk_adjustment_set_value(gtktext->vadj, adj_value); +} - item = gtk_menu_item_new(); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu),item); +static GSList *create_empty_dictionary_list(void) +{ + GSList *list = NULL; + Dictionary *dict; - submenu = gtk_menu_new(); - item = gtk_menu_item_new_with_label(_("Change dictionary")); - gtk_widget_show(item); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu); - gtk_menu_append(GTK_MENU(menu), item); - - /* Dict list */ - if (gtkpspell->dictionary_list==NULL) - gtkpspell->dictionary_list = gtkpspell_get_dictionary_list(gtkpspell->path); - - { - GtkWidget * curmenu = submenu; - int count = 0; - Dictionary *dict; - GSList *tmp; - - tmp = gtkpspell->dictionary_list; - for (tmp = gtkpspell->dictionary_list; tmp != NULL; tmp =g_slist_next(tmp)) { - dict = (Dictionary *) tmp->data; - item = gtk_check_menu_item_new_with_label(dict->name); - if (strcmp2(dict->name, gtkpspell->dict)) - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE); - else { - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); - gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE); - } - gtk_menu_append(GTK_MENU(curmenu), item); - gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(menu_change_dict), - gtkpspell); - gtk_widget_show(item); - count++; - if (count == MENUCOUNT) { - GtkWidget *newmenu; - newmenu = gtk_menu_new(); - item = gtk_menu_item_new_with_label(_("More...")); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), newmenu); - gtk_menu_append(GTK_MENU(curmenu), item); - gtk_widget_show(item); - curmenu = newmenu; - count = 0; - } - } - } - - item = gtk_menu_item_new(); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); - - item = gtk_check_menu_item_new_with_label(_("Fast Mode")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); - if (gtkpspell->mode == PSPELL_FASTMODE) { - gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE); - } - else - gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(set_sug_mode), - gtkpspell); - - item = gtk_check_menu_item_new_with_label(_("Normal Mode")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu),item); - if (gtkpspell->mode == PSPELL_NORMALMODE) { - gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); - } - else - gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(set_sug_mode), - gtkpspell); - - item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); - if (gtkpspell->mode==PSPELL_BADSPELLERMODE) { - gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); - } - else - gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(set_sug_mode), - gtkpspell); - item = gtk_menu_item_new(); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); - - item = gtk_check_menu_item_new_with_label(_("Learn from mistakes")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), - gtkpspell->learn); - gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(set_learn_mode), gtkpspell); - - - return GTK_MENU(menu); -} - -/* make_menu() - Add menus to accept this word for this session and to add it to - * personal dictionary */ -static GtkMenu *make_menu(GList *l, GtkPspell *gtkpspell) -{ - GtkWidget *menu, *item; - unsigned char *caption; - GtkXText * gtktext; - - gtktext = gtkpspell->gtktext; - - menu = gtk_menu_new(); - caption = g_strdup_printf(_("Accept `%s' for this session"), (unsigned char*)l->data); - item = gtk_menu_item_new_with_label(caption); - g_free(caption); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); - - gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(add_word_to_session), - gtkpspell); - - caption = g_strdup_printf(_("Add `%s' to personal dictionary"), (char*)l->data); - item = gtk_menu_item_new_with_label(caption); - g_free(caption); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); - - gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(add_word_to_personal), - gtkpspell); - - item = gtk_menu_item_new(); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); - - l = l->next; - if (l == NULL) { - item = gtk_menu_item_new_with_label(_("(no suggestions)")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(menu), item); - } else { - GtkWidget *curmenu = menu; - int count = 0; - - do { - if (l->data == NULL && l->next != NULL) { - count = 0; - curmenu = gtk_menu_new(); - item = gtk_menu_item_new_with_label(_("Others...")); - gtk_widget_show(item); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); - gtk_menu_append(GTK_MENU(curmenu), item); - l = l->next; - } else if (count > MENUCOUNT) { - count -= MENUCOUNT; - item = gtk_menu_item_new_with_label(_("More...")); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(curmenu), item); - curmenu = gtk_menu_new(); - gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); - } - item = gtk_menu_item_new_with_label((unsigned char*)l->data); - gtk_signal_connect(GTK_OBJECT(item), "activate", - GTK_SIGNAL_FUNC(replace_word), gtkpspell); - gtk_widget_show(item); - gtk_menu_append(GTK_MENU(curmenu), item); - count++; - } while ((l = l->next) != NULL); - } - return GTK_MENU(menu); -} - -static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb) -{ - unsigned char buf[BUFSIZE]; - GList *list, *l; - GtkXText * gtktext; - - gtktext = gtkpspell->gtktext; - gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - - if (!(eb->state & GDK_SHIFT_MASK)) - if (get_curword(gtkpspell, buf, NULL, NULL)) { - if (buf != NULL) { - strncpy(gtkpspell->theword, buf, BUFSIZE - 1); - gtkpspell->theword[BUFSIZE - 1] = 0; - list = misspelled_suggest(gtkpspell, buf); - if (list != NULL) { - gtk_menu_popup(make_menu(list, gtkpspell), NULL, NULL, NULL, NULL, - eb->button, eb->time); - for (l = list; l != NULL; l = l->next) - g_free(l->data); - g_list_free(list); - return; - } - } - } - gtk_menu_popup(make_menu_config(gtkpspell),NULL,NULL,NULL,NULL, - eb->button,eb->time); -} - -/* ok, this is pretty wacky: - * we need to let the right-mouse-click go through, so it moves the cursor, - * but we *can't* let it go through, because GtkText interprets rightclicks as - * weird selection modifiers. - * - * so what do we do? forge rightclicks as leftclicks, then popup the menu. - * HACK HACK HACK. - */ -static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, GtkPspell *gtkpspell) -{ - GdkEventButton *eb; - gboolean retval; - - if (!gtkpspell_running(gtkpspell)) - return FALSE; - - if (e->type != GDK_BUTTON_PRESS) - return FALSE; - eb = (GdkEventButton*) e; - - if (eb->button != 3) - return FALSE; - - /* forge the leftclick */ - eb->button = 1; - - gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(button_press_intercept_cb), - gtkpspell); - gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event", - e, &retval); - gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(button_press_intercept_cb), - gtkpspell); - gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event"); - - /* now do the menu wackiness */ - popup_menu(gtkpspell, eb); - gtk_grab_remove(GTK_WIDGET(gtktext)); - return TRUE; -} - -void gtkpspell_uncheck_all(GtkPspell * gtkpspell) -{ - int origpos; - unsigned char *text; - float adj_value; - GtkXText *gtktext; - - gtktext=gtkpspell->gtktext; - - adj_value = gtktext->vadj->value; - gtk_xtext_freeze(gtktext); - origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); - text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1); - gtk_xtext_set_point(gtktext, 0); - gtk_xtext_forward_delete(gtktext, gtk_xtext_get_length(gtktext)); - gtk_xtext_insert(gtktext, NULL, NULL, NULL, text, strlen(text)); - gtk_xtext_thaw(gtktext); - - gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); - gtk_adjustment_set_value(gtktext->vadj, adj_value); -} - -void gtkpspell_attach(GtkPspell *gtkpspell, GtkXText *gtktext) -{ - gtkpspell->gtktext = gtktext; - gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text", - GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); - gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text", - GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); - gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event", - GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); - - allocate_color(gtkpspell); - -} - -void gtkpspell_detach(GtkPspell * gtkpspell) -{ - GtkXText * gtktext; - - gtktext =gtkpspell->gtktext; -/* if (prefs_common.auto_makepspell) { */ - gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell); - gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell); -/* }; */ - gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext), - GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell); - - gtkpspell_uncheck_all(gtkpspell); -} - -/*** Sylpheed (Claws) ***/ - -static GSList *create_empty_dictionary_list(void) -{ - GSList *list = NULL; - Dictionary *dict; - - dict = g_new0(Dictionary, 1); - dict->name = g_strdup(_("None")); - return g_slist_append(list, dict); -} + dict = g_new0(Dictionary, 1);/*printf("N %08x dictionary\n", dict);*/ + dict->fullname = g_strdup(_("None"));/*printf("N %08x fullname\n", dict->fullname);*/ + dict->dictname = dict->fullname; + dict->encoding = NULL; + return g_slist_append(list, dict); +} /* gtkpspell_get_dictionary_list() - returns list of dictionary names */ -GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path) +GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path, gint refresh) { GSList *list; gchar *dict_path, *tmp, *prevdir; - GSList *walk; + gchar tmpname[BUFSIZE]; Dictionary *dict; DIR *dir; struct dirent *ent; + if (!gtkpspellcheckers) + gtkpspellcheckers = gtkpspell_checkers_new(); + + if (gtkpspellcheckers->dictionary_list && !refresh) + return gtkpspellcheckers->dictionary_list; + else + gtkpspell_free_dictionary_list(gtkpspellcheckers->dictionary_list); + list = NULL; #ifdef USE_THREADS #warning TODO: no directory change #endif - dict_path=g_strdup(pspell_path); + dict_path = g_strdup(pspell_path); prevdir = g_get_current_dir(); if (chdir(dict_path) <0) { - FILE_OP_ERROR(dict_path, "chdir"); + debug_print(_("Error when searching for dictionaries:\n%s\n"), + g_strerror(errno)); g_free(prevdir); g_free(dict_path); - return create_empty_dictionary_list(); + gtkpspellcheckers->dictionary_list = create_empty_dictionary_list(); + return gtkpspellcheckers->dictionary_list; } debug_print(_("Checking for dictionaries in %s\n"), dict_path); @@ -1308,52 +1190,36 @@ GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path) if (NULL != (dir = opendir("."))) { while (NULL != (ent = readdir(dir))) { /* search for pwli */ - if (NULL != (tmp = strstr(ent->d_name, ".pwli"))) { - dict = g_new0(Dictionary, 1); - dict->name = g_strndup(ent->d_name, tmp - ent->d_name); - debug_print(_("Found dictionary %s\n"), dict->name); + if ((NULL != (tmp = strstr2(ent->d_name, ".pwli"))) && (tmp[5] == 0x00)) { + g_snprintf(tmpname, BUFSIZE, "%s%s", G_DIR_SEPARATOR_S, ent->d_name); + tmpname[MIN(tmp - ent->d_name + 1, BUFSIZE-1)] = 0x00; + dict = g_new0(Dictionary, 1);/*printf("N %08x dictionary\n", dict);*/ + dict->fullname = g_strdup_printf("%s%s", dict_path, tmpname);/*printf("N %08x fullname\n", dict->fullname);*/ + dict->dictname = strrchr(dict->fullname, G_DIR_SEPARATOR) + 1; + dict->encoding = NULL; + debug_print(_("Found dictionary %s %s\n"), dict->fullname, dict->dictname); list = g_slist_insert_sorted(list, dict, (GCompareFunc) compare_dict); } } closedir(dir); } else { - FILE_OP_ERROR(dict_path, "opendir"); - debug_print(_("No dictionary found\n")); + debug_print(_("Error when searching for dictionaries.\nNo dictionary found.\n(%s)"), + g_strerror(errno)); list = create_empty_dictionary_list(); } if(list==NULL){ - debug_print(_("No dictionary found\n")); - list = create_empty_dictionary_list(); - } + + debug_print(_("Error when searching for dictionaries.\nNo dictionary found.")); + list = create_empty_dictionary_list(); + } chdir(prevdir); g_free(dict_path); g_free(prevdir); + gtkpspellcheckers->dictionary_list = list; return list; } -/* compare_dict () - compare 2 dict names */ - -static gint compare_dict(Dictionary *a, Dictionary *b) -{ - guchar *alanguage, *blanguage, - *aspelling, *bspelling, - *ajargon , *bjargon , - *amodule , *bmodule ; - guint aparts = 0, bparts = 0, i; - - for (i=0; i < strlen(a->name) ; i++) - if (a->name[i]=='-') - aparts++; - for (i=0; i < strlen(b->name) ; i++) - if (b->name[i]=='-') - bparts++; - - if (aparts != bparts) - return (aparts < bparts) ? -1 : +1 ; - else - return strcmp2(a->name, b->name); -} void gtkpspell_free_dictionary_list(GSList *list) { Dictionary *dict; @@ -1361,20 +1227,20 @@ void gtkpspell_free_dictionary_list(GSList *list) for (walk = list; walk != NULL; walk = g_slist_next(walk)) if (walk->data) { dict = (Dictionary *) walk->data; - if (dict->name) - g_free(dict->name); - g_free(dict); + dictionary_delete(dict); } g_slist_free(list); } +#if 0 static void dictionary_option_menu_item_data_destroy(gpointer data) { - gchar *str = (gchar *) data; + Dictionary *dict = (Dictionary *) data; - if (str) - g_free(str); + if (dict) + dictionary_delete(dict); } +#endif GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path) { @@ -1383,41 +1249,39 @@ GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path) GtkWidget *menu; Dictionary *dict; - dict_list = gtkpspell_get_dictionary_list(pspell_path); + dict_list = gtkpspell_get_dictionary_list(pspell_path, TRUE); g_return_val_if_fail(dict_list, NULL); menu = gtk_menu_new(); for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) { dict = (Dictionary *) tmp->data; - item = gtk_menu_item_new_with_label(dict->name); - if (dict->name) - gtk_object_set_data_full(GTK_OBJECT(item), "dict_name", - g_strdup(dict->name), - dictionary_option_menu_item_data_destroy); + item = gtk_menu_item_new_with_label(dict->dictname); + if (dict->dictname) + gtk_object_set_data(GTK_OBJECT(item), "dict_name", + dict); + gtk_menu_append(GTK_MENU(menu), item); gtk_widget_show(item); } gtk_widget_show(menu); - gtkpspell_free_dictionary_list(dict_list); - return menu; } - - gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu) { GtkWidget *menuitem; - gchar *result; + Dictionary *result; + gchar *label; g_return_val_if_fail(GTK_IS_MENU(menu), NULL); menuitem = gtk_menu_get_active(GTK_MENU(menu)); - result = gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name"); - g_return_val_if_fail(result, NULL); - return g_strdup(result); + result = (Dictionary *) gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name"); + g_return_val_if_fail(result->fullname, NULL); + label = g_strdup(result->fullname); + return label; } @@ -1473,42 +1337,593 @@ gint gtkpspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu) return sugmode; } - -/* convert_to_pspell_encoding () - converts ISO-8859-* strings to iso8859-* - * as needed by pspell. Returns an allocated string. - */ -guchar *convert_to_pspell_encoding (const guchar *encoding) +void gtkpspell_set_primary_dict(GtkPspell *gtkpspell, gchar *dict, gchar *encoding) { - guchar * pspell_encoding; + g_return_if_fail(gtkpspell); + if (gtkpspell->dict1) + dictionary_delete(gtkpspell->dict1); + gtkpspell->dict1 = g_new(Dictionary, 1); + gtkpspell->dict1->fullname = g_strdup(dict); + gtkpspell->dict1->encoding = g_strdup(encoding); +} - if (strstr2(encoding, "ISO-8859-")) { - pspell_encoding = g_strdup_printf("iso8859%s", encoding+8); - } - else - if (!strcmp2(encoding, "US-ASCII")) - pspell_encoding = g_strdup("iso8859-1"); - else - pspell_encoding = g_strdup(encoding); - return pspell_encoding; - +void gtkpspell_set_secondary_dict(GtkPspell *gtkpspell, gchar *dict, gchar *encoding) +{ + g_return_if_fail(gtkpspell); + if (gtkpspell->dict2) + dictionary_delete(gtkpspell->dict2); + gtkpspell->dict2 = g_new(Dictionary, 1); + gtkpspell->dict2->fullname = g_strdup(dict); + gtkpspell->dict2->encoding = g_strdup(encoding); } -static void allocate_color(GtkPspell *gtkpspell) +gboolean gtkpspell_use_dict(GtkPspell *gtkpspell, Dictionary *dict) { + return TRUE; +} - GdkColormap *gc; - /* Color allocation */ - gc = gtk_widget_get_colormap(GTK_WIDGET(gtkpspell->gtktext)); +gboolean gtkpspell_use_dictionary(GtkPspell *gtkpspell, gchar *dictpath, gchar *encoding) +{ + Dictionary *dict; + gboolean retval; + + g_return_val_if_fail(gtkpspell, FALSE); + g_return_val_if_fail(dict, FALSE); + g_return_val_if_fail(encoding, FALSE); - if (gtkpspell->highlight.pixel) + dict = g_new(Dictionary, 1); + + dict->fullname = g_strdup(dictpath); + dict->encoding = NULL; /* To be continued */ + + retval = gtkpspell_use_dict(gtkpspell, dict); + + dictionary_delete(dict); + + return retval; + +} + +gboolean gtkpspell_use_primary(GtkPspell *gtkpspell) +{ + g_return_val_if_fail(gtkpspell, FALSE); + + return gtkpspell_use_dict(gtkpspell, gtkpspell->dict1); +} + +gboolean gtkpspell_use_secondary(GtkPspell *gtkpspell) +{ + g_return_val_if_fail(gtkpspell, FALSE); + + return gtkpspell_use_dict(gtkpspell, gtkpspell->dict2); +} + +/*****************************************************************************/ + +static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb) +{ + GtkSText * gtktext; + + gtktext = gtkpspell->gtktext; + gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); + + if (!(eb->state & GDK_SHIFT_MASK)) { + if (check_at(gtkpspell, gtkpspell->orig_pos)) { + + gtk_editable_set_position(GTK_EDITABLE(gtktext), + gtkpspell->orig_pos); + gtk_stext_set_point(gtktext, gtkpspell->orig_pos); + + if (misspelled_suggest(gtkpspell, gtkpspell->theword)) { + gtk_menu_popup(make_sug_menu(gtkpspell), + NULL, NULL, NULL, NULL, + eb->button, eb->time); + + return; + } + } else { + gtk_editable_set_position(GTK_EDITABLE(gtktext), + gtkpspell->orig_pos); + gtk_stext_set_point(gtktext, gtkpspell->orig_pos); + } + } + + gtk_menu_popup(make_config_menu(gtkpspell),NULL,NULL,NULL,NULL, + eb->button,eb->time); +} + +/* make_sug_menu() - Add menus to accept this word for this session and to add it to + * personal dictionary */ +static GtkMenu *make_sug_menu(GtkPspell *gtkpspell) +{ + GtkWidget *menu, *item; + unsigned char *caption; + GtkSText *gtktext; + GList *l = gtkpspell->suggestions_list; + GtkAccelGroup *accel; + + + gtktext = gtkpspell->gtktext; + + accel = gtk_accel_group_new(); + menu = gtk_menu_new(); + + gtk_signal_connect(GTK_OBJECT(menu), "deactivate", + GTK_SIGNAL_FUNC(deactivate_menu_cb), gtkpspell); + + caption = g_strdup_printf(_("Unknown word: \"%s\""), + (unsigned char*) l->data); + item = gtk_menu_item_new_with_label(caption); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5); + g_free(caption); + + item = gtk_menu_item_new(); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + item = gtk_menu_item_new_with_label(_("Accept in this session")); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(add_word_to_session), + gtkpspell); + gtk_accel_group_add(accel, GDK_space, GDK_MOD1_MASK, + GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE, + GTK_OBJECT(item), "activate"); + + item = gtk_menu_item_new_with_label(_("Add to personal dictionary")); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(add_word_to_personal), + gtkpspell); + gtk_accel_group_add(accel, GDK_Return, GDK_MOD1_MASK, + GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE, + GTK_OBJECT(item), "activate"); + + item = gtk_menu_item_new(); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + l = l->next; + if (l == NULL) { + item = gtk_menu_item_new_with_label(_("(no suggestions)")); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + } else { + GtkWidget *curmenu = menu; + gint count = 0; + + do { + if (l->data == NULL && l->next != NULL) { + count = 0; + curmenu = gtk_menu_new(); + item = gtk_menu_item_new_with_label(_("Others...")); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(curmenu), item); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); + + l = l->next; + } else if (count > MENUCOUNT) { + count -= MENUCOUNT; + item = gtk_menu_item_new_with_label(_("More...")); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(curmenu), item); + curmenu = gtk_menu_new(); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu); + } + item = gtk_menu_item_new_with_label((unsigned char*)l->data); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(curmenu), item); + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(replace_word), gtkpspell); + if (count <= MENUCOUNT) { + gtk_accel_group_add(accel, 'a' + count, 0, + GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE, + GTK_OBJECT(item), "activate"); + gtk_accel_group_add(accel, 'a' + count, + GDK_MOD1_MASK, GTK_ACCEL_LOCKED, + GTK_OBJECT(item), "activate"); + } + + + count++; + } while ((l = l->next) != NULL); + } + + gtk_accel_group_attach(accel, GTK_OBJECT(menu)); + + return GTK_MENU(menu); +} + +static GtkMenu *make_config_menu(GtkPspell *gtkpspell) +{ + GtkWidget *menu, *item, *submenu; + gint ispell = gtkpspell->gtkpspeller->ispell; + + menu = gtk_menu_new(); + + item = gtk_menu_item_new_with_label(_("Spell check all")); + gtk_signal_connect(GTK_OBJECT(item),"activate", + GTK_SIGNAL_FUNC(check_all_cb), + gtkpspell); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + + item = gtk_menu_item_new(); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu),item); + + submenu = gtk_menu_new(); + item = gtk_menu_item_new_with_label(_("Change dictionary")); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + /* Dict list */ + if (gtkpspellcheckers->dictionary_list == NULL) + gtkpspell_get_dictionary_list(prefs_common.pspell_path, FALSE); + { + GtkWidget * curmenu = submenu; + int count = 0; + Dictionary *dict; + GSList *tmp; + tmp = gtkpspellcheckers->dictionary_list; + + for (tmp = gtkpspellcheckers->dictionary_list; tmp != NULL; + tmp = g_slist_next(tmp)) { + dict = (Dictionary *) tmp->data; + item = gtk_check_menu_item_new_with_label(dict->dictname); + gtk_object_set_data(GTK_OBJECT(item), "dict_name", dict); + if (strcmp2(dict->fullname, gtkpspell->gtkpspeller->dictionary->fullname)) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE); + else { + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); + gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE); + } + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(change_dict_cb), + gtkpspell); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(curmenu), item); + + count++; + + if (count == MENUCOUNT) { + GtkWidget *newmenu; + + newmenu = gtk_menu_new(); + item = gtk_menu_item_new_with_label(_("More...")); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), + newmenu); + + gtk_menu_append(GTK_MENU(curmenu), item); + gtk_widget_show(item); + curmenu = newmenu; + count = 0; + } + } + } + + item = gtk_menu_item_new(); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + item = gtk_check_menu_item_new_with_label(_("Fast Mode")); + if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_FASTMODE) + gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE); + if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_FASTMODE) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE); + else + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(set_sug_mode_cb), + gtkpspell); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + item = gtk_check_menu_item_new_with_label(_("Normal Mode")); + if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_NORMALMODE) + gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE); + if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_NORMALMODE) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); + else + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(set_sug_mode_cb), + gtkpspell); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu),item); + + item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode")); + if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_BADSPELLERMODE) + gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE); + if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_BADSPELLERMODE) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); + else + gtk_signal_connect(GTK_OBJECT(item), "activate", + GTK_SIGNAL_FUNC(set_sug_mode_cb), + gtkpspell); + gtk_widget_show(item); + gtk_menu_append(GTK_MENU(menu), item); + + return GTK_MENU(menu); +} + +static void set_menu_pos(GtkMenu *menu, gint *x, gint *y, gpointer data) +{ + GtkPspell *gtkpspell = (GtkPspell *) data; + gint xx = 0, yy = 0; + gint sx, sy; + gint wx, wy; + GtkSText *text = GTK_STEXT(gtkpspell->gtktext); + GtkRequisition r; + + gdk_window_get_origin(GTK_WIDGET(gtkpspell->gtktext)->window, &xx, &yy); + + sx = gdk_screen_width(); + sy = gdk_screen_height(); + + gtk_widget_get_child_requisition(GTK_WIDGET(menu), &r); + + wx = r.width; + wy = r.height; + + *x = gtkpspell->gtktext->cursor_pos_x + xx + + gdk_char_width(GTK_WIDGET(text)->style->font, ' '); + *y = gtkpspell->gtktext->cursor_pos_y + yy; + + if (*x + wx > sx) + *x = sx - wx; + if (*y + wy > sy) + *y = *y - wy - + gdk_string_height((GTK_WIDGET(gtkpspell->gtktext))->style->font, + gtkpspell->theword); + +} + +/*************************************************************************/ +/* Menu call backs */ + +static gboolean deactivate_menu_cb(GtkWidget *w, gpointer *data) +{ + GtkPspell *gtkpspell = (GtkPspell *) data; + GtkSText *gtktext; + gtktext = gtkpspell->gtktext; + + gtk_stext_thaw(gtktext); + gtk_stext_freeze(gtktext); + gtk_editable_set_position(GTK_EDITABLE(gtktext),gtkpspell->orig_pos); + gtk_stext_set_point(gtktext, gtkpspell->orig_pos); + gtk_stext_thaw(gtktext); + + return TRUE; +} + +/* change_dict_cb() - Menu callback : change dict */ +static void change_dict_cb(GtkWidget *w, GtkPspell *gtkpspell) +{ + Dictionary *dict, *dict2; + GtkPspeller *gtkpspeller; + gint sug_mode; + + /* Dict is simply the menu label */ + + dict = (Dictionary *) gtk_object_get_data(GTK_OBJECT(w), "dict_name"); + + if (!strcmp2(dict->fullname, _("None"))) + return; + + sug_mode = gtkpspell->default_sug_mode; + + dict2 = dictionary_dup(dict); + if (dict2->encoding) + g_free(dict2->encoding); + dict2->encoding = g_strdup(gtkpspell->gtkpspeller->dictionary->encoding); + + gtkpspeller = gtkpspeller_new(dict2); + + if (!gtkpspeller) { + gchar *message; + message = g_strdup_printf(_("The spell checker could not change dictionary.\n%s\n"), + gtkpspellcheckers->error_message); + + gtkpspell_alert_dialog(message); + g_free(message); + } else { + gtkpspeller_delete(gtkpspell->gtkpspeller); + gtkpspell->gtkpspeller = gtkpspeller; + gtkpspell_set_sug_mode(gtkpspell, sug_mode); + } + + dictionary_delete(dict2); +} + +/******************************************************************************/ +/* Misc. helper functions */ + +static void allocate_color(GtkPspell *gtkpspell) +{ + GdkColormap *gc; + GdkColor *color = &(gtkpspell->highlight); + gint rgbvalue = prefs_common.misspelled_col; + + gc = gtk_widget_get_colormap(GTK_WIDGET(gtkpspell->gtktext)); + + if (gtkpspell->highlight.pixel) gdk_colormap_free_colors(gc, &(gtkpspell->highlight), 1); - gtkut_convert_int_to_gdk_color(prefs_common.misspelled_col, - &(gtkpspell->highlight)); + /* Shameless copy from Sylpheed gtkutils.c */ + color->pixel = 0L; + color->red = (int) (((gdouble)((rgbvalue & 0xff0000) >> 16) / 255.0) * 65535.0); + color->green = (int) (((gdouble)((rgbvalue & 0x00ff00) >> 8) / 255.0) * 65535.0); + color->blue = (int) (((gdouble) (rgbvalue & 0x0000ff) / 255.0) * 65535.0); - /* add an entry for the highlight in the color map. */ gdk_colormap_alloc_color(gc, &(gtkpspell->highlight), FALSE, TRUE); } +static void change_color(GtkPspell * gtkpspell, + int start, int end, + GdkColor *color) +{ + char *newtext; + GtkSText *gtktext; + + g_return_if_fail(start < end); + + gtktext = gtkpspell->gtktext; + + gtk_stext_freeze(gtktext); + newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end); + if (newtext) { + gtk_stext_set_point(gtktext, start); + gtk_stext_forward_delete(gtktext, end - start); + + gtk_stext_insert(gtktext, NULL, color, NULL, newtext, end - start); + g_free(newtext); + } + gtk_stext_thaw(gtktext); +} + +/* convert_to_pspell_encoding () - converts ISO-8859-* strings to iso8859-* + * as needed by pspell. Returns an allocated string. + */ + +static guchar *convert_to_pspell_encoding (const guchar *encoding) +{ + guchar * pspell_encoding; + + if (strstr2(encoding, "ISO-8859-")) { + pspell_encoding = g_strdup_printf("iso8859%s", encoding+8); + } + else + if (!strcmp2(encoding, "US-ASCII")) + pspell_encoding = g_strdup("iso8859-1"); + else + pspell_encoding = g_strdup(encoding); + + return pspell_encoding; +} + +/* compare_dict () - compare 2 dict names */ +static gint compare_dict(Dictionary *a, Dictionary *b) +{ + guint aparts = 0, bparts = 0; + guint i; + + for (i=0; i < strlen(a->dictname); i++) + if (a->dictname[i] == '-') + aparts++; + for (i=0; i < strlen(b->dictname); i++) + if (b->dictname[i] == '-') + bparts++; + + if (aparts != bparts) + return (aparts < bparts) ? -1 : +1; + else { + gint compare; + compare = strcmp2(a->dictname, b->dictname); + if (!compare) + compare = strcmp2(a->fullname, b->fullname); + return compare; + } +} + + +static void dictionary_delete(Dictionary *dict) +{ + g_free(dict->fullname); + g_free(dict->encoding); + g_free(dict); +} + +static Dictionary *dictionary_dup(const Dictionary *dict) +{ + Dictionary *dict2; + + dict2 = g_new(Dictionary, 1); + + dict2->fullname = g_strdup(dict->fullname); + dict2->dictname = dict->dictname - dict->fullname + dict2->fullname; + dict2->encoding = g_strdup(dict->encoding); + + return dict2; +} + +static void free_suggestions_list(GtkPspell *gtkpspell) +{ + GList *list; + + for (list = gtkpspell->suggestions_list; list != NULL; list = list->next) + g_free(list->data); + g_list_free(list); + + gtkpspell->max_sug = -1; + gtkpspell->suggestions_list = NULL; + +} + +static void reset_theword_data(GtkPspell *gtkpspell) +{ + gtkpspell->start_pos = 0; + gtkpspell->end_pos = 0; + gtkpspell->theword[0] = 0; + gtkpspell->max_sug = -1; + gtkpspell->newword[0] = 0; + + free_suggestions_list(gtkpspell); +} + +static void free_checkers(gpointer elt, gpointer data) +{ + GtkPspeller *gtkpspeller = elt; + + g_return_if_fail(gtkpspeller); + + gtkpspeller_delete(gtkpspeller); +} + +static gint find_gtkpspeller(gconstpointer aa, gconstpointer bb) +{ + Dictionary *a = ((GtkPspeller *) aa)->dictionary; + Dictionary *b = ((GtkPspeller *) bb)->dictionary; + + if (!a || !b) + return 1; + + if (strcmp(a->fullname, b->fullname) == 0 + && a->encoding && b->encoding) + return strcmp(a->encoding, b->encoding); + + return 1; +} + +static void gtkpspell_alert_dialog(gchar *message) +{ + GtkWidget *dialog; + GtkWidget *label; + GtkWidget *ok_button; + + dialog = gtk_dialog_new(); + label = gtk_label_new(message); + ok_button = gtk_button_new_with_label(_("OK")); + + gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE); + gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_MOUSE); + GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT); + gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked", + GTK_SIGNAL_FUNC(gtk_widget_destroy), + GTK_OBJECT(dialog)); + + gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), ok_button); + + gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label); + gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), 8); + gtk_widget_grab_default(ok_button); + gtk_widget_grab_focus(ok_button); + gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); + gtk_widget_show_all(dialog); +} #endif diff --git a/src/gtkspell.h b/src/gtkspell.h index 3599c4a0b..502a3bcf9 100644 --- a/src/gtkspell.h +++ b/src/gtkspell.h @@ -2,7 +2,7 @@ Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev */ /* gtkpspell - a spell-checking addon for GtkText - * Copyright (c) 2000 Evan Martin. + * Copyright (c) 2001-2002 Melvin Hadasht * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -24,31 +24,14 @@ */ /* - * Adapted for pspell (c) 2001 Melvin Hadasht + * Adapted for pspell (c) 2001-2002 Melvin Hadasht * */ - /* first a pspell config must be created (at the beginning of the app) - with - GtkPspellConfig gtkpspellconfig = gtkpspell_init(); - then for each document use this to create a manager - GtkPspell = gtkpspell_new(GtkPspellConfig *gtkpspellconfig); - Now, path and dict can be set - gtkpspell_set_path_and_dict(GtkPspell *gtkpspell, guchar * path, guchar * dict); - then attach this to a gtktext widget : - gtkpspell_attach(GtkPspell *gtkpspell, GtkXText *gtkxtext); - and we can also detach : - gtkpspell_deattach(GtkPspell *gtkpspell, GtkXText *gtkxtext); - When finished, GtkPspell can be deleted with - gtkpspell_delete(GtkPspell * gtkpspell); - At the end of the app, GtkPspellConfig should be deleted with : - gtkpspell_finished(GtkPspellConfig * gtkpspellconfig); -*/ - #ifndef __gtkpspell_h__ #define __gtkpspell_h__ -#include "gtkxtext.h" +#include "gtkstext.h" #include #include @@ -57,82 +40,96 @@ #define PSPELL_NORMALMODE 2 #define PSPELL_BADSPELLERMODE 3 +typedef struct _GtkPspellCheckers { + GSList * checkers; + GSList * dictionary_list; + gchar * error_message; +} GtkPspellCheckers; + typedef struct _Dictionary { - gchar *name; + gchar * fullname; + gchar * dictname; /* dictname points into fullname */ + gchar * encoding; } Dictionary; -typedef struct _GtkPspell -{ - PspellConfig * config; - PspellCanHaveError * possible_err ; - PspellManager * checker; - gchar theword[1111]; - gchar *path; - gchar *dict; - guint mode; - guint learn; - guint orig_pos; - - GdkColor highlight; - - GSList * dictionary_list; - GtkXText * gtktext; - +typedef struct _GtkPspeller { + Dictionary * dictionary; + gint sug_mode; + gint ispell; + PspellConfig * config; + PspellManager * checker; +} GtkPspeller; + +#define GTKPSPELLWORDSIZE 1024 +typedef struct _GtkPspell { + GtkPspeller * gtkpspeller; + gchar theword[GTKPSPELLWORDSIZE]; + gchar newword[GTKPSPELLWORDSIZE]; + gint start_pos; + gint end_pos; + guint orig_pos; + + Dictionary * dict1; + Dictionary * dict2; + + GtkWidget * gui; + gpointer * compose; + + gint default_sug_mode; + gint max_sug; + GList * suggestions_list; + + GtkSText * gtktext; + GdkColor highlight; } GtkPspell; typedef PspellConfig GtkPspellConfig; -/* These ones create and delete a pspell config */ -GtkPspellConfig *gtkpspell_init(); -void gtkpspell_finished (GtkPspellConfig *gtkpspellconfig); - -/* These ones create and delete a manager*/ -GtkPspell *gtkpspell_new (GtkPspellConfig *config); +extern GtkPspellCheckers *gtkpspellcheckers; -GtkPspell *gtkpspell_new_with_config (GtkPspellConfig *gtkpspellconfig, - guchar *path, - guchar *dict, - guint mode, - const guchar *encoding); -GtkPspell *gtkpspell_delete (GtkPspell *gtkpspell); +GtkPspellCheckers* gtkpspell_checkers_new (); -int gtkpspell_set_path_and_dict (GtkPspell *gtkpspell, - guchar * path, - guchar * dict); -guchar *gtkpspell_get_dict (GtkPspell *gtkpspell); +GtkPspellCheckers* gtkpspell_checkers_delete (); -guchar *gtkpspell_get_path (GtkPspell *gtkpspell); +void gtkpspell_checkers_reset (); -/* This sets suggestion mode "fast" "normal" "bad-spellers" */ -/* and resets the dict & path (which should be set first) */ -/* return 0 on failure and -1 on success */ -int gtkpspell_set_sug_mode (GtkPspell * gtkpspell, - gchar * themode); +GtkPspell* gtkpspell_new (const gchar *dictionary, + const gchar *encoding, + GtkSText *gtktext); -void gtkpspell_attach (GtkPspell *gtkpspell, - GtkXText *text_ccc); +void gtkpspell_delete (GtkPspell *gtkpspell); -void gtkpspell_detach (GtkPspell *gtkpspell); +guchar* gtkpspell_get_dict (GtkPspell *gtkpspell); -void gtkpspell_check_all (GtkPspell *gtkpspell); +guchar* gtkpspell_get_path (GtkPspell *gtkpspell); -void gtkpspell_uncheck_all (GtkPspell *gtkpspell); +gboolean gtkpspell_set_sug_mode (GtkPspell *gtkpspell, + gint themode); -GSList *gtkpspell_get_dictionary_list (const char *pspell_path); +GSList* gtkpspell_get_dictionary_list (const char *pspell_path, + gint refresh); -void gtkpspell_free_dictionary_list (GSList *list); +void gtkpspell_free_dictionary_list (GSList *list); -GtkWidget *gtkpspell_dictionary_option_menu_new (const gchar *pspell_path); +void gtkpspell_check_forwards_go (GtkPspell *gtkpspell); +void gtkpspell_check_backwards (GtkPspell *gtkpspell); -gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu); +void gtkpspell_check_all (GtkPspell *gtkpspell); +void gtkpspell_uncheck_all (GtkPspell *gtkpspell); -GtkWidget *gtkpspell_sugmode_option_menu_new (gint sugmode); +GtkWidget* gtkpspell_dictionary_option_menu_new + (const gchar *pspell_path); +gchar* gtkpspell_get_dictionary_menu_active_item + (GtkWidget *menu); -void gtkpspell_sugmode_option_menu_set (GtkOptionMenu *optmenu, - gint sugmode); +GtkWidget* gtkpspell_sugmode_option_menu_new + (gint sugmode); -gint gtkpspell_get_sugmode_from_option_menu (GtkOptionMenu *optmenu); +void gtkpspell_sugmode_option_menu_set + (GtkOptionMenu *optmenu, + gint sugmode); -extern GtkPspellConfig * gtkpspellconfig; +gint gtkpspell_get_sugmode_from_option_menu + (GtkOptionMenu *optmenu); #endif /* __gtkpspell_h__ */ diff --git a/src/main.c b/src/main.c index 0858aa5f2..4fe31c7be 100644 --- a/src/main.c +++ b/src/main.c @@ -249,6 +249,11 @@ int main(int argc, char *argv[]) gpgme_register_idle(idle_function_for_gpgme); #endif +#if USE_PSPELL + gtkpspellcheckers = gtkpspell_checkers_new(); +#endif + + prefs_common_save_config(); prefs_filter_read_config(); prefs_filter_write_config(); @@ -309,7 +314,7 @@ int main(int argc, char *argv[]) gtk_main(); #if USE_PSPELL - gtkpspell_finished(gtkpspellconfig); + gtkpspell_checkers_delete(); #endif return 0; @@ -529,7 +534,7 @@ static void lock_socket_input_cb(gpointer data, static void open_compose_new_with_recipient(const gchar *address) { gchar *addr = NULL; - + if (address) { Xstrdup_a(addr, address, return); g_strstrip(addr); -- 2.25.1