09e3bff83b0534c81e53769746b8e34c91dd39a7
[claws.git] / src / gtkspell.c
1 /* gtkpspell - a spell-checking addon for GtkText
2  * Copyright (c) 2000 Evan Martin.
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  */
25  
26 #if defined(HAVE_CONFIG_H)
27 #include "config.h"
28 #endif
29
30 #if USE_PSPELL
31 #include "intl.h"
32
33 #include <gtk/gtk.h>
34 #include <gdk/gdk.h>
35 #include <sys/types.h>
36 #include <sys/wait.h>
37 #include <unistd.h>
38 #include <stdio.h>
39 #include <signal.h>
40 #include <ctype.h>
41 #include <string.h>
42 #include <stdlib.h>
43 #include <errno.h>
44 #include <stdio.h>
45 #include <sys/time.h>
46 #include <fcntl.h>
47 #include <time.h>
48 #include <prefs_common.h>
49 #include <utils.h>
50
51 #include <dirent.h>
52
53 #include <gtk/gtkoptionmenu.h>
54 #include <gtk/gtkmenu.h>
55 #include <gtk/gtkmenuitem.h>
56 #include <gdk/gdkkeysyms.h>
57
58 #include "gtkstext.h"
59
60 #include "gtkspell.h"
61
62 #include <pspell/pspell.h>
63 /* size of the text buffer used in various word-processing routines. */
64 #define BUFSIZE 1024
65
66 /* number of suggestions to display on each menu. */
67 #define MENUCOUNT 15
68
69 /* 'config' must be defined as a 'PspellConfig *' */
70 #define RETURN_FALSE_IF_CONFIG_ERROR() \
71         if (pspell_config_error_number(config) != 0) { \
72                 gtkpspellcheckers->error_message = g_strdup(pspell_config_error_message(config)); \
73                 return FALSE; \
74         }
75
76 #define CONFIG_REPLACE_RETURN_FALSE_IF_FAIL(option, value) { \
77         pspell_config_replace(config, option, value);       \
78         RETURN_FALSE_IF_CONFIG_ERROR();                      \
79         }
80
81 /******************************************************************************/
82
83 GtkPspellCheckers *gtkpspellcheckers;
84
85 /* Error message storage */
86 static void             gtkpspell_checkers_error_message(gchar *message);
87
88 /* Callbacks */
89 static void             entry_insert_cb                 (GtkSText *gtktext, 
90                                                          gchar *newtext, 
91                                                          guint len, 
92                                                          guint *ppos, 
93                                                          GtkPspell *gtkpspell);
94 static void             entry_delete_cb                 (GtkSText *gtktext, 
95                                                          gint start, 
96                                                          gint end,
97                                                          GtkPspell *gtkpspell);
98 static gint             button_press_intercept_cb       (GtkSText *gtktext, 
99                                                          GdkEvent *e, 
100                                                          GtkPspell *gtkpspell);
101
102 /* Checker creation */
103 static GtkPspeller *    gtkpspeller_new                 (Dictionary *dict);
104 static GtkPspeller *    gtkpspeller_real_new            (Dictionary *dict);
105 static GtkPspeller *    gtkpspeller_delete              (GtkPspeller *gtkpspeller);
106 static GtkPspeller *    gtkpspeller_real_delete         (GtkPspeller *gtkpspeller);
107
108 /* Checker configuration */
109 static gint             set_dictionary                  (PspellConfig *config, 
110                                                          Dictionary *dict);
111 static void             set_sug_mode_cb                 (GtkMenuItem *w, 
112                                                          GtkPspell *gtkpspell);
113 static void             set_real_sug_mode               (GtkPspell *gtkpspell, 
114                                                          const char *themode);
115
116 /* Checker actions */
117 static gboolean         check_at                        (GtkPspell *gtkpspell, 
118                                                          int from_pos);
119 static gboolean         check_next_prev                 (GtkPspell *gtkpspell, 
120                                                          gboolean forward);
121 static GList*           misspelled_suggest              (GtkPspell *gtkpspell, 
122                                                          guchar *word);
123 static void             add_word_to_session_cb          (GtkWidget *w, 
124                                                          gpointer data);
125 static void             add_word_to_personal_cb         (GtkWidget *w, 
126                                                          gpointer data);
127 static void             replace_with_create_dialog_cb   (GtkWidget *w,
128                                                          gpointer data);
129 static void             replace_with_supplied_word_cb   (GtkWidget *w, 
130                                                          GtkPspell *gtkpspell);
131 static void             replace_word_cb                 (GtkWidget *w, 
132                                                          gpointer data); 
133 static void             replace_real_word               (GtkPspell *gtkpspell, 
134                                                          gchar *newword);
135 static void             toggle_check_while_typing_cb    (GtkWidget *w, 
136                                                          gpointer data);
137
138 /* Menu creation */
139 static void             popup_menu                      (GtkPspell *gtkpspell, 
140                                                          GdkEventButton *eb);
141 static GtkMenu*         make_sug_menu                   (GtkPspell *gtkpspell);
142 static void             populate_submenu                (GtkPspell *gtkpspell, 
143                                                          GtkWidget *menu);
144 static GtkMenu*         make_config_menu                (GtkPspell *gtkpspell);
145 static void             set_menu_pos                    (GtkMenu *menu, 
146                                                          gint *x, 
147                                                          gint *y, 
148                                                          gpointer data);
149 /* Other menu callbacks */
150 static gboolean         cancel_menu_cb                  (GtkMenuShell *w,
151                                                          gpointer data);
152 static void             change_dict_cb                  (GtkWidget *w, 
153                                                          GtkPspell *gtkpspell);
154
155 /* Misc. helper functions */
156 static void             set_point_continue              (GtkPspell *gtkpspell);
157 static void             continue_check                  (gpointer *gtkpspell);
158 static gboolean         iswordsep                       (unsigned char c);
159 static guchar           get_text_index_whar             (GtkPspell *gtkpspell, 
160                                                          int pos);
161 static gboolean         get_word_from_pos               (GtkPspell *gtkpspell, 
162                                                          gint pos, 
163                                                          unsigned char* buf,
164                                                          gint buflen,
165                                                          gint *pstart, 
166                                                          gint *pend);
167 static void             allocate_color                  (GtkPspell *gtkpspell,
168                                                          gint rgbvalue);
169 static void             change_color                    (GtkPspell *gtkpspell, 
170                                                          gint start, 
171                                                          gint end, 
172                                                          gchar *newtext,
173                                                          GdkColor *color);
174 static guchar*          convert_to_pspell_encoding      (const guchar *encoding);
175 static gint             compare_dict                    (Dictionary *a, 
176                                                          Dictionary *b);
177 static void             dictionary_delete               (Dictionary *dict);
178 static Dictionary *     dictionary_dup                  (const Dictionary *dict);
179 static void             free_suggestions_list           (GtkPspell *gtkpspell);
180 static void             reset_theword_data              (GtkPspell *gtkpspell);
181 static void             free_checkers                   (gpointer elt, 
182                                                          gpointer data);
183 static gint             find_gtkpspeller                (gconstpointer aa, 
184                                                          gconstpointer bb);
185 static void             gtkpspell_alert_dialog          (gchar *message);
186 /* gtkspellconfig - only one config per session */
187 GtkPspellConfig * gtkpspellconfig;
188
189 /******************************************************************************/
190
191 GtkPspellCheckers * gtkpspell_checkers_new()
192 {
193         GtkPspellCheckers *gtkpspellcheckers;
194         
195         gtkpspellcheckers = g_new(GtkPspellCheckers, 1);
196         
197         gtkpspellcheckers->checkers        = NULL;
198
199         gtkpspellcheckers->dictionary_list = NULL;
200
201         gtkpspellcheckers->error_message   = NULL;
202         
203         return gtkpspellcheckers;
204 }
205         
206 GtkPspellCheckers *gtkpspell_checkers_delete()
207 {
208         GSList *checkers;
209         GSList *dict_list;
210
211         if (gtkpspellcheckers == NULL) return NULL;
212
213         if ((checkers  = gtkpspellcheckers->checkers)) {
214                 debug_print(_("Pspell: number of running checkers to delete %d\n"),
215                                 g_slist_length(checkers));
216
217                 g_slist_foreach(checkers, free_checkers, NULL);
218                 g_slist_free(checkers);
219         }
220
221         if ((dict_list = gtkpspellcheckers->dictionary_list)) {
222                 debug_print(_("Pspell: number of dictionaries to delete %d\n"),
223                                 g_slist_length(dict_list));
224
225                 gtkpspell_free_dictionary_list(dict_list);
226                 gtkpspellcheckers->dictionary_list = NULL;
227         }
228
229         g_free(gtkpspellcheckers->error_message);
230
231         return NULL;
232 }
233
234 static void gtkpspell_checkers_error_message (gchar *message)
235 {
236         gchar *tmp;
237         if (gtkpspellcheckers->error_message) {
238                 tmp = g_strdup_printf("%s\n%s", 
239                                       gtkpspellcheckers->error_message, message);
240                 g_free(message);
241                 g_free(gtkpspellcheckers->error_message);
242                 gtkpspellcheckers->error_message = tmp;
243         } else gtkpspellcheckers->error_message = message;
244 }
245
246 void gtkpspell_checkers_reset_error()
247 {
248         g_return_if_fail(gtkpspellcheckers);
249         
250         g_free(gtkpspellcheckers->error_message);
251         
252         gtkpspellcheckers->error_message = NULL;
253 }
254
255 GtkPspell *gtkpspell_new(const gchar *dictionary, 
256                          const gchar *encoding,
257                          gint  misspelled_color,
258                          gboolean check_while_typing,
259                          GtkSText *gtktext)
260 {
261         Dictionary      *dict = g_new0(Dictionary, 1);
262         GtkPspell       *gtkpspell;
263         GtkPspeller     *gtkpspeller;
264
265         g_return_val_if_fail(gtktext, NULL);
266         
267         dict->fullname = g_strdup(dictionary);
268         dict->encoding = g_strdup(encoding);
269         gtkpspeller    = gtkpspeller_new(dict); 
270         dictionary_delete(dict);
271
272         if (!gtkpspeller)
273                 return NULL;
274         
275         gtkpspell = g_new(GtkPspell, 1);
276
277         gtkpspell->gtkpspeller        = gtkpspeller;
278         gtkpspell->theword[0]         = 0x00;
279         gtkpspell->start_pos          = 0;
280         gtkpspell->end_pos            = 0;
281         gtkpspell->orig_pos           = -1;
282         gtkpspell->end_check_pos      = -1;
283         gtkpspell->misspelled         = -1;
284         gtkpspell->check_while_typing = check_while_typing;
285         gtkpspell->continue_check     = NULL;
286         gtkpspell->config_menu        = NULL;
287         gtkpspell->popup_config_menu  = NULL;
288         gtkpspell->sug_menu           = NULL;
289         gtkpspell->replace_entry      = NULL;
290         gtkpspell->gtktext            = gtktext;
291         gtkpspell->default_sug_mode   = PSPELL_FASTMODE;
292         gtkpspell->max_sug            = -1;
293         gtkpspell->suggestions_list   = NULL;
294
295         allocate_color(gtkpspell, misspelled_color);
296
297         gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text",
298                                  GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
299         gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
300                                  GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
301         gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
302                            GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
303         
304         debug_print("Pspell: created gtkpspell %0x\n", gtkpspell);
305
306         return gtkpspell;
307 }
308
309 void gtkpspell_delete(GtkPspell * gtkpspell) 
310 {
311         GtkSText * gtktext;
312         
313         gtktext = gtkpspell->gtktext;
314
315         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
316                                       GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
317         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
318                                       GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
319         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
320                                       GTK_SIGNAL_FUNC(button_press_intercept_cb), 
321                                       gtkpspell);
322
323         gtkpspell_uncheck_all(gtkpspell);
324         
325         gtkpspeller_delete(gtkpspell->gtkpspeller);
326
327         if (gtkpspell->sug_menu)
328                 gtk_widget_destroy(gtkpspell->sug_menu);
329         if (gtkpspell->popup_config_menu)
330                 gtk_widget_destroy(gtkpspell->popup_config_menu);
331         if (gtkpspell->config_menu)
332                 gtk_widget_destroy(gtkpspell->config_menu);
333         if (gtkpspell->suggestions_list)
334                 free_suggestions_list(gtkpspell);
335         
336         debug_print("Pspell: deleting gtkpspell %0x\n", gtkpspell);
337
338         g_free(gtkpspell);
339
340         gtkpspell = NULL;
341 }
342
343 static void entry_insert_cb(GtkSText *gtktext, gchar *newtext, 
344                             guint len, guint *ppos, 
345                             GtkPspell * gtkpspell) 
346 {
347         g_return_if_fail(gtkpspell->gtkpspeller->checker);
348
349         if (!gtkpspell->check_while_typing)
350                 return;
351         
352         /* We must insert ourself the character to impose the */
353         /* color of the inserted character to be default */
354         /* Never mess with set_insertion when frozen */
355         gtk_stext_freeze(gtktext);
356         gtk_stext_backward_delete(GTK_STEXT(gtktext), len);
357         gtk_stext_insert(GTK_STEXT(gtktext), NULL, NULL, NULL, newtext, len);
358         *ppos = gtk_stext_get_point(GTK_STEXT(gtktext));
359                
360         if (iswordsep(newtext[0])) {
361                 /* did we just end a word? */
362                 if (*ppos >= 2) 
363                         check_at(gtkpspell, *ppos - 2);
364
365                 /* did we just split a word? */
366                 if (*ppos < gtk_stext_get_length(gtktext))
367                         check_at(gtkpspell, *ppos + 1);
368         } else {
369                 /* check as they type, *except* if they're typing at the end (the most
370                  * common case.
371                  */
372                 if (*ppos < gtk_stext_get_length(gtktext) 
373                 &&  !iswordsep(get_text_index_whar(gtkpspell, *ppos)))
374                         check_at(gtkpspell, *ppos - 1);
375                 }
376         gtk_stext_thaw(gtktext);
377         gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos);
378 }
379
380 static void entry_delete_cb(GtkSText *gtktext, gint start, gint end, 
381                             GtkPspell *gtkpspell) 
382 {
383         int origpos;
384     
385         g_return_if_fail(gtkpspell->gtkpspeller->checker);
386
387         if (!gtkpspell->check_while_typing)
388                 return;
389
390         origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
391         if (start) {
392                 check_at(gtkpspell, start - 1);
393                 check_at(gtkpspell, start);
394         }
395
396         gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
397         gtk_stext_set_point(gtktext, origpos);
398         gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
399         /* this is to *UNDO* the selection, in case they were holding shift
400          * while hitting backspace. */
401 }
402
403 /* ok, this is pretty wacky:
404  * we need to let the right-mouse-click go through, so it moves the cursor,
405  * but we *can't* let it go through, because GtkText interprets rightclicks as
406  * weird selection modifiers.
407  *
408  * so what do we do?  forge rightclicks as leftclicks, then popup the menu.
409  * HACK HACK HACK.
410  */
411 static gint button_press_intercept_cb(GtkSText *gtktext, GdkEvent *e, GtkPspell *gtkpspell) 
412 {
413         GdkEventButton *eb;
414         gboolean retval;
415
416         g_return_val_if_fail(gtkpspell->gtkpspeller->checker, FALSE);
417
418         if (e->type != GDK_BUTTON_PRESS) 
419                 return FALSE;
420         eb = (GdkEventButton*) e;
421
422         if (eb->button != 3) 
423                 return FALSE;
424
425         /* forge the leftclick */
426         eb->button = 1;
427
428         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
429                                          GTK_SIGNAL_FUNC(button_press_intercept_cb), 
430                                          gtkpspell);
431         gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
432                                 e, &retval);
433         gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
434                                            GTK_SIGNAL_FUNC(button_press_intercept_cb), 
435                                            gtkpspell);
436         gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
437     
438         /* now do the menu wackiness */
439         popup_menu(gtkpspell, eb);
440         gtk_grab_remove(GTK_WIDGET(gtktext));
441         return TRUE;
442 }
443
444 /*****************************************************************************/
445 /* Checker creation */
446 static GtkPspeller *gtkpspeller_new(Dictionary *dictionary)
447 {
448         GSList          *exist;
449         GtkPspeller     *gtkpspeller = NULL;
450         GtkPspeller     *g           = g_new0(GtkPspeller, 1);
451         Dictionary      *dict;
452         gint            ispell;
453                 
454         g_return_val_if_fail(gtkpspellcheckers, NULL);
455
456         g_return_val_if_fail(dictionary, NULL);
457
458         if (dictionary->fullname == NULL)
459                 gtkpspell_checkers_error_message(g_strdup(_("No dictionary selected.")));
460         
461         g_return_val_if_fail(dictionary->fullname, NULL);
462         
463         if (dictionary->dictname == NULL) {
464                 gchar *tmp;
465
466                 tmp = strrchr(dictionary->fullname, G_DIR_SEPARATOR);
467
468                 if (tmp == NULL)
469                         dictionary->dictname = dictionary->fullname;
470                 else
471                         dictionary->dictname = tmp + 1;
472         }
473
474         dict = dictionary_dup(dictionary);
475
476         ispell = (strstr2(dict->dictname, "-ispell") != NULL);
477
478         g->dictionary = dict;
479
480         exist = g_slist_find_custom(gtkpspellcheckers->checkers, g, 
481                                     find_gtkpspeller);
482         
483         g_free(g);
484
485         if (exist && ispell) {
486                 gtkpspeller = (GtkPspeller *) exist->data;
487                 dictionary_delete(dict);
488
489                 debug_print(_("Pspell: Using existing ispell checker %0x\n"),
490                             (gint) gtkpspeller);
491         } else {
492                 if ((gtkpspeller = gtkpspeller_real_new(dict)) != NULL) {
493                         gtkpspellcheckers->checkers = g_slist_append(
494                                                 gtkpspellcheckers->checkers,
495                                                 gtkpspeller);
496
497                         debug_print(_("Pspell: Created a new gtkpspeller %0x\n"),
498                                     (gint) gtkpspeller);
499                 } else {
500                         dictionary_delete(dict);
501
502                         debug_print(_("Pspell: Could not create spell checker.\n"));
503                 }
504         }
505
506         debug_print(_("Pspell: number of existing checkers %d\n"), 
507                     g_slist_length(gtkpspellcheckers->checkers));
508
509         return gtkpspeller;
510 }
511
512 static GtkPspeller *gtkpspeller_real_new(Dictionary *dict)
513 {
514         GtkPspeller             *gtkpspeller;
515         PspellConfig            *config;
516         PspellCanHaveError      *ret;
517         
518         g_return_val_if_fail(gtkpspellcheckers, NULL);
519         g_return_val_if_fail(dict, NULL);
520
521         gtkpspeller = g_new(GtkPspeller, 1);
522         
523         gtkpspeller->dictionary = dict;
524         gtkpspeller->sug_mode   = PSPELL_FASTMODE;
525
526         config = new_pspell_config();
527
528         if (!set_dictionary(config, dict))
529                 return NULL;
530         
531         ret = new_pspell_manager(config);
532         delete_pspell_config(config);
533
534         if (pspell_error_number(ret) != 0) {
535                 gtkpspellcheckers->error_message = g_strdup(pspell_error_message(ret));
536                 
537                 delete_pspell_can_have_error(ret);
538                 
539                 return NULL;
540         }
541
542         gtkpspeller->checker = to_pspell_manager(ret);
543         gtkpspeller->config  = pspell_manager_config(gtkpspeller->checker);
544         gtkpspeller->ispell  = (strstr2(dict->fullname, "-ispell") != NULL);
545
546         return gtkpspeller;
547 }
548
549 static GtkPspeller *gtkpspeller_delete(GtkPspeller *gtkpspeller)
550 {
551         g_return_val_if_fail(gtkpspellcheckers, NULL);
552         
553         if (gtkpspeller->ispell) 
554                 debug_print(_("Pspell: Won't remove existing ispell checker %0x.\n"), 
555                             (gint) gtkpspeller);
556         else {
557                 gtkpspellcheckers->checkers = g_slist_remove(gtkpspellcheckers->checkers, 
558                                                 gtkpspeller);
559
560                 debug_print(_("Pspell: Deleting gtkpspeller %0x.\n"), 
561                             (gint) gtkpspeller);
562                 
563                 gtkpspeller_real_delete(gtkpspeller);
564         }
565
566         debug_print(_("Pspell: number of existing checkers %d\n"), 
567                     g_slist_length(gtkpspellcheckers->checkers));
568
569         return gtkpspeller;
570 }
571
572 static GtkPspeller *gtkpspeller_real_delete(GtkPspeller *gtkpspeller)
573 {
574         g_return_val_if_fail(gtkpspeller,          NULL);
575         g_return_val_if_fail(gtkpspeller->checker, NULL);
576
577         pspell_manager_save_all_word_lists(gtkpspeller->checker);
578
579         delete_pspell_manager(gtkpspeller->checker);
580
581         dictionary_delete(gtkpspeller->dictionary);
582
583         g_free(gtkpspeller);
584
585         return NULL;
586 }
587
588 /*****************************************************************************/
589 /* Checker configuration */
590
591 static gboolean set_dictionary(PspellConfig *config, Dictionary *dict)
592 {
593         gchar *language = NULL;
594         gchar *spelling = NULL;
595         gchar *jargon   = NULL;
596         gchar *module   = NULL;
597         gchar *end      = NULL;
598         gchar buf[BUFSIZE];
599         
600         g_return_val_if_fail(config, FALSE);
601         g_return_val_if_fail(dict,   FALSE);
602
603         strncpy(buf, dict->fullname, BUFSIZE-1);
604         buf[BUFSIZE-1] = 0x00;
605
606         buf[dict->dictname - dict->fullname] = 0x00;
607
608         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("rem-all-word-list-path", "");
609         debug_print(_("Pspell: removed all paths.\n"));
610
611         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("add-word-list-path", buf);
612         debug_print(_("Pspell: added path %s.\n"), buf);
613
614         strncpy(buf, dict->dictname, BUFSIZE-1);
615         language = buf;
616         
617         if ((module = strrchr(buf, '-')) != NULL) {
618                 module++;
619         }
620         if ((spelling = strchr(language, '-')) != NULL) 
621                 *spelling++ = 0x00;
622         if (spelling != module) {
623                 if ((end = strchr(spelling, '-')) != NULL) {
624                         *end++ = 0x00;
625                         jargon = end;
626                         if (jargon != module)
627                                 if ((end = strchr(jargon, '-')) != NULL)
628                                         *end = 0x00;
629                                 else
630                                         jargon = NULL;
631                         else
632                                 jargon = NULL;
633                 }
634                 else
635                         spelling = NULL;
636         }
637         else
638                 spelling = NULL;
639
640         debug_print(_("Pspell: Language: %s, spelling: %s, jargon: %s, module: %s\n"),
641                     language, spelling, jargon, module);
642         
643         if (language)
644                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("language-tag", language);
645         
646         if (spelling)
647                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("spelling",     spelling);
648         
649         if (jargon)
650                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("jargon",       jargon);
651         
652         if (module) {
653                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("rem-all-module-search-order", "");
654                 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("add-module-search-order", module);
655         }
656         
657         if (dict->encoding) {
658                 gchar *pspell_enc;
659         
660                 pspell_enc = convert_to_pspell_encoding (dict->encoding);
661                 pspell_config_replace(config, "encoding", (const char *) pspell_enc);
662                 g_free(pspell_enc);
663
664                 RETURN_FALSE_IF_CONFIG_ERROR();
665         }
666         
667         return TRUE;
668 }
669
670 guchar *gtkpspell_get_dict(GtkPspell *gtkpspell)
671 {
672
673         g_return_val_if_fail(gtkpspell->gtkpspeller->config,     NULL);
674         g_return_val_if_fail(gtkpspell->gtkpspeller->dictionary, NULL);
675         
676         return g_strdup(gtkpspell->gtkpspeller->dictionary->dictname);
677 }
678   
679 guchar *gtkpspell_get_path(GtkPspell *gtkpspell)
680 {
681         guchar *path;
682         Dictionary *dict;
683
684         g_return_val_if_fail(gtkpspell->gtkpspeller->config, NULL);
685         g_return_val_if_fail(gtkpspell->gtkpspeller->dictionary, NULL);
686
687         dict = gtkpspell->gtkpspeller->dictionary;
688         path = g_strndup(dict->fullname, dict->dictname - dict->fullname);
689
690         return path;
691 }
692
693 /* set_sug_mode_cb() - Menu callback : Set the suggestion mode */
694 static void set_sug_mode_cb(GtkMenuItem *w, GtkPspell *gtkpspell)
695 {
696         char *themode;
697         
698         if (gtkpspell->gtkpspeller->ispell) return;
699
700         gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode);
701         
702         set_real_sug_mode(gtkpspell, themode);
703
704         if (gtkpspell->config_menu)
705                 populate_submenu(gtkpspell, gtkpspell->config_menu);
706 }
707 static void set_real_sug_mode(GtkPspell *gtkpspell, const char *themode)
708 {
709         gint result;
710         gint mode = PSPELL_FASTMODE;
711         g_return_if_fail(gtkpspell);
712         g_return_if_fail(gtkpspell->gtkpspeller);
713         g_return_if_fail(themode);
714
715         if (!strcmp(themode,_("Normal Mode")))
716                 mode = PSPELL_NORMALMODE;
717         else if (!strcmp( themode,_("Bad Spellers Mode")))
718                 mode = PSPELL_BADSPELLERMODE;
719
720         result = gtkpspell_set_sug_mode(gtkpspell, mode);
721
722         if(!result) {
723                 debug_print(_("Pspell: error while changing suggestion mode:%s\n"),
724                             gtkpspellcheckers->error_message);
725                 gtkpspell_checkers_reset_error();
726         }
727 }
728   
729 /* gtkpspell_set_sug_mode() - Set the suggestion mode */
730 gboolean gtkpspell_set_sug_mode(GtkPspell *gtkpspell, gint themode)
731 {
732         PspellConfig *config;
733
734         g_return_val_if_fail(gtkpspell, FALSE);
735         g_return_val_if_fail(gtkpspell->gtkpspeller, FALSE);
736         g_return_val_if_fail(gtkpspell->gtkpspeller->config, FALSE);
737
738         debug_print("Pspell: setting sug mode of gtkpspeller %0x to %d\n",
739                         gtkpspell->gtkpspeller, themode);
740         config = gtkpspell->gtkpspeller->config;
741         switch (themode) {
742                 case PSPELL_FASTMODE: 
743                         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "fast");
744                         break;
745                 case PSPELL_NORMALMODE: 
746                         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "normal");
747                         break;
748                 case PSPELL_BADSPELLERMODE: 
749                         CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", 
750                                                             "bad-spellers");
751                         break;
752                 default: 
753                         gtkpspellcheckers->error_message = 
754                                 g_strdup(_("Unknown suggestion mode."));
755                         return FALSE;
756                 }
757
758         gtkpspell->gtkpspeller->sug_mode = themode;
759         gtkpspell->default_sug_mode      = themode;
760
761         return TRUE;
762 }
763
764 /* misspelled_suggest() - Create a suggestion list for  word  */
765 static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word) 
766 {
767         const guchar          *newword;
768         GList                 *list = NULL;
769         const PspellWordList  *suggestions;
770         PspellStringEmulation *elements;
771
772         g_return_val_if_fail(word, NULL);
773
774         if (!pspell_manager_check(gtkpspell->gtkpspeller->checker, word, -1)) {
775                 free_suggestions_list(gtkpspell);
776
777                 suggestions = pspell_manager_suggest(gtkpspell->gtkpspeller->checker, 
778                                                      (const char *)word, -1);
779                 elements    = pspell_word_list_elements(suggestions);
780                 list        = g_list_append(list, g_strdup(word)); 
781                 
782                 while ((newword = pspell_string_emulation_next(elements)) != NULL)
783                         list = g_list_append(list, g_strdup(newword));
784
785                 gtkpspell->max_sug          = g_list_length(list) - 1;
786                 gtkpspell->suggestions_list = list;
787
788                 return list;
789         }
790
791         free_suggestions_list(gtkpspell);
792
793         return NULL;
794 }
795
796 /* misspelled_test() - Just test if word is correctly spelled */  
797 static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word) 
798 {
799         return pspell_manager_check(gtkpspell->gtkpspeller->checker, word, -1) ? 0 : 1; 
800 }
801
802
803 static gboolean iswordsep(unsigned char c) 
804 {
805         return !isalpha(c) && c != '\'';
806 }
807
808 static guchar get_text_index_whar(GtkPspell *gtkpspell, int pos) 
809 {
810         guchar a;
811         gchar *text;
812         
813         text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1);
814         if (text == NULL) 
815                 return 0;
816         a = (guchar) *text;
817         g_free(text);
818         return a;
819 }
820
821 /* get_word_from_pos () - return the word pointed to. */
822 /* Handles correctly the quotes. */
823 static gboolean get_word_from_pos(GtkPspell *gtkpspell, gint pos, 
824                                   unsigned char* buf, gint buflen,
825                                   gint *pstart, gint *pend) 
826 {
827
828         /* TODO : when correcting a word into quotes, change the color of */
829         /* the quotes too, as may be they were highlighted before. To do  */
830         /* this, we can use two others pointers that points to the whole    */
831         /* word including quotes. */
832
833         gint      start, 
834                   end;
835         guchar    c;
836         GtkSText *gtktext;
837         
838         gtktext = gtkpspell->gtktext;
839         if (iswordsep(get_text_index_whar(gtkpspell, pos))) 
840                 return FALSE;
841         
842         /* The apostrophe character is somtimes used for quotes 
843          * So include it in the word only if it is not surrounded 
844          * by other characters. 
845          */
846          
847         for (start = pos; start >= 0; --start) {
848                 c = get_text_index_whar(gtkpspell, start);
849                 if (c == '\'') {
850                         if (start > 0) {
851                                 if (!isalpha(get_text_index_whar(gtkpspell, start - 1))) {
852                                         /* start_quote = TRUE; */
853                                         break;
854                                 }
855                         }
856                         else {
857                                 /* start_quote = TRUE; */
858                                 break;
859                         }
860                 }
861                 else
862                         if (!isalpha(c))
863                                 break;
864         }
865         start++;
866
867         for (end = pos; end < gtk_stext_get_length(gtktext); end++) {
868                 c = get_text_index_whar(gtkpspell, end); 
869                 if (c == '\'') {
870                         if (end < gtk_stext_get_length(gtktext)) {
871                                 if (!isalpha(get_text_index_whar(gtkpspell, end + 1))) {
872                                         /* end_quote = TRUE; */
873                                         break;
874                                 }
875                         }
876                         else {
877                                 /* end_quote = TRUE; */
878                                 break;
879                         }
880                 }
881                 else
882                         if(!isalpha(c))
883                                 break;
884         }
885                                                 
886         if (pstart) 
887                 *pstart = start;
888         if (pend) 
889                 *pend = end;
890
891         if (buf) {
892                 if (end - start < buflen) {
893                         for (pos = start; pos < end; pos++) 
894                                 buf[pos - start] = get_text_index_whar(gtkpspell, pos);
895                         buf[pos - start] = 0;
896                 } else return FALSE;
897         }
898
899         return TRUE;
900 }
901
902 static gboolean check_at(GtkPspell *gtkpspell, gint from_pos) 
903 {
904         gint          start, end;
905         unsigned char buf[GTKPSPELLWORDSIZE];
906         GtkSText     *gtktext;
907
908         g_return_val_if_fail(from_pos >= 0, FALSE);
909     
910         gtktext = gtkpspell->gtktext;
911
912         if (!get_word_from_pos(gtkpspell, from_pos, buf, sizeof(buf), 
913                                &start, &end))
914                 return FALSE;
915
916         if (misspelled_test(gtkpspell, buf)) {
917                 strncpy(gtkpspell->theword, buf, GTKPSPELLWORDSIZE - 1);
918                 gtkpspell->theword[GTKPSPELLWORDSIZE - 1] = 0;
919                 gtkpspell->start_pos  = start;
920                 gtkpspell->end_pos    = end;
921                 free_suggestions_list(gtkpspell);
922
923                 change_color(gtkpspell, start, end, buf, &(gtkpspell->highlight));
924                 return TRUE;
925         } else {
926                 change_color(gtkpspell, start, end, buf, NULL);
927                 return FALSE;
928         }
929 }
930
931 static gboolean check_next_prev(GtkPspell *gtkpspell, gboolean forward)
932 {
933         gint pos;
934         gint minpos;
935         gint maxpos;
936         gint direc = -1;
937         gboolean misspelled;
938         
939         minpos = 0;
940         maxpos = gtkpspell->end_check_pos;
941
942         if (forward) {
943                 minpos = -1;
944                 direc = 1;
945                 maxpos--;
946         } 
947
948         pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
949         gtkpspell->orig_pos = pos;
950         while (iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos) 
951                 pos += direc;
952         while (!(misspelled = check_at(gtkpspell, pos)) && pos > minpos && pos <= maxpos)
953         {
954                 while (!iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos)
955                         pos += direc;
956
957                 while (iswordsep(get_text_index_whar(gtkpspell, pos)) && pos > minpos && pos <= maxpos) 
958                         pos += direc;
959         }
960         if (misspelled) {
961                 misspelled_suggest(gtkpspell, gtkpspell->theword);
962                 if (forward)
963                         gtkpspell->orig_pos = gtkpspell->end_pos;
964                 gtk_stext_set_point(GTK_STEXT(gtkpspell->gtktext),
965                                 gtkpspell->end_pos);
966                 gtk_editable_set_position(GTK_EDITABLE(gtkpspell->gtktext),
967                                 gtkpspell->end_pos);
968                 gtk_menu_popup(make_sug_menu(gtkpspell), NULL, NULL, 
969                                 set_menu_pos, gtkpspell, 0, GDK_CURRENT_TIME);
970         } else {
971                 reset_theword_data(gtkpspell);
972
973                 gtkpspell_alert_dialog(_("No misspelled word found."));
974                 gtk_stext_set_point(GTK_STEXT(gtkpspell->gtktext), gtkpspell->orig_pos);
975                 gtk_editable_set_position(GTK_EDITABLE(gtkpspell->gtktext), gtkpspell->orig_pos);
976         }
977         return misspelled;
978 }
979
980 void gtkpspell_check_backwards(GtkPspell *gtkpspell)
981 {
982         gtkpspell->continue_check = NULL;
983         gtkpspell->end_check_pos = gtk_stext_get_length(GTK_STEXT(gtkpspell->gtktext));
984         check_next_prev(gtkpspell, FALSE);
985 }
986
987 void gtkpspell_check_forwards_go(GtkPspell *gtkpspell)
988 {
989
990         gtkpspell->continue_check = NULL;
991         gtkpspell->end_check_pos = gtk_stext_get_length(GTK_STEXT(gtkpspell->gtktext));
992         check_next_prev(gtkpspell, TRUE);
993 }
994
995 void gtkpspell_check_all(GtkPspell *gtkpspell)
996 {       
997         GtkWidget *gtktext;
998         
999         gint start, end;
1000
1001         g_return_if_fail(gtkpspell);
1002         g_return_if_fail(gtkpspell->gtktext);
1003
1004         gtktext = (GtkWidget *) gtkpspell->gtktext;
1005
1006         start = 0;      
1007         end   = gtk_stext_get_length(GTK_STEXT(gtktext));
1008
1009         if (GTK_EDITABLE(gtktext)->has_selection) {
1010                 start = GTK_EDITABLE(gtktext)->selection_start_pos;
1011                 end   = GTK_EDITABLE(gtktext)->selection_end_pos;
1012         }
1013
1014         if (start > end) {
1015                 gint tmp;
1016                 tmp   = start;
1017                 start = end;
1018                 end   = tmp;
1019         }
1020                 
1021         
1022         gtk_editable_set_position(GTK_EDITABLE(gtktext), start);
1023         gtk_stext_set_point(GTK_STEXT(gtktext), start);
1024
1025         gtkpspell->continue_check = continue_check;
1026         gtkpspell->end_check_pos = end;
1027
1028         gtkpspell->misspelled = check_next_prev(gtkpspell, TRUE);
1029
1030 }       
1031
1032 static void continue_check(gpointer *data)
1033 {
1034         GtkPspell *gtkpspell = (GtkPspell *) data;
1035         gint pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
1036         
1037         if (pos < gtkpspell->end_check_pos && gtkpspell->misspelled)
1038                 gtkpspell->misspelled = check_next_prev(gtkpspell, TRUE);
1039         else
1040                 gtkpspell->continue_check = NULL;
1041                 
1042 }
1043
1044 void gtkpspell_highlight_all(GtkPspell *gtkpspell) 
1045 {
1046         guint     origpos;
1047         guint     pos = 0;
1048         guint     len;
1049         GtkSText *gtktext;
1050         gfloat    adj_value;
1051
1052         g_return_if_fail(gtkpspell->gtkpspeller->checker);      
1053
1054         gtktext = gtkpspell->gtktext;
1055
1056         adj_value = gtktext->vadj->value;
1057
1058         len = gtk_stext_get_length(gtktext);
1059
1060         gtk_stext_freeze(gtktext);
1061
1062         origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1063
1064 /*      gtk_editable_set_position(GTK_EDITABLE(gtktext), 0);*/
1065
1066         while (pos < len) {
1067                 while (pos < len && 
1068                        iswordsep(get_text_index_whar(gtkpspell, pos)))
1069                         pos++;
1070                 while (pos < len &&
1071                        !iswordsep(get_text_index_whar(gtkpspell, pos)))
1072                         pos++;
1073                 if (pos > 0)
1074                         check_at(gtkpspell, pos - 1);
1075         }
1076         gtk_stext_thaw(gtktext);
1077         gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
1078         gtk_stext_set_point(GTK_STEXT(gtktext), origpos);
1079         gtk_adjustment_set_value(gtktext->vadj, adj_value);
1080         /*gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);*/
1081 }
1082
1083 static void replace_with_supplied_word_cb(GtkWidget *w, GtkPspell *gtkpspell) 
1084 {
1085         unsigned char *newword;
1086         GdkEvent *e= (GdkEvent *) gtk_get_current_event();
1087         
1088         newword = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->replace_entry), 0, -1);
1089         
1090         if (strcmp(newword, gtkpspell->theword)) {
1091                 replace_real_word(gtkpspell, newword);
1092
1093                 if ((e->type == GDK_KEY_PRESS && 
1094                     ((GdkEventKey *) e)->state & GDK_MOD1_MASK)) {
1095                         pspell_manager_store_replacement(gtkpspell->gtkpspeller->checker, 
1096                                                          gtkpspell->theword, -1, 
1097                                                          newword, -1);
1098                 }
1099                 gtkpspell->replace_entry = NULL;
1100         }
1101
1102         g_free(newword);
1103
1104         set_point_continue(gtkpspell);
1105 }
1106
1107
1108 static void replace_word_cb(GtkWidget *w, gpointer data)
1109 {
1110         unsigned char *newword;
1111         GtkPspell *gtkpspell = (GtkPspell *) data;
1112         GdkEvent *e= (GdkEvent *) gtk_get_current_event();
1113
1114
1115         gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
1116
1117         replace_real_word(gtkpspell, newword);
1118
1119         if ((e->type == GDK_KEY_PRESS && 
1120             ((GdkEventKey *) e)->state & GDK_MOD1_MASK) ||
1121             (e->type == GDK_BUTTON_RELEASE && 
1122              ((GdkEventButton *) e)->state & GDK_MOD1_MASK)) {
1123                 pspell_manager_store_replacement(gtkpspell->gtkpspeller->checker, 
1124                                                  gtkpspell->theword, -1, 
1125                                                  newword, -1);
1126         }
1127
1128         gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
1129
1130         set_point_continue(gtkpspell);
1131 }
1132
1133 static void replace_real_word(GtkPspell *gtkpspell, gchar *newword)
1134 {
1135         int             oldlen, newlen, wordlen;
1136         gint            origpos;
1137         gint            pos;
1138         gint            start = gtkpspell->start_pos;
1139         GtkSText       *gtktext;
1140     
1141         if (!newword) return;
1142
1143         gtktext = gtkpspell->gtktext;
1144
1145         gtk_stext_freeze(GTK_STEXT(gtktext));
1146         origpos = gtkpspell->orig_pos;
1147         pos     = origpos;
1148         oldlen  = gtkpspell->end_pos - gtkpspell->start_pos;
1149         wordlen = strlen(gtkpspell->theword);
1150
1151         newlen = strlen(newword); /* FIXME: multybyte characters? */
1152
1153         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
1154                                          GTK_SIGNAL_FUNC(entry_insert_cb), 
1155                                          gtkpspell);
1156         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
1157                                          GTK_SIGNAL_FUNC(entry_delete_cb), 
1158                                          gtkpspell);
1159
1160         gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "delete-text", 
1161                                 gtkpspell->start_pos, gtkpspell->end_pos);
1162         gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "insert-text", 
1163                                 newword, newlen, &start);
1164         
1165         gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
1166                                            GTK_SIGNAL_FUNC(entry_insert_cb), 
1167                                            gtkpspell);
1168         gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
1169                                            GTK_SIGNAL_FUNC(entry_delete_cb), 
1170                                            gtkpspell);
1171         
1172         /* Put the point and the position where we clicked with the mouse */
1173         /* It seems to be a hack, as I must thaw,freeze,thaw the widget   */
1174         /* to let it update correctly the word insertion and then the     */
1175         /* point & position position. If not, SEGV after the first replacement */
1176         /* If the new word ends before point, put the point at its end*/
1177     
1178         if (origpos - gtkpspell->start_pos < oldlen && 
1179             origpos - gtkpspell->start_pos >= 0) {
1180                 /* Original point was in the word. */
1181                 /* Let it there unless point is going to be outside of the word */
1182                 if (origpos - gtkpspell->start_pos >= newlen) {
1183                         pos = gtkpspell->start_pos + newlen;
1184                 }
1185         }
1186         else if (origpos >= gtkpspell->end_pos) {
1187                 /* move the position according to the change of length */
1188                 pos = origpos + newlen - oldlen;
1189         }
1190         
1191         gtkpspell->end_pos = gtkpspell->start_pos + strlen(newword); /* FIXME: multibyte characters? */
1192         
1193         gtk_stext_thaw(GTK_STEXT(gtktext));
1194         gtk_stext_freeze(GTK_STEXT(gtktext));
1195
1196         if (GTK_STEXT(gtktext)->text_len < pos)
1197                 pos = gtk_stext_get_length(GTK_STEXT(gtktext));
1198
1199         gtkpspell->orig_pos = pos;
1200
1201         gtk_editable_set_position(GTK_EDITABLE(gtktext), gtkpspell->orig_pos);
1202         gtk_stext_set_point(GTK_STEXT(gtktext), 
1203                             gtk_editable_get_position(GTK_EDITABLE(gtktext)));
1204
1205         gtk_stext_thaw(GTK_STEXT(gtktext));
1206 }
1207
1208 /* Accept this word for this session */
1209 static void add_word_to_session_cb(GtkWidget *w, gpointer data)
1210 {
1211         guint     pos;
1212         GtkSText *gtktext;
1213         GtkPspell *gtkpspell = (GtkPspell *) data; 
1214         gtktext = gtkpspell->gtktext;
1215
1216         gtk_stext_freeze(GTK_STEXT(gtktext));
1217
1218         pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1219     
1220         pspell_manager_add_to_session(gtkpspell->gtkpspeller->checker,
1221                                       gtkpspell->theword, 
1222                                       strlen(gtkpspell->theword));
1223
1224         check_at(gtkpspell, gtkpspell->start_pos);
1225
1226         gtk_stext_thaw(gtkpspell->gtktext);
1227
1228         gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1229
1230         set_point_continue(gtkpspell);
1231 }
1232
1233 /* add_word_to_personal_cb() - add word to personal dict. */
1234 static void add_word_to_personal_cb(GtkWidget *w, gpointer data)
1235 {
1236         GtkSText *gtktext;
1237         GtkPspell *gtkpspell = (GtkPspell *) data; 
1238         gtktext = gtkpspell->gtktext;
1239
1240         gtk_stext_freeze(GTK_STEXT(gtktext));
1241     
1242         pspell_manager_add_to_personal(gtkpspell->gtkpspeller->checker,
1243                                        gtkpspell->theword,
1244                                        strlen(gtkpspell->theword));
1245     
1246         check_at(gtkpspell, gtkpspell->start_pos);
1247
1248         gtk_stext_thaw(gtkpspell->gtktext);
1249
1250         gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1251         set_point_continue(gtkpspell);
1252 }
1253
1254 static void deactivate_sug_menu_cb(GtkObject *w, gpointer data)
1255 {
1256         GtkMenuShell *menu_shell = GTK_MENU_SHELL(data);
1257         debug_print("Destroying %0x\n", w);
1258         gtk_menu_shell_deactivate(menu_shell);
1259 }
1260
1261 static void replace_with_create_dialog_cb(GtkWidget *w, gpointer data)
1262 {
1263         GtkWidget *dialog;
1264         GtkWidget *label;
1265         GtkWidget *hbox;
1266         GtkWidget *entry;
1267         GtkWidget *ok_button;
1268         GtkWidget *cancel_button;
1269         gchar *thelabel;
1270         gint xx, yy;
1271         GtkPspell *gtkpspell = (GtkPspell *) data;
1272
1273         gdk_window_get_origin((GTK_WIDGET(w)->parent)->window, &xx, &yy);
1274
1275         gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1276
1277         dialog = gtk_dialog_new();
1278         gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
1279         gtk_window_set_title(GTK_WINDOW(dialog),_("Replace unknown word"));
1280         gtk_widget_set_uposition(dialog, xx, yy);
1281
1282         gtk_signal_connect_object(GTK_OBJECT(dialog), "destroy",
1283                                   GTK_SIGNAL_FUNC(gtk_widget_destroy), 
1284                                   GTK_OBJECT(dialog));
1285
1286         hbox = gtk_hbox_new(FALSE, 0);
1287         gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
1288
1289         thelabel = g_strdup_printf(_("Replace \"%s\" with: "), 
1290                                    gtkpspell->theword);
1291         label = gtk_label_new(thelabel);
1292         g_free(thelabel);
1293         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
1294
1295         entry = gtk_entry_new();
1296         gtkpspell->replace_entry = entry;
1297         gtk_entry_set_text(GTK_ENTRY(entry), gtkpspell->theword);
1298         gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
1299         gtk_signal_connect(GTK_OBJECT(entry), "activate",
1300                            GTK_SIGNAL_FUNC(replace_with_supplied_word_cb), 
1301                            gtkpspell);
1302         gtk_signal_connect_object(GTK_OBJECT(entry), "activate",
1303                            GTK_SIGNAL_FUNC(gtk_widget_destroy), 
1304                            GTK_OBJECT(dialog));
1305         gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
1306
1307         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, 
1308                            TRUE, 0);
1309         if (!gtkpspell->gtkpspeller->ispell) {
1310                 label = gtk_label_new(_("Holding down MOD1 key while pressing Enter\nwill learn from mistake.\n"));
1311                 gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
1312                 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
1313                 gtk_misc_set_padding(GTK_MISC(label), 8, 0);
1314                 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, 
1315                                    TRUE, TRUE, 0);
1316         }
1317
1318         hbox = gtk_hbox_new(TRUE, 0);
1319
1320         ok_button = gtk_button_new_with_label(_("OK"));
1321         gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 8);
1322         gtk_signal_connect(GTK_OBJECT(ok_button), "clicked",
1323                            GTK_SIGNAL_FUNC(replace_with_supplied_word_cb), 
1324                            gtkpspell);
1325         gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
1326                                   GTK_SIGNAL_FUNC(gtk_widget_destroy), 
1327                                   GTK_OBJECT(dialog));
1328
1329         cancel_button = gtk_button_new_with_label(_("Cancel"));
1330         gtk_box_pack_start(GTK_BOX(hbox), cancel_button, TRUE, TRUE, 8);
1331         gtk_signal_connect_object(GTK_OBJECT(cancel_button), "clicked",
1332                                   GTK_SIGNAL_FUNC(gtk_widget_destroy), 
1333                                   GTK_OBJECT(dialog));
1334
1335         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), hbox);
1336
1337         gtk_widget_grab_focus(entry);
1338
1339         gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
1340
1341         gtk_widget_show_all(dialog);
1342 }
1343
1344 void gtkpspell_uncheck_all(GtkPspell * gtkpspell) 
1345 {
1346         gint      origpos;
1347         gchar    *text;
1348         gfloat    adj_value;
1349         GtkSText *gtktext;
1350         
1351         gtktext = gtkpspell->gtktext;
1352
1353         adj_value = gtktext->vadj->value;
1354
1355         gtk_stext_freeze(gtktext);
1356
1357         origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1358
1359         text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
1360
1361         gtk_stext_set_point(gtktext, 0);
1362         gtk_stext_forward_delete(gtktext, gtk_stext_get_length(gtktext));
1363         gtk_stext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
1364
1365         gtk_stext_thaw(gtktext);
1366
1367         gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
1368         gtk_stext_set_point(gtktext, origpos);
1369         gtk_adjustment_set_value(gtktext->vadj, adj_value);
1370
1371         g_free(text);
1372
1373 }
1374
1375 static void toggle_check_while_typing_cb(GtkWidget *w, gpointer data)
1376 {
1377         GtkPspell *gtkpspell = (GtkPspell *) data;
1378
1379         gtkpspell->check_while_typing = gtkpspell->check_while_typing == FALSE;
1380         if (!gtkpspell->check_while_typing)
1381                 gtkpspell_uncheck_all(gtkpspell);
1382
1383         if (gtkpspell->config_menu)
1384                 populate_submenu(gtkpspell, gtkpspell->config_menu);
1385 }
1386
1387 static GSList *create_empty_dictionary_list(void)
1388 {
1389         GSList *list = NULL;
1390         Dictionary *dict;
1391
1392         dict = g_new0(Dictionary, 1);
1393         dict->fullname = g_strdup(_("None"));
1394         dict->dictname = dict->fullname;
1395         dict->encoding = NULL;
1396         return g_slist_append(list, dict);
1397 }
1398
1399 /* gtkpspell_get_dictionary_list() - returns list of dictionary names */
1400 GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path, gint refresh)
1401 {
1402         GSList *list;
1403         gchar *dict_path, *tmp, *prevdir;
1404         gchar tmpname[BUFSIZE];
1405         Dictionary *dict;
1406         DIR *dir;
1407         struct dirent *ent;
1408
1409         if (!gtkpspellcheckers)
1410                 gtkpspellcheckers = gtkpspell_checkers_new();
1411
1412         if (gtkpspellcheckers->dictionary_list && !refresh)
1413                 return gtkpspellcheckers->dictionary_list;
1414         else
1415                 gtkpspell_free_dictionary_list(gtkpspellcheckers->dictionary_list);
1416
1417         list = NULL;
1418
1419 #ifdef USE_THREADS
1420 #warning TODO: no directory change
1421 #endif
1422         dict_path = g_strdup(pspell_path);
1423         prevdir   = g_get_current_dir();
1424         if (chdir(dict_path) <0) {
1425                 debug_print(_("Pspell: error when searching for dictionaries:\n%s\n"),
1426                             g_strerror(errno));
1427                 g_free(prevdir);
1428                 g_free(dict_path);
1429                 gtkpspellcheckers->dictionary_list = create_empty_dictionary_list();
1430                 return gtkpspellcheckers->dictionary_list; 
1431         }
1432
1433         debug_print(_("Pspell: checking for dictionaries in %s\n"), dict_path);
1434
1435         if (NULL != (dir = opendir("."))) {
1436                 while (NULL != (ent = readdir(dir))) {
1437                         /* search for pwli */
1438                         if ((NULL != (tmp = strstr2(ent->d_name, ".pwli"))) && 
1439                             (tmp[5] == 0x00)) {
1440                                 g_snprintf(tmpname, BUFSIZE, "%s%s", 
1441                                            G_DIR_SEPARATOR_S, ent->d_name);
1442                                 tmpname[MIN(tmp - ent->d_name + 1, BUFSIZE-1)] = 0x00;
1443                                 dict = g_new0(Dictionary, 1);
1444                                 dict->fullname = g_strdup_printf("%s%s", 
1445                                                                  dict_path, 
1446                                                                  tmpname);
1447                                 dict->dictname = strrchr(dict->fullname, 
1448                                                          G_DIR_SEPARATOR) + 1;
1449                                 dict->encoding = NULL;
1450                                 debug_print(_("Pspell: found dictionary %s %s\n"),
1451                                             dict->fullname, dict->dictname);
1452                                 list = g_slist_insert_sorted(list, dict,
1453                                                 (GCompareFunc) compare_dict);
1454                         }
1455                 }                       
1456                 closedir(dir);
1457         }
1458         else {
1459                 debug_print(_("Pspell: error when searching for dictionaries.\nNo dictionary found.\n(%s)"), 
1460                             g_strerror(errno));
1461                 list = create_empty_dictionary_list();
1462         }
1463         if(list==NULL){
1464                 
1465                 debug_print(_("Pspell: error when searching for dictionaries.\nNo dictionary found."));
1466                 list = create_empty_dictionary_list();
1467         }
1468         chdir(prevdir);
1469         g_free(dict_path);
1470         g_free(prevdir);
1471         gtkpspellcheckers->dictionary_list = list;
1472         return list;
1473 }
1474
1475 void gtkpspell_free_dictionary_list(GSList *list)
1476 {
1477         Dictionary *dict;
1478         GSList *walk;
1479         for (walk = list; walk != NULL; walk = g_slist_next(walk))
1480                 if (walk->data) {
1481                         dict = (Dictionary *) walk->data;
1482                         dictionary_delete(dict);
1483                 }                               
1484         g_slist_free(list);
1485 }
1486
1487 #if 0
1488 static void dictionary_option_menu_item_data_destroy(gpointer data)
1489 {
1490         Dictionary *dict = (Dictionary *) data;
1491
1492         if (dict)
1493                 dictionary_delete(dict);
1494 }
1495 #endif
1496
1497 GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path)
1498 {
1499         GSList *dict_list, *tmp;
1500         GtkWidget *item;
1501         GtkWidget *menu;
1502         Dictionary *dict;
1503
1504         dict_list = gtkpspell_get_dictionary_list(pspell_path, TRUE);
1505         g_return_val_if_fail(dict_list, NULL);
1506
1507         menu = gtk_menu_new();
1508         
1509         for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
1510                 dict = (Dictionary *) tmp->data;
1511                 item = gtk_menu_item_new_with_label(dict->dictname);
1512                 gtk_object_set_data(GTK_OBJECT(item), "dict_name",
1513                                     dict->fullname); 
1514                                          
1515                 gtk_menu_append(GTK_MENU(menu), item);                                   
1516                 gtk_widget_show(item);
1517         }
1518
1519         gtk_widget_show(menu);
1520
1521         return menu;
1522 }
1523
1524 gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu)
1525 {
1526         GtkWidget *menuitem;
1527         gchar *dict_fullname;
1528         gchar *label;
1529
1530         g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
1531         menuitem = gtk_menu_get_active(GTK_MENU(menu));
1532         dict_fullname = (gchar *) gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name");
1533         g_return_val_if_fail(dict_fullname, NULL);
1534         label = g_strdup(dict_fullname);
1535         return label;
1536   
1537 }
1538
1539 GtkWidget *gtkpspell_sugmode_option_menu_new(gint sugmode)
1540 {
1541         GtkWidget *menu;
1542         GtkWidget *item;
1543
1544
1545         menu = gtk_menu_new();
1546         gtk_widget_show(menu);
1547
1548         item = gtk_menu_item_new_with_label(_("Fast Mode"));
1549         gtk_widget_show(item);
1550         gtk_menu_append(GTK_MENU(menu), item);
1551         gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_FASTMODE));
1552
1553         item = gtk_menu_item_new_with_label(_("Normal Mode"));
1554         gtk_widget_show(item);
1555         gtk_menu_append(GTK_MENU(menu), item);
1556         gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_NORMALMODE));
1557         
1558         item = gtk_menu_item_new_with_label(_("Bad Spellers Mode"));
1559         gtk_widget_show(item);
1560         gtk_menu_append(GTK_MENU(menu), item);
1561         gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(PSPELL_BADSPELLERMODE));
1562
1563         return menu;
1564 }
1565         
1566 void gtkpspell_sugmode_option_menu_set(GtkOptionMenu *optmenu, gint sugmode)
1567 {
1568         g_return_if_fail(GTK_IS_OPTION_MENU(optmenu));
1569
1570         g_return_if_fail(sugmode == PSPELL_FASTMODE ||
1571                          sugmode == PSPELL_NORMALMODE ||
1572                          sugmode == PSPELL_BADSPELLERMODE);
1573
1574         gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), sugmode - 1);
1575 }
1576
1577 gint gtkpspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu)
1578 {
1579         gint sugmode;
1580         GtkWidget *item;
1581         
1582         g_return_val_if_fail(GTK_IS_OPTION_MENU(optmenu), -1);
1583
1584         item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
1585         
1586         sugmode = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item), "sugmode"));
1587
1588         return sugmode;
1589         
1590 }
1591 #if 0 /* Experimenal */
1592 void gtkpspell_set_primary_dict(GtkPspell *gtkpspell, gchar *dict, gchar *encoding)
1593 {
1594         g_return_if_fail(gtkpspell);
1595         if (gtkpspell->dict1)
1596                 dictionary_delete(gtkpspell->dict1);
1597         gtkpspell->dict1 = g_new(Dictionary, 1);
1598         gtkpspell->dict1->fullname = g_strdup(dict);
1599         gtkpspell->dict1->encoding = g_strdup(encoding);
1600 }
1601
1602 void gtkpspell_set_secondary_dict(GtkPspell *gtkpspell, gchar *dict, gchar *encoding)
1603 {
1604         g_return_if_fail(gtkpspell);
1605         if (gtkpspell->dict2)
1606                 dictionary_delete(gtkpspell->dict2);
1607         gtkpspell->dict2 = g_new(Dictionary, 1);
1608         gtkpspell->dict2->fullname = g_strdup(dict);
1609         gtkpspell->dict2->encoding = g_strdup(encoding);
1610 }
1611
1612 gboolean gtkpspell_use_dict(GtkPspell *gtkpspell, Dictionary *dict)
1613 {
1614         return TRUE;
1615 }
1616
1617 gboolean gtkpspell_use_dictionary(GtkPspell *gtkpspell, gchar *dictpath, gchar *encoding)
1618 {
1619         Dictionary *dict;
1620         gboolean retval;
1621         
1622         g_return_val_if_fail(gtkpspell, FALSE);
1623         g_return_val_if_fail(dict, FALSE);
1624         g_return_val_if_fail(encoding, FALSE);
1625
1626         dict = g_new(Dictionary, 1);
1627         
1628         dict->fullname = g_strdup(dictpath);
1629         dict->encoding = NULL; /* To be continued */
1630
1631         retval = gtkpspell_use_dict(gtkpspell, dict);
1632
1633         dictionary_delete(dict);
1634         
1635         return retval;
1636         
1637 }
1638
1639 gboolean gtkpspell_use_primary(GtkPspell *gtkpspell)
1640 {
1641         g_return_val_if_fail(gtkpspell, FALSE);
1642
1643         return gtkpspell_use_dict(gtkpspell, gtkpspell->dict1);
1644 }
1645
1646 gboolean gtkpspell_use_secondary(GtkPspell *gtkpspell)
1647 {
1648         g_return_val_if_fail(gtkpspell, FALSE);
1649
1650         return gtkpspell_use_dict(gtkpspell, gtkpspell->dict2);
1651 }
1652 #endif
1653
1654 /*****************************************************************************/
1655
1656 static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb) 
1657 {
1658         GtkSText * gtktext;
1659         
1660         gtktext = gtkpspell->gtktext;
1661         gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1662
1663         if (!(eb->state & GDK_SHIFT_MASK)) {
1664                 if (check_at(gtkpspell, gtkpspell->orig_pos)) {
1665
1666                         gtk_editable_set_position(GTK_EDITABLE(gtktext), 
1667                                                   gtkpspell->orig_pos);
1668                         gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
1669
1670                         if (misspelled_suggest(gtkpspell, gtkpspell->theword)) {
1671                                 gtk_menu_popup(make_sug_menu(gtkpspell), 
1672                                                NULL, NULL, NULL, NULL,
1673                                                eb->button, GDK_CURRENT_TIME);
1674                                 
1675                                 return;
1676                         }
1677                 } else {
1678                         gtk_editable_set_position(GTK_EDITABLE(gtktext), 
1679                                                   gtkpspell->orig_pos);
1680                         gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
1681                 }
1682         }
1683
1684         gtk_menu_popup(make_config_menu(gtkpspell),NULL,NULL,NULL,NULL,
1685                        eb->button, GDK_CURRENT_TIME);
1686 }
1687
1688 /* make_sug_menu() - Add menus to accept this word for this session and to add it to 
1689  * personal dictionary */
1690 static GtkMenu *make_sug_menu(GtkPspell *gtkpspell) 
1691 {
1692         GtkWidget       *menu, *item;
1693         unsigned char   *caption;
1694         GtkSText        *gtktext;
1695         GList           *l = gtkpspell->suggestions_list;
1696         GtkAccelGroup   *accel;
1697         
1698
1699         gtktext = gtkpspell->gtktext;
1700
1701         accel = gtk_accel_group_new();
1702         menu = gtk_menu_new(); 
1703
1704         if (gtkpspell->sug_menu)
1705                 gtk_widget_destroy(gtkpspell->sug_menu);
1706
1707         gtkpspell->sug_menu = menu;     
1708
1709         gtk_signal_connect(GTK_OBJECT(menu), "cancel",
1710                 GTK_SIGNAL_FUNC(cancel_menu_cb), gtkpspell);
1711
1712         caption = g_strdup_printf(_("Unknown word: \"%s\""), 
1713                                   (unsigned char*) l->data);
1714         item = gtk_menu_item_new_with_label(caption);
1715         gtk_widget_show(item);
1716         gtk_menu_append(GTK_MENU(menu), item);
1717         gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
1718         g_free(caption);
1719
1720         item = gtk_menu_item_new();
1721         gtk_widget_show(item);
1722         gtk_menu_append(GTK_MENU(menu), item);
1723
1724         item = gtk_menu_item_new_with_label(_("Accept in this session"));
1725         gtk_widget_show(item);
1726         gtk_menu_append(GTK_MENU(menu), item);
1727         gtk_signal_connect(GTK_OBJECT(item), "activate",
1728                            GTK_SIGNAL_FUNC(add_word_to_session_cb), 
1729                            gtkpspell);
1730         gtk_widget_add_accelerator(item, "activate", accel, GDK_space, GDK_MOD1_MASK,
1731                                    GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1732
1733         item = gtk_menu_item_new_with_label(_("Add to personal dictionary"));
1734         gtk_widget_show(item);
1735         gtk_menu_append(GTK_MENU(menu), item);
1736         gtk_signal_connect(GTK_OBJECT(item), "activate",
1737                            GTK_SIGNAL_FUNC(add_word_to_personal_cb), 
1738                            gtkpspell);
1739         gtk_widget_add_accelerator(item, "activate", accel, GDK_Return, GDK_MOD1_MASK,
1740                                    GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1741
1742         item = gtk_menu_item_new_with_label(_("Replace with..."));
1743         gtk_widget_show(item);
1744         gtk_menu_append(GTK_MENU(menu), item);
1745         gtk_signal_connect(GTK_OBJECT(item), "activate",
1746                            GTK_SIGNAL_FUNC(replace_with_create_dialog_cb), 
1747                            gtkpspell);
1748         gtk_widget_add_accelerator(item, "activate", accel, GDK_R, 0,
1749                                    GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1750
1751         item = gtk_menu_item_new();
1752         gtk_widget_show(item);
1753         gtk_menu_append(GTK_MENU(menu), item);
1754
1755         l = l->next;
1756         if (l == NULL) {
1757                 item = gtk_menu_item_new_with_label(_("(no suggestions)"));
1758                 gtk_widget_show(item);
1759                 gtk_menu_append(GTK_MENU(menu), item);
1760         } else {
1761                 GtkWidget *curmenu = menu;
1762                 gint count = 0;
1763                 
1764                 do {
1765                         if (l->data == NULL && l->next != NULL) {
1766                                 count = 0;
1767                                 curmenu = gtk_menu_new();
1768                                 item = gtk_menu_item_new_with_label(_("Others..."));
1769                                 gtk_widget_show(item);
1770                                 gtk_menu_append(GTK_MENU(curmenu), item);
1771                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
1772
1773                                 l = l->next;
1774                         } else if (count > MENUCOUNT) {
1775                                 count -= MENUCOUNT;
1776
1777                                 item = gtk_menu_item_new_with_label(_("More..."));
1778                                 gtk_widget_show(item);
1779                                 gtk_menu_append(GTK_MENU(curmenu), item);
1780
1781                                 curmenu = gtk_menu_new();
1782                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
1783                         }
1784
1785                         item = gtk_menu_item_new_with_label((unsigned char*)l->data);
1786                         gtk_widget_show(item);
1787                         gtk_menu_append(GTK_MENU(curmenu), item);
1788                         gtk_signal_connect(GTK_OBJECT(item), "activate",
1789                                            GTK_SIGNAL_FUNC(replace_word_cb), gtkpspell);
1790
1791                         if (curmenu == menu && count < MENUCOUNT) {
1792                                 gtk_widget_add_accelerator(item, "activate",
1793                                                            accel,
1794                                                            GDK_A + count, 0,
1795                                                            GTK_ACCEL_LOCKED | 
1796                                                            GTK_ACCEL_VISIBLE);
1797                                 gtk_widget_add_accelerator(item, "activate", 
1798                                                            accel,
1799                                                            GDK_A + count, 
1800                                                            GDK_MOD1_MASK,
1801                                                            GTK_ACCEL_LOCKED);
1802                                 }
1803
1804                         count++;
1805
1806                 } while ((l = l->next) != NULL);
1807         }
1808
1809         gtk_accel_group_attach(accel, GTK_OBJECT(menu));
1810         gtk_accel_group_unref(accel);
1811         
1812         return GTK_MENU(menu);
1813 }
1814
1815 static void populate_submenu(GtkPspell *gtkpspell, GtkWidget *menu)
1816 {
1817         GtkWidget *item, *submenu;
1818         GtkPspeller *gtkpspeller = gtkpspell->gtkpspeller;
1819         gchar *dictname;
1820         gint ispell = gtkpspeller->ispell;
1821
1822         if (GTK_MENU_SHELL(menu)->children) {
1823                 GList *amenu, *alist;
1824                 for (amenu = (GTK_MENU_SHELL(menu)->children); amenu; ) {
1825                         alist = amenu->next;
1826                         gtk_widget_destroy(GTK_WIDGET(amenu->data));
1827                         amenu = alist;
1828                 }
1829         }
1830         
1831         dictname = g_strdup_printf(_("Dictionary: %s"), gtkpspeller->dictionary->dictname);
1832         item = gtk_menu_item_new_with_label(dictname);
1833         gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
1834         g_free(dictname);
1835         gtk_widget_show(item);
1836         gtk_menu_append(GTK_MENU(menu), item);
1837
1838         item = gtk_menu_item_new();
1839         gtk_widget_show(item);
1840         gtk_menu_append(GTK_MENU(menu), item);
1841                 
1842         item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
1843         if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_FASTMODE)
1844                 gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
1845         if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_FASTMODE)
1846                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
1847         else
1848                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1849                                    GTK_SIGNAL_FUNC(set_sug_mode_cb),
1850                                    gtkpspell);
1851         gtk_widget_show(item);
1852         gtk_menu_append(GTK_MENU(menu), item);
1853
1854         item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
1855         if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_NORMALMODE)
1856                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1857         if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_NORMALMODE) 
1858                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1859         else
1860                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1861                                    GTK_SIGNAL_FUNC(set_sug_mode_cb),
1862                                    gtkpspell);
1863         gtk_widget_show(item);
1864         gtk_menu_append(GTK_MENU(menu),item);
1865
1866         item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
1867         if (ispell || gtkpspell->gtkpspeller->sug_mode == PSPELL_BADSPELLERMODE)
1868                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1869         if (!ispell && gtkpspell->gtkpspeller->sug_mode == PSPELL_BADSPELLERMODE)
1870                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1871         else
1872                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1873                                    GTK_SIGNAL_FUNC(set_sug_mode_cb),
1874                                    gtkpspell);
1875         gtk_widget_show(item);
1876         gtk_menu_append(GTK_MENU(menu), item);
1877         
1878         item = gtk_menu_item_new();
1879         gtk_widget_show(item);
1880         gtk_menu_append(GTK_MENU(menu), item);
1881         
1882         item = gtk_check_menu_item_new_with_label(_("Check while typing"));
1883         if (gtkpspell->check_while_typing)
1884                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1885         else    
1886                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
1887         gtk_signal_connect(GTK_OBJECT(item), "activate",
1888                            GTK_SIGNAL_FUNC(toggle_check_while_typing_cb),
1889                            gtkpspell);
1890         gtk_widget_show(item);
1891         gtk_menu_append(GTK_MENU(menu), item);
1892
1893         item = gtk_menu_item_new();
1894         gtk_widget_show(item);
1895         gtk_menu_append(GTK_MENU(menu), item);
1896
1897         submenu = gtk_menu_new();
1898         item = gtk_menu_item_new_with_label(_("Change dictionary"));
1899         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
1900         gtk_widget_show(item);
1901         gtk_menu_append(GTK_MENU(menu), item);
1902
1903         /* Dict list */
1904         if (gtkpspellcheckers->dictionary_list == NULL)
1905                 gtkpspell_get_dictionary_list(prefs_common.pspell_path, FALSE);
1906         {
1907                 GtkWidget * curmenu = submenu;
1908                 int count = 0;
1909                 Dictionary *dict;
1910                 GSList *tmp;
1911                 tmp = gtkpspellcheckers->dictionary_list;
1912                 
1913                 for (tmp = gtkpspellcheckers->dictionary_list; tmp != NULL; 
1914                                 tmp = g_slist_next(tmp)) {
1915                         dict = (Dictionary *) tmp->data;
1916                         item = gtk_check_menu_item_new_with_label(dict->dictname);
1917                         gtk_object_set_data(GTK_OBJECT(item), "dict_name", dict->fullname); 
1918                         if (strcmp2(dict->fullname, gtkpspell->gtkpspeller->dictionary->fullname))
1919                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
1920                         else {
1921                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1922                                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1923                         }
1924                         gtk_signal_connect(GTK_OBJECT(item), "activate",
1925                                            GTK_SIGNAL_FUNC(change_dict_cb),
1926                                            gtkpspell);
1927                         gtk_widget_show(item);
1928                         gtk_menu_append(GTK_MENU(curmenu), item);
1929                         
1930                         count++;
1931                         
1932                         if (count == MENUCOUNT) {
1933                                 GtkWidget *newmenu;
1934                                 
1935                                 newmenu = gtk_menu_new();
1936                                 item = gtk_menu_item_new_with_label(_("More..."));
1937                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), 
1938                                                           newmenu);
1939                                 
1940                                 gtk_menu_append(GTK_MENU(curmenu), item);
1941                                 gtk_widget_show(item);
1942                                 curmenu = newmenu;
1943                                 count = 0;
1944                         }
1945                 }
1946         }  
1947
1948         
1949         
1950
1951 }
1952
1953 static GtkMenu *make_config_menu(GtkPspell *gtkpspell)
1954 {
1955         if (!gtkpspell->popup_config_menu)
1956                 gtkpspell->popup_config_menu = gtk_menu_new();
1957
1958         debug_print("Pspell: creating/using popup_config_menu %0x\n", 
1959                         gtkpspell->popup_config_menu);
1960         populate_submenu(gtkpspell, gtkpspell->popup_config_menu);
1961
1962         return GTK_MENU(gtkpspell->popup_config_menu);
1963 }
1964
1965 void gtkpspell_populate_submenu(GtkPspell *gtkpspell, GtkWidget *menuitem)
1966 {
1967         GtkWidget *menu;
1968
1969         menu = GTK_WIDGET(GTK_MENU_ITEM(menuitem)->submenu);
1970         
1971         debug_print("Pspell: using config menu %0x\n", 
1972                         gtkpspell->popup_config_menu);
1973         populate_submenu(gtkpspell, menu);
1974         
1975         gtkpspell->config_menu = menu;
1976         
1977 }
1978
1979 static void set_menu_pos(GtkMenu *menu, gint *x, gint *y, gpointer data)
1980 {
1981         GtkPspell       *gtkpspell = (GtkPspell *) data;
1982         gint             xx = 0, yy = 0;
1983         gint             sx,     sy;
1984         gint             wx,     wy;
1985         GtkSText        *text = GTK_STEXT(gtkpspell->gtktext);
1986         GtkRequisition   r;
1987
1988         gdk_window_get_origin(GTK_WIDGET(gtkpspell->gtktext)->window, &xx, &yy);
1989         
1990         sx = gdk_screen_width();
1991         sy = gdk_screen_height();
1992         
1993         gtk_widget_get_child_requisition(GTK_WIDGET(menu), &r);
1994         
1995         wx =  r.width;
1996         wy =  r.height;
1997         
1998         *x = gtkpspell->gtktext->cursor_pos_x + xx +
1999              gdk_char_width(GTK_WIDGET(text)->style->font, ' ');
2000         *y = gtkpspell->gtktext->cursor_pos_y + yy;
2001
2002         if (*x + wx > sx)
2003                 *x = sx - wx;
2004         if (*y + wy > sy)
2005                 *y = *y - wy - 
2006                      gdk_string_height((GTK_WIDGET(gtkpspell->gtktext))->style->font, 
2007                                        gtkpspell->theword);
2008
2009 }
2010
2011 /*************************************************************************/
2012 /* Menu call backs */
2013
2014 static gboolean cancel_menu_cb(GtkMenuShell *w, gpointer data)
2015 {
2016         GtkPspell *gtkpspell = (GtkPspell *) data;
2017         gtkpspell->continue_check = NULL;
2018         set_point_continue(gtkpspell);
2019         return FALSE;
2020         
2021 }
2022 /* change_dict_cb() - Menu callback : change dict */
2023 static void change_dict_cb(GtkWidget *w, GtkPspell *gtkpspell)
2024 {
2025         Dictionary      *dict;       
2026         gchar           *fullname;
2027         GtkPspeller     *gtkpspeller;
2028         gint             sug_mode;
2029   
2030         fullname = (gchar *) gtk_object_get_data(GTK_OBJECT(w), "dict_name");
2031         
2032         if (!strcmp2(fullname, _("None")))
2033                         return;
2034
2035         sug_mode  = gtkpspell->default_sug_mode;
2036
2037         dict = g_new0(Dictionary, 1);
2038         dict->fullname = g_strdup(fullname);
2039         dict->encoding = g_strdup(gtkpspell->gtkpspeller->dictionary->encoding);
2040         
2041         gtkpspeller = gtkpspeller_new(dict);
2042
2043         if (!gtkpspeller) {
2044                 gchar *message;
2045                 message = g_strdup_printf(_("The spell checker could not change dictionary.\n%s"), 
2046                                           gtkpspellcheckers->error_message);
2047
2048                 gtkpspell_alert_dialog(message); 
2049                 g_free(message);
2050         } else {
2051                 gtkpspeller_delete(gtkpspell->gtkpspeller);
2052                 gtkpspell->gtkpspeller = gtkpspeller;
2053                 gtkpspell_set_sug_mode(gtkpspell, sug_mode);
2054         }
2055         
2056         dictionary_delete(dict);
2057
2058         if (gtkpspell->config_menu)
2059                 populate_submenu(gtkpspell, gtkpspell->config_menu);
2060
2061 }
2062
2063 /******************************************************************************/
2064 /* Misc. helper functions */
2065
2066 static void set_point_continue(GtkPspell *gtkpspell)
2067 {
2068         GtkSText  *gtktext;
2069
2070         gtktext = gtkpspell->gtktext;
2071
2072         gtk_stext_freeze(gtktext);
2073         gtk_editable_set_position(GTK_EDITABLE(gtktext),gtkpspell->orig_pos);
2074         gtk_stext_set_point(gtktext, gtkpspell->orig_pos);
2075         gtk_stext_thaw(gtktext);
2076
2077         if (gtkpspell->continue_check)
2078                 gtkpspell->continue_check((gpointer *) gtkpspell);
2079 }
2080
2081 static void allocate_color(GtkPspell *gtkpspell, gint rgbvalue)
2082 {
2083         GdkColormap *gc;
2084         GdkColor *color = &(gtkpspell->highlight);
2085
2086         gc = gtk_widget_get_colormap(GTK_WIDGET(gtkpspell->gtktext));
2087
2088         if (gtkpspell->highlight.pixel)
2089                 gdk_colormap_free_colors(gc, &(gtkpspell->highlight), 1);
2090
2091         /* Shameless copy from Sylpheed's gtkutils.c */
2092         color->pixel = 0L;
2093         color->red   = (int) (((gdouble)((rgbvalue & 0xff0000) >> 16) / 255.0) * 65535.0);
2094         color->green = (int) (((gdouble)((rgbvalue & 0x00ff00) >>  8) / 255.0) * 65535.0);
2095         color->blue  = (int) (((gdouble) (rgbvalue & 0x0000ff)        / 255.0) * 65535.0);
2096
2097         gdk_colormap_alloc_color(gc, &(gtkpspell->highlight), FALSE, TRUE);
2098 }
2099
2100 static void change_color(GtkPspell * gtkpspell, 
2101                          gint start, gint end,
2102                          gchar *newtext,
2103                          GdkColor *color) 
2104 {
2105         GtkSText *gtktext;
2106
2107         g_return_if_fail(start < end);
2108     
2109         gtktext = gtkpspell->gtktext;
2110     
2111         gtk_stext_freeze(gtktext);
2112         if (newtext) {
2113                 gtk_stext_set_point(gtktext, start);
2114                 gtk_stext_forward_delete(gtktext, end - start);
2115                 gtk_stext_insert(gtktext, NULL, color, NULL, newtext, end - start);
2116         }
2117         gtk_stext_thaw(gtktext);
2118 }
2119
2120 /* convert_to_pspell_encoding () - converts ISO-8859-* strings to iso8859-* 
2121  * as needed by pspell. Returns an allocated string.
2122  */
2123
2124 static guchar *convert_to_pspell_encoding (const guchar *encoding)
2125 {
2126         guchar * pspell_encoding;
2127
2128         if (strstr2(encoding, "ISO-8859-")) {
2129                 pspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
2130         }
2131         else
2132                 if (!strcmp2(encoding, "US-ASCII"))
2133                         pspell_encoding = g_strdup("iso8859-1");
2134                 else
2135                         pspell_encoding = g_strdup(encoding);
2136
2137         return pspell_encoding;
2138 }
2139
2140 /* compare_dict () - compare 2 dict names */
2141 static gint compare_dict(Dictionary *a, Dictionary *b)
2142 {
2143         guint   aparts = 0,  bparts = 0;
2144         guint   i;
2145
2146         for (i=0; i < strlen(a->dictname); i++)
2147                 if (a->dictname[i] == '-')
2148                         aparts++;
2149         for (i=0; i < strlen(b->dictname); i++)
2150                 if (b->dictname[i] == '-')
2151                         bparts++;
2152
2153         if (aparts != bparts) 
2154                 return (aparts < bparts) ? -1 : +1;
2155         else {
2156                 gint compare;
2157                 compare = strcmp2(a->dictname, b->dictname);
2158                 if (!compare)
2159                         compare = strcmp2(a->fullname, b->fullname);
2160                 return compare;
2161         }
2162 }
2163
2164
2165 static void dictionary_delete(Dictionary *dict)
2166 {
2167         g_free(dict->fullname);
2168         g_free(dict->encoding);
2169         g_free(dict);
2170 }
2171
2172 static Dictionary *dictionary_dup(const Dictionary *dict)
2173 {
2174         Dictionary *dict2;
2175
2176         dict2 = g_new(Dictionary, 1); 
2177
2178         dict2->fullname = g_strdup(dict->fullname);
2179         dict2->dictname = dict->dictname - dict->fullname + dict2->fullname;
2180         dict2->encoding = g_strdup(dict->encoding);
2181
2182         return dict2;
2183 }
2184
2185 static void free_suggestions_list(GtkPspell *gtkpspell)
2186 {
2187         GList *list;
2188
2189         for (list = gtkpspell->suggestions_list; list != NULL; list = list->next)
2190                 g_free(list->data);
2191         g_list_free(list);
2192         
2193         gtkpspell->max_sug          = -1;
2194         gtkpspell->suggestions_list = NULL;
2195  
2196 }
2197
2198 static void reset_theword_data(GtkPspell *gtkpspell)
2199 {
2200         gtkpspell->start_pos     =  0;
2201         gtkpspell->end_pos       =  0;
2202         gtkpspell->theword[0]    =  0;
2203         gtkpspell->max_sug       = -1;
2204
2205         free_suggestions_list(gtkpspell);
2206 }
2207
2208 static void free_checkers(gpointer elt, gpointer data)
2209 {
2210         GtkPspeller *gtkpspeller = elt;
2211
2212         g_return_if_fail(gtkpspeller);
2213
2214         gtkpspeller_real_delete(gtkpspeller);
2215 }
2216
2217 static gint find_gtkpspeller(gconstpointer aa, gconstpointer bb)
2218 {
2219         Dictionary *a = ((GtkPspeller *) aa)->dictionary;
2220         Dictionary *b = ((GtkPspeller *) bb)->dictionary;
2221
2222         if (a && b && a->fullname && b->fullname  &&
2223             strcmp(a->fullname, b->fullname) == 0 &&
2224             a->encoding && b->encoding)
2225                 return strcmp(a->encoding, b->encoding);
2226
2227         return 1;
2228 }
2229
2230 static void gtkpspell_alert_dialog(gchar *message)
2231 {
2232         GtkWidget *dialog;
2233         GtkWidget *hbox;
2234         GtkWidget *label;
2235         GtkWidget *ok_button;
2236
2237         dialog = gtk_dialog_new();
2238         gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
2239         gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_MOUSE);
2240         gtk_signal_connect_object(GTK_OBJECT(dialog), "destroy",
2241                                    GTK_SIGNAL_FUNC(gtk_widget_destroy), 
2242                                    GTK_OBJECT(dialog));
2243
2244         label  = gtk_label_new(message);
2245         gtk_misc_set_padding(GTK_MISC(label), 8, 8);
2246
2247         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
2248         
2249         hbox = gtk_hbox_new(FALSE, 0);
2250
2251         ok_button = gtk_button_new_with_label(_("OK"));
2252         GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
2253         gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 8);    
2254
2255         gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
2256                                    GTK_SIGNAL_FUNC(gtk_widget_destroy), 
2257                                    GTK_OBJECT(dialog));
2258         gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), hbox);
2259                         
2260         gtk_widget_grab_default(ok_button);
2261         gtk_widget_grab_focus(ok_button);
2262         gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
2263
2264         gtk_widget_show_all(dialog);
2265 }
2266 #endif