616ceeef181464f53b0b7c179923ae4295f2a53c
[claws.git] / src / gtkspell.c
1 /* gtkpspell - a spell-checking addon for GtkText
2  * Copyright (c) 2000 Evan Martin.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
17  */
18
19 /*
20  * Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev
21  * Adapted for Sylpheed (Claws) (c) 2001 by Hiroyuki Yamamoto & 
22  * The Sylpheed Claws Team.
23  * Adapted for pspell (c) 2001 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 <sys/types.h>
35 #include <sys/wait.h>
36 #include <unistd.h>
37 #include <stdio.h>
38 #include <signal.h>
39 #include <ctype.h>
40 #include <string.h>
41 #include <stdlib.h>
42 #include <errno.h>
43 #include <stdio.h>
44 #include <sys/time.h>
45 #include <fcntl.h>
46 #include <time.h>
47 #include <prefs_common.h>
48 #include <utils.h>
49
50 #include <dirent.h>
51
52 #include <gtk/gtkoptionmenu.h>
53 #include <gtk/gtkmenu.h>
54 #include <gtk/gtkmenuitem.h>
55
56 #include "gtkxtext.h"
57
58 #include "gtkspell.h"
59
60 #include <pspell/pspell.h>
61 /* size of the text buffer used in various word-processing routines. */
62 #define BUFSIZE 1024
63
64 /* number of suggestions to display on each menu. */
65 #define MENUCOUNT 15
66
67 /******************************************************************************/
68
69 /* Function called from menus */
70
71 static void add_word_to_session         (GtkWidget *w, GtkPspell *d);
72 static void add_word_to_personal        (GtkWidget *w, GtkPspell *d);
73 static void set_sug_mode                (GtkWidget *w, GtkPspell *gtkpspell);
74 static void set_learn_mode              (GtkWidget *w, GtkPspell *gtkpspell);
75 static void check_all                   (GtkWidget *w, GtkPspell *gtkpspell);
76 static void menu_change_dict            (GtkWidget *w, GtkPspell *gtkpspell);
77 static void entry_insert_cb             (GtkXText *gtktext, gchar *newtext, 
78                                          guint len, guint *ppos, 
79                                          GtkPspell *gtkpspell);
80 static gint compare_dict                (Dictionary *a, Dictionary *b);
81 guchar *convert_to_pspell_encoding      (const guchar *encoding);
82
83 static void allocate_color(GtkPspell *gtkpspell);
84
85 /* gtkspellconfig - only one config per session */
86 GtkPspellConfig * gtkpspellconfig;
87
88 /******************************************************************************/
89
90 /* gtkspell_init() - run the first pspell_config from which every
91  * new config is cloned 
92  */
93 GtkPspellConfig * gtkpspell_init()
94 {
95         return new_pspell_config();
96 }
97
98 /* gtkspell_finished() - Finish all. No more spelling. Called when the 
99  * program ends 
100  */
101 void gtkpspell_finished(GtkPspellConfig *gtkpspellconfig)
102 {
103         if (gtkpspellconfig) {
104                 delete_pspell_config(gtkpspellconfig);
105                 gtkpspellconfig = NULL;
106         }
107 }
108
109 /* gtkspell_running - Test if there is a manager running 
110  */
111 int gtkpspell_running(GtkPspell * gtkpspell) 
112 {
113         return (gtkpspell->config!=NULL);
114 }
115
116 /* gtkspell_new() - creates a new session if a gtkpspellconfig exists. The 
117  * settings are defaults.  If no path/dict is set afterwards, the default 
118  * one is used  
119  */
120 GtkPspell * gtkpspell_new(GtkPspellConfig *gtkpspellconfig)
121 {
122         GtkPspell *gtkpspell;
123
124         if (gtkpspellconfig == NULL) {
125                 gtkpspellconfig = gtkpspell_init();
126                 if (gtkpspellconfig == NULL) {
127                         debug_print(_("Pspell could not be started."));
128                         prefs_common.enable_pspell=FALSE;
129                         return NULL;
130                 }
131         }
132
133         gtkpspell               = g_new(GtkPspell ,1);
134         gtkpspell->config       = gtkpspellconfig;
135         gtkpspell->possible_err = new_pspell_manager(gtkpspell->config);
136         gtkpspell->checker      = NULL;
137
138         if (pspell_error_number(gtkpspell->possible_err) != 0) {
139                 debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err));
140                 delete_pspell_can_have_error( gtkpspell->possible_err );
141         }
142         else {
143                 gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err);
144         }
145  
146         gtkpspell->dictionary_list = NULL;
147         gtkpspell->path            = NULL;
148         gtkpspell->dict            = NULL;
149         gtkpspell->mode            = PSPELL_FASTMODE;
150         gtkpspell->learn           = TRUE;
151         gtkpspell->gtktext         = NULL;
152
153         return gtkpspell;
154 }
155
156 /* gtkspell_new_with_config() - Creates a new session and set path/dic 
157  */
158 GtkPspell *gtkpspell_new_with_config(GtkPspellConfig *gtkpspellconfig, 
159                                      guchar *path, guchar *dict, 
160                                      guint mode, const guchar *encoding)
161 {
162         GtkPspell *gtkpspell;
163
164         if (gtkpspellconfig == NULL) {
165                 gtkpspellconfig=gtkpspell_init();
166                 if (gtkpspellconfig == NULL) {
167                         debug_print(_("Pspell could not be started."));
168                         prefs_common.enable_pspell = FALSE;
169                         return NULL;
170                 }
171         }
172
173         gtkpspell                  = g_new( GtkPspell ,1);
174         gtkpspell->path            = NULL;
175         gtkpspell->dict            = NULL;
176         gtkpspell->dictionary_list = NULL;
177         gtkpspell->gtktext         = NULL;
178   
179         gtkpspell->config          = pspell_config_clone(gtkpspellconfig);
180         gtkpspell->mode            = PSPELL_FASTMODE;
181         gtkpspell->learn           = TRUE;
182         
183         if (!set_path_and_dict(gtkpspell, gtkpspell->config, path, dict)) {
184                 debug_print(_("Pspell could not be configured."));
185                 gtkpspell = gtkpspell_delete(gtkpspell);
186                 return gtkpspell;
187         }
188         
189         if (encoding) {
190                 char *pspell_encoding;
191                 pspell_encoding = convert_to_pspell_encoding (encoding);
192                 debug_print(_("Pspell encoding: asked: %s changed to: %s\n"), encoding, pspell_encoding);
193                 pspell_config_replace(gtkpspell->config, "encoding", (const char *)pspell_encoding);
194                 if (pspell_config_error_number(gtkpspell->config) !=0 ) {
195                         debug_print(_("Pspell encoding error: %s\nSwitching to iso8859-1 (sorry)\n"), 
196                                     pspell_config_error_message(gtkpspell->config));
197                         pspell_config_replace(gtkpspell->config, "encoding", "iso8859-1");
198                 }
199                 g_free(pspell_encoding);
200         }
201
202         gtkpspell->possible_err = new_pspell_manager(gtkpspell->config);
203         gtkpspell->checker      = NULL;
204
205         if (pspell_error_number(gtkpspell->possible_err) != 0) {
206                 debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err));
207                 delete_pspell_can_have_error(gtkpspell->possible_err);
208                 gtkpspell = gtkpspell_delete(gtkpspell);
209         }
210         else {
211                 gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err );
212         }
213
214         return gtkpspell;
215 }
216
217 /* gtkspell_delete() - Finishes a session 
218  */
219 GtkPspell *gtkpspell_delete( GtkPspell *gtkpspell )
220 {
221         if ( gtkpspell->checker ) {
222                 /* First save all word lists */
223                 pspell_manager_save_all_word_lists(gtkpspell->checker);
224                 delete_pspell_manager(gtkpspell->checker);
225                 gtkpspell->checker      = NULL;
226                 gtkpspell->possible_err = NULL; /* checker is a cast from possible_err */
227         }
228
229         if (gtkpspell->dictionary_list)
230                 gtkpspell_free_dictionary_list(gtkpspell->dictionary_list);
231
232         g_free(gtkpspell->path);
233         g_free(gtkpspell->dict);
234         gtkpspell->path = NULL;
235         gtkpspell->dict = NULL;
236
237         g_free(gtkpspell);
238         return NULL;
239 }
240   
241 int set_path_and_dict(GtkPspell *gtkpspell, PspellConfig *config,
242                       guchar *path, guchar * dict)
243 {
244         guchar *module   = NULL;
245         guchar *language = NULL;
246         guchar *spelling = NULL;
247         guchar *jargon   = NULL;
248         guchar  buf[BUFSIZE];
249         guchar *end;
250         guchar *temppath;
251         guchar *tempdict;
252
253         /* Change nothing if any of path/dict/config is NULL */
254         g_return_val_if_fail(path, 0);
255         g_return_val_if_fail(dict, 0);
256         g_return_val_if_fail(config, 0);
257         
258         /* This is done, so we can free gtkpspell->path, even if it was
259          * given as an argument of the function */
260         temppath = g_strdup(path);
261         g_free(gtkpspell->path);
262   
263         /* pspell dict name format :                         */
264         /*   <lang>[[-<spelling>[-<jargon>]]-<module>.pwli   */
265         /* Strip off path                                    */
266         
267         if (!strrchr(dict,G_DIR_SEPARATOR)) {
268                 /* plain dict name */
269                 strncpy(buf,dict,BUFSIZE-1);
270         }
271         else { 
272                 /* strip path */
273                 strncpy(buf, strrchr(dict, G_DIR_SEPARATOR)+1, BUFSIZE-1);
274         }
275         
276         g_free(gtkpspell->dict);
277
278         /* Ensure no buffers overflows if the dict is to long */
279         buf[BUFSIZE-1] = 0x00;
280
281         language = buf;
282         if ((module = strrchr(buf, '-')) != NULL) {
283                 module++;
284                 if ((end = strrchr(module, '.')) != NULL)
285                         end[0] = 0x00;
286         }
287
288         /* In tempdict, we have only the dict name, without path nor
289            extension. Useful in the popup menus */
290
291         tempdict = g_strdup(buf);
292
293         /* Probably I am too paranoied... */
294         if (!(language[0] != 0x00 && language[1] != 0x00))
295                 language = NULL;
296         else {
297                 spelling = strchr(language, '-');
298                 if (spelling != NULL) {
299                         spelling[0] = 0x00;
300                         spelling++;
301                 }
302                 if (spelling != module) {
303                         if ((end = strchr(spelling, '-')) != NULL) {
304                                 end[0] = 0x00;
305                                 jargon = end + 1;
306                                 if (jargon != module)
307                                         if ((end = strchr(jargon, '-')) != NULL)
308                                                 end[0] = 0x00;
309                                         else
310                                                 jargon = NULL;
311                                 else
312                                         jargon = NULL;
313                         }
314                         else
315                                 spelling = NULL;
316                 }
317                 else 
318                         spelling = NULL;
319         }
320
321         debug_print(_("Language : %s\nSpelling: %s\nJargon: %s\nModule: %s\n"),
322                     language, spelling, jargon, module);
323         
324         if (temppath[strlen(temppath)-1] == G_DIR_SEPARATOR) 
325                 temppath[strlen(temppath)-1]= 0;
326         if (temppath) {
327                 pspell_config_replace(config, "add-word-list-path", temppath);
328                 debug_print(_("Pspell config: added path %s\n"), pspell_config_retrieve(config, "word-list-path"));
329                 if (pspell_config_error_number(config))
330                         debug_print(_("Pspell config: %s\n"), pspell_config_error_message(config));
331         }
332         if (language) 
333                 pspell_config_replace(config, "language-tag", language);
334         if (spelling) 
335                 pspell_config_replace(config, "spelling", spelling);
336         if (jargon)
337                 pspell_config_replace(config, "jargon", jargon);
338         if (module)
339                 pspell_config_replace(config, "module", module);
340
341         switch(gtkpspell->mode) {
342         case PSPELL_FASTMODE: 
343                 pspell_config_replace(config, "sug-mode", "fast");
344                 break;
345         case PSPELL_NORMALMODE: 
346                 pspell_config_replace(config, "sug-mode", "normal");
347                 break;
348         case PSPELL_BADSPELLERMODE: 
349                 pspell_config_replace(config, "sug-mode", "bad-spellers");
350                 break;
351         }
352   
353         gtkpspell->path = g_strdup(temppath);
354         gtkpspell->dict = g_strdup(tempdict);
355         g_free(temppath);
356         g_free(tempdict);
357
358         return TRUE;
359 }
360
361
362 /* gtkpspell_set_path_and_dict() - Set path and dict. The session is 
363  * resetted. 
364  * FALSE on error, TRUE on success */
365 int gtkpspell_set_path_and_dict(GtkPspell * gtkpspell, guchar * path, 
366                                 guchar * dict)
367 {
368         PspellConfig * config2;
369
370         /* It seems changing an already running config is not the way to go
371          */
372
373         config2 = pspell_config_clone(gtkpspell->config);
374
375         if (gtkpspell->checker) {
376                 pspell_manager_save_all_word_lists(gtkpspell->checker);
377                 delete_pspell_manager(gtkpspell->checker);
378         }
379         
380         gtkpspell->checker      = NULL;
381         gtkpspell->possible_err = NULL;
382
383         if (set_path_and_dict(gtkpspell,config2,path,dict) == 0) {
384                 debug_print(_("Pspell set_path_and_dict error."));
385                 return FALSE;
386         }
387   
388         gtkpspell->possible_err = new_pspell_manager(config2);
389
390         delete_pspell_config(config2);
391         config2 = NULL;
392
393         if (pspell_error_number(gtkpspell->possible_err) != 0) {
394                 debug_print(_("Pspell path & dict. error %s\n"),
395                             pspell_error_message(gtkpspell->possible_err));
396                 delete_pspell_can_have_error(gtkpspell->possible_err);
397                 gtkpspell->possible_err = NULL;
398                 return FALSE;
399         }
400
401         gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err);
402
403         return TRUE;
404 }
405   
406 /* gtkpspell_get_dict() - What dict are we using ? language-spelling-jargon-module format */
407 /* Actually, this function is not used and hence not tested. */
408 /* Returns an allocated string */  
409 guchar *gtkpspell_get_dict(GtkPspell *gtkpspell)
410 {
411 /* Number of dashes in a dictionary name + 1 (for trailing null)
412  * needed when rebuilding dictionary name 
413  */
414 #define DASHES_IN_DICTNAME 3+1
415
416         guchar *dict;
417         guchar *language;
418         guchar *spelling;
419         guchar *jargon;
420         guint   len;
421
422         g_return_val_if_fail(gtkpspell->config, NULL);
423   
424         language = g_strdup(pspell_config_retrieve(gtkpspell->config, "language"));
425         spelling = g_strdup(pspell_config_retrieve(gtkpspell->config, "spelling"));
426         jargon   = g_strdup(pspell_config_retrieve(gtkpspell->config, "jargon"  ));
427         len      = strlen(language) + strlen(spelling) + strlen(jargon);
428
429         if (len + DASHES_IN_DICTNAME < BUFSIZE) {
430                 dict = g_new(char,len + DASHES_IN_DICTNAME);
431                 strcpy(dict, language);
432                 if (spelling) {
433                         strcat(dict, "-");
434                         strcat(dict, spelling);
435                         if (jargon) {
436                                 strcat(dict, "-");
437                                 strcat(dict,jargon);
438                         }
439                 }
440         }
441         g_free(language);
442         g_free(spelling);
443         g_free(jargon);
444   
445         return dict;
446 }
447   
448 /* gtkpspell_get_path() - Return the dict path as an allocated string */
449 /* Not used = not tested */
450 guchar *gtkpspell_get_path(GtkPspell *gtkpspell)
451 {
452         guchar * path;
453
454
455         g_return_val_if_fail(gtkpspell->config, NULL);
456
457         path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path"));
458
459         return path;
460 }
461
462 /* menu_change_dict() - Menu callback : change dict */
463 static void menu_change_dict(GtkWidget *w, GtkPspell *gtkpspell)
464 {
465         guchar *thedict,
466                *thelabel;
467   
468         /* Dict is simply the menu label */
469
470         gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &thelabel);
471
472         if (!strcmp2(thelabel, _("None")))
473                         return;
474
475         thedict = g_strdup(thelabel);
476
477         /* Set path, dict, (and sug_mode ?) */
478         if(!gtkpspell_set_path_and_dict(gtkpspell, gtkpspell->path, thedict)) {
479                 /* FIXME : try to handle this very special case */
480                 debug_print("Pspell: Attempt to change to a non existant dict. I will crash after closing compose window.\n");
481                 gtkpspell_detach(gtkpspell);
482                 gtkpspell = gtkpspell_delete(gtkpspell);
483         }
484         g_free(thedict);
485 }
486
487 /* set_sug_mode() - Menu callback : Set the suggestion mode */
488 static void set_sug_mode(GtkWidget *w, GtkPspell *gtkpspell)
489 {
490         unsigned char *themode;
491
492         gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode);
493
494         if (!strcmp(themode, _("Fast Mode"))) {
495                 gtkpspell_set_sug_mode(gtkpspell, "fast");
496                 gtkpspell->mode = PSPELL_FASTMODE;
497         }
498         if (!strcmp(themode,_("Normal Mode"))) {
499                 gtkpspell_set_sug_mode(gtkpspell, "normal");
500                 gtkpspell->mode = PSPELL_NORMALMODE;
501         }
502         if (!strcmp( themode,_("Bad Spellers Mode"))) {
503                 gtkpspell_set_sug_mode(gtkpspell, "bad-spellers");
504                 gtkpspell->mode = PSPELL_BADSPELLERMODE;
505         }
506 }
507   
508 /* gtkpspell_set_sug_mode() - Set the suggestion mode */
509 /* Actually, the session is resetted and everything is reset. */
510 /* We take the used path/dict pair and create a new config with them */
511 int gtkpspell_set_sug_mode(GtkPspell *gtkpspell, gchar *themode)
512 {
513         PspellConfig *config2;
514         guchar       *path;
515         guchar       *dict;
516
517         pspell_manager_save_all_word_lists(gtkpspell->checker);
518         delete_pspell_manager(gtkpspell->checker);
519
520         gtkpspell->checker = NULL;
521
522         config2 = pspell_config_clone(gtkpspell->config);
523
524         if (!set_path_and_dict(gtkpspell, config2, gtkpspell->path, gtkpspell->dict)) {
525                 debug_print(_("Pspell set_sug_mod could not reset path & dict\n"));
526                 return FALSE;
527         }
528
529         pspell_config_replace(config2, "sug-mode", themode);
530
531         gtkpspell->possible_err = new_pspell_manager(config2);
532         delete_pspell_config(config2);
533         config2 = NULL;
534
535         if (pspell_error_number(gtkpspell->possible_err) != 0) {
536                 debug_print(_("Pspell set sug-mode error %s\n"),
537                             pspell_error_message(gtkpspell->possible_err));
538                 delete_pspell_can_have_error(gtkpspell->possible_err);
539                 gtkpspell->possible_err = NULL;
540                 return FALSE;
541         }
542         gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err);
543         return TRUE;
544 }
545
546 /* set_learn_mode() - menu callback to toggle learn mode */
547 static void set_learn_mode (GtkWidget *w, GtkPspell *gtkpspell)
548 {
549         gtkpspell->learn = gtkpspell->learn == FALSE ;
550 }
551   
552 /* misspelled_suggest() - Create a suggestion list for  word  */
553 static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word) 
554 {
555         const guchar          *newword;
556         GList                 *list = NULL;
557         int                    count;
558         const PspellWordList  *suggestions;
559         PspellStringEmulation *elements;
560
561         g_return_val_if_fail(word, NULL);
562
563         if (!pspell_manager_check(gtkpspell->checker, word, -1)) {
564                 suggestions = pspell_manager_suggest(gtkpspell->checker, (const char *)word, -1);
565                 elements    = pspell_word_list_elements(suggestions);
566                 /* First one must be the misspelled (why this ?) */
567                 list        = g_list_append(list, g_strdup(word)); 
568                 
569                 while ((newword = pspell_string_emulation_next(elements)) != NULL)
570                         list = g_list_append(list, g_strdup(newword));
571                 return list;
572         }
573         return NULL;
574 }
575
576 /* misspelled_test() - Just test if word is correctly spelled */  
577 static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word) 
578 {
579         return pspell_manager_check(gtkpspell->checker, word, -1) ? 0 : 1; 
580 }
581
582
583 static gboolean iswordsep(unsigned char c) 
584 {
585         return !isalpha(c) && c != '\'';
586 }
587
588 static guchar get_text_index_whar(GtkPspell *gtkpspell, int pos) 
589 {
590         guchar a;
591         gchar *text;
592         
593         text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1);
594         if (text == NULL) 
595                 return 0;
596         a = (guchar) *text;
597         g_free(text);
598         return a;
599 }
600
601 /* get_word_from_pos () - return the word pointed to. */
602 /* Handles correctly the quotes. */
603 static gboolean get_word_from_pos(GtkPspell *gtkpspell, int pos, 
604                                   unsigned char* buf,
605                                   int *pstart, int *pend) 
606 {
607
608         /* TODO : when correcting a word into quotes, change the color of */
609         /* the quotes too, as may be they were highlighted before. To do  */
610         /* so, we can use two others pointers that points to the whole    */
611         /* word including quotes. */
612
613         gint      start, 
614                   end;
615         guchar    c;
616         GtkXText *gtktext;
617         
618         gtktext = gtkpspell->gtktext;
619         if (iswordsep(get_text_index_whar(gtkpspell, pos))) 
620                 return FALSE;
621         
622         /* The apostrophe character is somtimes used for quotes 
623          * So include it in the word only if it is not surrounded 
624          * by other characters. 
625          */
626          
627         for (start = pos; start >= 0; --start) {
628                 c = get_text_index_whar(gtkpspell, start);
629                 if (c == '\'') {
630                         if (start > 0) {
631                                 if (!isalpha(get_text_index_whar(gtkpspell, start - 1))) {
632                                         /* start_quote = TRUE; */
633                                         break;
634                                 }
635                         }
636                         else {
637                                 /* start_quote = TRUE; */
638                                 break;
639                         }
640                 }
641                 else
642                         if (!isalpha(c))
643                                 break;
644         }
645         start++;
646
647         for (end = pos; end < gtk_xtext_get_length(gtktext); end++) {
648                 c = get_text_index_whar(gtkpspell, end); 
649                 if (c == '\'') {
650                         if (end < gtk_xtext_get_length(gtktext)) {
651                                 if (!isalpha(get_text_index_whar(gtkpspell, end + 1))) {
652                                         /* end_quote = TRUE; */
653                                         break;
654                                 }
655                         }
656                         else {
657                                 /* end_quote = TRUE; */
658                                 break;
659                         }
660                 }
661                 else
662                         if(!isalpha(c))
663                                 break;
664         }
665                                                 
666         if (buf) {
667                 for (pos = start; pos < end; pos++) 
668                         buf[pos - start] = get_text_index_whar(gtkpspell, pos);
669                 buf[pos - start] = 0;
670         }
671
672         if (pstart) 
673                 *pstart = start;
674         if (pend) 
675                 *pend = end;
676
677         return TRUE;
678 }
679
680 static gboolean get_curword(GtkPspell *gtkpspell, unsigned char* buf,
681                             int *pstart, int *pend) 
682 {
683         int pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
684         return get_word_from_pos(gtkpspell, pos, buf, pstart, pend);
685 }
686
687 static void change_color(GtkPspell * gtkpspell, 
688                          int start, int end, 
689                          GdkColor *color) 
690 {
691         char     *newtext;
692         GtkXText *gtktext;
693
694         g_return_if_fail(start < end);
695     
696         gtktext = gtkpspell->gtktext;
697     
698         gtk_xtext_freeze(gtktext);
699         newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end);
700         if (newtext) {
701                 gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
702                                                  GTK_SIGNAL_FUNC(entry_insert_cb), 
703                                                  gtkpspell);
704                 gtk_xtext_set_point(gtktext, start);
705                 gtk_xtext_forward_delete(gtktext, end - start);
706
707                 gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start);
708                 gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
709                                                    GTK_SIGNAL_FUNC(entry_insert_cb), 
710                                                    gtkpspell);
711                 g_free(newtext);
712         }
713         gtk_xtext_thaw(gtktext);
714 }
715
716 static gboolean check_at(GtkPspell *gtkpspell, int from_pos) 
717 {
718         int           start, end;
719         unsigned char buf[BUFSIZE];
720         GtkXText     *gtktext;
721
722         g_return_val_if_fail(from_pos >= 0, FALSE);
723     
724         gtktext = gtkpspell->gtktext;
725
726         if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end))
727                 return FALSE;
728
729         strncpy(gtkpspell->theword, buf, BUFSIZE - 1);
730         gtkpspell->theword[BUFSIZE - 1] = 0;
731
732         if (misspelled_test(gtkpspell, buf)) {
733                         change_color(gtkpspell, start, end, &(gtkpspell->highlight));
734                 return TRUE;
735         } else {
736                 change_color(gtkpspell, start, end, NULL);
737                 return FALSE;
738         }
739 }
740
741
742 static void check_all(GtkWidget *w, GtkPspell *gtkpspell)
743 {
744         gtkpspell_check_all(gtkpspell);
745 }
746
747
748 void gtkpspell_check_all(GtkPspell *gtkpspell) 
749 {
750         guint     origpos;
751         guint     pos = 0;
752         guint     len;
753         float     adj_value;
754         GtkXText *gtktext;
755
756         
757         if (!gtkpspell_running(gtkpspell)) return ;
758         gtktext = gtkpspell->gtktext;
759
760         len = gtk_xtext_get_length(gtktext);
761
762         adj_value = gtktext->vadj->value;
763         gtk_xtext_freeze(gtktext);
764         origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
765         gtk_editable_set_position(GTK_EDITABLE(gtktext),0);
766         while (pos < len) {
767                 while (pos < len && iswordsep(get_text_index_whar(gtkpspell, pos)))
768                         pos++;
769                 while (pos < len && !iswordsep(get_text_index_whar(gtkpspell, pos)))
770                         pos++;
771                 if (pos > 0)
772                         check_at(gtkpspell, pos - 1);
773         }
774         gtk_xtext_thaw(gtktext);
775         gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
776         gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
777 }
778
779 static void entry_insert_cb(GtkXText *gtktext, gchar *newtext, 
780                             guint len, guint *ppos, 
781                             GtkPspell * gtkpspell) 
782 {
783         guint origpos;
784         if (!gtkpspell_running(gtkpspell)) 
785                 return;
786
787         /* We must insert ourself the character to impose the */
788         /* color of the inserted character to be default */
789         /* Never mess with set_insertion when frozen */
790         gtk_xtext_freeze(gtktext);
791         gtk_xtext_backward_delete(GTK_XTEXT(gtktext), len);
792         gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newtext, len);
793         *ppos = gtk_xtext_get_point(GTK_XTEXT(gtktext));
794                
795         if (iswordsep(newtext[0])) {
796                 /* did we just end a word? */
797                 if (*ppos >= 2) 
798                         check_at(gtkpspell, *ppos - 2);
799
800                 /* did we just split a word? */
801                 if (*ppos < gtk_xtext_get_length(gtktext))
802                         check_at(gtkpspell, *ppos + 1);
803         } else {
804                 /* check as they type, *except* if they're typing at the end (the most
805                  * common case.
806                  */
807                 if (*ppos < gtk_xtext_get_length(gtktext) 
808                 &&  !iswordsep(get_text_index_whar(gtkpspell, *ppos)))
809                         check_at(gtkpspell, *ppos - 1);
810                 }
811         gtk_xtext_thaw(gtktext);
812         gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos);
813 }
814
815 static void entry_delete_cb(GtkXText *gtktext, gint start, gint end, 
816                             GtkPspell *gtkpspell) 
817 {
818         int origpos;
819     
820         if (!gtkpspell_running(gtkpspell)) 
821                 return;
822
823         origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
824         if (start) {
825                 check_at(gtkpspell, start - 1);
826                 check_at(gtkpspell, start);
827         }
828
829         gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
830         gtk_xtext_set_point(gtktext, origpos);
831         gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
832         /* this is to *UNDO* the selection, in case they were holding shift
833          * while hitting backspace. */
834 }
835
836 static void replace_word(GtkWidget *w, GtkPspell *gtkpspell) 
837 {
838         int             start, end,oldlen, newlen;
839         guint           origpos;
840         unsigned char  *newword;
841         unsigned char   buf[BUFSIZE];
842         guint           pos;
843         GtkXText       *gtktext;
844     
845         gtktext = gtkpspell->gtktext;
846
847         gtk_xtext_freeze(GTK_XTEXT(gtktext));
848         origpos = gtkpspell->orig_pos;
849         pos     = origpos;
850
851         gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
852         newlen = strlen(newword);
853
854         get_curword(gtkpspell, buf, &start, &end);
855         oldlen = end - start;
856
857         gtk_xtext_set_point(GTK_XTEXT(gtktext), end);
858         gtk_xtext_backward_delete(GTK_XTEXT(gtktext), end - start);
859         gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newword, strlen(newword));
860     
861         if (end-start > 0 && gtkpspell->learn) { 
862                 /* Just be sure the buffer ends somewhere... */
863                 buf[end-start] = 0; 
864                 /* Learn from common misspellings */
865                 pspell_manager_store_replacement(gtkpspell->checker, buf, 
866                                                  end-start, newword, 
867                                                  strlen(newword));
868         }
869
870         /* Put the point and the position where we clicked with the mouse */
871         /* It seems to be a hack, as I must thaw,freeze,thaw the widget   */
872         /* to let it update correctly the word insertion and then the     */
873         /* point & position position. If not, SEGV after the first replacement */
874         /* If the new word ends before point, put the point at its end*/
875     
876         if (origpos-start <= oldlen && origpos-start >= 0) {
877                 /* Original point was in the word. */
878                 /* Put the insertion point in the same location */
879                 /* with respect to the new length */
880                 /* If the original position is still within the word, */
881                 /* then keep the original position. If not, move to the */
882                 /* end of the word */
883                 if (origpos-start > newlen)
884                         pos = start + newlen;
885         }
886         else if (origpos > end) {
887                 /* move the position according to the change of length */
888                 pos = origpos + newlen - oldlen;
889         }
890         gtk_xtext_thaw(GTK_XTEXT(gtktext));
891         gtk_xtext_freeze(GTK_XTEXT(gtktext));
892         if (GTK_XTEXT(gtktext)->text_len < pos)
893                 pos = gtk_xtext_get_length(GTK_XTEXT(gtktext));
894         gtkpspell->orig_pos = pos;
895         gtk_editable_set_position(GTK_EDITABLE(gtktext), gtkpspell->orig_pos);
896         gtk_xtext_set_point(GTK_XTEXT(gtktext), 
897                             gtk_editable_get_position(GTK_EDITABLE(gtktext)));
898         gtk_xtext_thaw(GTK_XTEXT(gtktext));
899 }
900
901 /* Accept this word for this session */
902
903 static void add_word_to_session(GtkWidget *w, GtkPspell *gtkpspell)
904 {
905         guint     pos;
906         GtkXText *gtkxtext;
907     
908         gtkxtext = gtkpspell->gtktext;
909         gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
910         pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
911     
912         pspell_manager_add_to_session(gtkpspell->checker,gtkpspell->theword, strlen(gtkpspell->theword));
913
914         check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
915
916         gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
917         gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
918         gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
919         gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
920         gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
921 }
922
923 /* add_word_to_personal() - add word to personal dict. */
924
925 static void add_word_to_personal(GtkWidget *w, GtkPspell *gtkpspell)
926 {
927         guint     pos;
928         GtkXText *gtkxtext;
929     
930         gtkxtext = gtkpspell->gtktext;
931
932         gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
933         pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
934     
935         pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword));
936     
937         check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
938         gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
939         gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
940         gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
941         gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
942         gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
943 }
944
945        
946 static GtkMenu *make_menu_config(GtkPspell *gtkpspell)
947 {
948         GtkWidget *menu, *item, *submenu;
949
950   
951         menu = gtk_menu_new();
952
953         item = gtk_menu_item_new_with_label(_("Spell check all"));
954         gtk_widget_show(item);
955         gtk_menu_append(GTK_MENU(menu), item);
956         gtk_signal_connect(GTK_OBJECT(item),"activate",
957                            GTK_SIGNAL_FUNC(check_all), 
958                            gtkpspell);
959
960
961         item = gtk_menu_item_new();
962         gtk_widget_show(item);
963         gtk_menu_append(GTK_MENU(menu),item);
964
965         submenu = gtk_menu_new();
966         item = gtk_menu_item_new_with_label(_("Change dictionary"));
967         gtk_widget_show(item);
968         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
969         gtk_menu_append(GTK_MENU(menu), item);
970
971         /* Dict list */
972         if (gtkpspell->dictionary_list==NULL)
973                 gtkpspell->dictionary_list = gtkpspell_get_dictionary_list(gtkpspell->path);
974        
975         {
976                 GtkWidget * curmenu = submenu;
977                 int count = 0;
978                 Dictionary *dict;
979                 GSList *tmp;
980                 
981                 tmp = gtkpspell->dictionary_list;
982                 for (tmp = gtkpspell->dictionary_list; tmp != NULL; tmp =g_slist_next(tmp)) {
983                         dict = (Dictionary *) tmp->data;
984                         item = gtk_check_menu_item_new_with_label(dict->name);
985                         if (strcmp2(dict->name, gtkpspell->dict))
986                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
987                         else {
988                                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
989                                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
990                         }
991                         gtk_menu_append(GTK_MENU(curmenu), item);
992                         gtk_signal_connect(GTK_OBJECT(item), "activate",
993                                            GTK_SIGNAL_FUNC(menu_change_dict),
994                                            gtkpspell);
995                         gtk_widget_show(item);
996                         count++;
997                         if (count == MENUCOUNT) {
998                                 GtkWidget *newmenu;
999                                 newmenu = gtk_menu_new();
1000                                 item = gtk_menu_item_new_with_label(_("More..."));
1001                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), newmenu);
1002                                 gtk_menu_append(GTK_MENU(curmenu), item);
1003                                 gtk_widget_show(item);
1004                                 curmenu = newmenu;
1005                                 count = 0;
1006                         }
1007                 }
1008         }  
1009
1010         item = gtk_menu_item_new();
1011         gtk_widget_show(item);
1012         gtk_menu_append(GTK_MENU(menu), item);
1013
1014         item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
1015         gtk_widget_show(item);
1016         gtk_menu_append(GTK_MENU(menu), item);
1017         if (gtkpspell->mode == PSPELL_FASTMODE) {
1018                 gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
1019                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
1020         }
1021         else
1022                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1023                                    GTK_SIGNAL_FUNC(set_sug_mode),
1024                                    gtkpspell);
1025
1026         item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
1027         gtk_widget_show(item);
1028         gtk_menu_append(GTK_MENU(menu),item);
1029         if (gtkpspell->mode == PSPELL_NORMALMODE) {
1030                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1031                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1032         }
1033         else
1034                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1035                                    GTK_SIGNAL_FUNC(set_sug_mode),
1036                                    gtkpspell);
1037         
1038         item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
1039         gtk_widget_show(item);
1040         gtk_menu_append(GTK_MENU(menu), item);
1041         if (gtkpspell->mode==PSPELL_BADSPELLERMODE) {
1042                 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1043                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1044         }
1045         else
1046                 gtk_signal_connect(GTK_OBJECT(item), "activate",
1047                                    GTK_SIGNAL_FUNC(set_sug_mode),
1048                                    gtkpspell);
1049         item = gtk_menu_item_new();
1050         gtk_widget_show(item);
1051         gtk_menu_append(GTK_MENU(menu), item);
1052
1053         item = gtk_check_menu_item_new_with_label(_("Learn from mistakes"));
1054         gtk_widget_show(item);
1055         gtk_menu_append(GTK_MENU(menu), item);
1056         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), 
1057                                        gtkpspell->learn);
1058         gtk_signal_connect(GTK_OBJECT(item), "activate", 
1059                            GTK_SIGNAL_FUNC(set_learn_mode), gtkpspell);
1060                         
1061         
1062         return GTK_MENU(menu);
1063 }
1064   
1065 /* make_menu() - Add menus to accept this word for this session and to add it to 
1066  * personal dictionary */
1067 static GtkMenu *make_menu(GList *l, GtkPspell *gtkpspell) 
1068 {
1069         GtkWidget *menu, *item;
1070         unsigned char *caption;
1071         GtkXText * gtktext;
1072         
1073         gtktext = gtkpspell->gtktext;
1074
1075         menu = gtk_menu_new(); 
1076         caption = g_strdup_printf(_("Accept `%s' for this session"), (unsigned char*)l->data);
1077         item = gtk_menu_item_new_with_label(caption);
1078         g_free(caption);
1079         gtk_widget_show(item);
1080         gtk_menu_append(GTK_MENU(menu), item);
1081
1082         gtk_signal_connect(GTK_OBJECT(item), "activate",
1083                            GTK_SIGNAL_FUNC(add_word_to_session), 
1084                            gtkpspell);
1085
1086         caption = g_strdup_printf(_("Add `%s' to personal dictionary"), (char*)l->data);
1087         item = gtk_menu_item_new_with_label(caption);
1088         g_free(caption);
1089         gtk_widget_show(item);
1090         gtk_menu_append(GTK_MENU(menu), item);
1091
1092         gtk_signal_connect(GTK_OBJECT(item), "activate",
1093                            GTK_SIGNAL_FUNC(add_word_to_personal), 
1094                            gtkpspell);
1095          
1096         item = gtk_menu_item_new();
1097         gtk_widget_show(item);
1098         gtk_menu_append(GTK_MENU(menu), item);
1099
1100         l = l->next;
1101         if (l == NULL) {
1102                 item = gtk_menu_item_new_with_label(_("(no suggestions)"));
1103                 gtk_widget_show(item);
1104                 gtk_menu_append(GTK_MENU(menu), item);
1105         } else {
1106                 GtkWidget *curmenu = menu;
1107                 int count = 0;
1108                 
1109                 do {
1110                         if (l->data == NULL && l->next != NULL) {
1111                                 count = 0;
1112                                 curmenu = gtk_menu_new();
1113                                 item = gtk_menu_item_new_with_label(_("Others..."));
1114                                 gtk_widget_show(item);
1115                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
1116                                 gtk_menu_append(GTK_MENU(curmenu), item);
1117                                 l = l->next;
1118                         } else if (count > MENUCOUNT) {
1119                                 count -= MENUCOUNT;
1120                                 item = gtk_menu_item_new_with_label(_("More..."));
1121                                 gtk_widget_show(item);
1122                                 gtk_menu_append(GTK_MENU(curmenu), item);
1123                                 curmenu = gtk_menu_new();
1124                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
1125                         }
1126                         item = gtk_menu_item_new_with_label((unsigned char*)l->data);
1127                         gtk_signal_connect(GTK_OBJECT(item), "activate",
1128                                            GTK_SIGNAL_FUNC(replace_word), gtkpspell);
1129                         gtk_widget_show(item);
1130                         gtk_menu_append(GTK_MENU(curmenu), item);
1131                         count++;
1132                 } while ((l = l->next) != NULL);
1133         }
1134         return GTK_MENU(menu);
1135 }
1136
1137 static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb) 
1138 {
1139         unsigned char buf[BUFSIZE];
1140         GList *list, *l;
1141         GtkXText * gtktext;
1142         
1143         gtktext = gtkpspell->gtktext;
1144         gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1145
1146         if (!(eb->state & GDK_SHIFT_MASK))
1147                 if (get_curword(gtkpspell, buf, NULL, NULL)) {
1148                         if (buf != NULL) {
1149                                 strncpy(gtkpspell->theword, buf, BUFSIZE - 1);
1150                                 gtkpspell->theword[BUFSIZE - 1] = 0;
1151                                 list = misspelled_suggest(gtkpspell, buf);
1152                                 if (list != NULL) {
1153                                         gtk_menu_popup(make_menu(list, gtkpspell), NULL, NULL, NULL, NULL,
1154                                                        eb->button, eb->time);
1155                                         for (l = list; l != NULL; l = l->next)
1156                                                 g_free(l->data);
1157                                         g_list_free(list);
1158                                         return;
1159                                 }
1160                         }
1161                 }
1162         gtk_menu_popup(make_menu_config(gtkpspell),NULL,NULL,NULL,NULL,
1163         eb->button,eb->time);
1164 }
1165
1166 /* ok, this is pretty wacky:
1167  * we need to let the right-mouse-click go through, so it moves the cursor,
1168  * but we *can't* let it go through, because GtkText interprets rightclicks as
1169  * weird selection modifiers.
1170  *
1171  * so what do we do?  forge rightclicks as leftclicks, then popup the menu.
1172  * HACK HACK HACK.
1173  */
1174 static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, GtkPspell *gtkpspell) 
1175 {
1176         GdkEventButton *eb;
1177         gboolean retval;
1178
1179         if (!gtkpspell_running(gtkpspell)) 
1180                 return FALSE;
1181
1182         if (e->type != GDK_BUTTON_PRESS) 
1183                 return FALSE;
1184         eb = (GdkEventButton*) e;
1185
1186         if (eb->button != 3) 
1187                 return FALSE;
1188
1189         /* forge the leftclick */
1190         eb->button = 1;
1191
1192         gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
1193                                          GTK_SIGNAL_FUNC(button_press_intercept_cb), 
1194                                          gtkpspell);
1195         gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
1196                                 e, &retval);
1197         gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
1198                                            GTK_SIGNAL_FUNC(button_press_intercept_cb), 
1199                                            gtkpspell);
1200         gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
1201     
1202         /* now do the menu wackiness */
1203         popup_menu(gtkpspell, eb);
1204         gtk_grab_remove(GTK_WIDGET(gtktext));
1205         return TRUE;
1206 }
1207
1208 void gtkpspell_uncheck_all(GtkPspell * gtkpspell) 
1209 {
1210         int origpos;
1211         unsigned char *text;
1212         float adj_value;
1213         GtkXText *gtktext;
1214         
1215         gtktext=gtkpspell->gtktext;
1216
1217         adj_value = gtktext->vadj->value;
1218         gtk_xtext_freeze(gtktext);
1219         origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1220         text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
1221         gtk_xtext_set_point(gtktext, 0);
1222         gtk_xtext_forward_delete(gtktext, gtk_xtext_get_length(gtktext));
1223         gtk_xtext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
1224         gtk_xtext_thaw(gtktext);
1225
1226         gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
1227         gtk_adjustment_set_value(gtktext->vadj, adj_value);
1228 }
1229
1230 void gtkpspell_attach(GtkPspell *gtkpspell, GtkXText *gtktext) 
1231 {
1232         gtkpspell->gtktext = gtktext;
1233         gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text",
1234                            GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
1235         gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
1236                                  GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
1237         gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
1238                            GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
1239
1240         allocate_color(gtkpspell);
1241         
1242 }
1243
1244 void gtkpspell_detach(GtkPspell * gtkpspell) 
1245 {
1246         GtkXText * gtktext;
1247         
1248         gtktext =gtkpspell->gtktext;
1249 /*    if (prefs_common.auto_makepspell) { */
1250         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
1251                                       GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
1252         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
1253                                       GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
1254 /*    }; */
1255         gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
1256                                       GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
1257
1258         gtkpspell_uncheck_all(gtkpspell);
1259 }
1260
1261 /*** Sylpheed (Claws) ***/
1262
1263 static GSList *create_empty_dictionary_list(void)
1264 {
1265         GSList *list = NULL;
1266         Dictionary *dict;
1267         
1268         dict = g_new0(Dictionary, 1);
1269         dict->name = g_strdup(_("None"));
1270         return g_slist_append(list, dict);
1271 }
1272
1273 /* gtkpspell_get_dictionary_list() - returns list of dictionary names */
1274 GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path)
1275 {
1276         GSList *list;
1277         gchar *dict_path, *tmp, *prevdir;
1278         GSList *walk;
1279         Dictionary *dict;
1280         DIR *dir;
1281         struct dirent *ent;
1282
1283         list = NULL;
1284
1285 #ifdef USE_THREADS
1286 #warning TODO: no directory change
1287 #endif
1288         dict_path=g_strdup(pspell_path);
1289         prevdir = g_get_current_dir();
1290         if (chdir(dict_path) <0) {
1291                 FILE_OP_ERROR(dict_path, "chdir");
1292                 g_free(prevdir);
1293                 g_free(dict_path);
1294                 return create_empty_dictionary_list();
1295         }
1296
1297         debug_print(_("Checking for dictionaries in %s\n"), dict_path);
1298
1299         if (NULL != (dir = opendir("."))) {
1300                 while (NULL != (ent = readdir(dir))) {
1301                         /* search for pwli */
1302                         if (NULL != (tmp = strstr(ent->d_name, ".pwli"))) {
1303                                 dict = g_new0(Dictionary, 1);
1304                                 dict->name = g_strndup(ent->d_name, tmp - ent->d_name);
1305                                 debug_print(_("Found dictionary %s\n"), dict->name);
1306                                 list = g_slist_insert_sorted(list, dict, (GCompareFunc) compare_dict);
1307                         }
1308                 }                       
1309                 closedir(dir);
1310         }
1311         else {
1312                 FILE_OP_ERROR(dict_path, "opendir");
1313                 debug_print(_("No dictionary found\n"));
1314                 list = create_empty_dictionary_list();
1315         }
1316         if(list==NULL){
1317           debug_print(_("No dictionary found\n"));
1318           list = create_empty_dictionary_list();
1319         }
1320         chdir(prevdir);
1321         g_free(dict_path);
1322         g_free(prevdir);
1323         return list;
1324 }
1325
1326 /* compare_dict () - compare 2 dict names */
1327
1328 static gint compare_dict(Dictionary *a, Dictionary *b)
1329 {
1330         guchar *alanguage, *blanguage,
1331                *aspelling, *bspelling,
1332                *ajargon  , *bjargon  ,
1333                *amodule  , *bmodule  ;
1334         guint aparts = 0, bparts = 0, i;
1335
1336         for (i=0; i < strlen(a->name) ; i++)
1337                 if (a->name[i]=='-')
1338                         aparts++;
1339         for (i=0; i < strlen(b->name) ; i++)
1340                 if (b->name[i]=='-')
1341                         bparts++;
1342
1343         if (aparts != bparts) 
1344                 return (aparts < bparts) ? -1 : +1 ;
1345         else 
1346                 return strcmp2(a->name, b->name);
1347 }
1348 void gtkpspell_free_dictionary_list(GSList *list)
1349 {
1350         Dictionary *dict;
1351         GSList *walk;
1352         for (walk = list; walk != NULL; walk = g_slist_next(walk))
1353                 if (walk->data) {
1354                         dict = (Dictionary *) walk->data;
1355                         if (dict->name)
1356                                 g_free(dict->name);
1357                         g_free(dict);
1358                 }                               
1359         g_slist_free(list);
1360 }
1361
1362 static void dictionary_option_menu_item_data_destroy(gpointer data)
1363 {
1364         gchar *str = (gchar *) data;
1365
1366         if (str)
1367                 g_free(str);
1368 }
1369
1370 GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path)
1371 {
1372         GSList *dict_list, *tmp;
1373         GtkWidget *item;
1374         GtkWidget *menu;
1375         Dictionary *dict;
1376
1377         dict_list = gtkpspell_get_dictionary_list(pspell_path);
1378         g_return_val_if_fail(dict_list, NULL);
1379
1380         menu = gtk_menu_new();
1381         
1382         for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
1383                 dict = (Dictionary *) tmp->data;
1384                 item = gtk_menu_item_new_with_label(dict->name);
1385                 if (dict->name)
1386                         gtk_object_set_data_full(GTK_OBJECT(item), "dict_name",
1387                                          g_strdup(dict->name), 
1388                                          dictionary_option_menu_item_data_destroy);
1389                 gtk_menu_append(GTK_MENU(menu), item);                                   
1390                 gtk_widget_show(item);
1391         }
1392
1393         gtk_widget_show(menu);
1394
1395         gtkpspell_free_dictionary_list(dict_list);
1396
1397         return menu;
1398 }
1399
1400
1401
1402 gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu)
1403 {
1404         GtkWidget *menuitem;
1405         gchar *result;
1406
1407         g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
1408         menuitem = gtk_menu_get_active(GTK_MENU(menu));
1409         result = gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name");
1410         g_return_val_if_fail(result, NULL);
1411         return g_strdup(result);
1412   
1413 }
1414
1415 /* convert_to_pspell_encoding () - converts ISO-8859-* strings to iso8859-* 
1416  * as needed by pspell. Returns an allocated string.
1417  */
1418
1419 guchar *convert_to_pspell_encoding (const guchar *encoding)
1420 {
1421         guchar * pspell_encoding;
1422
1423         if (strstr2(encoding, "ISO-8859-")) {
1424                 pspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
1425         }
1426         else
1427                 if (!strcmp2(encoding, "US-ASCII"))
1428                         pspell_encoding = g_strdup("iso8859-1");
1429                 else
1430                         pspell_encoding = g_strdup(encoding);
1431         return pspell_encoding;
1432         
1433 }
1434
1435 static void allocate_color(GtkPspell *gtkpspell)
1436 {
1437
1438         GdkColormap *gc;
1439         /* Color allocation */
1440         gc = gtk_widget_get_colormap(GTK_WIDGET(gtkpspell->gtktext));
1441
1442         if (gtkpspell->highlight.pixel)
1443                 gdk_colormap_free_colors(gc, &(gtkpspell->highlight), 1);
1444
1445         gtkut_convert_int_to_gdk_color(prefs_common.misspelled_col,
1446                         &(gtkpspell->highlight));
1447
1448         /* add an entry for the highlight in the color map. */
1449         gdk_colormap_alloc_color(gc, &(gtkpspell->highlight), FALSE, TRUE);
1450 }
1451
1452 #endif