7144718f845d1ffa4bd88093d00d0b202d0739a3
[claws.git] / src / gtk / gtkaspell.c
1 /* gtkaspell - a spell-checking addon for GtkText
2  * Copyright (c) 2000 Evan Martin (original code for ispell).
3  * Copyright (c) 2002 Melvin Hadasht.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; If not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
18  */
19 /*
20  * Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev
21  * Adapted for Sylpheed (Claws) (c) 2001-2002 by Hiroyuki Yamamoto & 
22  * The Sylpheed Claws Team.
23  * Adapted for pspell (c) 2001-2002 Melvin Hadasht
24  * Adapted for GNU/aspell (c) 2002 Melvin Hadasht
25  */
26  
27 #ifdef HAVE_CONFIG_H
28 #  include "config.h"
29 #endif
30
31 #ifdef USE_ASPELL
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <unistd.h>
36 #include <sys/types.h>
37 #include <sys/wait.h>
38 #include <signal.h>
39 #include <ctype.h>
40 #include <string.h>
41 #include <errno.h>
42 #include <sys/time.h>
43 #include <fcntl.h>
44 #include <time.h>
45 #include <dirent.h>
46
47 #include <glib.h>
48 #include <glib/gi18n.h>
49
50 #include <gtk/gtk.h>
51 #include <gdk/gdk.h>
52 #include <gtk/gtkoptionmenu.h>
53 #include <gtk/gtkmenu.h>
54 #include <gtk/gtkmenuitem.h>
55 #include <gdk/gdkkeysyms.h>
56
57 #include <aspell.h>
58
59 #include "utils.h"
60 #include "codeconv.h"
61 #include "alertpanel.h"
62 #include "gtkaspell.h"
63 #include "gtk/gtkutils.h"
64
65 #define ASPELL_FASTMODE       1
66 #define ASPELL_NORMALMODE     2
67 #define ASPELL_BADSPELLERMODE 3
68
69 #define GTKASPELLWORDSIZE 1024
70
71 /* size of the text buffer used in various word-processing routines. */
72 #define BUFSIZE 1024
73
74 /* number of suggestions to display on each menu. */
75 #define MENUCOUNT 15
76
77 /* 'config' must be defined as a 'AspellConfig *' */
78 #define RETURN_FALSE_IF_CONFIG_ERROR() \
79 { \
80         if (aspell_config_error_number(config) != 0) { \
81                 gtkaspellcheckers->error_message = g_strdup(aspell_config_error_message(config)); \
82                 return FALSE; \
83         } \
84 }
85
86 #define CONFIG_REPLACE_RETURN_FALSE_IF_FAIL(option, value) { \
87         aspell_config_replace(config, option, value);        \
88         RETURN_FALSE_IF_CONFIG_ERROR();                      \
89         }
90
91 typedef struct _GtkAspellCheckers {
92         GSList          *checkers;
93         GSList          *dictionary_list;
94         gchar           *error_message;
95 } GtkAspellCheckers;
96
97 typedef struct _Dictionary {
98         gchar *fullname;
99         gchar *dictname;
100         gchar *encoding;
101 } Dictionary;
102
103 typedef struct _GtkAspeller {
104         Dictionary      *dictionary;
105         gint             sug_mode;
106         AspellConfig    *config;
107         AspellSpeller   *checker;
108 } GtkAspeller;
109
110 typedef void (*ContCheckFunc) (gpointer *gtkaspell);
111
112 struct _GtkAspell
113 {
114         GtkAspeller     *gtkaspeller;
115         GtkAspeller     *alternate_speller;
116         gchar           *dictionary_path;
117         gchar            theword[GTKASPELLWORDSIZE];
118         gint             start_pos;
119         gint             end_pos;
120         gint             orig_pos;
121         gint             end_check_pos;
122         gboolean         misspelled;
123         gboolean         check_while_typing;
124         gboolean         use_alternate;
125
126         ContCheckFunc    continue_check; 
127
128         GtkWidget       *config_menu;
129         GtkWidget       *popup_config_menu;
130         GtkWidget       *sug_menu;
131         GtkWidget       *replace_entry;
132         GtkWidget       *parent_window;
133
134         gint             default_sug_mode;
135         gint             max_sug;
136         GList           *suggestions_list;
137
138         GtkTextView     *gtktext;
139         GdkColor         highlight;
140         GtkAccelGroup   *accel_group;
141 };
142
143 typedef AspellConfig GtkAspellConfig;
144
145 /******************************************************************************/
146
147 static GtkAspellCheckers *gtkaspellcheckers;
148
149 /* Error message storage */
150 static void gtkaspell_checkers_error_message    (gchar          *message);
151
152 /* Callbacks */
153 static void entry_insert_cb                     (GtkTextBuffer  *textbuf,
154                                                  GtkTextIter    *iter,
155                                                  gchar          *newtext, 
156                                                  gint           len,
157                                                  GtkAspell      *gtkaspell);
158 static void entry_delete_cb                     (GtkTextBuffer  *textbuf,
159                                                  GtkTextIter    *startiter,
160                                                  GtkTextIter    *enditer,
161                                                  GtkAspell      *gtkaspell);
162 static gint button_press_intercept_cb           (GtkTextView    *gtktext,
163                                                  GdkEvent       *e, 
164                                                  GtkAspell      *gtkaspell);
165
166 /* Checker creation */
167 static GtkAspeller* gtkaspeller_new             (Dictionary     *dict);
168 static GtkAspeller* gtkaspeller_real_new        (Dictionary     *dict);
169 static GtkAspeller* gtkaspeller_delete          (GtkAspeller    *gtkaspeller);
170 static GtkAspeller* gtkaspeller_real_delete     (GtkAspeller    *gtkaspeller);
171
172 /* Checker configuration */
173 static gint             set_dictionary                  (AspellConfig *config, 
174                                                          Dictionary *dict);
175 static void             set_sug_mode_cb                 (GtkMenuItem *w, 
176                                                          GtkAspell *gtkaspell);
177 static void             set_real_sug_mode               (GtkAspell *gtkaspell, 
178                                                          const char *themode);
179
180 /* Checker actions */
181 static gboolean check_at                        (GtkAspell      *gtkaspell, 
182                                                  int             from_pos);
183 static gboolean check_next_prev                 (GtkAspell      *gtkaspell, 
184                                                  gboolean        forward);
185 static GList* misspelled_suggest                (GtkAspell      *gtkaspell, 
186                                                  guchar         *word);
187 static void add_word_to_session_cb              (GtkWidget      *w, 
188                                                  gpointer        data);
189 static void add_word_to_personal_cb             (GtkWidget      *w, 
190                                                  gpointer        data);
191 static void replace_with_create_dialog_cb       (GtkWidget      *w,
192                                                  gpointer        data);
193 static void replace_with_supplied_word_cb       (GtkWidget      *w, 
194                                                  GtkAspell      *gtkaspell);
195 static void replace_word_cb                     (GtkWidget      *w, 
196                                                  gpointer       data); 
197 static void replace_real_word                   (GtkAspell      *gtkaspell, 
198                                                  gchar          *newword);
199 static void check_with_alternate_cb             (GtkWidget      *w,
200                                                  gpointer        data);
201 static void use_alternate_dict                  (GtkAspell      *gtkaspell);
202 static void toggle_check_while_typing_cb        (GtkWidget      *w, 
203                                                  gpointer        data);
204
205 /* Menu creation */
206 static void popup_menu                          (GtkAspell      *gtkaspell, 
207                                                  GdkEventButton *eb);
208 static GtkMenu* make_sug_menu                   (GtkAspell      *gtkaspell);
209 static void populate_submenu                    (GtkAspell      *gtkaspell, 
210                                                  GtkWidget      *menu);
211 static GtkMenu* make_config_menu                (GtkAspell      *gtkaspell);
212 static void set_menu_pos                        (GtkMenu        *menu, 
213                                                  gint           *x, 
214                                                  gint           *y, 
215                                                  gboolean       *push_in,
216                                                  gpointer        data);
217 /* Other menu callbacks */
218 static gboolean cancel_menu_cb                  (GtkMenuShell   *w,
219                                                  gpointer        data);
220 static void change_dict_cb                      (GtkWidget      *w, 
221                                                  GtkAspell      *gtkaspell);
222 static void switch_to_alternate_cb              (GtkWidget      *w, 
223                                                  gpointer        data);
224
225 /* Misc. helper functions */
226 static void             set_point_continue              (GtkAspell *gtkaspell);
227 static void             continue_check                  (gpointer *gtkaspell);
228 static gboolean         iswordsep                       (unsigned char c);
229 static guchar           get_text_index_whar             (GtkAspell *gtkaspell, 
230                                                          int pos);
231 static gboolean         get_word_from_pos               (GtkAspell *gtkaspell, 
232                                                          gint pos, 
233                                                          unsigned char* buf,
234                                                          gint buflen,
235                                                          gint *pstart, 
236                                                          gint *pend);
237 static void             allocate_color                  (GtkAspell *gtkaspell,
238                                                          gint rgbvalue);
239 static void             change_color                    (GtkAspell *gtkaspell, 
240                                                          gint start, 
241                                                          gint end, 
242                                                          gchar *newtext,
243                                                          GdkColor *color);
244 static guchar*          convert_to_aspell_encoding      (const guchar *encoding);
245 static gint             compare_dict                    (Dictionary *a, 
246                                                          Dictionary *b);
247 static void             dictionary_delete               (Dictionary *dict);
248 static Dictionary *     dictionary_dup                  (const Dictionary *dict);
249 static void             free_suggestions_list           (GtkAspell *gtkaspell);
250 static void             reset_theword_data              (GtkAspell *gtkaspell);
251 static void             free_checkers                   (gpointer elt, 
252                                                          gpointer data);
253 static gint             find_gtkaspeller                (gconstpointer aa, 
254                                                          gconstpointer bb);
255 /* gtkspellconfig - only one config per session */
256 GtkAspellConfig * gtkaspellconfig;
257 static void destroy_menu(GtkWidget *widget, gpointer user_data);        
258
259 /******************************************************************************/
260 static gint get_textview_buffer_charcount(GtkTextView *view);
261
262 static gint get_textview_buffer_charcount(GtkTextView *view)
263 {
264         GtkTextBuffer *buffer;
265
266         g_return_val_if_fail(view, 0);
267
268         buffer = gtk_text_view_get_buffer(view);
269         g_return_val_if_fail(buffer, 0);
270
271         return gtk_text_buffer_get_char_count(buffer);
272 }
273 static gint get_textview_buffer_offset(GtkTextView *view)
274 {
275         GtkTextBuffer * buffer;
276         GtkTextMark * mark;
277         GtkTextIter iter;
278
279         g_return_val_if_fail(view, 0);
280
281         buffer = gtk_text_view_get_buffer(view);
282         g_return_val_if_fail(buffer, 0);
283
284         mark = gtk_text_buffer_get_insert(buffer);
285         g_return_val_if_fail(mark, 0);
286
287         gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
288
289         return gtk_text_iter_get_offset(&iter);
290 }
291 static void set_textview_buffer_offset(GtkTextView *view, gint offset)
292 {
293         GtkTextBuffer *buffer;
294         GtkTextIter iter;
295
296         g_return_if_fail(view);
297
298         buffer = gtk_text_view_get_buffer(view);
299         g_return_if_fail(buffer);
300
301         gtk_text_buffer_get_iter_at_offset(buffer, &iter, offset);
302         gtk_text_buffer_place_cursor(buffer, &iter);
303 }
304 /******************************************************************************/
305
306 void gtkaspell_checkers_init(void)
307 {
308         gtkaspellcheckers                  = g_new(GtkAspellCheckers, 1);
309         gtkaspellcheckers->checkers        = NULL;
310         gtkaspellcheckers->dictionary_list = NULL;
311         gtkaspellcheckers->error_message   = NULL;
312 }
313         
314 void gtkaspell_checkers_quit(void)
315 {
316         GSList *checkers;
317         GSList *dict_list;
318
319         if (gtkaspellcheckers == NULL) 
320                 return;
321
322         if ((checkers  = gtkaspellcheckers->checkers)) {
323                 debug_print("Aspell: number of running checkers to delete %d\n",
324                                 g_slist_length(checkers));
325
326                 g_slist_foreach(checkers, free_checkers, NULL);
327                 g_slist_free(checkers);
328                 gtkaspellcheckers->checkers = NULL;
329         }
330
331         if ((dict_list = gtkaspellcheckers->dictionary_list)) {
332                 debug_print("Aspell: number of dictionaries to delete %d\n",
333                                 g_slist_length(dict_list));
334
335                 gtkaspell_free_dictionary_list(dict_list);
336                 gtkaspellcheckers->dictionary_list = NULL;
337         }
338
339         g_free(gtkaspellcheckers->error_message);
340         gtkaspellcheckers->error_message = NULL;
341         return;
342 }
343
344 static void gtkaspell_checkers_error_message (gchar *message)
345 {
346         gchar *tmp;
347         if (gtkaspellcheckers->error_message) {
348                 tmp = g_strdup_printf("%s\n%s", 
349                                       gtkaspellcheckers->error_message,
350                                       message);
351                 g_free(message);
352                 g_free(gtkaspellcheckers->error_message);
353                 gtkaspellcheckers->error_message = tmp;
354         } else 
355                 gtkaspellcheckers->error_message = message;
356 }
357
358 const char *gtkaspell_checkers_strerror(void)
359 {
360         g_return_val_if_fail(gtkaspellcheckers, "");
361         return gtkaspellcheckers->error_message;
362 }
363
364 void gtkaspell_checkers_reset_error(void)
365 {
366         g_return_if_fail(gtkaspellcheckers);
367         
368         g_free(gtkaspellcheckers->error_message);
369         
370         gtkaspellcheckers->error_message = NULL;
371 }
372
373 GtkAspell *gtkaspell_new(const gchar *dictionary_path,
374                          const gchar *dictionary, 
375                          const gchar *encoding,
376                          gint  misspelled_color,
377                          gboolean check_while_typing,
378                          gboolean use_alternate,
379                          GtkTextView *gtktext,
380                          GtkWindow *parent_win)
381 {
382         Dictionary      *dict;
383         GtkAspell       *gtkaspell;
384         GtkAspeller     *gtkaspeller;
385         GtkTextBuffer *buffer;
386
387         g_return_val_if_fail(gtktext, NULL);
388         buffer = gtk_text_view_get_buffer(gtktext);
389         
390         dict           = g_new0(Dictionary, 1);
391         dict->fullname = g_strdup(dictionary);
392         dict->encoding = g_strdup(encoding);
393
394         gtkaspeller    = gtkaspeller_new(dict); 
395         dictionary_delete(dict);
396
397         if (!gtkaspeller)
398                 return NULL;
399         
400         gtkaspell = g_new0(GtkAspell, 1);
401
402         gtkaspell->dictionary_path    = g_strdup(dictionary_path);
403
404         gtkaspell->gtkaspeller        = gtkaspeller;
405         gtkaspell->alternate_speller  = NULL;
406         gtkaspell->theword[0]         = 0x00;
407         gtkaspell->start_pos          = 0;
408         gtkaspell->end_pos            = 0;
409         gtkaspell->orig_pos           = -1;
410         gtkaspell->end_check_pos      = -1;
411         gtkaspell->misspelled         = -1;
412         gtkaspell->check_while_typing = check_while_typing;
413         gtkaspell->continue_check     = NULL;
414         gtkaspell->config_menu        = NULL;
415         gtkaspell->popup_config_menu  = NULL;
416         gtkaspell->sug_menu           = NULL;
417         gtkaspell->replace_entry      = NULL;
418         gtkaspell->gtktext            = gtktext;
419         gtkaspell->default_sug_mode   = ASPELL_FASTMODE;
420         gtkaspell->max_sug            = -1;
421         gtkaspell->suggestions_list   = NULL;
422         gtkaspell->use_alternate      = use_alternate;
423         gtkaspell->parent_window      = GTK_WIDGET(parent_win);
424         
425         allocate_color(gtkaspell, misspelled_color);
426
427         g_signal_connect_after(G_OBJECT(buffer), "insert-text",
428                                G_CALLBACK(entry_insert_cb), gtkaspell);
429         g_signal_connect_after(G_OBJECT(buffer), "delete-range",
430                                G_CALLBACK(entry_delete_cb), gtkaspell);
431         g_signal_connect(G_OBJECT(gtktext), "button-press-event",
432                          G_CALLBACK(button_press_intercept_cb),
433                          gtkaspell);
434         
435         debug_print("Aspell: created gtkaspell %0x\n", (guint) gtkaspell);
436
437         return gtkaspell;
438 }
439
440 void gtkaspell_delete(GtkAspell * gtkaspell) 
441 {
442         GtkTextView *gtktext = gtkaspell->gtktext;
443         
444         g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
445                                              G_CALLBACK(entry_insert_cb),
446                                       gtkaspell);
447         g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
448                                              G_CALLBACK(entry_delete_cb),
449                                              gtkaspell);
450         g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
451                                              G_CALLBACK(button_press_intercept_cb),
452                                              gtkaspell);
453
454         gtkaspell_uncheck_all(gtkaspell);
455         
456         gtkaspeller_delete(gtkaspell->gtkaspeller);
457
458         if (gtkaspell->use_alternate && gtkaspell->alternate_speller)
459                 gtkaspeller_delete(gtkaspell->alternate_speller);
460
461         if (gtkaspell->sug_menu)
462                 gtk_widget_destroy(gtkaspell->sug_menu);
463
464         if (gtkaspell->popup_config_menu)
465                 gtk_widget_destroy(gtkaspell->popup_config_menu);
466
467         if (gtkaspell->config_menu)
468                 gtk_widget_destroy(gtkaspell->config_menu);
469
470         if (gtkaspell->suggestions_list)
471                 free_suggestions_list(gtkaspell);
472
473         g_free((gchar *)gtkaspell->dictionary_path);
474         gtkaspell->dictionary_path = NULL;
475
476         debug_print("Aspell: deleting gtkaspell %0x\n", (guint) gtkaspell);
477
478         g_free(gtkaspell);
479
480         gtkaspell = NULL;
481 }
482
483 static void entry_insert_cb(GtkTextBuffer *textbuf,
484                             GtkTextIter *iter,
485                             gchar *newtext,
486                             gint len,
487                             GtkAspell *gtkaspell)
488 {
489         guint pos;
490
491         g_return_if_fail(gtkaspell->gtkaspeller->checker);
492
493         if (!gtkaspell->check_while_typing)
494                 return;
495
496         pos = gtk_text_iter_get_offset(iter);
497         
498         if (iswordsep(newtext[0])) {
499                 /* did we just end a word? */
500                 if (pos >= 2)
501                         check_at(gtkaspell, pos - 2);
502
503                 /* did we just split a word? */
504                 if (pos < gtk_text_buffer_get_char_count(textbuf))
505                         check_at(gtkaspell, pos + 1);
506         } else {
507                 /* check as they type, *except* if they're typing at the end (the most
508                  * common case).
509                  */
510                 if (pos < gtk_text_buffer_get_char_count(textbuf) &&
511                     !iswordsep(get_text_index_whar(gtkaspell, pos))) {
512                         check_at(gtkaspell, pos - 1);
513                 }
514         }
515 }
516
517 static void entry_delete_cb(GtkTextBuffer *textbuf,
518                             GtkTextIter *startiter,
519                             GtkTextIter *enditer,
520                             GtkAspell *gtkaspell)
521 {
522         int origpos;
523         gint start, end;
524     
525         g_return_if_fail(gtkaspell->gtkaspeller->checker);
526
527         if (!gtkaspell->check_while_typing)
528                 return;
529
530         start = gtk_text_iter_get_offset(startiter);
531         end = gtk_text_iter_get_offset(enditer);
532         origpos = get_textview_buffer_offset(gtkaspell->gtktext);
533         if (start) {
534                 check_at(gtkaspell, start - 1);
535                 check_at(gtkaspell, start);
536         }
537
538         set_textview_buffer_offset(gtkaspell->gtktext, origpos);
539         /* this is to *UNDO* the selection, in case they were holding shift
540          * while hitting backspace. */
541         /* needed with textview ??? */
542         /* gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); */
543 }
544
545 /* ok, this is pretty wacky:
546  * we need to let the right-mouse-click go through, so it moves the cursor,
547  * but we *can't* let it go through, because GtkText interprets rightclicks as
548  * weird selection modifiers.
549  *
550  * so what do we do?  forge rightclicks as leftclicks, then popup the menu.
551  * HACK HACK HACK.
552  */
553 static gint button_press_intercept_cb(GtkTextView *gtktext,
554                                       GdkEvent *e, 
555                                       GtkAspell *gtkaspell)
556 {
557         GdkEventButton *eb;
558         gboolean retval;
559
560         g_return_val_if_fail(gtkaspell->gtkaspeller->checker, FALSE);
561
562         if (e->type != GDK_BUTTON_PRESS) 
563                 return FALSE;
564         eb = (GdkEventButton*) e;
565
566         if (eb->button != 3) 
567                 return FALSE;
568
569         g_signal_handlers_block_by_func(G_OBJECT(gtktext),
570                                         G_CALLBACK(button_press_intercept_cb), 
571                                         gtkaspell);
572         g_signal_emit_by_name(G_OBJECT(gtktext), "button-release-event",
573                               e, &retval);
574
575         /* forge the leftclick */
576         eb->button = 1;
577         
578         g_signal_emit_by_name(G_OBJECT(gtktext), "button-press-event",
579                               e, &retval);
580         g_signal_emit_by_name(G_OBJECT(gtktext), "button-release-event",
581                               e, &retval);
582         g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
583                                           G_CALLBACK(button_press_intercept_cb), 
584                                            gtkaspell);
585         g_signal_stop_emission_by_name(G_OBJECT(gtktext), "button-press-event");
586     
587         /* now do the menu wackiness */
588         popup_menu(gtkaspell, eb);
589         gtk_grab_remove(GTK_WIDGET(gtktext));
590         return FALSE;
591 }
592
593 /* Checker creation */
594 static GtkAspeller *gtkaspeller_new(Dictionary *dictionary)
595 {
596         GSList          *exist;
597         GtkAspeller     *gtkaspeller = NULL;
598         GtkAspeller     *tmp;
599         Dictionary      *dict;
600
601         g_return_val_if_fail(gtkaspellcheckers, NULL);
602
603         g_return_val_if_fail(dictionary, NULL);
604
605         if (dictionary->fullname == NULL)
606                 gtkaspell_checkers_error_message(
607                                 g_strdup(_("No dictionary selected.")));
608         
609         g_return_val_if_fail(dictionary->fullname, NULL);
610         
611         if (dictionary->dictname == NULL) {
612                 gchar *tmp;
613
614                 tmp = strrchr(dictionary->fullname, G_DIR_SEPARATOR);
615
616                 if (tmp == NULL)
617                         dictionary->dictname = dictionary->fullname;
618                 else
619                         dictionary->dictname = tmp + 1;
620         }
621
622         dict = dictionary_dup(dictionary);
623
624         tmp = g_new0(GtkAspeller, 1);
625         tmp->dictionary = dict;
626
627         exist = g_slist_find_custom(gtkaspellcheckers->checkers, tmp, 
628                                     find_gtkaspeller);
629         
630         g_free(tmp);
631
632         if ((gtkaspeller = gtkaspeller_real_new(dict)) != NULL) {
633                 gtkaspellcheckers->checkers = g_slist_append(
634                                 gtkaspellcheckers->checkers,
635                                 gtkaspeller);
636
637                 debug_print("Aspell: Created a new gtkaspeller %0x\n",
638                                 (gint) gtkaspeller);
639         } else {
640                 dictionary_delete(dict);
641
642                 debug_print("Aspell: Could not create spell checker.\n");
643         }
644
645         debug_print("Aspell: number of existing checkers %d\n", 
646                         g_slist_length(gtkaspellcheckers->checkers));
647
648         return gtkaspeller;
649 }
650
651 static GtkAspeller *gtkaspeller_real_new(Dictionary *dict)
652 {
653         GtkAspeller             *gtkaspeller;
654         AspellConfig            *config;
655         AspellCanHaveError      *ret;
656         
657         g_return_val_if_fail(gtkaspellcheckers, NULL);
658         g_return_val_if_fail(dict, NULL);
659
660         gtkaspeller = g_new(GtkAspeller, 1);
661         
662         gtkaspeller->dictionary = dict;
663         gtkaspeller->sug_mode   = ASPELL_FASTMODE;
664
665         config = new_aspell_config();
666
667         if (!set_dictionary(config, dict))
668                 return NULL;
669         
670         ret = new_aspell_speller(config);
671         delete_aspell_config(config);
672
673         if (aspell_error_number(ret) != 0) {
674                 gtkaspellcheckers->error_message
675                         = g_strdup(aspell_error_message(ret));
676                 
677                 delete_aspell_can_have_error(ret);
678                 
679                 return NULL;
680         }
681
682         gtkaspeller->checker = to_aspell_speller(ret);
683         gtkaspeller->config  = aspell_speller_config(gtkaspeller->checker);
684
685         return gtkaspeller;
686 }
687
688 static GtkAspeller *gtkaspeller_delete(GtkAspeller *gtkaspeller)
689 {
690         g_return_val_if_fail(gtkaspellcheckers, NULL);
691         
692         gtkaspellcheckers->checkers = 
693                 g_slist_remove(gtkaspellcheckers->checkers, 
694                                 gtkaspeller);
695
696         debug_print("Aspell: Deleting gtkaspeller %0x.\n", 
697                         (gint) gtkaspeller);
698
699         gtkaspeller_real_delete(gtkaspeller);
700
701         debug_print("Aspell: number of existing checkers %d\n", 
702                         g_slist_length(gtkaspellcheckers->checkers));
703
704         return gtkaspeller;
705 }
706
707 static GtkAspeller *gtkaspeller_real_delete(GtkAspeller *gtkaspeller)
708 {
709         g_return_val_if_fail(gtkaspeller,          NULL);
710         g_return_val_if_fail(gtkaspeller->checker, NULL);
711
712         aspell_speller_save_all_word_lists(gtkaspeller->checker);
713
714         delete_aspell_speller(gtkaspeller->checker);
715
716         dictionary_delete(gtkaspeller->dictionary);
717
718         debug_print("Aspell: gtkaspeller %0x deleted.\n", 
719                     (gint) gtkaspeller);
720
721         g_free(gtkaspeller);
722
723         return NULL;
724 }
725
726 /*****************************************************************************/
727 /* Checker configuration */
728
729 static gboolean set_dictionary(AspellConfig *config, Dictionary *dict)
730 {
731         gchar *language = NULL;
732         gchar *jargon = NULL;
733         gchar *size   = NULL;
734         gchar  buf[BUFSIZE];
735         
736         g_return_val_if_fail(config, FALSE);
737         g_return_val_if_fail(dict,   FALSE);
738
739         strncpy(buf, dict->fullname, BUFSIZE-1);
740         buf[BUFSIZE-1] = 0x00;
741
742         buf[dict->dictname - dict->fullname] = 0x00;
743
744         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("dict-dir", buf);
745         debug_print("Aspell: looking for dictionaries in path %s.\n", buf);
746
747         strncpy(buf, dict->dictname, BUFSIZE-1);
748         language = buf;
749         
750         if ((size = strrchr(buf, '-')) && isdigit((int) size[1]))
751                 *size++ = 0x00;
752         else
753                 size = NULL;
754                                 
755         if ((jargon = strchr(language, '-')) != NULL) 
756                 *jargon++ = 0x00;
757         
758         if (size != NULL && jargon == size)
759                 jargon = NULL;
760
761         debug_print("Aspell: language: %s, jargon: %s, size: %s\n",
762                     language, jargon ? jargon : "",
763                     size ? size : "");
764         
765         if (language)
766                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("lang", language);
767         if (jargon)
768                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("jargon", jargon);
769         if (size)
770                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("size", size);
771         if (dict->encoding) {
772                 gchar *aspell_enc;
773         
774                 aspell_enc = convert_to_aspell_encoding (dict->encoding);
775                 aspell_config_replace(config, "encoding",
776                                       (const char *) aspell_enc);
777                 g_free(aspell_enc);
778
779                 RETURN_FALSE_IF_CONFIG_ERROR();
780         }
781         
782         return TRUE;
783 }
784
785 guchar *gtkaspell_get_dict(GtkAspell *gtkaspell)
786 {
787
788         g_return_val_if_fail(gtkaspell->gtkaspeller->config,     NULL);
789         g_return_val_if_fail(gtkaspell->gtkaspeller->dictionary, NULL);
790         
791         return g_strdup(gtkaspell->gtkaspeller->dictionary->dictname);
792 }
793   
794 guchar *gtkaspell_get_path(GtkAspell *gtkaspell)
795 {
796         guchar *path;
797         Dictionary *dict;
798
799         g_return_val_if_fail(gtkaspell->gtkaspeller->config, NULL);
800         g_return_val_if_fail(gtkaspell->gtkaspeller->dictionary, NULL);
801
802         dict = gtkaspell->gtkaspeller->dictionary;
803         path = g_strndup(dict->fullname, dict->dictname - dict->fullname);
804
805         return path;
806 }
807
808 /* set_sug_mode_cb() - Menu callback: Set the suggestion mode */
809 static void set_sug_mode_cb(GtkMenuItem *w, GtkAspell *gtkaspell)
810 {
811         char *themode;
812         
813         themode = (char *) gtk_label_get_text(GTK_LABEL(GTK_BIN(w)->child));
814         themode = g_strdup(themode);
815         
816         set_real_sug_mode(gtkaspell, themode);
817         g_free(themode);
818
819         if (gtkaspell->config_menu)
820                 populate_submenu(gtkaspell, gtkaspell->config_menu);
821 }
822
823 static void set_real_sug_mode(GtkAspell *gtkaspell, const char *themode)
824 {
825         gint result;
826         gint mode = ASPELL_FASTMODE;
827         g_return_if_fail(gtkaspell);
828         g_return_if_fail(gtkaspell->gtkaspeller);
829         g_return_if_fail(themode);
830
831         if (!strcmp(themode,_("Normal Mode")))
832                 mode = ASPELL_NORMALMODE;
833         else if (!strcmp( themode,_("Bad Spellers Mode")))
834                 mode = ASPELL_BADSPELLERMODE;
835
836         result = gtkaspell_set_sug_mode(gtkaspell, mode);
837
838         if(!result) {
839                 debug_print("Aspell: error while changing suggestion mode:%s\n",
840                             gtkaspellcheckers->error_message);
841                 gtkaspell_checkers_reset_error();
842         }
843 }
844   
845 /* gtkaspell_set_sug_mode() - Set the suggestion mode */
846 gboolean gtkaspell_set_sug_mode(GtkAspell *gtkaspell, gint themode)
847 {
848         AspellConfig *config;
849
850         g_return_val_if_fail(gtkaspell, FALSE);
851         g_return_val_if_fail(gtkaspell->gtkaspeller, FALSE);
852         g_return_val_if_fail(gtkaspell->gtkaspeller->config, FALSE);
853
854         debug_print("Aspell: setting sug mode of gtkaspeller %0x to %d\n",
855                         (guint) gtkaspell->gtkaspeller, themode);
856
857         config = gtkaspell->gtkaspeller->config;
858
859         switch (themode) {
860                 case ASPELL_FASTMODE: 
861                         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "fast");
862                         break;
863                 case ASPELL_NORMALMODE: 
864                         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "normal");
865                         break;
866                 case ASPELL_BADSPELLERMODE: 
867                         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", 
868                                                             "bad-spellers");
869                         break;
870                 default: 
871                         gtkaspellcheckers->error_message = 
872                                 g_strdup(_("Unknown suggestion mode."));
873                         return FALSE;
874                 }
875
876         gtkaspell->gtkaspeller->sug_mode = themode;
877         gtkaspell->default_sug_mode      = themode;
878
879         return TRUE;
880 }
881
882 /* misspelled_suggest() - Create a suggestion list for  word  */
883 static GList *misspelled_suggest(GtkAspell *gtkaspell, guchar *word) 
884 {
885         const guchar          *newword;
886         GList                 *list = NULL;
887         const AspellWordList  *suggestions;
888         AspellStringEnumeration *elements;
889
890         g_return_val_if_fail(word, NULL);
891
892         if (!aspell_speller_check(gtkaspell->gtkaspeller->checker, word, -1)) {
893                 free_suggestions_list(gtkaspell);
894
895                 suggestions = aspell_speller_suggest(
896                                 gtkaspell->gtkaspeller->checker,
897                                                      (const char *)word, -1);
898                 elements    = aspell_word_list_elements(suggestions);
899                 list        = g_list_append(list, g_strdup(word)); 
900                 
901                 while (newword = aspell_string_enumeration_next(elements))
902                         list = g_list_append(list, g_strdup(newword));
903
904                 gtkaspell->max_sug          = g_list_length(list) - 1;
905                 gtkaspell->suggestions_list = list;
906
907                 return list;
908         }
909
910         free_suggestions_list(gtkaspell);
911
912         return NULL;
913 }
914
915 /* misspelled_test() - Just test if word is correctly spelled */  
916 static int misspelled_test(GtkAspell *gtkaspell, unsigned char *word) 
917 {
918         return aspell_speller_check(gtkaspell->gtkaspeller->checker, word, -1)
919                                     ? 0 : 1;
920 }
921
922
923 static gboolean iswordsep(unsigned char c) 
924 {
925         return !isalpha(c) && c != '\'';
926 }
927
928 static guchar get_text_index_whar(GtkAspell *gtkaspell, int pos) 
929 {
930         GtkTextView *view = gtkaspell->gtktext;
931         GtkTextBuffer *buffer = gtk_text_view_get_buffer(view);
932         GtkTextIter start, end;
933         const gchar *utf8chars;
934         guchar a = '\0';
935
936         gtk_text_buffer_get_iter_at_offset(buffer, &start, pos);
937         gtk_text_buffer_get_iter_at_offset(buffer, &end, pos+1);
938
939         utf8chars = gtk_text_iter_get_text(&start, &end);
940         if (is_ascii_str(utf8chars)) {
941                 a = utf8chars ? utf8chars[0] : '\0' ;
942         } else {
943                 gchar *tr = conv_iconv_strdup(utf8chars, CS_UTF_8, 
944                                 gtkaspell->gtkaspeller->dictionary->encoding);
945                 if (tr) {
946                         a = tr[0];
947                         g_free(tr);
948                 }
949         }
950
951         return a;
952 }
953
954 /* get_word_from_pos () - return the word pointed to. */
955 /* Handles correctly the quotes. */
956 static gboolean get_word_from_pos(GtkAspell *gtkaspell, gint pos, 
957                                   unsigned char* buf, gint buflen,
958                                   gint *pstart, gint *pend) 
959 {
960
961         /* TODO : when correcting a word into quotes, change the color of */
962         /* the quotes too, as may be they were highlighted before. To do  */
963         /* this, we can use two others pointers that points to the whole    */
964         /* word including quotes. */
965
966         gint start;
967         gint end;
968                   
969         guchar c;
970         GtkTextView *gtktext;
971         
972         gtktext = gtkaspell->gtktext;
973         if (iswordsep(get_text_index_whar(gtkaspell, pos))) 
974                 return FALSE;
975         
976         /* The apostrophe character is somtimes used for quotes 
977          * So include it in the word only if it is not surrounded 
978          * by other characters. 
979          */
980          
981         for (start = pos; start >= 0; --start) {
982                 c = get_text_index_whar(gtkaspell, start);
983                 if (c == '\'') {
984                         if (start > 0) {
985                                 if (!isalpha(get_text_index_whar(gtkaspell,
986                                                                  start - 1))) {
987                                         /* start_quote = TRUE; */
988                                         break;
989                                 }
990                         }
991                         else {
992                                 /* start_quote = TRUE; */
993                                 break;
994                         }
995                 }
996                 else if (!isalpha(c))
997                                 break;
998         }
999
1000         start++;
1001
1002         for (end = pos; end < get_textview_buffer_charcount(gtktext); end++) {
1003                 c = get_text_index_whar(gtkaspell, end); 
1004                 if (c == '\'') {
1005                         if (end < get_textview_buffer_charcount(gtktext)) {
1006                                 if (!isalpha(get_text_index_whar(gtkaspell,
1007                                                                  end + 1))) {
1008                                         /* end_quote = TRUE; */
1009                                         break;
1010                                 }
1011                         }
1012                         else {
1013                                 /* end_quote = TRUE; */
1014                                 break;
1015                         }
1016                 }
1017                 else if(!isalpha(c))
1018                                 break;
1019         }
1020                                                 
1021         if (pstart) 
1022                 *pstart = start;
1023         if (pend) 
1024                 *pend = end;
1025
1026         if (buf) {
1027                 if (end - start < buflen) {
1028                         for (pos = start; pos < end; pos++) {
1029                                 buf[pos - start] =
1030                                         get_text_index_whar(gtkaspell, pos);
1031                         }
1032                         buf[pos - start] = 0;
1033                 } else
1034                         return FALSE;
1035         }
1036
1037         return TRUE;
1038 }
1039
1040 static gboolean check_at(GtkAspell *gtkaspell, gint from_pos) 
1041 {
1042         gint          start, end;
1043         unsigned char buf[GTKASPELLWORDSIZE];
1044         GtkTextView     *gtktext;
1045
1046         g_return_val_if_fail(from_pos >= 0, FALSE);
1047     
1048         gtktext = gtkaspell->gtktext;
1049
1050         if (!get_word_from_pos(gtkaspell, from_pos, buf, sizeof(buf), 
1051                                &start, &end))
1052                 return FALSE;
1053
1054         if (misspelled_test(gtkaspell, buf)) {
1055                 strncpy(gtkaspell->theword, buf, GTKASPELLWORDSIZE - 1);
1056                 gtkaspell->theword[GTKASPELLWORDSIZE - 1] = 0;
1057                 gtkaspell->start_pos  = start;
1058                 gtkaspell->end_pos    = end;
1059                 free_suggestions_list(gtkaspell);
1060
1061                 change_color(gtkaspell, start, end, buf, &(gtkaspell->highlight));
1062                 return TRUE;
1063         } else {
1064                 change_color(gtkaspell, start, end, buf, NULL);
1065                 return FALSE;
1066         }
1067 }
1068
1069 static gboolean check_next_prev(GtkAspell *gtkaspell, gboolean forward)
1070 {
1071         gint pos;
1072         gint minpos;
1073         gint maxpos;
1074         gint direc = -1;
1075         gboolean misspelled;
1076         
1077         minpos = 0;
1078         maxpos = gtkaspell->end_check_pos;
1079
1080         if (forward) {
1081                 minpos = -1;
1082                 direc = 1;
1083                 maxpos--;
1084         } 
1085
1086         pos = get_textview_buffer_offset(gtkaspell->gtktext);
1087         gtkaspell->orig_pos = pos;
1088         while (iswordsep(get_text_index_whar(gtkaspell, pos)) &&
1089                pos > minpos && pos <= maxpos)
1090                 pos += direc;
1091         while (!(misspelled = check_at(gtkaspell, pos)) &&
1092                pos > minpos && pos <= maxpos) {
1093
1094                 while (!iswordsep(get_text_index_whar(gtkaspell, pos)) &&
1095                        pos > minpos && pos <= maxpos)
1096                         pos += direc;
1097
1098                 while (iswordsep(get_text_index_whar(gtkaspell, pos)) &&
1099                        pos > minpos && pos <= maxpos)
1100                         pos += direc;
1101         }
1102         if (misspelled) {
1103                 GtkMenu *menu = NULL;
1104                 misspelled_suggest(gtkaspell, gtkaspell->theword);
1105
1106                 if (forward)
1107                         gtkaspell->orig_pos = gtkaspell->end_pos;
1108
1109                 set_textview_buffer_offset(gtkaspell->gtktext,
1110                                 gtkaspell->end_pos);
1111                 /* scroll line to window center */
1112                 gtk_text_view_scroll_to_mark(gtkaspell->gtktext,
1113                         gtk_text_buffer_get_insert(
1114                                 gtk_text_view_get_buffer(gtkaspell->gtktext)),
1115                         0.0, TRUE, 0.0, 0.5);
1116                 /* let textview recalculate coordinates (set_menu_pos) */
1117                 while (gtk_events_pending ())
1118                         gtk_main_iteration ();
1119
1120                 menu = make_sug_menu(gtkaspell);
1121                 gtk_menu_popup(menu, NULL, NULL,
1122                                 set_menu_pos, gtkaspell, 0, GDK_CURRENT_TIME);
1123                 g_signal_connect(G_OBJECT(menu), "deactivate",
1124                                          G_CALLBACK(destroy_menu), 
1125                                          gtkaspell);
1126
1127         } else {
1128                 reset_theword_data(gtkaspell);
1129
1130                 alertpanel_notice(_("No misspelled word found."));
1131                 set_textview_buffer_offset(gtkaspell->gtktext,
1132                                           gtkaspell->orig_pos);
1133         }
1134
1135         return misspelled;
1136 }
1137
1138 void gtkaspell_check_backwards(GtkAspell *gtkaspell)
1139 {
1140         gtkaspell->continue_check = NULL;
1141         gtkaspell->end_check_pos =
1142                 get_textview_buffer_charcount(gtkaspell->gtktext);
1143         check_next_prev(gtkaspell, FALSE);
1144 }
1145
1146 void gtkaspell_check_forwards_go(GtkAspell *gtkaspell)
1147 {
1148
1149         gtkaspell->continue_check = NULL;
1150         gtkaspell->end_check_pos =
1151                 get_textview_buffer_charcount(gtkaspell->gtktext);
1152         check_next_prev(gtkaspell, TRUE);
1153 }
1154
1155 void gtkaspell_check_all(GtkAspell *gtkaspell)
1156 {       
1157         GtkTextView *gtktext;
1158         gint start, end;
1159         GtkTextBuffer *buffer;
1160         GtkTextIter startiter, enditer;
1161
1162         g_return_if_fail(gtkaspell);
1163         g_return_if_fail(gtkaspell->gtktext);
1164
1165         gtktext = gtkaspell->gtktext;
1166         buffer = gtk_text_view_get_buffer(gtktext);
1167         gtk_text_buffer_get_selection_bounds(buffer, &startiter, &enditer);
1168         start = gtk_text_iter_get_offset(&startiter);
1169         end = gtk_text_iter_get_offset(&enditer);
1170
1171         if (start == end) {
1172                 start = 0;
1173                 end = gtk_text_buffer_get_char_count(buffer);
1174         } else if (start > end) {
1175                 gint tmp;
1176
1177                 tmp   = start;
1178                 start = end;
1179                 end   = tmp;
1180         }
1181
1182         set_textview_buffer_offset(gtktext, start);
1183
1184         gtkaspell->continue_check = continue_check;
1185         gtkaspell->end_check_pos  = end;
1186
1187         gtkaspell->misspelled = check_next_prev(gtkaspell, TRUE);
1188 }       
1189
1190 static void continue_check(gpointer *data)
1191 {
1192         GtkAspell *gtkaspell = (GtkAspell *) data;
1193         gint pos = get_textview_buffer_offset(gtkaspell->gtktext);
1194         if (pos < gtkaspell->end_check_pos && gtkaspell->misspelled)
1195                 gtkaspell->misspelled = check_next_prev(gtkaspell, TRUE);
1196         else
1197                 gtkaspell->continue_check = NULL;
1198 }
1199
1200 void gtkaspell_highlight_all(GtkAspell *gtkaspell) 
1201 {
1202         guint     origpos;
1203         guint     pos = 0;
1204         guint     len;
1205         GtkTextView *gtktext;
1206
1207         g_return_if_fail(gtkaspell->gtkaspeller->checker);      
1208
1209         gtktext = gtkaspell->gtktext;
1210
1211         len = get_textview_buffer_charcount(gtktext);
1212
1213         origpos = get_textview_buffer_offset(gtktext);
1214
1215         while (pos < len) {
1216                 while (pos < len &&
1217                        iswordsep(get_text_index_whar(gtkaspell, pos)))
1218                         pos++;
1219                 while (pos < len &&
1220                        !iswordsep(get_text_index_whar(gtkaspell, pos)))
1221                         pos++;
1222                 if (pos > 0)
1223                         check_at(gtkaspell, pos - 1);
1224         }
1225         set_textview_buffer_offset(gtktext, origpos);
1226 }
1227
1228 static void replace_with_supplied_word_cb(GtkWidget *w, GtkAspell *gtkaspell) 
1229 {
1230         unsigned char *newword;
1231         GdkEvent *e= (GdkEvent *) gtk_get_current_event();
1232
1233         newword = gtk_editable_get_chars(GTK_EDITABLE(gtkaspell->replace_entry),
1234                                          0, -1);
1235
1236         if (strcmp(newword, gtkaspell->theword)) {
1237                 replace_real_word(gtkaspell, newword);
1238
1239                 if ((e->type == GDK_KEY_PRESS &&
1240                     ((GdkEventKey *) e)->state & GDK_CONTROL_MASK)) {
1241                         aspell_speller_store_replacement(
1242                                         gtkaspell->gtkaspeller->checker,
1243                                          gtkaspell->theword, -1,
1244                                          newword, -1);
1245                 }
1246                 gtkaspell->replace_entry = NULL;
1247         }
1248
1249         g_free(newword);
1250
1251         if (w && GTK_IS_DIALOG(w)) {
1252                 gtk_widget_destroy(w);
1253         }
1254
1255         set_point_continue(gtkaspell);
1256 }
1257
1258
1259 static void replace_word_cb(GtkWidget *w, gpointer data)
1260 {
1261         unsigned char *newword;
1262         GtkAspell *gtkaspell = (GtkAspell *) data;
1263         GdkEvent *e= (GdkEvent *) gtk_get_current_event();
1264
1265         newword = (unsigned char *) gtk_label_get_text(GTK_LABEL(GTK_BIN(w)->child));
1266         newword = g_strdup(newword);
1267
1268         replace_real_word(gtkaspell, newword);
1269
1270         if ((e->type == GDK_KEY_PRESS && 
1271             ((GdkEventKey *) e)->state & GDK_CONTROL_MASK) ||
1272             (e->type == GDK_BUTTON_RELEASE && 
1273              ((GdkEventButton *) e)->state & GDK_CONTROL_MASK)) {
1274                 aspell_speller_store_replacement(
1275                                 gtkaspell->gtkaspeller->checker,
1276                                                  gtkaspell->theword, -1, 
1277                                                  newword, -1);
1278         }
1279
1280         gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
1281
1282         set_point_continue(gtkaspell);
1283         g_free(newword);
1284 }
1285
1286 static void replace_real_word(GtkAspell *gtkaspell, gchar *newword)
1287 {
1288         int             oldlen, newlen, wordlen;
1289         gint            origpos;
1290         gint            pos;
1291         GtkTextView     *gtktext;
1292         GtkTextBuffer   *textbuf;
1293         GtkTextIter     startiter, enditer;
1294     
1295         if (!newword) return;
1296
1297         gtktext = gtkaspell->gtktext;
1298         textbuf = gtk_text_view_get_buffer(gtktext);
1299
1300         origpos = gtkaspell->orig_pos;
1301         pos     = origpos;
1302         oldlen  = gtkaspell->end_pos - gtkaspell->start_pos;
1303         wordlen = strlen(gtkaspell->theword);
1304
1305         newlen = strlen(newword); /* FIXME: multybyte characters? */
1306
1307         g_signal_handlers_block_by_func(G_OBJECT(gtktext),
1308                                          G_CALLBACK(entry_insert_cb),
1309                                          gtkaspell);
1310         g_signal_handlers_block_by_func(G_OBJECT(gtktext),
1311                                          G_CALLBACK(entry_delete_cb),
1312                                          gtkaspell);
1313
1314         gtk_text_buffer_get_iter_at_offset(textbuf, &startiter,
1315                                            gtkaspell->start_pos);
1316         gtk_text_buffer_get_iter_at_offset(textbuf, &enditer,
1317                                            gtkaspell->end_pos);
1318         g_signal_emit_by_name(G_OBJECT(textbuf), "delete-range",
1319                               &startiter, &enditer, gtkaspell);
1320         g_signal_emit_by_name(G_OBJECT(textbuf), "insert-text",
1321                               &startiter, newword, newlen, gtkaspell);
1322
1323         g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
1324                                            G_CALLBACK(entry_insert_cb),
1325                                            gtkaspell);
1326         g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
1327                                            G_CALLBACK(entry_delete_cb),
1328                                            gtkaspell);
1329
1330         /* Put the point and the position where we clicked with the mouse
1331          * It seems to be a hack, as I must thaw,freeze,thaw the widget
1332          * to let it update correctly the word insertion and then the
1333          * point & position position. If not, SEGV after the first replacement
1334          * If the new word ends before point, put the point at its end.
1335          */
1336
1337         if (origpos - gtkaspell->start_pos < oldlen &&
1338             origpos - gtkaspell->start_pos >= 0) {
1339                 /* Original point was in the word.
1340                  * Let it there unless point is going to be outside of the word
1341                  */
1342                 if (origpos - gtkaspell->start_pos >= newlen) {
1343                         pos = gtkaspell->start_pos + newlen;
1344                 }
1345         }
1346         else if (origpos >= gtkaspell->end_pos) {
1347                 /* move the position according to the change of length */
1348                 pos = origpos + newlen - oldlen;
1349         }
1350
1351         gtkaspell->end_pos = gtkaspell->start_pos + strlen(newword); /* FIXME: multibyte characters? */
1352
1353         if (get_textview_buffer_charcount(gtktext) < pos)
1354                 pos = get_textview_buffer_charcount(gtktext);
1355         gtkaspell->orig_pos = pos;
1356
1357         set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
1358 }
1359
1360 /* Accept this word for this session */
1361 static void add_word_to_session_cb(GtkWidget *w, gpointer data)
1362 {
1363         guint     pos;
1364         GtkTextView *gtktext;
1365         GtkAspell *gtkaspell = (GtkAspell *) data; 
1366         gtktext = gtkaspell->gtktext;
1367
1368         pos = get_textview_buffer_offset(gtktext);
1369
1370         aspell_speller_add_to_session(gtkaspell->gtkaspeller->checker,
1371                                       gtkaspell->theword,
1372                                       strlen(gtkaspell->theword));
1373
1374         check_at(gtkaspell, gtkaspell->start_pos);
1375
1376         gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1377
1378         set_point_continue(gtkaspell);
1379 }
1380
1381 /* add_word_to_personal_cb() - add word to personal dict. */
1382 static void add_word_to_personal_cb(GtkWidget *w, gpointer data)
1383 {
1384         GtkAspell *gtkaspell = (GtkAspell *) data; 
1385
1386         aspell_speller_add_to_personal(gtkaspell->gtkaspeller->checker,
1387                                        gtkaspell->theword,
1388                                        strlen(gtkaspell->theword));
1389
1390         check_at(gtkaspell, gtkaspell->start_pos);
1391
1392         gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1393         set_point_continue(gtkaspell);
1394 }
1395
1396 static void check_with_alternate_cb(GtkWidget *w, gpointer data)
1397 {
1398         GtkAspell *gtkaspell = (GtkAspell *) data;
1399         gint misspelled;
1400
1401         gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1402
1403         use_alternate_dict(gtkaspell);
1404         misspelled = check_at(gtkaspell, gtkaspell->start_pos);
1405
1406         if (!gtkaspell->continue_check) {
1407
1408                 gtkaspell->misspelled = misspelled;
1409
1410                 if (gtkaspell->misspelled) {
1411                         GtkMenu *menu;
1412                         misspelled_suggest(gtkaspell, gtkaspell->theword);
1413
1414                         set_textview_buffer_offset(gtkaspell->gtktext,
1415                                             gtkaspell->end_pos);
1416
1417                         menu = make_sug_menu(gtkaspell);
1418                         gtk_menu_popup(menu, NULL, NULL,
1419                                        set_menu_pos, gtkaspell, 0,
1420                                        GDK_CURRENT_TIME);
1421                         g_signal_connect(G_OBJECT(menu), "deactivate",
1422                                          G_CALLBACK(destroy_menu), 
1423                                          gtkaspell);
1424                         return;
1425                 }
1426         } else
1427                 gtkaspell->orig_pos = gtkaspell->start_pos;
1428
1429         set_point_continue(gtkaspell);
1430 }
1431         
1432 static gboolean replace_key_pressed(GtkWidget *widget,
1433                                    GdkEventKey *event,
1434                                    GtkAspell *gtkaspell)
1435 {
1436         if (event && event->keyval == GDK_Escape) {
1437                 gtk_widget_destroy(widget);
1438                 return TRUE;
1439         } else if (event && event->keyval == GDK_Return) {
1440                 replace_with_supplied_word_cb(widget, gtkaspell);
1441                 return TRUE;
1442         }
1443         return FALSE;
1444 }
1445         
1446 static void replace_with_create_dialog_cb(GtkWidget *w, gpointer data)
1447 {
1448         static PangoFontDescription *font_desc;
1449         GtkWidget *dialog;
1450         GtkWidget *label;
1451         GtkWidget *w_hbox;
1452         GtkWidget *hbox;
1453         GtkWidget *vbox;
1454         GtkWidget *entry;
1455         GtkWidget *ok_button;
1456         GtkWidget *cancel_button;
1457         GtkWidget *confirm_area;
1458         GtkWidget *icon;
1459         gchar *thelabel;
1460         gint xx, yy;
1461         GtkAspell *gtkaspell = (GtkAspell *) data;
1462
1463         gdk_window_get_origin((GTK_WIDGET(w)->parent)->window, &xx, &yy);
1464
1465         gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1466
1467         dialog = gtk_dialog_new();
1468
1469         gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
1470         gtk_window_set_title(GTK_WINDOW(dialog),_("Replace unknown word"));
1471         gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
1472         gtk_widget_set_uposition(dialog, xx, yy);
1473
1474         g_signal_connect_swapped(G_OBJECT(dialog), "destroy",
1475                                  G_CALLBACK(gtk_widget_destroy), 
1476                                  G_OBJECT(dialog));
1477
1478         gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 14);
1479         hbox = gtk_hbox_new (FALSE, 12);
1480         gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1481         gtk_widget_show (hbox);
1482         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
1483                             FALSE, FALSE, 0);
1484
1485         thelabel = g_strdup_printf(_("<span weight=\"bold\" "
1486                                         "size=\"larger\">Replace \"%s\" with: </span>"), 
1487                                    gtkaspell->theword);
1488         /* for title label */
1489         w_hbox = gtk_hbox_new(FALSE, 0);
1490         
1491         icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION,
1492                                         GTK_ICON_SIZE_DIALOG); 
1493         gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0.0);
1494         gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
1495         
1496         vbox = gtk_vbox_new (FALSE, 12);
1497         gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
1498         gtk_widget_show (vbox);
1499         
1500         label = gtk_label_new(thelabel);
1501         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1502         gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
1503         gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
1504         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
1505         gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
1506         if (!font_desc) {
1507                 gint size;
1508
1509                 size = pango_font_description_get_size
1510                         (label->style->font_desc);
1511                 font_desc = pango_font_description_new();
1512                 pango_font_description_set_weight
1513                         (font_desc, PANGO_WEIGHT_BOLD);
1514                 pango_font_description_set_size
1515                         (font_desc, size * PANGO_SCALE_LARGE);
1516         }
1517         if (font_desc)
1518                 gtk_widget_modify_font(label, font_desc);
1519         g_free(thelabel);
1520         
1521         entry = gtk_entry_new();
1522         gtkaspell->replace_entry = entry;
1523         gtk_entry_set_text(GTK_ENTRY(entry), gtkaspell->theword);
1524         gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
1525         g_signal_connect(G_OBJECT(dialog),
1526                         "key_press_event",
1527                         G_CALLBACK(replace_key_pressed), gtkaspell);
1528         gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
1529
1530         label = gtk_label_new(_("Holding down Control key while pressing "
1531                                 "Enter\nwill learn from mistake.\n"));
1532         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1533         gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
1534         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
1535         gtk_widget_show(label);
1536
1537         hbox = gtk_hbox_new(TRUE, 0);
1538
1539         gtkut_stock_button_set_create(&confirm_area,
1540                                       &ok_button, GTK_STOCK_OK,
1541                                       &cancel_button, GTK_STOCK_CANCEL,
1542                                       NULL, NULL);
1543
1544         gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->action_area),
1545                          confirm_area, FALSE, FALSE, 0);
1546         gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5);
1547
1548         g_signal_connect(G_OBJECT(ok_button), "clicked",
1549                          G_CALLBACK(replace_with_supplied_word_cb), 
1550                          gtkaspell);
1551         g_signal_connect_swapped(G_OBJECT(ok_button), "clicked",
1552                                    G_CALLBACK(gtk_widget_destroy), 
1553                                    G_OBJECT(dialog));
1554
1555         g_signal_connect_swapped(G_OBJECT(cancel_button), "clicked",
1556                                  G_CALLBACK(gtk_widget_destroy), 
1557                                  G_OBJECT(dialog));
1558
1559         gtk_widget_grab_focus(entry);
1560
1561         gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
1562
1563         gtk_widget_show_all(dialog);
1564 }
1565
1566 void gtkaspell_uncheck_all(GtkAspell * gtkaspell) 
1567 {
1568         GtkTextView *gtktext;
1569         GtkTextBuffer *buffer;
1570         GtkTextIter startiter, enditer;
1571         
1572         gtktext = gtkaspell->gtktext;
1573
1574         buffer = gtk_text_view_get_buffer(gtktext);
1575         gtk_text_buffer_get_iter_at_offset(buffer, &startiter, 0);
1576         gtk_text_buffer_get_iter_at_offset(buffer, &enditer,
1577                                    get_textview_buffer_charcount(gtktext)-1);
1578         gtk_text_buffer_remove_tag_by_name(buffer, "misspelled",
1579                                            &startiter, &enditer);
1580 }
1581
1582 static void toggle_check_while_typing_cb(GtkWidget *w, gpointer data)
1583 {
1584         GtkAspell *gtkaspell = (GtkAspell *) data;
1585
1586         gtkaspell->check_while_typing = gtkaspell->check_while_typing == FALSE;
1587
1588         if (!gtkaspell->check_while_typing)
1589                 gtkaspell_uncheck_all(gtkaspell);
1590
1591         if (gtkaspell->config_menu)
1592                 populate_submenu(gtkaspell, gtkaspell->config_menu);
1593 }
1594
1595 static GSList *create_empty_dictionary_list(void)
1596 {
1597         GSList *list = NULL;
1598         Dictionary *dict;
1599
1600         dict = g_new0(Dictionary, 1);
1601         dict->fullname = g_strdup(_("None"));
1602         dict->dictname = dict->fullname;
1603         dict->encoding = NULL;
1604
1605         return g_slist_append(list, dict);
1606 }
1607
1608 /* gtkaspell_get_dictionary_list() - returns list of dictionary names */
1609 GSList *gtkaspell_get_dictionary_list(const gchar *aspell_path, gint refresh)
1610 {
1611         GSList *list;
1612         Dictionary *dict;
1613         AspellConfig *config;
1614         AspellDictInfoList *dlist;
1615         AspellDictInfoEnumeration *dels;
1616         const AspellDictInfo *entry;
1617
1618         if (!gtkaspellcheckers)
1619                 gtkaspell_checkers_init();
1620
1621         if (gtkaspellcheckers->dictionary_list && !refresh)
1622                 return gtkaspellcheckers->dictionary_list;
1623         else
1624                 gtkaspell_free_dictionary_list(
1625                                 gtkaspellcheckers->dictionary_list);
1626         list = NULL;
1627
1628         config = new_aspell_config();
1629
1630         aspell_config_replace(config, "dict-dir", aspell_path);
1631         if (aspell_config_error_number(config) != 0) {
1632                 gtkaspellcheckers->error_message = g_strdup(
1633                                 aspell_config_error_message(config));
1634                 gtkaspellcheckers->dictionary_list =
1635                         create_empty_dictionary_list();
1636
1637                 return gtkaspellcheckers->dictionary_list; 
1638         }
1639
1640         dlist = get_aspell_dict_info_list(config);
1641         delete_aspell_config(config);
1642
1643         debug_print("Aspell: checking for dictionaries in %s\n", aspell_path);
1644         dels = aspell_dict_info_list_elements(dlist);
1645         while ( (entry = aspell_dict_info_enumeration_next(dels)) != 0) 
1646         {
1647                 dict = g_new0(Dictionary, 1);
1648                 dict->fullname = g_strdup_printf("%s%s", aspell_path, 
1649                                 entry->name);
1650                 dict->dictname = dict->fullname + strlen(aspell_path);
1651                 dict->encoding = g_strdup(entry->code);
1652                 
1653                 if (g_slist_find_custom(list, dict, 
1654                                 (GCompareFunc) compare_dict) != NULL) {
1655                         dictionary_delete(dict);
1656                         continue;       
1657                 }
1658                 
1659                 debug_print("Aspell: found dictionary %s %s %s\n", dict->fullname,
1660                                 dict->dictname, dict->encoding);
1661                 list = g_slist_insert_sorted(list, dict,
1662                                 (GCompareFunc) compare_dict);
1663         }
1664
1665         delete_aspell_dict_info_enumeration(dels);
1666         
1667         if(list==NULL){
1668                 
1669                 debug_print("Aspell: error when searching for dictionaries: "
1670                               "No dictionary found.\n");
1671                 list = create_empty_dictionary_list();
1672         }
1673
1674         gtkaspellcheckers->dictionary_list = list;
1675
1676         return list;
1677 }
1678
1679 void gtkaspell_free_dictionary_list(GSList *list)
1680 {
1681         Dictionary *dict;
1682         GSList *walk;
1683         for (walk = list; walk != NULL; walk = g_slist_next(walk))
1684                 if (walk->data) {
1685                         dict = (Dictionary *) walk->data;
1686                         dictionary_delete(dict);
1687                 }                               
1688         g_slist_free(list);
1689 }
1690
1691 GtkWidget *gtkaspell_dictionary_option_menu_new(const gchar *aspell_path)
1692 {
1693         GSList *dict_list, *tmp;
1694         GtkWidget *item;
1695         GtkWidget *menu;
1696         Dictionary *dict;
1697
1698         dict_list = gtkaspell_get_dictionary_list(aspell_path, TRUE);
1699         g_return_val_if_fail(dict_list, NULL);
1700
1701         menu = gtk_menu_new();
1702         
1703         for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
1704                 dict = (Dictionary *) tmp->data;
1705                 item = gtk_menu_item_new_with_label(dict->dictname);
1706                 g_object_set_data(G_OBJECT(item), "dict_name",
1707                                   dict->fullname); 
1708                                          
1709                 gtk_menu_append(GTK_MENU(menu), item);                                   
1710                 gtk_widget_show(item);
1711         }
1712
1713         gtk_widget_show(menu);
1714
1715         return menu;
1716 }
1717
1718 gchar *gtkaspell_get_dictionary_menu_active_item(GtkWidget *menu)
1719 {
1720         GtkWidget *menuitem;
1721         gchar *dict_fullname;
1722         gchar *label;
1723
1724         g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
1725
1726         menuitem = gtk_menu_get_active(GTK_MENU(menu));
1727         dict_fullname = (gchar *) g_object_get_data(G_OBJECT(menuitem), 
1728                                                     "dict_name");
1729         g_return_val_if_fail(dict_fullname, NULL);
1730
1731         label = g_strdup(dict_fullname);
1732
1733         return label;
1734   
1735 }
1736
1737 gint gtkaspell_set_dictionary_menu_active_item(GtkWidget *menu,
1738                                                const gchar *dictionary)
1739 {
1740         GList *cur;
1741         gint n;
1742
1743         g_return_val_if_fail(menu != NULL, 0);
1744         g_return_val_if_fail(dictionary != NULL, 0);
1745         g_return_val_if_fail(GTK_IS_OPTION_MENU(menu), 0);
1746
1747         n = 0;
1748         for (cur = GTK_MENU_SHELL(gtk_option_menu_get_menu(
1749                                         GTK_OPTION_MENU(menu)))->children;
1750              cur != NULL; cur = cur->next) {
1751                 GtkWidget *menuitem;
1752                 gchar *dict_name;
1753
1754                 menuitem = GTK_WIDGET(cur->data);
1755                 dict_name = g_object_get_data(G_OBJECT(menuitem), 
1756                                               "dict_name");
1757                 if ((dict_name != NULL) && !strcmp2(dict_name, dictionary)) {
1758                         gtk_option_menu_set_history(GTK_OPTION_MENU(menu), n);
1759
1760                         return 1;
1761                 }
1762                 n++;
1763         }
1764
1765         return 0;
1766 }
1767
1768 GtkWidget *gtkaspell_sugmode_option_menu_new(gint sugmode)
1769 {
1770         GtkWidget *menu;
1771         GtkWidget *item;
1772
1773         menu = gtk_menu_new();
1774         gtk_widget_show(menu);
1775
1776         item = gtk_menu_item_new_with_label(_("Fast Mode"));
1777         gtk_widget_show(item);
1778         gtk_menu_append(GTK_MENU(menu), item);
1779         g_object_set_data(G_OBJECT(item), "sugmode",
1780                           GINT_TO_POINTER(ASPELL_FASTMODE));
1781
1782         item = gtk_menu_item_new_with_label(_("Normal Mode"));
1783         gtk_widget_show(item);
1784         gtk_menu_append(GTK_MENU(menu), item);
1785         g_object_set_data(G_OBJECT(item), "sugmode",
1786                           GINT_TO_POINTER(ASPELL_NORMALMODE));
1787         
1788         item = gtk_menu_item_new_with_label(_("Bad Spellers Mode"));
1789         gtk_widget_show(item);
1790         gtk_menu_append(GTK_MENU(menu), item);
1791         g_object_set_data(G_OBJECT(item), "sugmode",
1792                           GINT_TO_POINTER(ASPELL_BADSPELLERMODE));
1793
1794         return menu;
1795 }
1796         
1797 void gtkaspell_sugmode_option_menu_set(GtkOptionMenu *optmenu, gint sugmode)
1798 {
1799         g_return_if_fail(GTK_IS_OPTION_MENU(optmenu));
1800
1801         g_return_if_fail(sugmode == ASPELL_FASTMODE ||
1802                          sugmode == ASPELL_NORMALMODE ||
1803                          sugmode == ASPELL_BADSPELLERMODE);
1804
1805         gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), sugmode - 1);
1806 }
1807
1808 gint gtkaspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu)
1809 {
1810         gint sugmode;
1811         GtkWidget *item;
1812         
1813         g_return_val_if_fail(GTK_IS_OPTION_MENU(optmenu), -1);
1814
1815         item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
1816         
1817         sugmode = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item),
1818                                                     "sugmode"));
1819
1820         return sugmode;
1821 }
1822
1823 static void use_alternate_dict(GtkAspell *gtkaspell)
1824 {
1825         GtkAspeller *tmp;
1826
1827         tmp = gtkaspell->gtkaspeller;
1828         gtkaspell->gtkaspeller = gtkaspell->alternate_speller;
1829         gtkaspell->alternate_speller = tmp;
1830
1831         if (gtkaspell->config_menu)
1832                 populate_submenu(gtkaspell, gtkaspell->config_menu);
1833 }
1834
1835 static void destroy_menu(GtkWidget *widget,
1836                              gpointer user_data) {
1837
1838         GtkAspell *gtkaspell = (GtkAspell *)user_data;
1839
1840         if (gtkaspell->accel_group) {
1841                 gtk_window_remove_accel_group(GTK_WINDOW(gtkaspell->parent_window), 
1842                                 gtkaspell->accel_group);
1843                 gtkaspell->accel_group = NULL;
1844         }
1845 }
1846
1847 static void popup_menu(GtkAspell *gtkaspell, GdkEventButton *eb) 
1848 {
1849         GtkTextView * gtktext;
1850         GtkMenu *menu = NULL;
1851         
1852         gtktext = gtkaspell->gtktext;
1853
1854         gtkaspell->orig_pos = get_textview_buffer_offset(gtktext);
1855
1856         if (!(eb->state & GDK_SHIFT_MASK)) {
1857                 if (check_at(gtkaspell, gtkaspell->orig_pos)) {
1858
1859                         set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
1860
1861                         if (misspelled_suggest(gtkaspell, gtkaspell->theword)) {
1862                                 menu = make_sug_menu(gtkaspell);
1863                                 gtk_menu_popup(menu,
1864                                                NULL, NULL, NULL, NULL,
1865                                                eb->button, eb->time);
1866
1867                                 g_signal_connect(G_OBJECT(menu), "deactivate",
1868                                                          G_CALLBACK(destroy_menu), 
1869                                                          gtkaspell);
1870                                 return;
1871                         }
1872                 } else
1873                         set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
1874         }
1875         menu = make_config_menu(gtkaspell);
1876         gtk_menu_popup(menu, NULL, NULL, NULL, NULL,
1877                        eb->button, eb->time);
1878
1879         g_signal_connect(G_OBJECT(menu), "deactivate",
1880                                  G_CALLBACK(destroy_menu), 
1881                                  gtkaspell);
1882 }
1883
1884 static gboolean aspell_key_pressed(GtkWidget *widget,
1885                                    GdkEventKey *event,
1886                                    GtkAspell *gtkaspell)
1887 {
1888         if (event && (isascii(event->keyval) || event->keyval == GDK_Return)) {
1889                 gtk_accel_groups_activate(
1890                                 G_OBJECT(gtkaspell->parent_window),
1891                                 event->keyval, event->state);
1892         } else if (event && event->keyval == GDK_Escape) {
1893                 destroy_menu(NULL, gtkaspell);
1894         }
1895         return FALSE;
1896 }
1897
1898 /* make_sug_menu() - Add menus to accept this word for this session 
1899  * and to add it to personal dictionary 
1900  */
1901 static GtkMenu *make_sug_menu(GtkAspell *gtkaspell) 
1902 {
1903         GtkWidget       *menu, *item;
1904         unsigned char   *caption;
1905         GtkTextView     *gtktext;
1906         GtkAccelGroup   *accel;
1907         GList           *l = gtkaspell->suggestions_list;
1908         gchar           *utf8buf;
1909
1910         gtktext = gtkaspell->gtktext;
1911
1912         accel = gtk_accel_group_new();
1913         menu = gtk_menu_new(); 
1914
1915         if (gtkaspell->sug_menu)
1916                 gtk_widget_destroy(gtkaspell->sug_menu);
1917
1918         if (gtkaspell->accel_group) {
1919                 gtk_window_remove_accel_group(GTK_WINDOW(gtkaspell->parent_window), 
1920                                 gtkaspell->accel_group);
1921                 gtkaspell->accel_group = NULL;
1922         }
1923
1924         gtkaspell->sug_menu = menu;     
1925
1926         g_signal_connect(G_OBJECT(menu), "cancel",
1927                          G_CALLBACK(cancel_menu_cb), gtkaspell);
1928
1929         utf8buf  = conv_codeset_strdup((unsigned char*)l->data,
1930                                 conv_get_locale_charset_str(),
1931                                 CS_UTF_8);
1932         caption = g_strdup_printf(_("\"%s\" unknown in %s"), 
1933                                   utf8buf, 
1934                                   gtkaspell->gtkaspeller->dictionary->dictname);
1935         item = gtk_menu_item_new_with_label(caption);
1936         g_free(utf8buf);
1937         gtk_widget_show(item);
1938         gtk_menu_append(GTK_MENU(menu), item);
1939         gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
1940         g_free(caption);
1941
1942         item = gtk_menu_item_new();
1943         gtk_widget_show(item);
1944         gtk_menu_append(GTK_MENU(menu), item);
1945
1946         item = gtk_menu_item_new_with_label(_("Accept in this session"));
1947         gtk_widget_show(item);
1948         gtk_menu_append(GTK_MENU(menu), item);
1949         g_signal_connect(G_OBJECT(item), "activate",
1950                          G_CALLBACK(add_word_to_session_cb), 
1951                          gtkaspell);
1952         gtk_widget_add_accelerator(item, "activate", accel, GDK_space,
1953                                    GDK_CONTROL_MASK,
1954                                    GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1955
1956         item = gtk_menu_item_new_with_label(_("Add to personal dictionary"));
1957         gtk_widget_show(item);
1958         gtk_menu_append(GTK_MENU(menu), item);
1959         g_signal_connect(G_OBJECT(item), "activate",
1960                          G_CALLBACK(add_word_to_personal_cb), 
1961                          gtkaspell);
1962         gtk_widget_add_accelerator(item, "activate", accel, GDK_Return,
1963                                    GDK_CONTROL_MASK,
1964                                    GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1965
1966         item = gtk_menu_item_new_with_label(_("Replace with..."));
1967         gtk_widget_show(item);
1968         gtk_menu_append(GTK_MENU(menu), item);
1969         g_signal_connect(G_OBJECT(item), "activate",
1970                          G_CALLBACK(replace_with_create_dialog_cb), 
1971                          gtkaspell);
1972         gtk_widget_add_accelerator(item, "activate", accel, GDK_R, 0,
1973                                    GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1974         gtk_widget_add_accelerator(item, "activate", accel, GDK_R, 
1975                                    GDK_CONTROL_MASK,
1976                                    GTK_ACCEL_LOCKED);
1977
1978         if (gtkaspell->use_alternate && gtkaspell->alternate_speller) {
1979                 caption = g_strdup_printf(_("Check with %s"), 
1980                         gtkaspell->alternate_speller->dictionary->dictname);
1981                 item = gtk_menu_item_new_with_label(caption);
1982                 g_free(caption);
1983                 gtk_widget_show(item);
1984                 gtk_menu_append(GTK_MENU(menu), item);
1985                 g_signal_connect(G_OBJECT(item), "activate",
1986                                  G_CALLBACK(check_with_alternate_cb),
1987                                  gtkaspell);
1988                 gtk_widget_add_accelerator(item, "activate", accel, GDK_X, 0,
1989                                            GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1990                 gtk_widget_add_accelerator(item, "activate", accel, GDK_X, 
1991                                            GDK_CONTROL_MASK,
1992                                            GTK_ACCEL_LOCKED);
1993         }
1994
1995         item = gtk_menu_item_new();
1996         gtk_widget_show(item);
1997         gtk_menu_append(GTK_MENU(menu), item);
1998
1999         l = l->next;
2000         if (l == NULL) {
2001                 item = gtk_menu_item_new_with_label(_("(no suggestions)"));
2002                 gtk_widget_show(item);
2003                 gtk_menu_append(GTK_MENU(menu), item);
2004         } else {
2005                 GtkWidget *curmenu = menu;
2006                 gint count = 0;
2007                 
2008                 do {
2009                         if (count == MENUCOUNT) {
2010                                 count -= MENUCOUNT;
2011
2012                                 item = gtk_menu_item_new_with_label(_("More..."));
2013                                 gtk_widget_show(item);
2014                                 gtk_menu_append(GTK_MENU(curmenu), item);
2015
2016                                 curmenu = gtk_menu_new();
2017                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
2018                                                           curmenu);
2019                         }
2020
2021                         utf8buf  = conv_codeset_strdup((unsigned char*)l->data,
2022                                                         conv_get_locale_charset_str(),
2023                                                         CS_UTF_8);
2024                         item = gtk_menu_item_new_with_label(utf8buf);
2025                         g_free(utf8buf);
2026                         gtk_widget_show(item);
2027                         gtk_menu_append(GTK_MENU(curmenu), item);
2028                         g_signal_connect(G_OBJECT(item), "activate",
2029                                          G_CALLBACK(replace_word_cb),
2030                                          gtkaspell);
2031
2032                         if (curmenu == menu && count < MENUCOUNT) {
2033                                 gtk_widget_add_accelerator(item, "activate",
2034                                                            accel,
2035                                                            GDK_A + count, 0,
2036                                                            GTK_ACCEL_LOCKED | 
2037                                                            GTK_ACCEL_VISIBLE);
2038                                 gtk_widget_add_accelerator(item, "activate", 
2039                                                            accel,
2040                                                            GDK_A + count, 
2041                                                            GDK_CONTROL_MASK,
2042                                                            GTK_ACCEL_LOCKED);
2043                                 }
2044
2045                         count++;
2046
2047                 } while ((l = l->next) != NULL);
2048         }
2049
2050         gtk_window_add_accel_group
2051                 (GTK_WINDOW(gtkaspell->parent_window),
2052                  accel);
2053         gtkaspell->accel_group = accel;
2054
2055         g_signal_connect(G_OBJECT(menu),
2056                         "key_press_event",
2057                         G_CALLBACK(aspell_key_pressed), gtkaspell);
2058         
2059         return GTK_MENU(menu);
2060 }
2061
2062 static void populate_submenu(GtkAspell *gtkaspell, GtkWidget *menu)
2063 {
2064         GtkWidget *item, *submenu;
2065         gchar *dictname;
2066         GtkAspeller *gtkaspeller = gtkaspell->gtkaspeller;
2067
2068         if (GTK_MENU_SHELL(menu)->children) {
2069                 GList *amenu, *alist;
2070                 for (amenu = (GTK_MENU_SHELL(menu)->children); amenu; ) {
2071                         alist = amenu->next;
2072                         gtk_widget_destroy(GTK_WIDGET(amenu->data));
2073                         amenu = alist;
2074                 }
2075         }
2076         
2077         dictname = g_strdup_printf(_("Dictionary: %s"),
2078                                    gtkaspeller->dictionary->dictname);
2079         item = gtk_menu_item_new_with_label(dictname);
2080         gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
2081         g_free(dictname);
2082         gtk_widget_show(item);
2083         gtk_menu_append(GTK_MENU(menu), item);
2084
2085         item = gtk_menu_item_new();
2086         gtk_widget_show(item);
2087         gtk_menu_append(GTK_MENU(menu), item);
2088                 
2089         if (gtkaspell->use_alternate && gtkaspell->alternate_speller) {
2090                 dictname = g_strdup_printf(_("Use alternate (%s)"), 
2091                                 gtkaspell->alternate_speller->dictionary->dictname);
2092                 item = gtk_menu_item_new_with_label(dictname);
2093                 g_free(dictname);
2094                 g_signal_connect(G_OBJECT(item), "activate",
2095                                  G_CALLBACK(switch_to_alternate_cb),
2096                                  gtkaspell);
2097                 gtk_widget_show(item);
2098                 gtk_menu_append(GTK_MENU(menu), item);
2099         }
2100
2101         item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
2102         if (gtkaspell->gtkaspeller->sug_mode == ASPELL_FASTMODE) {
2103                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
2104                 gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
2105         } else
2106                 g_signal_connect(G_OBJECT(item), "activate",
2107                                  G_CALLBACK(set_sug_mode_cb),
2108                                  gtkaspell);
2109         gtk_widget_show(item);
2110         gtk_menu_append(GTK_MENU(menu), item);
2111
2112         item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
2113         if (gtkaspell->gtkaspeller->sug_mode == ASPELL_NORMALMODE) {
2114                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
2115                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
2116         } else
2117                 g_signal_connect(G_OBJECT(item), "activate",
2118                                  G_CALLBACK(set_sug_mode_cb),
2119                                  gtkaspell);
2120         gtk_widget_show(item);
2121         gtk_menu_append(GTK_MENU(menu),item);
2122
2123         item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
2124         if (gtkaspell->gtkaspeller->sug_mode == ASPELL_BADSPELLERMODE) {
2125                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
2126                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
2127         } else
2128                 g_signal_connect(G_OBJECT(item), "activate",
2129                                  G_CALLBACK(set_sug_mode_cb),
2130                                  gtkaspell);
2131         gtk_widget_show(item);
2132         gtk_menu_append(GTK_MENU(menu), item);
2133         
2134         item = gtk_menu_item_new();
2135         gtk_widget_show(item);
2136         gtk_menu_append(GTK_MENU(menu), item);
2137         
2138         item = gtk_check_menu_item_new_with_label(_("Check while typing"));
2139         if (gtkaspell->check_while_typing)
2140                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
2141         else    
2142                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
2143         g_signal_connect(G_OBJECT(item), "activate",
2144                          G_CALLBACK(toggle_check_while_typing_cb),
2145                          gtkaspell);
2146         gtk_widget_show(item);
2147         gtk_menu_append(GTK_MENU(menu), item);
2148
2149         item = gtk_menu_item_new();
2150         gtk_widget_show(item);
2151         gtk_menu_append(GTK_MENU(menu), item);
2152
2153         submenu = gtk_menu_new();
2154         item = gtk_menu_item_new_with_label(_("Change dictionary"));
2155         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
2156         gtk_widget_show(item);
2157         gtk_menu_append(GTK_MENU(menu), item);
2158
2159         /* Dict list */
2160         if (gtkaspellcheckers->dictionary_list == NULL)
2161                 gtkaspell_get_dictionary_list(gtkaspell->dictionary_path, FALSE);
2162         {
2163                 GtkWidget * curmenu = submenu;
2164                 int count = 0;
2165                 Dictionary *dict;
2166                 GSList *tmp;
2167                 tmp = gtkaspellcheckers->dictionary_list;
2168                 
2169                 for (tmp = gtkaspellcheckers->dictionary_list; tmp != NULL; 
2170                                 tmp = g_slist_next(tmp)) {
2171                         if (count == MENUCOUNT) {
2172                                 GtkWidget *newmenu;
2173                                 
2174                                 newmenu = gtk_menu_new();
2175                                 item = gtk_menu_item_new_with_label(_("More..."));
2176                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), 
2177                                                           newmenu);
2178                                 
2179                                 gtk_menu_append(GTK_MENU(curmenu), item);
2180                                 gtk_widget_show(item);
2181                                 curmenu = newmenu;
2182                                 count = 0;
2183                         }
2184                         dict = (Dictionary *) tmp->data;
2185                         item = gtk_check_menu_item_new_with_label(dict->dictname);
2186                         g_object_set_data(G_OBJECT(item), "dict_name",
2187                                           dict->fullname); 
2188                         if (strcmp2(dict->fullname,
2189                             gtkaspell->gtkaspeller->dictionary->fullname))
2190                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
2191                         else {
2192                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
2193                                 gtk_widget_set_sensitive(GTK_WIDGET(item),
2194                                                          FALSE);
2195                         }
2196                         g_signal_connect(G_OBJECT(item), "activate",
2197                                          G_CALLBACK(change_dict_cb),
2198                                          gtkaspell);
2199                         gtk_widget_show(item);
2200                         gtk_menu_append(GTK_MENU(curmenu), item);
2201                         
2202                         count++;
2203                 }
2204         }  
2205 }
2206
2207 static GtkMenu *make_config_menu(GtkAspell *gtkaspell)
2208 {
2209         if (!gtkaspell->popup_config_menu)
2210                 gtkaspell->popup_config_menu = gtk_menu_new();
2211
2212         debug_print("Aspell: creating/using popup_config_menu %0x\n", 
2213                         (guint) gtkaspell->popup_config_menu);
2214         populate_submenu(gtkaspell, gtkaspell->popup_config_menu);
2215
2216         return GTK_MENU(gtkaspell->popup_config_menu);
2217 }
2218
2219 void gtkaspell_populate_submenu(GtkAspell *gtkaspell, GtkWidget *menuitem)
2220 {
2221         GtkWidget *menu;
2222
2223         menu = GTK_WIDGET(GTK_MENU_ITEM(menuitem)->submenu);
2224         
2225         debug_print("Aspell: using config menu %0x\n", 
2226                         (guint) gtkaspell->popup_config_menu);
2227         populate_submenu(gtkaspell, menu);
2228         
2229         gtkaspell->config_menu = menu;
2230         
2231 }
2232
2233 static void set_menu_pos(GtkMenu *menu, gint *x, gint *y, 
2234                          gboolean *push_in, gpointer data)
2235 {
2236         GtkAspell       *gtkaspell = (GtkAspell *) data;
2237         gint             xx = 0, yy = 0;
2238         gint             sx,     sy;
2239         gint             wx,     wy;
2240         GtkTextView     *text = GTK_TEXT_VIEW(gtkaspell->gtktext);
2241         GtkTextBuffer   *textbuf;
2242         GtkTextIter      iter;
2243         GdkRectangle     rect;
2244         GtkRequisition   r;
2245
2246         textbuf = gtk_text_view_get_buffer(gtkaspell->gtktext);
2247         gtk_text_buffer_get_iter_at_mark(textbuf, &iter,
2248                                          gtk_text_buffer_get_insert(textbuf));
2249         gtk_text_view_get_iter_location(gtkaspell->gtktext, &iter, &rect);
2250         gtk_text_view_buffer_to_window_coords(text, GTK_TEXT_WINDOW_TEXT,
2251                                               rect.x, rect.y, 
2252                                               &rect.x, &rect.y);
2253
2254         gdk_window_get_origin(GTK_WIDGET(gtkaspell->gtktext)->window, &xx, &yy);
2255
2256         sx = gdk_screen_width();
2257         sy = gdk_screen_height();
2258
2259         gtk_widget_get_child_requisition(GTK_WIDGET(menu), &r);
2260
2261         wx =  r.width;
2262         wy =  r.height;
2263
2264         *x = rect.x + xx +
2265              gdk_char_width(gtk_style_get_font(GTK_WIDGET(text)->style), ' ');
2266
2267         *y = rect.y + rect.height + yy;
2268
2269         if (*x + wx > sx)
2270                 *x = sx - wx;
2271         if (*y + wy > sy)
2272                 *y = *y - wy -
2273                      gdk_string_height(gtk_style_get_font(
2274                                                 GTK_WIDGET(text)->style),
2275                                        gtkaspell->theword);
2276 }
2277
2278 /* Menu call backs */
2279
2280 static gboolean cancel_menu_cb(GtkMenuShell *w, gpointer data)
2281 {
2282         GtkAspell *gtkaspell = (GtkAspell *) data;
2283
2284         gtkaspell->continue_check = NULL;
2285         set_point_continue(gtkaspell);
2286
2287         return FALSE;
2288 }
2289
2290 gboolean gtkaspell_change_dict(GtkAspell *gtkaspell, const gchar *dictionary)
2291 {
2292         Dictionary      *dict;       
2293         GtkAspeller     *gtkaspeller;
2294         gint             sug_mode;
2295
2296         g_return_val_if_fail(gtkaspell, FALSE);
2297         g_return_val_if_fail(dictionary, FALSE);
2298   
2299         sug_mode  = gtkaspell->default_sug_mode;
2300
2301         dict = g_new0(Dictionary, 1);
2302         dict->fullname = g_strdup(dictionary);
2303         dict->encoding = g_strdup(gtkaspell->gtkaspeller->dictionary->encoding);
2304
2305         if (gtkaspell->use_alternate && gtkaspell->alternate_speller &&
2306             dict == gtkaspell->alternate_speller->dictionary) {
2307                 use_alternate_dict(gtkaspell);
2308                 dictionary_delete(dict);
2309                 gtkaspell->alternate_speller->dictionary = NULL;
2310                 return TRUE;
2311         }
2312         
2313         gtkaspeller = gtkaspeller_new(dict);
2314
2315         if (!gtkaspeller) {
2316                 gchar *message;
2317                 message = g_strdup_printf(_("The spell checker could not change dictionary.\n%s"), 
2318                                           gtkaspellcheckers->error_message);
2319
2320                 alertpanel_warning(message); 
2321                 g_free(message);
2322         } else {
2323                 if (gtkaspell->use_alternate) {
2324                         if (gtkaspell->alternate_speller)
2325                                 gtkaspeller_delete(gtkaspell->alternate_speller);
2326                         gtkaspell->alternate_speller = gtkaspell->gtkaspeller;
2327                 } else
2328                         gtkaspeller_delete(gtkaspell->gtkaspeller);
2329
2330                 gtkaspell->gtkaspeller = gtkaspeller;
2331                 gtkaspell_set_sug_mode(gtkaspell, sug_mode);
2332         }
2333         
2334         dictionary_delete(dict);
2335
2336         if (gtkaspell->config_menu)
2337                 populate_submenu(gtkaspell, gtkaspell->config_menu);
2338
2339         return TRUE;    
2340 }
2341
2342 /* change_dict_cb() - Menu callback : change dict */
2343 static void change_dict_cb(GtkWidget *w, GtkAspell *gtkaspell)
2344 {
2345         gchar           *fullname;
2346   
2347         fullname = (gchar *) g_object_get_data(G_OBJECT(w), "dict_name");
2348         
2349         if (!strcmp2(fullname, _("None")))
2350                 return;
2351
2352         gtkaspell_change_dict(gtkaspell, fullname);
2353 }
2354
2355 static void switch_to_alternate_cb(GtkWidget *w,
2356                                    gpointer data)
2357 {
2358         GtkAspell *gtkaspell = (GtkAspell *) data;
2359         use_alternate_dict(gtkaspell);
2360 }
2361
2362 /* Misc. helper functions */
2363
2364 static void set_point_continue(GtkAspell *gtkaspell)
2365 {
2366         GtkTextView  *gtktext;
2367
2368         gtktext = gtkaspell->gtktext;
2369
2370         set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
2371
2372         if (gtkaspell->continue_check)
2373                 gtkaspell->continue_check((gpointer *) gtkaspell);
2374 }
2375
2376 static void allocate_color(GtkAspell *gtkaspell, gint rgbvalue)
2377 {
2378         GtkTextBuffer *buffer = gtk_text_view_get_buffer(gtkaspell->gtktext);
2379         GdkColor *color = &(gtkaspell->highlight);
2380
2381         /* Shameless copy from Sylpheed's gtkutils.c */
2382         color->pixel = 0L;
2383         color->red   = (int) (((gdouble)((rgbvalue & 0xff0000) >> 16) / 255.0)
2384                         * 65535.0);
2385         color->green = (int) (((gdouble)((rgbvalue & 0x00ff00) >>  8) / 255.0)
2386                         * 65535.0);
2387         color->blue  = (int) (((gdouble) (rgbvalue & 0x0000ff)        / 255.0)
2388                         * 65535.0);
2389
2390         gtk_text_buffer_create_tag(buffer, "misspelled",
2391                                    "foreground-gdk", color, NULL);
2392 }
2393
2394 static void change_color(GtkAspell * gtkaspell, 
2395                          gint start, gint end,
2396                          gchar *newtext,
2397                          GdkColor *color) 
2398 {
2399         GtkTextView *gtktext;
2400         GtkTextBuffer *buffer;
2401         GtkTextIter startiter, enditer;
2402
2403         g_return_if_fail(start < end);
2404     
2405         gtktext = gtkaspell->gtktext;
2406     
2407         buffer = gtk_text_view_get_buffer(gtktext);
2408         gtk_text_buffer_get_iter_at_offset(buffer, &startiter, start);
2409         gtk_text_buffer_get_iter_at_offset(buffer, &enditer, end);
2410         if (color)
2411                 gtk_text_buffer_apply_tag_by_name(buffer, "misspelled",
2412                                                   &startiter, &enditer);
2413         else
2414                 gtk_text_buffer_remove_tag_by_name(buffer, "misspelled",
2415                                                    &startiter, &enditer);
2416 }
2417
2418 /* convert_to_aspell_encoding () - converts ISO-8859-* strings to iso8859-* 
2419  * as needed by aspell. Returns an allocated string.
2420  */
2421
2422 static guchar *convert_to_aspell_encoding (const guchar *encoding)
2423 {
2424         guchar * aspell_encoding;
2425
2426         if (strstr2(encoding, "ISO-8859-")) {
2427                 aspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
2428         }
2429         else {
2430                 if (!strcmp2(encoding, "US-ASCII"))
2431                         aspell_encoding = g_strdup("iso8859-1");
2432                 else
2433                         aspell_encoding = g_strdup(encoding);
2434         }
2435
2436         return aspell_encoding;
2437 }
2438
2439 /* compare_dict () - compare 2 dict names */
2440 static gint compare_dict(Dictionary *a, Dictionary *b)
2441 {
2442         guint   aparts = 0,  bparts = 0;
2443         guint   i;
2444
2445         for (i=0; i < strlen(a->dictname); i++)
2446                 if (a->dictname[i] == '-')
2447                         aparts++;
2448         for (i=0; i < strlen(b->dictname); i++)
2449                 if (b->dictname[i] == '-')
2450                         bparts++;
2451
2452         if (aparts != bparts) 
2453                 return (aparts < bparts) ? -1 : +1;
2454         else {
2455                 gint compare;
2456                 compare = strcmp2(a->dictname, b->dictname);
2457                 if (!compare)
2458                         compare = strcmp2(a->fullname, b->fullname);
2459                 return compare;
2460         }
2461 }
2462
2463 static void dictionary_delete(Dictionary *dict)
2464 {
2465         g_free(dict->fullname);
2466         g_free(dict->encoding);
2467         g_free(dict);
2468 }
2469
2470 static Dictionary *dictionary_dup(const Dictionary *dict)
2471 {
2472         Dictionary *dict2;
2473
2474         dict2 = g_new(Dictionary, 1); 
2475
2476         dict2->fullname = g_strdup(dict->fullname);
2477         dict2->dictname = dict->dictname - dict->fullname + dict2->fullname;
2478         dict2->encoding = g_strdup(dict->encoding);
2479
2480         return dict2;
2481 }
2482
2483 static void free_suggestions_list(GtkAspell *gtkaspell)
2484 {
2485         GList *list;
2486
2487         for (list = gtkaspell->suggestions_list; list != NULL;
2488              list = list->next)
2489                 g_free(list->data);
2490
2491         g_list_free(gtkaspell->suggestions_list);
2492         
2493         gtkaspell->max_sug          = -1;
2494         gtkaspell->suggestions_list = NULL;
2495 }
2496
2497 static void reset_theword_data(GtkAspell *gtkaspell)
2498 {
2499         gtkaspell->start_pos     =  0;
2500         gtkaspell->end_pos       =  0;
2501         gtkaspell->theword[0]    =  0;
2502         gtkaspell->max_sug       = -1;
2503
2504         free_suggestions_list(gtkaspell);
2505 }
2506
2507 static void free_checkers(gpointer elt, gpointer data)
2508 {
2509         GtkAspeller *gtkaspeller = elt;
2510
2511         g_return_if_fail(gtkaspeller);
2512
2513         gtkaspeller_real_delete(gtkaspeller);
2514 }
2515
2516 static gint find_gtkaspeller(gconstpointer aa, gconstpointer bb)
2517 {
2518         Dictionary *a = ((GtkAspeller *) aa)->dictionary;
2519         Dictionary *b = ((GtkAspeller *) bb)->dictionary;
2520
2521         if (a && b && a->fullname && b->fullname  &&
2522             strcmp(a->fullname, b->fullname) == 0 &&
2523             a->encoding && b->encoding)
2524                 return strcmp(a->encoding, b->encoding);
2525
2526         return 1;
2527 }
2528 #endif