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