New spell checker code
authorMelvin Hadasht <melvin.hadasht@free.fr>
Wed, 16 Jan 2002 06:56:38 +0000 (06:56 +0000)
committerMelvin Hadasht <melvin.hadasht@free.fr>
Wed, 16 Jan 2002 06:56:38 +0000 (06:56 +0000)
ChangeLog.claws
README.claws
configure.in
src/compose.c
src/gtkspell.c
src/gtkspell.h
src/main.c

index 8c75639..dbc2b45 100644 (file)
@@ -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
index 23e1622..bba0b37 100644 (file)
@@ -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
   -----------------
index b922ad5..b9197d5 100644 (file)
@@ -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
index 9cda5ed..0d88640 100644 (file)
@@ -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"),           "<control>V", compose_paste_cb,  0, NULL},
        {N_("/_Edit/Select _all"),      "<control>A", compose_allsel_cb, 0, NULL},
        {N_("/_Edit/---"),              NULL, NULL, 0, "<Separator>"},
+#if USE_PSPELL
+       {N_("/_Edit/Check backwards misspelled word"),  "<control>;", compose_check_backwards , 0, NULL},
+       {N_("/_Edit/Forward to next misspelled word"),  "<control>!", compose_check_forwards_go, 0, NULL},
+       {N_("/_Edit/---"),              NULL, NULL, 0, "<Separator>"},
+#endif
        {N_("/_Edit/_Wrap current paragraph"),
                                        "<alt>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
index d4b1838..21b3b1d 100644 (file)
@@ -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
  * 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 <gtk/gtk.h>
+#include <gdk/gdk.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
@@ -52,8 +53,9 @@
 #include <gtk/gtkoptionmenu.h>
 #include <gtk/gtkmenu.h>
 #include <gtk/gtkmenuitem.h>
+#include <gdk/gdkkeysyms.h>
 
-#include "gtkxtext.h"
+#include "gtkstext.h"
 
 #include "gtkspell.h"
 
 /* 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 :                         */
-       /*   <lang>[[-<spelling>[-<jargon>]]-<module>.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
index 3599c4a..502a3bc 100644 (file)
@@ -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
  */
 
 /*
- *  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 <gtk/gtkoptionmenu.h>
 #include <pspell/pspell.h>
 #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__ */
index 0858aa5..4fe31c7 100644 (file)
@@ -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);