1 /* gtkaspell - a spell-checking addon for GtkText
2 * Copyright (c) 2000 Evan Martin (original code for ispell).
3 * Copyright (c) 2002 Melvin Hadasht.
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.
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.
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
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
36 #include <sys/types.h>
49 #include <gtk/gtkoptionmenu.h>
50 #include <gtk/gtkmenu.h>
51 #include <gtk/gtkmenuitem.h>
52 #include <gdk/gdkkeysyms.h>
56 #include "prefs_common.h"
58 #include "gtkaspell.h"
60 /* size of the text buffer used in various word-processing routines. */
63 /* number of suggestions to display on each menu. */
66 /* 'config' must be defined as a 'AspellConfig *' */
67 #define RETURN_FALSE_IF_CONFIG_ERROR() \
69 if (aspell_config_error_number(config) != 0) { \
70 gtkaspellcheckers->error_message = g_strdup(aspell_config_error_message(config)); \
75 #define CONFIG_REPLACE_RETURN_FALSE_IF_FAIL(option, value) { \
76 aspell_config_replace(config, option, value); \
77 RETURN_FALSE_IF_CONFIG_ERROR(); \
80 /******************************************************************************/
82 GtkAspellCheckers *gtkaspellcheckers;
84 /* Error message storage */
85 static void gtkaspell_checkers_error_message (gchar *message);
88 static void entry_insert_cb (GtkSText *gtktext,
92 GtkAspell *gtkaspell);
93 static void entry_delete_cb (GtkSText *gtktext,
96 GtkAspell *gtkaspell);
97 static gint button_press_intercept_cb (GtkSText *gtktext,
99 GtkAspell *gtkaspell);
101 /* Checker creation */
102 static GtkAspeller* gtkaspeller_new (Dictionary *dict);
103 static GtkAspeller* gtkaspeller_real_new (Dictionary *dict);
104 static GtkAspeller* gtkaspeller_delete (GtkAspeller *gtkaspeller);
105 static GtkAspeller* gtkaspeller_real_delete (GtkAspeller *gtkaspeller);
107 /* Checker configuration */
108 static gint set_dictionary (AspellConfig *config,
110 static void set_sug_mode_cb (GtkMenuItem *w,
111 GtkAspell *gtkaspell);
112 static void set_real_sug_mode (GtkAspell *gtkaspell,
113 const char *themode);
115 /* Checker actions */
116 static gboolean check_at (GtkAspell *gtkaspell,
118 static gboolean check_next_prev (GtkAspell *gtkaspell,
120 static GList* misspelled_suggest (GtkAspell *gtkaspell,
122 static void add_word_to_session_cb (GtkWidget *w,
124 static void add_word_to_personal_cb (GtkWidget *w,
126 static void replace_with_create_dialog_cb (GtkWidget *w,
128 static void replace_with_supplied_word_cb (GtkWidget *w,
129 GtkAspell *gtkaspell);
130 static void replace_word_cb (GtkWidget *w,
132 static void replace_real_word (GtkAspell *gtkaspell,
134 static void check_with_alternate_cb (GtkWidget *w,
136 static void use_alternate_dict (GtkAspell *gtkaspell);
137 static void toggle_check_while_typing_cb (GtkWidget *w,
141 static void popup_menu (GtkAspell *gtkaspell,
143 static GtkMenu* make_sug_menu (GtkAspell *gtkaspell);
144 static void populate_submenu (GtkAspell *gtkaspell,
146 static GtkMenu* make_config_menu (GtkAspell *gtkaspell);
147 static void set_menu_pos (GtkMenu *menu,
151 /* Other menu callbacks */
152 static gboolean cancel_menu_cb (GtkMenuShell *w,
154 static void change_dict_cb (GtkWidget *w,
155 GtkAspell *gtkaspell);
156 static void switch_to_alternate_cb (GtkWidget *w,
159 /* Misc. helper functions */
160 static void set_point_continue (GtkAspell *gtkaspell);
161 static void continue_check (gpointer *gtkaspell);
162 static gboolean iswordsep (unsigned char c);
163 static guchar get_text_index_whar (GtkAspell *gtkaspell,
165 static gboolean get_word_from_pos (GtkAspell *gtkaspell,
171 static void allocate_color (GtkAspell *gtkaspell,
173 static void change_color (GtkAspell *gtkaspell,
178 static guchar* convert_to_aspell_encoding (const guchar *encoding);
179 static gint compare_dict (Dictionary *a,
181 static void dictionary_delete (Dictionary *dict);
182 static Dictionary * dictionary_dup (const Dictionary *dict);
183 static void free_suggestions_list (GtkAspell *gtkaspell);
184 static void reset_theword_data (GtkAspell *gtkaspell);
185 static void free_checkers (gpointer elt,
187 static gint find_gtkaspeller (gconstpointer aa,
189 static void gtkaspell_alert_dialog (gchar *message);
190 /* gtkspellconfig - only one config per session */
191 GtkAspellConfig * gtkaspellconfig;
193 /******************************************************************************/
195 GtkAspellCheckers *gtkaspell_checkers_new()
197 GtkAspellCheckers *gtkaspellcheckers;
199 gtkaspellcheckers = g_new(GtkAspellCheckers, 1);
200 gtkaspellcheckers->checkers = NULL;
201 gtkaspellcheckers->dictionary_list = NULL;
202 gtkaspellcheckers->error_message = NULL;
204 return gtkaspellcheckers;
207 GtkAspellCheckers *gtkaspell_checkers_delete()
212 if (gtkaspellcheckers == NULL)
215 if ((checkers = gtkaspellcheckers->checkers)) {
216 debug_print("Aspell: number of running checkers to delete %d\n",
217 g_slist_length(checkers));
219 g_slist_foreach(checkers, free_checkers, NULL);
220 g_slist_free(checkers);
223 if ((dict_list = gtkaspellcheckers->dictionary_list)) {
224 debug_print("Aspell: number of dictionaries to delete %d\n",
225 g_slist_length(dict_list));
227 gtkaspell_free_dictionary_list(dict_list);
228 gtkaspellcheckers->dictionary_list = NULL;
231 g_free(gtkaspellcheckers->error_message);
236 static void gtkaspell_checkers_error_message (gchar *message)
239 if (gtkaspellcheckers->error_message) {
240 tmp = g_strdup_printf("%s\n%s",
241 gtkaspellcheckers->error_message, message);
243 g_free(gtkaspellcheckers->error_message);
244 gtkaspellcheckers->error_message = tmp;
246 gtkaspellcheckers->error_message = message;
249 void gtkaspell_checkers_reset_error(void)
251 g_return_if_fail(gtkaspellcheckers);
253 g_free(gtkaspellcheckers->error_message);
255 gtkaspellcheckers->error_message = NULL;
258 GtkAspell *gtkaspell_new(const gchar *dictionary,
259 const gchar *encoding,
260 gint misspelled_color,
261 gboolean check_while_typing,
262 gboolean use_alternate,
266 GtkAspell *gtkaspell;
267 GtkAspeller *gtkaspeller;
269 g_return_val_if_fail(gtktext, NULL);
271 dict = g_new0(Dictionary, 1);
272 dict->fullname = g_strdup(dictionary);
273 dict->encoding = g_strdup(encoding);
275 gtkaspeller = gtkaspeller_new(dict);
276 dictionary_delete(dict);
281 gtkaspell = g_new(GtkAspell, 1);
283 gtkaspell->gtkaspeller = gtkaspeller;
284 gtkaspell->alternate_speller = NULL;
285 gtkaspell->theword[0] = 0x00;
286 gtkaspell->start_pos = 0;
287 gtkaspell->end_pos = 0;
288 gtkaspell->orig_pos = -1;
289 gtkaspell->end_check_pos = -1;
290 gtkaspell->misspelled = -1;
291 gtkaspell->check_while_typing = check_while_typing;
292 gtkaspell->continue_check = NULL;
293 gtkaspell->config_menu = NULL;
294 gtkaspell->popup_config_menu = NULL;
295 gtkaspell->sug_menu = NULL;
296 gtkaspell->replace_entry = NULL;
297 gtkaspell->gtktext = gtktext;
298 gtkaspell->default_sug_mode = ASPELL_FASTMODE;
299 gtkaspell->max_sug = -1;
300 gtkaspell->suggestions_list = NULL;
301 gtkaspell->use_alternate = use_alternate;
303 allocate_color(gtkaspell, misspelled_color);
305 gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text",
306 GTK_SIGNAL_FUNC(entry_insert_cb), gtkaspell);
307 gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
308 GTK_SIGNAL_FUNC(entry_delete_cb), gtkaspell);
309 gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
310 GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkaspell);
312 debug_print("Aspell: created gtkaspell %0x\n", (guint) gtkaspell);
317 void gtkaspell_delete(GtkAspell * gtkaspell)
319 GtkSText *gtktext = gtkaspell->gtktext;
321 gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
322 GTK_SIGNAL_FUNC(entry_insert_cb),
324 gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
325 GTK_SIGNAL_FUNC(entry_delete_cb),
327 gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
328 GTK_SIGNAL_FUNC(button_press_intercept_cb),
331 gtkaspell_uncheck_all(gtkaspell);
333 gtkaspeller_delete(gtkaspell->gtkaspeller);
335 if (gtkaspell->use_alternate && gtkaspell->alternate_speller)
336 gtkaspeller_delete(gtkaspell->alternate_speller);
338 if (gtkaspell->sug_menu)
339 gtk_widget_destroy(gtkaspell->sug_menu);
341 if (gtkaspell->popup_config_menu)
342 gtk_widget_destroy(gtkaspell->popup_config_menu);
344 if (gtkaspell->config_menu)
345 gtk_widget_destroy(gtkaspell->config_menu);
347 if (gtkaspell->suggestions_list)
348 free_suggestions_list(gtkaspell);
350 debug_print("Aspell: deleting gtkaspell %0x\n", (guint) gtkaspell);
357 static void entry_insert_cb(GtkSText *gtktext,
361 GtkAspell *gtkaspell)
363 g_return_if_fail(gtkaspell->gtkaspeller->checker);
365 if (!gtkaspell->check_while_typing)
368 /* We must insert ourselves the character so the
369 * color of the inserted character is the default color.
370 * Never mess with set_insertion when frozen.
373 gtk_stext_freeze(gtktext);
374 gtk_stext_backward_delete(GTK_STEXT(gtktext), len);
375 gtk_stext_insert(GTK_STEXT(gtktext), NULL, NULL, NULL, newtext, len);
376 *ppos = gtk_stext_get_point(GTK_STEXT(gtktext));
378 if (iswordsep(newtext[0])) {
379 /* did we just end a word? */
381 check_at(gtkaspell, *ppos - 2);
383 /* did we just split a word? */
384 if (*ppos < gtk_stext_get_length(gtktext))
385 check_at(gtkaspell, *ppos + 1);
387 /* check as they type, *except* if they're typing at the end (the most
390 if (*ppos < gtk_stext_get_length(gtktext) &&
391 !iswordsep(get_text_index_whar(gtkaspell, *ppos))) {
392 check_at(gtkaspell, *ppos - 1);
396 gtk_stext_thaw(gtktext);
397 gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos);
400 static void entry_delete_cb(GtkSText *gtktext,
403 GtkAspell *gtkaspell)
407 g_return_if_fail(gtkaspell->gtkaspeller->checker);
409 if (!gtkaspell->check_while_typing)
412 origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
414 check_at(gtkaspell, start - 1);
415 check_at(gtkaspell, start);
418 gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
419 gtk_stext_set_point(gtktext, origpos);
420 /* this is to *UNDO* the selection, in case they were holding shift
421 * while hitting backspace. */
422 gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
425 /* ok, this is pretty wacky:
426 * we need to let the right-mouse-click go through, so it moves the cursor,
427 * but we *can't* let it go through, because GtkText interprets rightclicks as
428 * weird selection modifiers.
430 * so what do we do? forge rightclicks as leftclicks, then popup the menu.
433 static gint button_press_intercept_cb(GtkSText *gtktext, GdkEvent *e, GtkAspell *gtkaspell)
438 g_return_val_if_fail(gtkaspell->gtkaspeller->checker, FALSE);
440 if (e->type != GDK_BUTTON_PRESS)
442 eb = (GdkEventButton*) e;
447 /* forge the leftclick */
450 gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
451 GTK_SIGNAL_FUNC(button_press_intercept_cb),
453 gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
455 gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
456 GTK_SIGNAL_FUNC(button_press_intercept_cb),
458 gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
460 /* now do the menu wackiness */
461 popup_menu(gtkaspell, eb);
462 gtk_grab_remove(GTK_WIDGET(gtktext));
466 /* Checker creation */
467 static GtkAspeller *gtkaspeller_new(Dictionary *dictionary)
470 GtkAspeller *gtkaspeller = NULL;
474 g_return_val_if_fail(gtkaspellcheckers, NULL);
476 g_return_val_if_fail(dictionary, NULL);
478 if (dictionary->fullname == NULL)
479 gtkaspell_checkers_error_message(g_strdup(_("No dictionary selected.")));
481 g_return_val_if_fail(dictionary->fullname, NULL);
483 if (dictionary->dictname == NULL) {
486 tmp = strrchr(dictionary->fullname, G_DIR_SEPARATOR);
489 dictionary->dictname = dictionary->fullname;
491 dictionary->dictname = tmp + 1;
494 dict = dictionary_dup(dictionary);
496 tmp = g_new0(GtkAspeller, 1);
497 tmp->dictionary = dict;
499 exist = g_slist_find_custom(gtkaspellcheckers->checkers, tmp,
504 if ((gtkaspeller = gtkaspeller_real_new(dict)) != NULL) {
505 gtkaspellcheckers->checkers = g_slist_append(
506 gtkaspellcheckers->checkers,
509 debug_print("Aspell: Created a new gtkaspeller %0x\n",
512 dictionary_delete(dict);
514 debug_print("Aspell: Could not create spell checker.\n");
517 debug_print("Aspell: number of existing checkers %d\n",
518 g_slist_length(gtkaspellcheckers->checkers));
523 static GtkAspeller *gtkaspeller_real_new(Dictionary *dict)
525 GtkAspeller *gtkaspeller;
526 AspellConfig *config;
527 AspellCanHaveError *ret;
529 g_return_val_if_fail(gtkaspellcheckers, NULL);
530 g_return_val_if_fail(dict, NULL);
532 gtkaspeller = g_new(GtkAspeller, 1);
534 gtkaspeller->dictionary = dict;
535 gtkaspeller->sug_mode = ASPELL_FASTMODE;
537 config = new_aspell_config();
539 if (!set_dictionary(config, dict))
542 ret = new_aspell_speller(config);
543 delete_aspell_config(config);
545 if (aspell_error_number(ret) != 0) {
546 gtkaspellcheckers->error_message = g_strdup(aspell_error_message(ret));
548 delete_aspell_can_have_error(ret);
553 gtkaspeller->checker = to_aspell_speller(ret);
554 gtkaspeller->config = aspell_speller_config(gtkaspeller->checker);
559 static GtkAspeller *gtkaspeller_delete(GtkAspeller *gtkaspeller)
561 g_return_val_if_fail(gtkaspellcheckers, NULL);
563 gtkaspellcheckers->checkers =
564 g_slist_remove(gtkaspellcheckers->checkers,
567 debug_print("Aspell: Deleting gtkaspeller %0x.\n",
570 gtkaspeller_real_delete(gtkaspeller);
572 debug_print("Aspell: number of existing checkers %d\n",
573 g_slist_length(gtkaspellcheckers->checkers));
578 static GtkAspeller *gtkaspeller_real_delete(GtkAspeller *gtkaspeller)
580 g_return_val_if_fail(gtkaspeller, NULL);
581 g_return_val_if_fail(gtkaspeller->checker, NULL);
583 aspell_speller_save_all_word_lists(gtkaspeller->checker);
585 delete_aspell_speller(gtkaspeller->checker);
587 dictionary_delete(gtkaspeller->dictionary);
589 debug_print("Aspell: gtkaspeller %0x deleted.\n",
597 /*****************************************************************************/
598 /* Checker configuration */
600 static gboolean set_dictionary(AspellConfig *config, Dictionary *dict)
602 gchar *language = NULL;
603 gchar *jargon = NULL;
607 g_return_val_if_fail(config, FALSE);
608 g_return_val_if_fail(dict, FALSE);
610 strncpy(buf, dict->fullname, BUFSIZE-1);
611 buf[BUFSIZE-1] = 0x00;
613 buf[dict->dictname - dict->fullname] = 0x00;
615 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("dict-dir", buf);
616 debug_print("Aspell: looking for dictionaries in path %s.\n", buf);
618 strncpy(buf, dict->dictname, BUFSIZE-1);
621 if ((size = strrchr(buf, '-')) && isdigit((int) size[1]))
626 if ((jargon = strchr(language, '-')) != NULL)
629 if (size != NULL && jargon == size)
632 debug_print("Aspell: language: %s, jargon: %s, size: %s\n",
633 language, jargon, size);
636 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("lang", language);
638 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("jargon", jargon);
640 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("size", size);
641 if (dict->encoding) {
644 aspell_enc = convert_to_aspell_encoding (dict->encoding);
645 aspell_config_replace(config, "encoding", (const char *) aspell_enc);
648 RETURN_FALSE_IF_CONFIG_ERROR();
654 guchar *gtkaspell_get_dict(GtkAspell *gtkaspell)
657 g_return_val_if_fail(gtkaspell->gtkaspeller->config, NULL);
658 g_return_val_if_fail(gtkaspell->gtkaspeller->dictionary, NULL);
660 return g_strdup(gtkaspell->gtkaspeller->dictionary->dictname);
663 guchar *gtkaspell_get_path(GtkAspell *gtkaspell)
668 g_return_val_if_fail(gtkaspell->gtkaspeller->config, NULL);
669 g_return_val_if_fail(gtkaspell->gtkaspeller->dictionary, NULL);
671 dict = gtkaspell->gtkaspeller->dictionary;
672 path = g_strndup(dict->fullname, dict->dictname - dict->fullname);
677 /* set_sug_mode_cb() - Menu callback: Set the suggestion mode */
678 static void set_sug_mode_cb(GtkMenuItem *w, GtkAspell *gtkaspell)
682 gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode);
684 set_real_sug_mode(gtkaspell, themode);
686 if (gtkaspell->config_menu)
687 populate_submenu(gtkaspell, gtkaspell->config_menu);
690 static void set_real_sug_mode(GtkAspell *gtkaspell, const char *themode)
693 gint mode = ASPELL_FASTMODE;
694 g_return_if_fail(gtkaspell);
695 g_return_if_fail(gtkaspell->gtkaspeller);
696 g_return_if_fail(themode);
698 if (!strcmp(themode,_("Normal Mode")))
699 mode = ASPELL_NORMALMODE;
700 else if (!strcmp( themode,_("Bad Spellers Mode")))
701 mode = ASPELL_BADSPELLERMODE;
703 result = gtkaspell_set_sug_mode(gtkaspell, mode);
706 debug_print("Aspell: error while changing suggestion mode:%s\n",
707 gtkaspellcheckers->error_message);
708 gtkaspell_checkers_reset_error();
712 /* gtkaspell_set_sug_mode() - Set the suggestion mode */
713 gboolean gtkaspell_set_sug_mode(GtkAspell *gtkaspell, gint themode)
715 AspellConfig *config;
717 g_return_val_if_fail(gtkaspell, FALSE);
718 g_return_val_if_fail(gtkaspell->gtkaspeller, FALSE);
719 g_return_val_if_fail(gtkaspell->gtkaspeller->config, FALSE);
721 debug_print("Aspell: setting sug mode of gtkaspeller %0x to %d\n",
722 (guint) gtkaspell->gtkaspeller, themode);
724 config = gtkaspell->gtkaspeller->config;
727 case ASPELL_FASTMODE:
728 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "fast");
730 case ASPELL_NORMALMODE:
731 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "normal");
733 case ASPELL_BADSPELLERMODE:
734 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode",
738 gtkaspellcheckers->error_message =
739 g_strdup(_("Unknown suggestion mode."));
743 gtkaspell->gtkaspeller->sug_mode = themode;
744 gtkaspell->default_sug_mode = themode;
749 /* misspelled_suggest() - Create a suggestion list for word */
750 static GList *misspelled_suggest(GtkAspell *gtkaspell, guchar *word)
752 const guchar *newword;
754 const AspellWordList *suggestions;
755 AspellStringEnumeration *elements;
757 g_return_val_if_fail(word, NULL);
759 if (!aspell_speller_check(gtkaspell->gtkaspeller->checker, word, -1)) {
760 free_suggestions_list(gtkaspell);
762 suggestions = aspell_speller_suggest(gtkaspell->gtkaspeller->checker,
763 (const char *)word, -1);
764 elements = aspell_word_list_elements(suggestions);
765 list = g_list_append(list, g_strdup(word));
767 while ((newword = aspell_string_enumeration_next(elements)) != NULL)
768 list = g_list_append(list, g_strdup(newword));
770 gtkaspell->max_sug = g_list_length(list) - 1;
771 gtkaspell->suggestions_list = list;
776 free_suggestions_list(gtkaspell);
781 /* misspelled_test() - Just test if word is correctly spelled */
782 static int misspelled_test(GtkAspell *gtkaspell, unsigned char *word)
784 return aspell_speller_check(gtkaspell->gtkaspeller->checker, word, -1) ? 0 : 1;
788 static gboolean iswordsep(unsigned char c)
790 return !isalpha(c) && c != '\'';
793 static guchar get_text_index_whar(GtkAspell *gtkaspell, int pos)
798 text = gtk_editable_get_chars(GTK_EDITABLE(gtkaspell->gtktext), pos,
810 /* get_word_from_pos () - return the word pointed to. */
811 /* Handles correctly the quotes. */
812 static gboolean get_word_from_pos(GtkAspell *gtkaspell, gint pos,
813 unsigned char* buf, gint buflen,
814 gint *pstart, gint *pend)
817 /* TODO : when correcting a word into quotes, change the color of */
818 /* the quotes too, as may be they were highlighted before. To do */
819 /* this, we can use two others pointers that points to the whole */
820 /* word including quotes. */
828 gtktext = gtkaspell->gtktext;
829 if (iswordsep(get_text_index_whar(gtkaspell, pos)))
832 /* The apostrophe character is somtimes used for quotes
833 * So include it in the word only if it is not surrounded
834 * by other characters.
837 for (start = pos; start >= 0; --start) {
838 c = get_text_index_whar(gtkaspell, start);
841 if (!isalpha(get_text_index_whar(gtkaspell,
843 /* start_quote = TRUE; */
848 /* start_quote = TRUE; */
852 else if (!isalpha(c))
858 for (end = pos; end < gtk_stext_get_length(gtktext); end++) {
859 c = get_text_index_whar(gtkaspell, end);
861 if (end < gtk_stext_get_length(gtktext)) {
862 if (!isalpha(get_text_index_whar(gtkaspell,
864 /* end_quote = TRUE; */
869 /* end_quote = TRUE; */
883 if (end - start < buflen) {
884 for (pos = start; pos < end; pos++)
886 get_text_index_whar(gtkaspell, pos);
887 buf[pos - start] = 0;
895 static gboolean check_at(GtkAspell *gtkaspell, gint from_pos)
898 unsigned char buf[GTKASPELLWORDSIZE];
901 g_return_val_if_fail(from_pos >= 0, FALSE);
903 gtktext = gtkaspell->gtktext;
905 if (!get_word_from_pos(gtkaspell, from_pos, buf, sizeof(buf),
909 if (misspelled_test(gtkaspell, buf)) {
910 strncpy(gtkaspell->theword, buf, GTKASPELLWORDSIZE - 1);
911 gtkaspell->theword[GTKASPELLWORDSIZE - 1] = 0;
912 gtkaspell->start_pos = start;
913 gtkaspell->end_pos = end;
914 free_suggestions_list(gtkaspell);
916 change_color(gtkaspell, start, end, buf, &(gtkaspell->highlight));
919 change_color(gtkaspell, start, end, buf, NULL);
924 static gboolean check_next_prev(GtkAspell *gtkaspell, gboolean forward)
933 maxpos = gtkaspell->end_check_pos;
941 pos = gtk_editable_get_position(GTK_EDITABLE(gtkaspell->gtktext));
942 gtkaspell->orig_pos = pos;
943 while (iswordsep(get_text_index_whar(gtkaspell, pos)) &&
944 pos > minpos && pos <= maxpos)
946 while (!(misspelled = check_at(gtkaspell, pos)) &&
947 pos > minpos && pos <= maxpos) {
949 while (!iswordsep(get_text_index_whar(gtkaspell, pos)) &&
950 pos > minpos && pos <= maxpos)
953 while (iswordsep(get_text_index_whar(gtkaspell, pos)) &&
954 pos > minpos && pos <= maxpos)
958 misspelled_suggest(gtkaspell, gtkaspell->theword);
961 gtkaspell->orig_pos = gtkaspell->end_pos;
963 gtk_stext_set_point(GTK_STEXT(gtkaspell->gtktext),
965 gtk_editable_set_position(GTK_EDITABLE(gtkaspell->gtktext),
967 gtk_menu_popup(make_sug_menu(gtkaspell), NULL, NULL,
968 set_menu_pos, gtkaspell, 0, GDK_CURRENT_TIME);
970 reset_theword_data(gtkaspell);
972 gtkaspell_alert_dialog(_("No misspelled word found."));
973 gtk_stext_set_point(GTK_STEXT(gtkaspell->gtktext),
974 gtkaspell->orig_pos);
975 gtk_editable_set_position(GTK_EDITABLE(gtkaspell->gtktext),
976 gtkaspell->orig_pos);
983 void gtkaspell_check_backwards(GtkAspell *gtkaspell)
985 gtkaspell->continue_check = NULL;
986 gtkaspell->end_check_pos =
987 gtk_stext_get_length(GTK_STEXT(gtkaspell->gtktext));
988 check_next_prev(gtkaspell, FALSE);
991 void gtkaspell_check_forwards_go(GtkAspell *gtkaspell)
994 gtkaspell->continue_check = NULL;
995 gtkaspell->end_check_pos
996 = gtk_stext_get_length(GTK_STEXT(gtkaspell->gtktext));
997 check_next_prev(gtkaspell, TRUE);
1000 void gtkaspell_check_all(GtkAspell *gtkaspell)
1005 g_return_if_fail(gtkaspell);
1006 g_return_if_fail(gtkaspell->gtktext);
1008 gtktext = (GtkWidget *) gtkaspell->gtktext;
1011 end = gtk_stext_get_length(GTK_STEXT(gtktext));
1013 if (GTK_EDITABLE(gtktext)->has_selection) {
1014 start = GTK_EDITABLE(gtktext)->selection_start_pos;
1015 end = GTK_EDITABLE(gtktext)->selection_end_pos;
1027 gtk_editable_set_position(GTK_EDITABLE(gtktext), start);
1028 gtk_stext_set_point(GTK_STEXT(gtktext), start);
1030 gtkaspell->continue_check = continue_check;
1031 gtkaspell->end_check_pos = end;
1033 gtkaspell->misspelled = check_next_prev(gtkaspell, TRUE);
1037 static void continue_check(gpointer *data)
1039 GtkAspell *gtkaspell = (GtkAspell *) data;
1040 gint pos = gtk_editable_get_position(GTK_EDITABLE(gtkaspell->gtktext));
1041 if (pos < gtkaspell->end_check_pos && gtkaspell->misspelled)
1042 gtkaspell->misspelled = check_next_prev(gtkaspell, TRUE);
1044 gtkaspell->continue_check = NULL;
1048 void gtkaspell_highlight_all(GtkAspell *gtkaspell)
1056 g_return_if_fail(gtkaspell->gtkaspeller->checker);
1058 gtktext = gtkaspell->gtktext;
1060 adj_value = gtktext->vadj->value;
1062 len = gtk_stext_get_length(gtktext);
1064 origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1068 iswordsep(get_text_index_whar(gtkaspell, pos)))
1071 !iswordsep(get_text_index_whar(gtkaspell, pos)))
1074 check_at(gtkaspell, pos - 1);
1076 gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
1077 gtk_stext_set_point(GTK_STEXT(gtktext), origpos);
1078 gtk_adjustment_set_value(gtktext->vadj, adj_value);
1081 static void replace_with_supplied_word_cb(GtkWidget *w, GtkAspell *gtkaspell)
1083 unsigned char *newword;
1084 GdkEvent *e= (GdkEvent *) gtk_get_current_event();
1086 newword = gtk_editable_get_chars(GTK_EDITABLE(gtkaspell->replace_entry),
1089 if (strcmp(newword, gtkaspell->theword)) {
1090 replace_real_word(gtkaspell, newword);
1092 if ((e->type == GDK_KEY_PRESS &&
1093 ((GdkEventKey *) e)->state & GDK_MOD1_MASK)) {
1094 aspell_speller_store_replacement(gtkaspell->gtkaspeller->checker,
1095 gtkaspell->theword, -1,
1098 gtkaspell->replace_entry = NULL;
1103 set_point_continue(gtkaspell);
1107 static void replace_word_cb(GtkWidget *w, gpointer data)
1109 unsigned char *newword;
1110 GtkAspell *gtkaspell = (GtkAspell *) data;
1111 GdkEvent *e= (GdkEvent *) gtk_get_current_event();
1113 gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
1115 replace_real_word(gtkaspell, newword);
1117 if ((e->type == GDK_KEY_PRESS &&
1118 ((GdkEventKey *) e)->state & GDK_MOD1_MASK) ||
1119 (e->type == GDK_BUTTON_RELEASE &&
1120 ((GdkEventButton *) e)->state & GDK_MOD1_MASK)) {
1121 aspell_speller_store_replacement(gtkaspell->gtkaspeller->checker,
1122 gtkaspell->theword, -1,
1126 gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
1128 set_point_continue(gtkaspell);
1131 static void replace_real_word(GtkAspell *gtkaspell, gchar *newword)
1133 int oldlen, newlen, wordlen;
1136 gint start = gtkaspell->start_pos;
1139 if (!newword) return;
1141 gtktext = gtkaspell->gtktext;
1143 gtk_stext_freeze(GTK_STEXT(gtktext));
1144 origpos = gtkaspell->orig_pos;
1146 oldlen = gtkaspell->end_pos - gtkaspell->start_pos;
1147 wordlen = strlen(gtkaspell->theword);
1149 newlen = strlen(newword); /* FIXME: multybyte characters? */
1151 gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
1152 GTK_SIGNAL_FUNC(entry_insert_cb),
1154 gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
1155 GTK_SIGNAL_FUNC(entry_delete_cb),
1158 gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "delete-text",
1159 gtkaspell->start_pos, gtkaspell->end_pos);
1160 gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "insert-text",
1161 newword, newlen, &start);
1163 gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
1164 GTK_SIGNAL_FUNC(entry_insert_cb),
1166 gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
1167 GTK_SIGNAL_FUNC(entry_delete_cb),
1170 /* Put the point and the position where we clicked with the mouse
1171 * It seems to be a hack, as I must thaw,freeze,thaw the widget
1172 * to let it update correctly the word insertion and then the
1173 * point & position position. If not, SEGV after the first replacement
1174 * If the new word ends before point, put the point at its end.
1177 if (origpos - gtkaspell->start_pos < oldlen &&
1178 origpos - gtkaspell->start_pos >= 0) {
1179 /* Original point was in the word.
1180 * Let it there unless point is going to be outside of the word
1182 if (origpos - gtkaspell->start_pos >= newlen) {
1183 pos = gtkaspell->start_pos + newlen;
1186 else if (origpos >= gtkaspell->end_pos) {
1187 /* move the position according to the change of length */
1188 pos = origpos + newlen - oldlen;
1191 gtkaspell->end_pos = gtkaspell->start_pos + strlen(newword); /* FIXME: multibyte characters? */
1193 gtk_stext_thaw(GTK_STEXT(gtktext));
1194 gtk_stext_freeze(GTK_STEXT(gtktext));
1196 if (GTK_STEXT(gtktext)->text_len < pos)
1197 pos = gtk_stext_get_length(GTK_STEXT(gtktext));
1199 gtkaspell->orig_pos = pos;
1201 gtk_editable_set_position(GTK_EDITABLE(gtktext), gtkaspell->orig_pos);
1202 gtk_stext_set_point(GTK_STEXT(gtktext),
1203 gtk_editable_get_position(GTK_EDITABLE(gtktext)));
1205 gtk_stext_thaw(GTK_STEXT(gtktext));
1208 /* Accept this word for this session */
1209 static void add_word_to_session_cb(GtkWidget *w, gpointer data)
1213 GtkAspell *gtkaspell = (GtkAspell *) data;
1214 gtktext = gtkaspell->gtktext;
1216 gtk_stext_freeze(GTK_STEXT(gtktext));
1218 pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1220 aspell_speller_add_to_session(gtkaspell->gtkaspeller->checker,
1222 strlen(gtkaspell->theword));
1224 check_at(gtkaspell, gtkaspell->start_pos);
1226 gtk_stext_thaw(gtkaspell->gtktext);
1228 gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1230 set_point_continue(gtkaspell);
1233 /* add_word_to_personal_cb() - add word to personal dict. */
1234 static void add_word_to_personal_cb(GtkWidget *w, gpointer data)
1236 GtkAspell *gtkaspell = (GtkAspell *) data;
1237 GtkSText *gtktext = gtkaspell->gtktext;
1239 gtk_stext_freeze(GTK_STEXT(gtktext));
1241 aspell_speller_add_to_personal(gtkaspell->gtkaspeller->checker,
1243 strlen(gtkaspell->theword));
1245 check_at(gtkaspell, gtkaspell->start_pos);
1247 gtk_stext_thaw(gtkaspell->gtktext);
1249 gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1250 set_point_continue(gtkaspell);
1253 static void check_with_alternate_cb(GtkWidget *w, gpointer data)
1255 GtkAspell *gtkaspell = (GtkAspell *) data;
1258 gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1260 use_alternate_dict(gtkaspell);
1261 misspelled = check_at(gtkaspell, gtkaspell->start_pos);
1263 if (!gtkaspell->continue_check) {
1265 gtkaspell->misspelled = misspelled;
1267 if (gtkaspell->misspelled) {
1269 misspelled_suggest(gtkaspell, gtkaspell->theword);
1271 gtk_stext_set_point(GTK_STEXT(gtkaspell->gtktext),
1272 gtkaspell->end_pos);
1273 gtk_editable_set_position(GTK_EDITABLE(gtkaspell->gtktext),
1274 gtkaspell->end_pos);
1276 gtk_menu_popup(make_sug_menu(gtkaspell), NULL, NULL,
1277 set_menu_pos, gtkaspell, 0,
1282 gtkaspell->orig_pos = gtkaspell->start_pos;
1284 set_point_continue(gtkaspell);
1287 static void replace_with_create_dialog_cb(GtkWidget *w, gpointer data)
1293 GtkWidget *ok_button;
1294 GtkWidget *cancel_button;
1297 GtkAspell *gtkaspell = (GtkAspell *) data;
1299 gdk_window_get_origin((GTK_WIDGET(w)->parent)->window, &xx, &yy);
1301 gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1303 dialog = gtk_dialog_new();
1305 gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
1306 gtk_window_set_title(GTK_WINDOW(dialog),_("Replace unknown word"));
1307 gtk_widget_set_uposition(dialog, xx, yy);
1309 gtk_signal_connect_object(GTK_OBJECT(dialog), "destroy",
1310 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1311 GTK_OBJECT(dialog));
1313 hbox = gtk_hbox_new(FALSE, 0);
1314 gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
1316 thelabel = g_strdup_printf(_("Replace \"%s\" with: "),
1317 gtkaspell->theword);
1318 label = gtk_label_new(thelabel);
1320 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
1322 entry = gtk_entry_new();
1323 gtkaspell->replace_entry = entry;
1324 gtk_entry_set_text(GTK_ENTRY(entry), gtkaspell->theword);
1325 gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
1326 gtk_signal_connect(GTK_OBJECT(entry), "activate",
1327 GTK_SIGNAL_FUNC(replace_with_supplied_word_cb),
1329 gtk_signal_connect_object(GTK_OBJECT(entry), "activate",
1330 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1331 GTK_OBJECT(dialog));
1332 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
1334 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE,
1336 label = gtk_label_new(_("Holding down MOD1 key while pressing "
1337 "Enter\nwill learn from mistake.\n"));
1338 gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
1339 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
1340 gtk_misc_set_padding(GTK_MISC(label), 8, 0);
1341 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label,
1344 hbox = gtk_hbox_new(TRUE, 0);
1346 ok_button = gtk_button_new_with_label(_("OK"));
1347 gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 8);
1348 gtk_signal_connect(GTK_OBJECT(ok_button), "clicked",
1349 GTK_SIGNAL_FUNC(replace_with_supplied_word_cb),
1351 gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
1352 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1353 GTK_OBJECT(dialog));
1355 cancel_button = gtk_button_new_with_label(_("Cancel"));
1356 gtk_box_pack_start(GTK_BOX(hbox), cancel_button, TRUE, TRUE, 8);
1357 gtk_signal_connect_object(GTK_OBJECT(cancel_button), "clicked",
1358 GTK_SIGNAL_FUNC(gtk_widget_destroy),
1359 GTK_OBJECT(dialog));
1361 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), hbox);
1363 gtk_widget_grab_focus(entry);
1365 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
1367 gtk_widget_show_all(dialog);
1370 void gtkaspell_uncheck_all(GtkAspell * gtkaspell)
1377 gtktext = gtkaspell->gtktext;
1379 adj_value = gtktext->vadj->value;
1381 gtk_stext_freeze(gtktext);
1383 origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1385 text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
1387 gtk_stext_set_point(gtktext, 0);
1388 gtk_stext_forward_delete(gtktext, gtk_stext_get_length(gtktext));
1389 gtk_stext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
1391 gtk_stext_thaw(gtktext);
1393 gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
1394 gtk_stext_set_point(gtktext, origpos);
1395 gtk_adjustment_set_value(gtktext->vadj, adj_value);
1401 static void toggle_check_while_typing_cb(GtkWidget *w, gpointer data)
1403 GtkAspell *gtkaspell = (GtkAspell *) data;
1405 gtkaspell->check_while_typing = gtkaspell->check_while_typing == FALSE;
1407 if (!gtkaspell->check_while_typing)
1408 gtkaspell_uncheck_all(gtkaspell);
1410 if (gtkaspell->config_menu)
1411 populate_submenu(gtkaspell, gtkaspell->config_menu);
1414 static GSList *create_empty_dictionary_list(void)
1416 GSList *list = NULL;
1419 dict = g_new0(Dictionary, 1);
1420 dict->fullname = g_strdup(_("None"));
1421 dict->dictname = dict->fullname;
1422 dict->encoding = NULL;
1424 return g_slist_append(list, dict);
1427 /* gtkaspell_get_dictionary_list() - returns list of dictionary names */
1428 GSList *gtkaspell_get_dictionary_list(const gchar *aspell_path, gint refresh)
1432 AspellConfig *config;
1433 AspellDictInfoList *dlist;
1434 AspellDictInfoEnumeration *dels;
1435 const AspellDictInfo *entry;
1437 if (!gtkaspellcheckers)
1438 gtkaspellcheckers = gtkaspell_checkers_new();
1440 if (gtkaspellcheckers->dictionary_list && !refresh)
1441 return gtkaspellcheckers->dictionary_list;
1443 gtkaspell_free_dictionary_list(gtkaspellcheckers->dictionary_list);
1446 config = new_aspell_config();
1448 aspell_config_replace(config, "rem-all-word-list-path", "");
1449 if (aspell_config_error_number(config) != 0) {
1450 gtkaspellcheckers->error_message = g_strdup(
1451 aspell_config_error_message(config));
1452 gtkaspellcheckers->dictionary_list =
1453 create_empty_dictionary_list();
1455 return gtkaspellcheckers->dictionary_list;
1458 aspell_config_replace(config, "dict-dir", aspell_path);
1459 if (aspell_config_error_number(config) != 0) {
1460 gtkaspellcheckers->error_message = g_strdup(
1461 aspell_config_error_message(config));
1462 gtkaspellcheckers->dictionary_list =
1463 create_empty_dictionary_list();
1465 return gtkaspellcheckers->dictionary_list;
1468 dlist = get_aspell_dict_info_list(config);
1469 delete_aspell_config(config);
1471 debug_print("Aspell: checking for dictionaries in %s\n", aspell_path);
1472 dels = aspell_dict_info_list_elements(dlist);
1473 while ( (entry = aspell_dict_info_enumeration_next(dels)) != 0)
1475 dict = g_new0(Dictionary, 1);
1476 dict->fullname = g_strdup_printf("%s%s", aspell_path,
1478 dict->dictname = dict->fullname + strlen(aspell_path);
1479 dict->encoding = g_strdup(entry->code);
1480 debug_print("Aspell: found dictionary %s %s\n", dict->fullname,
1482 list = g_slist_insert_sorted(list, dict,
1483 (GCompareFunc) compare_dict);
1486 delete_aspell_dict_info_enumeration(dels);
1490 debug_print("Aspell: error when searching for dictionaries: "
1491 "No dictionary found.\n");
1492 list = create_empty_dictionary_list();
1495 gtkaspellcheckers->dictionary_list = list;
1500 void gtkaspell_free_dictionary_list(GSList *list)
1504 for (walk = list; walk != NULL; walk = g_slist_next(walk))
1506 dict = (Dictionary *) walk->data;
1507 dictionary_delete(dict);
1512 GtkWidget *gtkaspell_dictionary_option_menu_new(const gchar *aspell_path)
1514 GSList *dict_list, *tmp;
1519 dict_list = gtkaspell_get_dictionary_list(aspell_path, TRUE);
1520 g_return_val_if_fail(dict_list, NULL);
1522 menu = gtk_menu_new();
1524 for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
1525 dict = (Dictionary *) tmp->data;
1526 item = gtk_menu_item_new_with_label(dict->dictname);
1527 gtk_object_set_data(GTK_OBJECT(item), "dict_name",
1530 gtk_menu_append(GTK_MENU(menu), item);
1531 gtk_widget_show(item);
1534 gtk_widget_show(menu);
1539 gchar *gtkaspell_get_dictionary_menu_active_item(GtkWidget *menu)
1541 GtkWidget *menuitem;
1542 gchar *dict_fullname;
1545 g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
1547 menuitem = gtk_menu_get_active(GTK_MENU(menu));
1548 dict_fullname = (gchar *) gtk_object_get_data(GTK_OBJECT(menuitem),
1550 g_return_val_if_fail(dict_fullname, NULL);
1552 label = g_strdup(dict_fullname);
1558 GtkWidget *gtkaspell_sugmode_option_menu_new(gint sugmode)
1563 menu = gtk_menu_new();
1564 gtk_widget_show(menu);
1566 item = gtk_menu_item_new_with_label(_("Fast Mode"));
1567 gtk_widget_show(item);
1568 gtk_menu_append(GTK_MENU(menu), item);
1569 gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(ASPELL_FASTMODE));
1571 item = gtk_menu_item_new_with_label(_("Normal Mode"));
1572 gtk_widget_show(item);
1573 gtk_menu_append(GTK_MENU(menu), item);
1574 gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(ASPELL_NORMALMODE));
1576 item = gtk_menu_item_new_with_label(_("Bad Spellers Mode"));
1577 gtk_widget_show(item);
1578 gtk_menu_append(GTK_MENU(menu), item);
1579 gtk_object_set_data(GTK_OBJECT(item), "sugmode", GINT_TO_POINTER(ASPELL_BADSPELLERMODE));
1584 void gtkaspell_sugmode_option_menu_set(GtkOptionMenu *optmenu, gint sugmode)
1586 g_return_if_fail(GTK_IS_OPTION_MENU(optmenu));
1588 g_return_if_fail(sugmode == ASPELL_FASTMODE ||
1589 sugmode == ASPELL_NORMALMODE ||
1590 sugmode == ASPELL_BADSPELLERMODE);
1592 gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), sugmode - 1);
1595 gint gtkaspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu)
1600 g_return_val_if_fail(GTK_IS_OPTION_MENU(optmenu), -1);
1602 item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
1604 sugmode = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(item),
1610 static void use_alternate_dict(GtkAspell *gtkaspell)
1614 tmp = gtkaspell->gtkaspeller;
1615 gtkaspell->gtkaspeller = gtkaspell->alternate_speller;
1616 gtkaspell->alternate_speller = tmp;
1618 if (gtkaspell->config_menu)
1619 populate_submenu(gtkaspell, gtkaspell->config_menu);
1622 static void popup_menu(GtkAspell *gtkaspell, GdkEventButton *eb)
1626 gtktext = gtkaspell->gtktext;
1627 gtkaspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1629 if (!(eb->state & GDK_SHIFT_MASK)) {
1630 if (check_at(gtkaspell, gtkaspell->orig_pos)) {
1632 gtk_editable_set_position(GTK_EDITABLE(gtktext),
1633 gtkaspell->orig_pos);
1634 gtk_stext_set_point(gtktext, gtkaspell->orig_pos);
1636 if (misspelled_suggest(gtkaspell, gtkaspell->theword)) {
1637 gtk_menu_popup(make_sug_menu(gtkaspell),
1638 NULL, NULL, NULL, NULL,
1639 eb->button, GDK_CURRENT_TIME);
1644 gtk_editable_set_position(GTK_EDITABLE(gtktext),
1645 gtkaspell->orig_pos);
1646 gtk_stext_set_point(gtktext, gtkaspell->orig_pos);
1650 gtk_menu_popup(make_config_menu(gtkaspell), NULL, NULL, NULL, NULL,
1651 eb->button, GDK_CURRENT_TIME);
1654 /* make_sug_menu() - Add menus to accept this word for this session
1655 * and to add it to personal dictionary
1657 static GtkMenu *make_sug_menu(GtkAspell *gtkaspell)
1659 GtkWidget *menu, *item;
1660 unsigned char *caption;
1662 GtkAccelGroup *accel;
1663 GList *l = gtkaspell->suggestions_list;
1665 gtktext = gtkaspell->gtktext;
1667 accel = gtk_accel_group_new();
1668 menu = gtk_menu_new();
1670 if (gtkaspell->sug_menu)
1671 gtk_widget_destroy(gtkaspell->sug_menu);
1673 gtkaspell->sug_menu = menu;
1675 gtk_signal_connect(GTK_OBJECT(menu), "cancel",
1676 GTK_SIGNAL_FUNC(cancel_menu_cb), gtkaspell);
1678 caption = g_strdup_printf(_("\"%s\" unknown in %s"),
1679 (unsigned char*) l->data,
1680 gtkaspell->gtkaspeller->dictionary->dictname);
1681 item = gtk_menu_item_new_with_label(caption);
1682 gtk_widget_show(item);
1683 gtk_menu_append(GTK_MENU(menu), item);
1684 gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
1687 item = gtk_menu_item_new();
1688 gtk_widget_show(item);
1689 gtk_menu_append(GTK_MENU(menu), item);
1691 item = gtk_menu_item_new_with_label(_("Accept in this session"));
1692 gtk_widget_show(item);
1693 gtk_menu_append(GTK_MENU(menu), item);
1694 gtk_signal_connect(GTK_OBJECT(item), "activate",
1695 GTK_SIGNAL_FUNC(add_word_to_session_cb),
1697 gtk_widget_add_accelerator(item, "activate", accel, GDK_space,
1699 GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1701 item = gtk_menu_item_new_with_label(_("Add to personal dictionary"));
1702 gtk_widget_show(item);
1703 gtk_menu_append(GTK_MENU(menu), item);
1704 gtk_signal_connect(GTK_OBJECT(item), "activate",
1705 GTK_SIGNAL_FUNC(add_word_to_personal_cb),
1707 gtk_widget_add_accelerator(item, "activate", accel, GDK_Return,
1709 GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1711 item = gtk_menu_item_new_with_label(_("Replace with..."));
1712 gtk_widget_show(item);
1713 gtk_menu_append(GTK_MENU(menu), item);
1714 gtk_signal_connect(GTK_OBJECT(item), "activate",
1715 GTK_SIGNAL_FUNC(replace_with_create_dialog_cb),
1717 gtk_widget_add_accelerator(item, "activate", accel, GDK_R, 0,
1718 GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1720 if (gtkaspell->use_alternate && gtkaspell->alternate_speller) {
1721 caption = g_strdup_printf(_("Check with %s"),
1722 gtkaspell->alternate_speller->dictionary->dictname);
1723 item = gtk_menu_item_new_with_label(caption);
1725 gtk_widget_show(item);
1726 gtk_menu_append(GTK_MENU(menu), item);
1727 gtk_signal_connect(GTK_OBJECT(item), "activate",
1728 GTK_SIGNAL_FUNC(check_with_alternate_cb),
1730 gtk_widget_add_accelerator(item, "activate", accel, GDK_X, 0,
1731 GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1734 item = gtk_menu_item_new();
1735 gtk_widget_show(item);
1736 gtk_menu_append(GTK_MENU(menu), item);
1740 item = gtk_menu_item_new_with_label(_("(no suggestions)"));
1741 gtk_widget_show(item);
1742 gtk_menu_append(GTK_MENU(menu), item);
1744 GtkWidget *curmenu = menu;
1748 if (count == MENUCOUNT) {
1751 item = gtk_menu_item_new_with_label(_("More..."));
1752 gtk_widget_show(item);
1753 gtk_menu_append(GTK_MENU(curmenu), item);
1755 curmenu = gtk_menu_new();
1756 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
1760 item = gtk_menu_item_new_with_label((unsigned char*)l->data);
1761 gtk_widget_show(item);
1762 gtk_menu_append(GTK_MENU(curmenu), item);
1763 gtk_signal_connect(GTK_OBJECT(item), "activate",
1764 GTK_SIGNAL_FUNC(replace_word_cb),
1767 if (curmenu == menu && count < MENUCOUNT) {
1768 gtk_widget_add_accelerator(item, "activate",
1773 gtk_widget_add_accelerator(item, "activate",
1782 } while ((l = l->next) != NULL);
1785 gtk_accel_group_attach(accel, GTK_OBJECT(menu));
1786 gtk_accel_group_unref(accel);
1788 return GTK_MENU(menu);
1791 static void populate_submenu(GtkAspell *gtkaspell, GtkWidget *menu)
1793 GtkWidget *item, *submenu;
1795 GtkAspeller *gtkaspeller = gtkaspell->gtkaspeller;
1797 if (GTK_MENU_SHELL(menu)->children) {
1798 GList *amenu, *alist;
1799 for (amenu = (GTK_MENU_SHELL(menu)->children); amenu; ) {
1800 alist = amenu->next;
1801 gtk_widget_destroy(GTK_WIDGET(amenu->data));
1806 dictname = g_strdup_printf(_("Dictionary: %s"),
1807 gtkaspeller->dictionary->dictname);
1808 item = gtk_menu_item_new_with_label(dictname);
1809 gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
1811 gtk_widget_show(item);
1812 gtk_menu_append(GTK_MENU(menu), item);
1814 item = gtk_menu_item_new();
1815 gtk_widget_show(item);
1816 gtk_menu_append(GTK_MENU(menu), item);
1818 if (gtkaspell->use_alternate && gtkaspell->alternate_speller) {
1819 dictname = g_strdup_printf(_("Use alternate (%s)"),
1820 gtkaspell->alternate_speller->dictionary->dictname);
1821 item = gtk_menu_item_new_with_label(dictname);
1823 gtk_signal_connect(GTK_OBJECT(item), "activate",
1824 GTK_SIGNAL_FUNC(switch_to_alternate_cb),
1826 gtk_widget_show(item);
1827 gtk_menu_append(GTK_MENU(menu), item);
1830 item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
1831 if (gtkaspell->gtkaspeller->sug_mode == ASPELL_FASTMODE) {
1832 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
1833 gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
1835 gtk_signal_connect(GTK_OBJECT(item), "activate",
1836 GTK_SIGNAL_FUNC(set_sug_mode_cb),
1838 gtk_widget_show(item);
1839 gtk_menu_append(GTK_MENU(menu), item);
1841 item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
1842 if (gtkaspell->gtkaspeller->sug_mode == ASPELL_NORMALMODE) {
1843 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1844 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1846 gtk_signal_connect(GTK_OBJECT(item), "activate",
1847 GTK_SIGNAL_FUNC(set_sug_mode_cb),
1849 gtk_widget_show(item);
1850 gtk_menu_append(GTK_MENU(menu),item);
1852 item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
1853 if (gtkaspell->gtkaspeller->sug_mode == ASPELL_BADSPELLERMODE) {
1854 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1855 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1857 gtk_signal_connect(GTK_OBJECT(item), "activate",
1858 GTK_SIGNAL_FUNC(set_sug_mode_cb),
1860 gtk_widget_show(item);
1861 gtk_menu_append(GTK_MENU(menu), item);
1863 item = gtk_menu_item_new();
1864 gtk_widget_show(item);
1865 gtk_menu_append(GTK_MENU(menu), item);
1867 item = gtk_check_menu_item_new_with_label(_("Check while typing"));
1868 if (gtkaspell->check_while_typing)
1869 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1871 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
1872 gtk_signal_connect(GTK_OBJECT(item), "activate",
1873 GTK_SIGNAL_FUNC(toggle_check_while_typing_cb),
1875 gtk_widget_show(item);
1876 gtk_menu_append(GTK_MENU(menu), item);
1878 item = gtk_menu_item_new();
1879 gtk_widget_show(item);
1880 gtk_menu_append(GTK_MENU(menu), item);
1882 submenu = gtk_menu_new();
1883 item = gtk_menu_item_new_with_label(_("Change dictionary"));
1884 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
1885 gtk_widget_show(item);
1886 gtk_menu_append(GTK_MENU(menu), item);
1889 if (gtkaspellcheckers->dictionary_list == NULL)
1890 gtkaspell_get_dictionary_list(prefs_common.aspell_path, FALSE);
1892 GtkWidget * curmenu = submenu;
1896 tmp = gtkaspellcheckers->dictionary_list;
1898 for (tmp = gtkaspellcheckers->dictionary_list; tmp != NULL;
1899 tmp = g_slist_next(tmp)) {
1900 if (count == MENUCOUNT) {
1903 newmenu = gtk_menu_new();
1904 item = gtk_menu_item_new_with_label(_("More..."));
1905 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
1908 gtk_menu_append(GTK_MENU(curmenu), item);
1909 gtk_widget_show(item);
1913 dict = (Dictionary *) tmp->data;
1914 item = gtk_check_menu_item_new_with_label(dict->dictname);
1915 gtk_object_set_data(GTK_OBJECT(item), "dict_name",
1917 if (strcmp2(dict->fullname,
1918 gtkaspell->gtkaspeller->dictionary->fullname))
1919 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
1921 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1922 gtk_widget_set_sensitive(GTK_WIDGET(item),
1925 gtk_signal_connect(GTK_OBJECT(item), "activate",
1926 GTK_SIGNAL_FUNC(change_dict_cb),
1928 gtk_widget_show(item);
1929 gtk_menu_append(GTK_MENU(curmenu), item);
1936 static GtkMenu *make_config_menu(GtkAspell *gtkaspell)
1938 if (!gtkaspell->popup_config_menu)
1939 gtkaspell->popup_config_menu = gtk_menu_new();
1941 debug_print("Aspell: creating/using popup_config_menu %0x\n",
1942 (guint) gtkaspell->popup_config_menu);
1943 populate_submenu(gtkaspell, gtkaspell->popup_config_menu);
1945 return GTK_MENU(gtkaspell->popup_config_menu);
1948 void gtkaspell_populate_submenu(GtkAspell *gtkaspell, GtkWidget *menuitem)
1952 menu = GTK_WIDGET(GTK_MENU_ITEM(menuitem)->submenu);
1954 debug_print("Aspell: using config menu %0x\n",
1955 (guint) gtkaspell->popup_config_menu);
1956 populate_submenu(gtkaspell, menu);
1958 gtkaspell->config_menu = menu;
1962 static void set_menu_pos(GtkMenu *menu, gint *x, gint *y, gpointer data)
1964 GtkAspell *gtkaspell = (GtkAspell *) data;
1965 gint xx = 0, yy = 0;
1968 GtkSText *text = GTK_STEXT(gtkaspell->gtktext);
1971 gdk_window_get_origin(GTK_WIDGET(gtkaspell->gtktext)->window, &xx, &yy);
1973 sx = gdk_screen_width();
1974 sy = gdk_screen_height();
1976 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &r);
1981 *x = gtkaspell->gtktext->cursor_pos_x + xx +
1982 gdk_char_width(GTK_WIDGET(text)->style->font, ' ');
1983 *y = gtkaspell->gtktext->cursor_pos_y + yy;
1989 gdk_string_height((GTK_WIDGET(gtkaspell->gtktext))->style->font,
1990 gtkaspell->theword);
1994 /* Menu call backs */
1996 static gboolean cancel_menu_cb(GtkMenuShell *w, gpointer data)
1998 GtkAspell *gtkaspell = (GtkAspell *) data;
2000 gtkaspell->continue_check = NULL;
2001 set_point_continue(gtkaspell);
2007 /* change_dict_cb() - Menu callback : change dict */
2008 static void change_dict_cb(GtkWidget *w, GtkAspell *gtkaspell)
2012 GtkAspeller *gtkaspeller;
2015 fullname = (gchar *) gtk_object_get_data(GTK_OBJECT(w), "dict_name");
2017 if (!strcmp2(fullname, _("None")))
2020 sug_mode = gtkaspell->default_sug_mode;
2022 dict = g_new0(Dictionary, 1);
2023 dict->fullname = g_strdup(fullname);
2024 dict->encoding = g_strdup(gtkaspell->gtkaspeller->dictionary->encoding);
2026 if (gtkaspell->use_alternate && gtkaspell->alternate_speller &&
2027 dict == gtkaspell->alternate_speller->dictionary) {
2028 use_alternate_dict(gtkaspell);
2029 dictionary_delete(dict);
2033 gtkaspeller = gtkaspeller_new(dict);
2037 message = g_strdup_printf(_("The spell checker could not change dictionary.\n%s"),
2038 gtkaspellcheckers->error_message);
2040 gtkaspell_alert_dialog(message);
2043 if (gtkaspell->use_alternate) {
2044 if (gtkaspell->alternate_speller)
2045 gtkaspeller_delete(gtkaspell->alternate_speller);
2046 gtkaspell->alternate_speller = gtkaspell->gtkaspeller;
2048 gtkaspeller_delete(gtkaspell->gtkaspeller);
2050 gtkaspell->gtkaspeller = gtkaspeller;
2051 gtkaspell_set_sug_mode(gtkaspell, sug_mode);
2054 dictionary_delete(dict);
2056 if (gtkaspell->config_menu)
2057 populate_submenu(gtkaspell, gtkaspell->config_menu);
2060 static void switch_to_alternate_cb(GtkWidget *w,
2063 GtkAspell *gtkaspell = (GtkAspell *) data;
2064 use_alternate_dict(gtkaspell);
2067 /* Misc. helper functions */
2069 static void set_point_continue(GtkAspell *gtkaspell)
2073 gtktext = gtkaspell->gtktext;
2075 gtk_stext_freeze(gtktext);
2076 gtk_editable_set_position(GTK_EDITABLE(gtktext),gtkaspell->orig_pos);
2077 gtk_stext_set_point(gtktext, gtkaspell->orig_pos);
2078 gtk_stext_thaw(gtktext);
2080 if (gtkaspell->continue_check)
2081 gtkaspell->continue_check((gpointer *) gtkaspell);
2084 static void allocate_color(GtkAspell *gtkaspell, gint rgbvalue)
2087 GdkColor *color = &(gtkaspell->highlight);
2089 gc = gtk_widget_get_colormap(GTK_WIDGET(gtkaspell->gtktext));
2091 if (gtkaspell->highlight.pixel)
2092 gdk_colormap_free_colors(gc, &(gtkaspell->highlight), 1);
2094 /* Shameless copy from Sylpheed's gtkutils.c */
2096 color->red = (int) (((gdouble)((rgbvalue & 0xff0000) >> 16) / 255.0)
2098 color->green = (int) (((gdouble)((rgbvalue & 0x00ff00) >> 8) / 255.0)
2100 color->blue = (int) (((gdouble) (rgbvalue & 0x0000ff) / 255.0)
2103 gdk_colormap_alloc_color(gc, &(gtkaspell->highlight), FALSE, TRUE);
2106 static void change_color(GtkAspell * gtkaspell,
2107 gint start, gint end,
2113 g_return_if_fail(start < end);
2115 gtktext = gtkaspell->gtktext;
2117 gtk_stext_freeze(gtktext);
2119 gtk_stext_set_point(gtktext, start);
2120 gtk_stext_forward_delete(gtktext, end - start);
2121 gtk_stext_insert(gtktext, NULL, color, NULL, newtext,
2124 gtk_stext_thaw(gtktext);
2127 /* convert_to_aspell_encoding () - converts ISO-8859-* strings to iso8859-*
2128 * as needed by aspell. Returns an allocated string.
2131 static guchar *convert_to_aspell_encoding (const guchar *encoding)
2133 guchar * aspell_encoding;
2135 if (strstr2(encoding, "ISO-8859-")) {
2136 aspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
2139 if (!strcmp2(encoding, "US-ASCII"))
2140 aspell_encoding = g_strdup("iso8859-1");
2142 aspell_encoding = g_strdup(encoding);
2145 return aspell_encoding;
2148 /* compare_dict () - compare 2 dict names */
2149 static gint compare_dict(Dictionary *a, Dictionary *b)
2151 guint aparts = 0, bparts = 0;
2154 for (i=0; i < strlen(a->dictname); i++)
2155 if (a->dictname[i] == '-')
2157 for (i=0; i < strlen(b->dictname); i++)
2158 if (b->dictname[i] == '-')
2161 if (aparts != bparts)
2162 return (aparts < bparts) ? -1 : +1;
2165 compare = strcmp2(a->dictname, b->dictname);
2167 compare = strcmp2(a->fullname, b->fullname);
2172 static void dictionary_delete(Dictionary *dict)
2174 g_free(dict->fullname);
2175 g_free(dict->encoding);
2179 static Dictionary *dictionary_dup(const Dictionary *dict)
2183 dict2 = g_new(Dictionary, 1);
2185 dict2->fullname = g_strdup(dict->fullname);
2186 dict2->dictname = dict->dictname - dict->fullname + dict2->fullname;
2187 dict2->encoding = g_strdup(dict->encoding);
2192 static void free_suggestions_list(GtkAspell *gtkaspell)
2196 for (list = gtkaspell->suggestions_list; list != NULL;
2202 gtkaspell->max_sug = -1;
2203 gtkaspell->suggestions_list = NULL;
2206 static void reset_theword_data(GtkAspell *gtkaspell)
2208 gtkaspell->start_pos = 0;
2209 gtkaspell->end_pos = 0;
2210 gtkaspell->theword[0] = 0;
2211 gtkaspell->max_sug = -1;
2213 free_suggestions_list(gtkaspell);
2216 static void free_checkers(gpointer elt, gpointer data)
2218 GtkAspeller *gtkaspeller = elt;
2220 g_return_if_fail(gtkaspeller);
2222 gtkaspeller_real_delete(gtkaspeller);
2225 static gint find_gtkaspeller(gconstpointer aa, gconstpointer bb)
2227 Dictionary *a = ((GtkAspeller *) aa)->dictionary;
2228 Dictionary *b = ((GtkAspeller *) bb)->dictionary;
2230 if (a && b && a->fullname && b->fullname &&
2231 strcmp(a->fullname, b->fullname) == 0 &&
2232 a->encoding && b->encoding)
2233 return strcmp(a->encoding, b->encoding);
2238 static void gtkaspell_alert_dialog(gchar *message)
2243 GtkWidget *ok_button;
2245 dialog = gtk_dialog_new();
2246 gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
2247 gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_MOUSE);
2248 gtk_signal_connect_object(GTK_OBJECT(dialog), "destroy",
2249 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2250 GTK_OBJECT(dialog));
2252 label = gtk_label_new(message);
2253 gtk_misc_set_padding(GTK_MISC(label), 8, 8);
2255 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
2257 hbox = gtk_hbox_new(FALSE, 0);
2259 ok_button = gtk_button_new_with_label(_("OK"));
2260 GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
2261 gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 8);
2263 gtk_signal_connect_object(GTK_OBJECT(ok_button), "clicked",
2264 GTK_SIGNAL_FUNC(gtk_widget_destroy),
2265 GTK_OBJECT(dialog));
2266 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), hbox);
2268 gtk_widget_grab_default(ok_button);
2269 gtk_widget_grab_focus(ok_button);
2270 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
2272 gtk_widget_show_all(dialog);