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>
48 #include <glib/gi18n.h>
52 #include <gtk/gtkoptionmenu.h>
53 #include <gtk/gtkmenu.h>
54 #include <gtk/gtkmenuitem.h>
55 #include <gdk/gdkkeysyms.h>
61 #include "alertpanel.h"
62 #include "gtkaspell.h"
63 #include "gtk/gtkutils.h"
65 #define ASPELL_FASTMODE 1
66 #define ASPELL_NORMALMODE 2
67 #define ASPELL_BADSPELLERMODE 3
69 #define GTKASPELLWORDSIZE 1024
71 /* size of the text buffer used in various word-processing routines. */
74 /* number of suggestions to display on each menu. */
77 /* 'config' must be defined as a 'AspellConfig *' */
78 #define RETURN_FALSE_IF_CONFIG_ERROR() \
80 if (aspell_config_error_number(config) != 0) { \
81 gtkaspellcheckers->error_message = g_strdup(aspell_config_error_message(config)); \
86 #define CONFIG_REPLACE_RETURN_FALSE_IF_FAIL(option, value) { \
87 aspell_config_replace(config, option, value); \
88 RETURN_FALSE_IF_CONFIG_ERROR(); \
91 typedef struct _GtkAspellCheckers {
93 GSList *dictionary_list;
97 typedef struct _Dictionary {
103 typedef struct _GtkAspeller {
104 Dictionary *dictionary;
106 AspellConfig *config;
107 AspellSpeller *checker;
110 typedef void (*ContCheckFunc) (gpointer *gtkaspell);
114 GtkAspeller *gtkaspeller;
115 GtkAspeller *alternate_speller;
116 gchar *dictionary_path;
117 gchar theword[GTKASPELLWORDSIZE];
123 gboolean check_while_typing;
124 gboolean use_alternate;
126 ContCheckFunc continue_check;
128 GtkWidget *config_menu;
129 GtkWidget *popup_config_menu;
131 GtkWidget *replace_entry;
132 GtkWidget *parent_window;
134 gint default_sug_mode;
136 GList *suggestions_list;
138 GtkTextView *gtktext;
140 GtkAccelGroup *accel_group;
143 typedef AspellConfig GtkAspellConfig;
145 /******************************************************************************/
147 static GtkAspellCheckers *gtkaspellcheckers;
149 /* Error message storage */
150 static void gtkaspell_checkers_error_message (gchar *message);
153 static void entry_insert_cb (GtkTextBuffer *textbuf,
157 GtkAspell *gtkaspell);
158 static void entry_delete_cb (GtkTextBuffer *textbuf,
159 GtkTextIter *startiter,
160 GtkTextIter *enditer,
161 GtkAspell *gtkaspell);
162 static gint button_press_intercept_cb (GtkTextView *gtktext,
164 GtkAspell *gtkaspell);
166 /* Checker creation */
167 static GtkAspeller* gtkaspeller_new (Dictionary *dict);
168 static GtkAspeller* gtkaspeller_real_new (Dictionary *dict);
169 static GtkAspeller* gtkaspeller_delete (GtkAspeller *gtkaspeller);
170 static GtkAspeller* gtkaspeller_real_delete (GtkAspeller *gtkaspeller);
172 /* Checker configuration */
173 static gint set_dictionary (AspellConfig *config,
175 static void set_sug_mode_cb (GtkMenuItem *w,
176 GtkAspell *gtkaspell);
177 static void set_real_sug_mode (GtkAspell *gtkaspell,
178 const char *themode);
180 /* Checker actions */
181 static gboolean check_at (GtkAspell *gtkaspell,
183 static gboolean check_next_prev (GtkAspell *gtkaspell,
185 static GList* misspelled_suggest (GtkAspell *gtkaspell,
187 static void add_word_to_session_cb (GtkWidget *w,
189 static void add_word_to_personal_cb (GtkWidget *w,
191 static void replace_with_create_dialog_cb (GtkWidget *w,
193 static void replace_with_supplied_word_cb (GtkWidget *w,
194 GtkAspell *gtkaspell);
195 static void replace_word_cb (GtkWidget *w,
197 static void replace_real_word (GtkAspell *gtkaspell,
199 static void check_with_alternate_cb (GtkWidget *w,
201 static void use_alternate_dict (GtkAspell *gtkaspell);
202 static void toggle_check_while_typing_cb (GtkWidget *w,
206 static void popup_menu (GtkAspell *gtkaspell,
208 static GtkMenu* make_sug_menu (GtkAspell *gtkaspell);
209 static void populate_submenu (GtkAspell *gtkaspell,
211 static GtkMenu* make_config_menu (GtkAspell *gtkaspell);
212 static void set_menu_pos (GtkMenu *menu,
217 /* Other menu callbacks */
218 static gboolean cancel_menu_cb (GtkMenuShell *w,
220 static void change_dict_cb (GtkWidget *w,
221 GtkAspell *gtkaspell);
222 static void switch_to_alternate_cb (GtkWidget *w,
225 /* Misc. helper functions */
226 static void set_point_continue (GtkAspell *gtkaspell);
227 static void continue_check (gpointer *gtkaspell);
228 static gboolean iswordsep (unsigned char c);
229 static guchar get_text_index_whar (GtkAspell *gtkaspell,
231 static gboolean get_word_from_pos (GtkAspell *gtkaspell,
237 static void allocate_color (GtkAspell *gtkaspell,
239 static void change_color (GtkAspell *gtkaspell,
244 static guchar* convert_to_aspell_encoding (const guchar *encoding);
245 static gint compare_dict (Dictionary *a,
247 static void dictionary_delete (Dictionary *dict);
248 static Dictionary * dictionary_dup (const Dictionary *dict);
249 static void free_suggestions_list (GtkAspell *gtkaspell);
250 static void reset_theword_data (GtkAspell *gtkaspell);
251 static void free_checkers (gpointer elt,
253 static gint find_gtkaspeller (gconstpointer aa,
255 /* gtkspellconfig - only one config per session */
256 GtkAspellConfig * gtkaspellconfig;
257 static void destroy_menu(GtkWidget *widget, gpointer user_data);
259 /******************************************************************************/
260 static gint get_textview_buffer_charcount(GtkTextView *view);
262 static gint get_textview_buffer_charcount(GtkTextView *view)
264 GtkTextBuffer *buffer;
266 g_return_val_if_fail(view, 0);
268 buffer = gtk_text_view_get_buffer(view);
269 g_return_val_if_fail(buffer, 0);
271 return gtk_text_buffer_get_char_count(buffer);
273 static gint get_textview_buffer_offset(GtkTextView *view)
275 GtkTextBuffer * buffer;
279 g_return_val_if_fail(view, 0);
281 buffer = gtk_text_view_get_buffer(view);
282 g_return_val_if_fail(buffer, 0);
284 mark = gtk_text_buffer_get_insert(buffer);
285 g_return_val_if_fail(mark, 0);
287 gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
289 return gtk_text_iter_get_offset(&iter);
291 static void set_textview_buffer_offset(GtkTextView *view, gint offset)
293 GtkTextBuffer *buffer;
296 g_return_if_fail(view);
298 buffer = gtk_text_view_get_buffer(view);
299 g_return_if_fail(buffer);
301 gtk_text_buffer_get_iter_at_offset(buffer, &iter, offset);
302 gtk_text_buffer_place_cursor(buffer, &iter);
304 /******************************************************************************/
306 void gtkaspell_checkers_init(void)
308 gtkaspellcheckers = g_new(GtkAspellCheckers, 1);
309 gtkaspellcheckers->checkers = NULL;
310 gtkaspellcheckers->dictionary_list = NULL;
311 gtkaspellcheckers->error_message = NULL;
314 void gtkaspell_checkers_quit(void)
319 if (gtkaspellcheckers == NULL)
322 if ((checkers = gtkaspellcheckers->checkers)) {
323 debug_print("Aspell: number of running checkers to delete %d\n",
324 g_slist_length(checkers));
326 g_slist_foreach(checkers, free_checkers, NULL);
327 g_slist_free(checkers);
328 gtkaspellcheckers->checkers = NULL;
331 if ((dict_list = gtkaspellcheckers->dictionary_list)) {
332 debug_print("Aspell: number of dictionaries to delete %d\n",
333 g_slist_length(dict_list));
335 gtkaspell_free_dictionary_list(dict_list);
336 gtkaspellcheckers->dictionary_list = NULL;
339 g_free(gtkaspellcheckers->error_message);
340 gtkaspellcheckers->error_message = NULL;
344 static void gtkaspell_checkers_error_message (gchar *message)
347 if (gtkaspellcheckers->error_message) {
348 tmp = g_strdup_printf("%s\n%s",
349 gtkaspellcheckers->error_message,
352 g_free(gtkaspellcheckers->error_message);
353 gtkaspellcheckers->error_message = tmp;
355 gtkaspellcheckers->error_message = message;
358 const char *gtkaspell_checkers_strerror(void)
360 g_return_val_if_fail(gtkaspellcheckers, "");
361 return gtkaspellcheckers->error_message;
364 void gtkaspell_checkers_reset_error(void)
366 g_return_if_fail(gtkaspellcheckers);
368 g_free(gtkaspellcheckers->error_message);
370 gtkaspellcheckers->error_message = NULL;
373 GtkAspell *gtkaspell_new(const gchar *dictionary_path,
374 const gchar *dictionary,
375 const gchar *encoding,
376 gint misspelled_color,
377 gboolean check_while_typing,
378 gboolean use_alternate,
379 GtkTextView *gtktext,
380 GtkWindow *parent_win)
383 GtkAspell *gtkaspell;
384 GtkAspeller *gtkaspeller;
385 GtkTextBuffer *buffer;
387 g_return_val_if_fail(gtktext, NULL);
388 buffer = gtk_text_view_get_buffer(gtktext);
390 dict = g_new0(Dictionary, 1);
391 dict->fullname = g_strdup(dictionary);
392 dict->encoding = g_strdup(encoding);
394 gtkaspeller = gtkaspeller_new(dict);
395 dictionary_delete(dict);
400 gtkaspell = g_new0(GtkAspell, 1);
402 gtkaspell->dictionary_path = g_strdup(dictionary_path);
404 gtkaspell->gtkaspeller = gtkaspeller;
405 gtkaspell->alternate_speller = NULL;
406 gtkaspell->theword[0] = 0x00;
407 gtkaspell->start_pos = 0;
408 gtkaspell->end_pos = 0;
409 gtkaspell->orig_pos = -1;
410 gtkaspell->end_check_pos = -1;
411 gtkaspell->misspelled = -1;
412 gtkaspell->check_while_typing = check_while_typing;
413 gtkaspell->continue_check = NULL;
414 gtkaspell->config_menu = NULL;
415 gtkaspell->popup_config_menu = NULL;
416 gtkaspell->sug_menu = NULL;
417 gtkaspell->replace_entry = NULL;
418 gtkaspell->gtktext = gtktext;
419 gtkaspell->default_sug_mode = ASPELL_FASTMODE;
420 gtkaspell->max_sug = -1;
421 gtkaspell->suggestions_list = NULL;
422 gtkaspell->use_alternate = use_alternate;
423 gtkaspell->parent_window = GTK_WIDGET(parent_win);
425 allocate_color(gtkaspell, misspelled_color);
427 g_signal_connect_after(G_OBJECT(buffer), "insert-text",
428 G_CALLBACK(entry_insert_cb), gtkaspell);
429 g_signal_connect_after(G_OBJECT(buffer), "delete-range",
430 G_CALLBACK(entry_delete_cb), gtkaspell);
431 g_signal_connect(G_OBJECT(gtktext), "button-press-event",
432 G_CALLBACK(button_press_intercept_cb),
435 debug_print("Aspell: created gtkaspell %0x\n", (guint) gtkaspell);
440 void gtkaspell_delete(GtkAspell *gtkaspell)
442 GtkTextView *gtktext = gtkaspell->gtktext;
444 g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
445 G_CALLBACK(entry_insert_cb),
447 g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
448 G_CALLBACK(entry_delete_cb),
450 g_signal_handlers_disconnect_by_func(G_OBJECT(gtktext),
451 G_CALLBACK(button_press_intercept_cb),
454 gtkaspell_uncheck_all(gtkaspell);
456 gtkaspeller_delete(gtkaspell->gtkaspeller);
458 if (gtkaspell->use_alternate && gtkaspell->alternate_speller)
459 gtkaspeller_delete(gtkaspell->alternate_speller);
461 if (gtkaspell->sug_menu)
462 gtk_widget_destroy(gtkaspell->sug_menu);
464 if (gtkaspell->popup_config_menu)
465 gtk_widget_destroy(gtkaspell->popup_config_menu);
467 if (gtkaspell->config_menu)
468 gtk_widget_destroy(gtkaspell->config_menu);
470 if (gtkaspell->suggestions_list)
471 free_suggestions_list(gtkaspell);
473 g_free((gchar *)gtkaspell->dictionary_path);
474 gtkaspell->dictionary_path = NULL;
476 debug_print("Aspell: deleting gtkaspell %0x\n", (guint) gtkaspell);
483 static void entry_insert_cb(GtkTextBuffer *textbuf,
487 GtkAspell *gtkaspell)
491 g_return_if_fail(gtkaspell->gtkaspeller->checker);
493 if (!gtkaspell->check_while_typing)
496 pos = gtk_text_iter_get_offset(iter);
498 if (iswordsep(newtext[0])) {
499 /* did we just end a word? */
501 check_at(gtkaspell, pos - 2);
503 /* did we just split a word? */
504 if (pos < gtk_text_buffer_get_char_count(textbuf))
505 check_at(gtkaspell, pos + 1);
507 /* check as they type, *except* if they're typing at the end (the most
510 if (pos < gtk_text_buffer_get_char_count(textbuf) &&
511 !iswordsep(get_text_index_whar(gtkaspell, pos))) {
512 check_at(gtkaspell, pos - 1);
517 static void entry_delete_cb(GtkTextBuffer *textbuf,
518 GtkTextIter *startiter,
519 GtkTextIter *enditer,
520 GtkAspell *gtkaspell)
525 g_return_if_fail(gtkaspell->gtkaspeller->checker);
527 if (!gtkaspell->check_while_typing)
530 start = gtk_text_iter_get_offset(startiter);
531 end = gtk_text_iter_get_offset(enditer);
532 origpos = get_textview_buffer_offset(gtkaspell->gtktext);
534 check_at(gtkaspell, start - 1);
535 check_at(gtkaspell, start);
538 set_textview_buffer_offset(gtkaspell->gtktext, origpos);
539 /* this is to *UNDO* the selection, in case they were holding shift
540 * while hitting backspace. */
541 /* needed with textview ??? */
542 /* gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos); */
545 /* ok, this is pretty wacky:
546 * we need to let the right-mouse-click go through, so it moves the cursor,
547 * but we *can't* let it go through, because GtkText interprets rightclicks as
548 * weird selection modifiers.
550 * so what do we do? forge rightclicks as leftclicks, then popup the menu.
553 static gint button_press_intercept_cb(GtkTextView *gtktext,
555 GtkAspell *gtkaspell)
560 g_return_val_if_fail(gtkaspell->gtkaspeller->checker, FALSE);
562 if (e->type != GDK_BUTTON_PRESS)
564 eb = (GdkEventButton*) e;
569 g_signal_handlers_block_by_func(G_OBJECT(gtktext),
570 G_CALLBACK(button_press_intercept_cb),
572 g_signal_emit_by_name(G_OBJECT(gtktext), "button-release-event",
575 /* forge the leftclick */
578 g_signal_emit_by_name(G_OBJECT(gtktext), "button-press-event",
580 g_signal_emit_by_name(G_OBJECT(gtktext), "button-release-event",
582 g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
583 G_CALLBACK(button_press_intercept_cb),
585 g_signal_stop_emission_by_name(G_OBJECT(gtktext), "button-press-event");
587 /* now do the menu wackiness */
588 popup_menu(gtkaspell, eb);
589 gtk_grab_remove(GTK_WIDGET(gtktext));
593 /* Checker creation */
594 static GtkAspeller *gtkaspeller_new(Dictionary *dictionary)
597 GtkAspeller *gtkaspeller = NULL;
601 g_return_val_if_fail(gtkaspellcheckers, NULL);
603 g_return_val_if_fail(dictionary, NULL);
605 if (dictionary->fullname == NULL)
606 gtkaspell_checkers_error_message(
607 g_strdup(_("No dictionary selected.")));
609 g_return_val_if_fail(dictionary->fullname, NULL);
611 if (dictionary->dictname == NULL) {
614 tmp = strrchr(dictionary->fullname, G_DIR_SEPARATOR);
617 dictionary->dictname = dictionary->fullname;
619 dictionary->dictname = tmp + 1;
622 dict = dictionary_dup(dictionary);
624 tmp = g_new0(GtkAspeller, 1);
625 tmp->dictionary = dict;
627 exist = g_slist_find_custom(gtkaspellcheckers->checkers, tmp,
632 if ((gtkaspeller = gtkaspeller_real_new(dict)) != NULL) {
633 gtkaspellcheckers->checkers = g_slist_append(
634 gtkaspellcheckers->checkers,
637 debug_print("Aspell: Created a new gtkaspeller %0x\n",
640 dictionary_delete(dict);
642 debug_print("Aspell: Could not create spell checker.\n");
645 debug_print("Aspell: number of existing checkers %d\n",
646 g_slist_length(gtkaspellcheckers->checkers));
651 static GtkAspeller *gtkaspeller_real_new(Dictionary *dict)
653 GtkAspeller *gtkaspeller;
654 AspellConfig *config;
655 AspellCanHaveError *ret;
657 g_return_val_if_fail(gtkaspellcheckers, NULL);
658 g_return_val_if_fail(dict, NULL);
660 gtkaspeller = g_new(GtkAspeller, 1);
662 gtkaspeller->dictionary = dict;
663 gtkaspeller->sug_mode = ASPELL_FASTMODE;
665 config = new_aspell_config();
667 if (!set_dictionary(config, dict))
670 ret = new_aspell_speller(config);
671 delete_aspell_config(config);
673 if (aspell_error_number(ret) != 0) {
674 gtkaspellcheckers->error_message
675 = g_strdup(aspell_error_message(ret));
677 delete_aspell_can_have_error(ret);
682 gtkaspeller->checker = to_aspell_speller(ret);
683 gtkaspeller->config = aspell_speller_config(gtkaspeller->checker);
688 static GtkAspeller *gtkaspeller_delete(GtkAspeller *gtkaspeller)
690 g_return_val_if_fail(gtkaspellcheckers, NULL);
692 gtkaspellcheckers->checkers =
693 g_slist_remove(gtkaspellcheckers->checkers,
696 debug_print("Aspell: Deleting gtkaspeller %0x.\n",
699 gtkaspeller_real_delete(gtkaspeller);
701 debug_print("Aspell: number of existing checkers %d\n",
702 g_slist_length(gtkaspellcheckers->checkers));
707 static GtkAspeller *gtkaspeller_real_delete(GtkAspeller *gtkaspeller)
709 g_return_val_if_fail(gtkaspeller, NULL);
710 g_return_val_if_fail(gtkaspeller->checker, NULL);
712 aspell_speller_save_all_word_lists(gtkaspeller->checker);
714 delete_aspell_speller(gtkaspeller->checker);
716 dictionary_delete(gtkaspeller->dictionary);
718 debug_print("Aspell: gtkaspeller %0x deleted.\n",
726 /*****************************************************************************/
727 /* Checker configuration */
729 static gboolean set_dictionary(AspellConfig *config, Dictionary *dict)
731 gchar *language = NULL;
732 gchar *jargon = NULL;
736 g_return_val_if_fail(config, FALSE);
737 g_return_val_if_fail(dict, FALSE);
739 strncpy(buf, dict->fullname, BUFSIZE-1);
740 buf[BUFSIZE-1] = 0x00;
742 buf[dict->dictname - dict->fullname] = 0x00;
744 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("dict-dir", buf);
745 debug_print("Aspell: looking for dictionaries in path %s.\n", buf);
747 strncpy(buf, dict->dictname, BUFSIZE-1);
750 if ((size = strrchr(buf, '-')) && isdigit((int) size[1]))
755 if ((jargon = strchr(language, '-')) != NULL)
758 if (size != NULL && jargon == size)
761 debug_print("Aspell: language: %s, jargon: %s, size: %s\n",
762 language, jargon ? jargon : "",
766 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("lang", language);
768 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("jargon", jargon);
770 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("size", size);
771 if (dict->encoding) {
774 aspell_enc = convert_to_aspell_encoding (dict->encoding);
775 aspell_config_replace(config, "encoding",
776 (const char *) aspell_enc);
779 RETURN_FALSE_IF_CONFIG_ERROR();
785 guchar *gtkaspell_get_dict(GtkAspell *gtkaspell)
788 g_return_val_if_fail(gtkaspell->gtkaspeller->config, NULL);
789 g_return_val_if_fail(gtkaspell->gtkaspeller->dictionary, NULL);
791 return g_strdup(gtkaspell->gtkaspeller->dictionary->dictname);
794 guchar *gtkaspell_get_path(GtkAspell *gtkaspell)
799 g_return_val_if_fail(gtkaspell->gtkaspeller->config, NULL);
800 g_return_val_if_fail(gtkaspell->gtkaspeller->dictionary, NULL);
802 dict = gtkaspell->gtkaspeller->dictionary;
803 path = g_strndup(dict->fullname, dict->dictname - dict->fullname);
808 /* set_sug_mode_cb() - Menu callback: Set the suggestion mode */
809 static void set_sug_mode_cb(GtkMenuItem *w, GtkAspell *gtkaspell)
813 themode = (char *) gtk_label_get_text(GTK_LABEL(GTK_BIN(w)->child));
814 themode = g_strdup(themode);
816 set_real_sug_mode(gtkaspell, themode);
819 if (gtkaspell->config_menu)
820 populate_submenu(gtkaspell, gtkaspell->config_menu);
823 static void set_real_sug_mode(GtkAspell *gtkaspell, const char *themode)
826 gint mode = ASPELL_FASTMODE;
827 g_return_if_fail(gtkaspell);
828 g_return_if_fail(gtkaspell->gtkaspeller);
829 g_return_if_fail(themode);
831 if (!strcmp(themode,_("Normal Mode")))
832 mode = ASPELL_NORMALMODE;
833 else if (!strcmp( themode,_("Bad Spellers Mode")))
834 mode = ASPELL_BADSPELLERMODE;
836 result = gtkaspell_set_sug_mode(gtkaspell, mode);
839 debug_print("Aspell: error while changing suggestion mode:%s\n",
840 gtkaspellcheckers->error_message);
841 gtkaspell_checkers_reset_error();
845 /* gtkaspell_set_sug_mode() - Set the suggestion mode */
846 gboolean gtkaspell_set_sug_mode(GtkAspell *gtkaspell, gint themode)
848 AspellConfig *config;
850 g_return_val_if_fail(gtkaspell, FALSE);
851 g_return_val_if_fail(gtkaspell->gtkaspeller, FALSE);
852 g_return_val_if_fail(gtkaspell->gtkaspeller->config, FALSE);
854 debug_print("Aspell: setting sug mode of gtkaspeller %0x to %d\n",
855 (guint) gtkaspell->gtkaspeller, themode);
857 config = gtkaspell->gtkaspeller->config;
860 case ASPELL_FASTMODE:
861 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "fast");
863 case ASPELL_NORMALMODE:
864 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode", "normal");
866 case ASPELL_BADSPELLERMODE:
867 CONFIG_REPLACE_RETURN_FALSE_IF_FAIL("sug-mode",
871 gtkaspellcheckers->error_message =
872 g_strdup(_("Unknown suggestion mode."));
876 gtkaspell->gtkaspeller->sug_mode = themode;
877 gtkaspell->default_sug_mode = themode;
882 /* misspelled_suggest() - Create a suggestion list for word */
883 static GList *misspelled_suggest(GtkAspell *gtkaspell, guchar *word)
885 const guchar *newword;
887 const AspellWordList *suggestions;
888 AspellStringEnumeration *elements;
890 g_return_val_if_fail(word, NULL);
892 if (!aspell_speller_check(gtkaspell->gtkaspeller->checker, word, -1)) {
893 free_suggestions_list(gtkaspell);
895 suggestions = aspell_speller_suggest(
896 gtkaspell->gtkaspeller->checker,
897 (const char *)word, -1);
898 elements = aspell_word_list_elements(suggestions);
899 list = g_list_append(list, g_strdup(word));
901 while ((newword = aspell_string_enumeration_next(elements)) != NULL)
902 list = g_list_append(list, g_strdup(newword));
904 gtkaspell->max_sug = g_list_length(list) - 1;
905 gtkaspell->suggestions_list = list;
910 free_suggestions_list(gtkaspell);
915 /* misspelled_test() - Just test if word is correctly spelled */
916 static int misspelled_test(GtkAspell *gtkaspell, unsigned char *word)
918 return aspell_speller_check(gtkaspell->gtkaspeller->checker, word, -1)
923 static gboolean iswordsep(unsigned char c)
925 return (isspace(c) || ispunct(c)) && c != '\'';
928 static guchar get_text_index_whar(GtkAspell *gtkaspell, int pos)
930 GtkTextView *view = gtkaspell->gtktext;
931 GtkTextBuffer *buffer = gtk_text_view_get_buffer(view);
932 GtkTextIter start, end;
933 const gchar *utf8chars;
936 gtk_text_buffer_get_iter_at_offset(buffer, &start, pos);
937 gtk_text_buffer_get_iter_at_offset(buffer, &end, pos+1);
939 utf8chars = gtk_text_iter_get_text(&start, &end);
940 if (is_ascii_str(utf8chars)) {
941 a = utf8chars ? utf8chars[0] : '\0' ;
943 gchar *tr = conv_iconv_strdup(utf8chars, CS_UTF_8,
944 gtkaspell->gtkaspeller->dictionary->encoding);
954 /* get_word_from_pos () - return the word pointed to. */
955 /* Handles correctly the quotes. */
956 static gboolean get_word_from_pos(GtkAspell *gtkaspell, gint pos,
957 unsigned char* buf, gint buflen,
958 gint *pstart, gint *pend)
961 /* TODO : when correcting a word into quotes, change the color of */
962 /* the quotes too, as may be they were highlighted before. To do */
963 /* this, we can use two others pointers that points to the whole */
964 /* word including quotes. */
970 GtkTextView *gtktext;
972 gtktext = gtkaspell->gtktext;
973 if (iswordsep(get_text_index_whar(gtkaspell, pos)))
976 /* The apostrophe character is somtimes used for quotes
977 * So include it in the word only if it is not surrounded
978 * by other characters.
981 for (start = pos; start >= 0; --start) {
982 c = get_text_index_whar(gtkaspell, start);
985 if (isspace(get_text_index_whar(gtkaspell,
987 || ispunct(get_text_index_whar(gtkaspell,
989 || isdigit(get_text_index_whar(gtkaspell,
991 /* start_quote = TRUE; */
996 /* start_quote = TRUE; */
1000 else if (isspace(c) || ispunct(c) || isdigit(c))
1006 for (end = pos; end < get_textview_buffer_charcount(gtktext); end++) {
1007 c = get_text_index_whar(gtkaspell, end);
1009 if (end < get_textview_buffer_charcount(gtktext)) {
1010 if (isspace(get_text_index_whar(gtkaspell,
1012 || ispunct(get_text_index_whar(gtkaspell,
1014 || isdigit(get_text_index_whar(gtkaspell,
1016 /* end_quote = TRUE; */
1021 /* end_quote = TRUE; */
1025 else if (isspace(c) || ispunct(c) || isdigit(c))
1035 if (end - start < buflen) {
1036 GtkTextIter iterstart, iterend;
1038 GtkTextBuffer *buffer = gtk_text_view_get_buffer(gtktext);
1039 gtk_text_buffer_get_iter_at_offset(buffer, &iterstart, start);
1040 gtk_text_buffer_get_iter_at_offset(buffer, &iterend, end);
1041 tmp = gtk_text_buffer_get_text(buffer, &iterstart, &iterend, FALSE);
1042 conv = conv_iconv_strdup(tmp, CS_UTF_8,
1043 gtkaspell->gtkaspeller->dictionary->encoding);
1045 strncpy(buf, conv, buflen-1);
1055 static gboolean check_at(GtkAspell *gtkaspell, gint from_pos)
1058 unsigned char buf[GTKASPELLWORDSIZE];
1059 GtkTextView *gtktext;
1061 g_return_val_if_fail(from_pos >= 0, FALSE);
1063 gtktext = gtkaspell->gtktext;
1065 if (!get_word_from_pos(gtkaspell, from_pos, buf, sizeof(buf),
1068 if (misspelled_test(gtkaspell, buf)) {
1069 strncpy(gtkaspell->theword, buf, GTKASPELLWORDSIZE - 1);
1070 gtkaspell->theword[GTKASPELLWORDSIZE - 1] = 0;
1071 gtkaspell->start_pos = start;
1072 gtkaspell->end_pos = end;
1073 free_suggestions_list(gtkaspell);
1075 change_color(gtkaspell, start, end, buf, &(gtkaspell->highlight));
1078 change_color(gtkaspell, start, end, buf, NULL);
1083 static gboolean check_next_prev(GtkAspell *gtkaspell, gboolean forward)
1089 gboolean misspelled;
1092 maxpos = gtkaspell->end_check_pos;
1100 pos = get_textview_buffer_offset(gtkaspell->gtktext);
1101 gtkaspell->orig_pos = pos;
1102 while (iswordsep(get_text_index_whar(gtkaspell, pos)) &&
1103 pos > minpos && pos <= maxpos)
1105 while (!(misspelled = check_at(gtkaspell, pos)) &&
1106 pos > minpos && pos <= maxpos) {
1108 while (!iswordsep(get_text_index_whar(gtkaspell, pos)) &&
1109 pos > minpos && pos <= maxpos)
1112 while (iswordsep(get_text_index_whar(gtkaspell, pos)) &&
1113 pos > minpos && pos <= maxpos)
1117 GtkMenu *menu = NULL;
1118 misspelled_suggest(gtkaspell, gtkaspell->theword);
1121 gtkaspell->orig_pos = gtkaspell->end_pos;
1123 set_textview_buffer_offset(gtkaspell->gtktext,
1124 gtkaspell->end_pos);
1125 /* scroll line to window center */
1126 gtk_text_view_scroll_to_mark(gtkaspell->gtktext,
1127 gtk_text_buffer_get_insert(
1128 gtk_text_view_get_buffer(gtkaspell->gtktext)),
1129 0.0, TRUE, 0.0, 0.5);
1130 /* let textview recalculate coordinates (set_menu_pos) */
1131 while (gtk_events_pending ())
1132 gtk_main_iteration ();
1134 menu = make_sug_menu(gtkaspell);
1135 gtk_menu_popup(menu, NULL, NULL,
1136 set_menu_pos, gtkaspell, 0, GDK_CURRENT_TIME);
1137 g_signal_connect(G_OBJECT(menu), "deactivate",
1138 G_CALLBACK(destroy_menu),
1142 reset_theword_data(gtkaspell);
1144 alertpanel_notice(_("No misspelled word found."));
1145 set_textview_buffer_offset(gtkaspell->gtktext,
1146 gtkaspell->orig_pos);
1152 void gtkaspell_check_backwards(GtkAspell *gtkaspell)
1154 gtkaspell->continue_check = NULL;
1155 gtkaspell->end_check_pos =
1156 get_textview_buffer_charcount(gtkaspell->gtktext);
1157 check_next_prev(gtkaspell, FALSE);
1160 void gtkaspell_check_forwards_go(GtkAspell *gtkaspell)
1163 gtkaspell->continue_check = NULL;
1164 gtkaspell->end_check_pos =
1165 get_textview_buffer_charcount(gtkaspell->gtktext);
1166 check_next_prev(gtkaspell, TRUE);
1169 void gtkaspell_check_all(GtkAspell *gtkaspell)
1171 GtkTextView *gtktext;
1173 GtkTextBuffer *buffer;
1174 GtkTextIter startiter, enditer;
1176 g_return_if_fail(gtkaspell);
1177 g_return_if_fail(gtkaspell->gtktext);
1179 gtktext = gtkaspell->gtktext;
1180 buffer = gtk_text_view_get_buffer(gtktext);
1181 gtk_text_buffer_get_selection_bounds(buffer, &startiter, &enditer);
1182 start = gtk_text_iter_get_offset(&startiter);
1183 end = gtk_text_iter_get_offset(&enditer);
1187 end = gtk_text_buffer_get_char_count(buffer);
1188 } else if (start > end) {
1196 set_textview_buffer_offset(gtktext, start);
1198 gtkaspell->continue_check = continue_check;
1199 gtkaspell->end_check_pos = end;
1201 gtkaspell->misspelled = check_next_prev(gtkaspell, TRUE);
1204 static void continue_check(gpointer *data)
1206 GtkAspell *gtkaspell = (GtkAspell *) data;
1207 gint pos = get_textview_buffer_offset(gtkaspell->gtktext);
1208 if (pos < gtkaspell->end_check_pos && gtkaspell->misspelled)
1209 gtkaspell->misspelled = check_next_prev(gtkaspell, TRUE);
1211 gtkaspell->continue_check = NULL;
1214 void gtkaspell_highlight_all(GtkAspell *gtkaspell)
1219 GtkTextView *gtktext;
1221 g_return_if_fail(gtkaspell->gtkaspeller->checker);
1223 gtktext = gtkaspell->gtktext;
1225 len = get_textview_buffer_charcount(gtktext);
1227 origpos = get_textview_buffer_offset(gtktext);
1231 iswordsep(get_text_index_whar(gtkaspell, pos)))
1234 !iswordsep(get_text_index_whar(gtkaspell, pos)))
1237 check_at(gtkaspell, pos - 1);
1239 set_textview_buffer_offset(gtktext, origpos);
1242 static void replace_with_supplied_word_cb(GtkWidget *w, GtkAspell *gtkaspell)
1244 unsigned char *newword;
1245 GdkEvent *e= (GdkEvent *) gtk_get_current_event();
1247 newword = gtk_editable_get_chars(GTK_EDITABLE(gtkaspell->replace_entry),
1250 if (strcmp(newword, gtkaspell->theword)) {
1251 replace_real_word(gtkaspell, newword);
1253 if ((e->type == GDK_KEY_PRESS &&
1254 ((GdkEventKey *) e)->state & GDK_CONTROL_MASK)) {
1255 aspell_speller_store_replacement(
1256 gtkaspell->gtkaspeller->checker,
1257 gtkaspell->theword, -1,
1260 gtkaspell->replace_entry = NULL;
1265 if (w && GTK_IS_DIALOG(w)) {
1266 gtk_widget_destroy(w);
1269 set_point_continue(gtkaspell);
1273 static void replace_word_cb(GtkWidget *w, gpointer data)
1275 unsigned char *newword;
1276 GtkAspell *gtkaspell = (GtkAspell *) data;
1277 GdkEvent *e= (GdkEvent *) gtk_get_current_event();
1279 newword = (unsigned char *) gtk_label_get_text(GTK_LABEL(GTK_BIN(w)->child));
1280 newword = g_strdup(newword);
1282 replace_real_word(gtkaspell, newword);
1284 if ((e->type == GDK_KEY_PRESS &&
1285 ((GdkEventKey *) e)->state & GDK_CONTROL_MASK) ||
1286 (e->type == GDK_BUTTON_RELEASE &&
1287 ((GdkEventButton *) e)->state & GDK_CONTROL_MASK)) {
1288 aspell_speller_store_replacement(
1289 gtkaspell->gtkaspeller->checker,
1290 gtkaspell->theword, -1,
1294 gtk_menu_shell_deactivate(GTK_MENU_SHELL(w->parent));
1296 set_point_continue(gtkaspell);
1300 static void replace_real_word(GtkAspell *gtkaspell, gchar *newword)
1302 int oldlen, newlen, wordlen;
1305 GtkTextView *gtktext;
1306 GtkTextBuffer *textbuf;
1307 GtkTextIter startiter, enditer;
1309 if (!newword) return;
1311 gtktext = gtkaspell->gtktext;
1312 textbuf = gtk_text_view_get_buffer(gtktext);
1314 origpos = gtkaspell->orig_pos;
1316 oldlen = gtkaspell->end_pos - gtkaspell->start_pos;
1317 wordlen = strlen(gtkaspell->theword);
1319 newlen = strlen(newword); /* FIXME: multybyte characters? */
1321 g_signal_handlers_block_by_func(G_OBJECT(gtktext),
1322 G_CALLBACK(entry_insert_cb),
1324 g_signal_handlers_block_by_func(G_OBJECT(gtktext),
1325 G_CALLBACK(entry_delete_cb),
1328 gtk_text_buffer_get_iter_at_offset(textbuf, &startiter,
1329 gtkaspell->start_pos);
1330 gtk_text_buffer_get_iter_at_offset(textbuf, &enditer,
1331 gtkaspell->end_pos);
1332 g_signal_emit_by_name(G_OBJECT(textbuf), "delete-range",
1333 &startiter, &enditer, gtkaspell);
1334 g_signal_emit_by_name(G_OBJECT(textbuf), "insert-text",
1335 &startiter, newword, newlen, gtkaspell);
1337 g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
1338 G_CALLBACK(entry_insert_cb),
1340 g_signal_handlers_unblock_by_func(G_OBJECT(gtktext),
1341 G_CALLBACK(entry_delete_cb),
1344 /* Put the point and the position where we clicked with the mouse
1345 * It seems to be a hack, as I must thaw,freeze,thaw the widget
1346 * to let it update correctly the word insertion and then the
1347 * point & position position. If not, SEGV after the first replacement
1348 * If the new word ends before point, put the point at its end.
1351 if (origpos - gtkaspell->start_pos < oldlen &&
1352 origpos - gtkaspell->start_pos >= 0) {
1353 /* Original point was in the word.
1354 * Let it there unless point is going to be outside of the word
1356 if (origpos - gtkaspell->start_pos >= newlen) {
1357 pos = gtkaspell->start_pos + newlen;
1360 else if (origpos >= gtkaspell->end_pos) {
1361 /* move the position according to the change of length */
1362 pos = origpos + newlen - oldlen;
1365 gtkaspell->end_pos = gtkaspell->start_pos + strlen(newword); /* FIXME: multibyte characters? */
1367 if (get_textview_buffer_charcount(gtktext) < pos)
1368 pos = get_textview_buffer_charcount(gtktext);
1369 gtkaspell->orig_pos = pos;
1371 set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
1374 /* Accept this word for this session */
1375 static void add_word_to_session_cb(GtkWidget *w, gpointer data)
1378 GtkTextView *gtktext;
1379 GtkAspell *gtkaspell = (GtkAspell *) data;
1380 gtktext = gtkaspell->gtktext;
1382 pos = get_textview_buffer_offset(gtktext);
1384 aspell_speller_add_to_session(gtkaspell->gtkaspeller->checker,
1386 strlen(gtkaspell->theword));
1388 check_at(gtkaspell, gtkaspell->start_pos);
1390 gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1392 set_point_continue(gtkaspell);
1395 /* add_word_to_personal_cb() - add word to personal dict. */
1396 static void add_word_to_personal_cb(GtkWidget *w, gpointer data)
1398 GtkAspell *gtkaspell = (GtkAspell *) data;
1400 aspell_speller_add_to_personal(gtkaspell->gtkaspeller->checker,
1402 strlen(gtkaspell->theword));
1404 check_at(gtkaspell, gtkaspell->start_pos);
1406 gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1407 set_point_continue(gtkaspell);
1410 static void check_with_alternate_cb(GtkWidget *w, gpointer data)
1412 GtkAspell *gtkaspell = (GtkAspell *) data;
1415 gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1417 use_alternate_dict(gtkaspell);
1418 misspelled = check_at(gtkaspell, gtkaspell->start_pos);
1420 if (!gtkaspell->continue_check) {
1422 gtkaspell->misspelled = misspelled;
1424 if (gtkaspell->misspelled) {
1426 misspelled_suggest(gtkaspell, gtkaspell->theword);
1428 set_textview_buffer_offset(gtkaspell->gtktext,
1429 gtkaspell->end_pos);
1431 menu = make_sug_menu(gtkaspell);
1432 gtk_menu_popup(menu, NULL, NULL,
1433 set_menu_pos, gtkaspell, 0,
1435 g_signal_connect(G_OBJECT(menu), "deactivate",
1436 G_CALLBACK(destroy_menu),
1441 gtkaspell->orig_pos = gtkaspell->start_pos;
1443 set_point_continue(gtkaspell);
1446 static gboolean replace_key_pressed(GtkWidget *widget,
1448 GtkAspell *gtkaspell)
1450 if (event && event->keyval == GDK_Escape) {
1451 gtk_widget_destroy(widget);
1453 } else if (event && event->keyval == GDK_Return) {
1454 replace_with_supplied_word_cb(widget, gtkaspell);
1460 static void replace_with_create_dialog_cb(GtkWidget *w, gpointer data)
1462 static PangoFontDescription *font_desc;
1469 GtkWidget *ok_button;
1470 GtkWidget *cancel_button;
1471 GtkWidget *confirm_area;
1475 GtkAspell *gtkaspell = (GtkAspell *) data;
1477 gdk_window_get_origin((GTK_WIDGET(w)->parent)->window, &xx, &yy);
1479 gtk_menu_shell_deactivate(GTK_MENU_SHELL(GTK_WIDGET(w)->parent));
1481 dialog = gtk_dialog_new();
1483 gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
1484 gtk_window_set_title(GTK_WINDOW(dialog),_("Replace unknown word"));
1485 gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
1486 gtk_widget_set_uposition(dialog, xx, yy);
1488 g_signal_connect_swapped(G_OBJECT(dialog), "destroy",
1489 G_CALLBACK(gtk_widget_destroy),
1492 gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 14);
1493 hbox = gtk_hbox_new (FALSE, 12);
1494 gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
1495 gtk_widget_show (hbox);
1496 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
1499 thelabel = g_strdup_printf(_("<span weight=\"bold\" "
1500 "size=\"larger\">Replace \"%s\" with: </span>"),
1501 gtkaspell->theword);
1502 /* for title label */
1503 w_hbox = gtk_hbox_new(FALSE, 0);
1505 icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_QUESTION,
1506 GTK_ICON_SIZE_DIALOG);
1507 gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0.0);
1508 gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
1510 vbox = gtk_vbox_new (FALSE, 12);
1511 gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
1512 gtk_widget_show (vbox);
1514 label = gtk_label_new(thelabel);
1515 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1516 gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
1517 gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
1518 gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
1519 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
1523 size = pango_font_description_get_size
1524 (label->style->font_desc);
1525 font_desc = pango_font_description_new();
1526 pango_font_description_set_weight
1527 (font_desc, PANGO_WEIGHT_BOLD);
1528 pango_font_description_set_size
1529 (font_desc, size * PANGO_SCALE_LARGE);
1532 gtk_widget_modify_font(label, font_desc);
1535 entry = gtk_entry_new();
1536 gtkaspell->replace_entry = entry;
1537 gtk_entry_set_text(GTK_ENTRY(entry), gtkaspell->theword);
1538 gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
1539 g_signal_connect(G_OBJECT(dialog),
1541 G_CALLBACK(replace_key_pressed), gtkaspell);
1542 gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
1544 label = gtk_label_new(_("Holding down Control key while pressing "
1545 "Enter\nwill learn from mistake.\n"));
1546 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1547 gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
1548 gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
1549 gtk_widget_show(label);
1551 hbox = gtk_hbox_new(TRUE, 0);
1553 gtkut_stock_button_set_create(&confirm_area,
1554 &ok_button, GTK_STOCK_OK,
1555 &cancel_button, GTK_STOCK_CANCEL,
1558 gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->action_area),
1559 confirm_area, FALSE, FALSE, 0);
1560 gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5);
1562 g_signal_connect(G_OBJECT(ok_button), "clicked",
1563 G_CALLBACK(replace_with_supplied_word_cb),
1565 g_signal_connect_swapped(G_OBJECT(ok_button), "clicked",
1566 G_CALLBACK(gtk_widget_destroy),
1569 g_signal_connect_swapped(G_OBJECT(cancel_button), "clicked",
1570 G_CALLBACK(gtk_widget_destroy),
1573 gtk_widget_grab_focus(entry);
1575 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
1577 gtk_widget_show_all(dialog);
1580 void gtkaspell_uncheck_all(GtkAspell * gtkaspell)
1582 GtkTextView *gtktext;
1583 GtkTextBuffer *buffer;
1584 GtkTextIter startiter, enditer;
1586 gtktext = gtkaspell->gtktext;
1588 buffer = gtk_text_view_get_buffer(gtktext);
1589 gtk_text_buffer_get_iter_at_offset(buffer, &startiter, 0);
1590 gtk_text_buffer_get_iter_at_offset(buffer, &enditer,
1591 get_textview_buffer_charcount(gtktext)-1);
1592 gtk_text_buffer_remove_tag_by_name(buffer, "misspelled",
1593 &startiter, &enditer);
1596 static void toggle_check_while_typing_cb(GtkWidget *w, gpointer data)
1598 GtkAspell *gtkaspell = (GtkAspell *) data;
1600 gtkaspell->check_while_typing = gtkaspell->check_while_typing == FALSE;
1602 if (!gtkaspell->check_while_typing)
1603 gtkaspell_uncheck_all(gtkaspell);
1605 if (gtkaspell->config_menu)
1606 populate_submenu(gtkaspell, gtkaspell->config_menu);
1609 static GSList *create_empty_dictionary_list(void)
1611 GSList *list = NULL;
1614 dict = g_new0(Dictionary, 1);
1615 dict->fullname = g_strdup(_("None"));
1616 dict->dictname = dict->fullname;
1617 dict->encoding = NULL;
1619 return g_slist_append(list, dict);
1622 /* gtkaspell_get_dictionary_list() - returns list of dictionary names */
1623 GSList *gtkaspell_get_dictionary_list(const gchar *aspell_path, gint refresh)
1627 AspellConfig *config;
1628 AspellDictInfoList *dlist;
1629 AspellDictInfoEnumeration *dels;
1630 const AspellDictInfo *entry;
1632 if (!gtkaspellcheckers)
1633 gtkaspell_checkers_init();
1635 if (gtkaspellcheckers->dictionary_list && !refresh)
1636 return gtkaspellcheckers->dictionary_list;
1638 gtkaspell_free_dictionary_list(
1639 gtkaspellcheckers->dictionary_list);
1642 config = new_aspell_config();
1644 aspell_config_replace(config, "dict-dir", aspell_path);
1645 if (aspell_config_error_number(config) != 0) {
1646 gtkaspellcheckers->error_message = g_strdup(
1647 aspell_config_error_message(config));
1648 gtkaspellcheckers->dictionary_list =
1649 create_empty_dictionary_list();
1651 return gtkaspellcheckers->dictionary_list;
1654 dlist = get_aspell_dict_info_list(config);
1655 delete_aspell_config(config);
1657 debug_print("Aspell: checking for dictionaries in %s\n", aspell_path);
1658 dels = aspell_dict_info_list_elements(dlist);
1659 while ( (entry = aspell_dict_info_enumeration_next(dels)) != 0)
1661 dict = g_new0(Dictionary, 1);
1662 dict->fullname = g_strdup_printf("%s%s", aspell_path,
1664 dict->dictname = dict->fullname + strlen(aspell_path);
1665 dict->encoding = g_strdup(entry->code);
1667 if (g_slist_find_custom(list, dict,
1668 (GCompareFunc) compare_dict) != NULL) {
1669 dictionary_delete(dict);
1673 debug_print("Aspell: found dictionary %s %s %s\n", dict->fullname,
1674 dict->dictname, dict->encoding);
1675 list = g_slist_insert_sorted(list, dict,
1676 (GCompareFunc) compare_dict);
1679 delete_aspell_dict_info_enumeration(dels);
1683 debug_print("Aspell: error when searching for dictionaries: "
1684 "No dictionary found.\n");
1685 list = create_empty_dictionary_list();
1688 gtkaspellcheckers->dictionary_list = list;
1693 void gtkaspell_free_dictionary_list(GSList *list)
1697 for (walk = list; walk != NULL; walk = g_slist_next(walk))
1699 dict = (Dictionary *) walk->data;
1700 dictionary_delete(dict);
1705 GtkWidget *gtkaspell_dictionary_option_menu_new(const gchar *aspell_path)
1707 GSList *dict_list, *tmp;
1712 dict_list = gtkaspell_get_dictionary_list(aspell_path, TRUE);
1713 g_return_val_if_fail(dict_list, NULL);
1715 menu = gtk_menu_new();
1717 for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
1718 dict = (Dictionary *) tmp->data;
1719 item = gtk_menu_item_new_with_label(dict->dictname);
1720 g_object_set_data(G_OBJECT(item), "dict_name",
1723 gtk_menu_append(GTK_MENU(menu), item);
1724 gtk_widget_show(item);
1727 gtk_widget_show(menu);
1732 gchar *gtkaspell_get_dictionary_menu_active_item(GtkWidget *menu)
1734 GtkWidget *menuitem;
1735 gchar *dict_fullname;
1738 g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
1740 menuitem = gtk_menu_get_active(GTK_MENU(menu));
1741 dict_fullname = (gchar *) g_object_get_data(G_OBJECT(menuitem),
1743 g_return_val_if_fail(dict_fullname, NULL);
1745 label = g_strdup(dict_fullname);
1751 gint gtkaspell_set_dictionary_menu_active_item(GtkWidget *menu,
1752 const gchar *dictionary)
1757 g_return_val_if_fail(menu != NULL, 0);
1758 g_return_val_if_fail(dictionary != NULL, 0);
1759 g_return_val_if_fail(GTK_IS_OPTION_MENU(menu), 0);
1762 for (cur = GTK_MENU_SHELL(gtk_option_menu_get_menu(
1763 GTK_OPTION_MENU(menu)))->children;
1764 cur != NULL; cur = cur->next) {
1765 GtkWidget *menuitem;
1768 menuitem = GTK_WIDGET(cur->data);
1769 dict_name = g_object_get_data(G_OBJECT(menuitem),
1771 if ((dict_name != NULL) && !strcmp2(dict_name, dictionary)) {
1772 gtk_option_menu_set_history(GTK_OPTION_MENU(menu), n);
1782 GtkWidget *gtkaspell_sugmode_option_menu_new(gint sugmode)
1787 menu = gtk_menu_new();
1788 gtk_widget_show(menu);
1790 item = gtk_menu_item_new_with_label(_("Fast Mode"));
1791 gtk_widget_show(item);
1792 gtk_menu_append(GTK_MENU(menu), item);
1793 g_object_set_data(G_OBJECT(item), "sugmode",
1794 GINT_TO_POINTER(ASPELL_FASTMODE));
1796 item = gtk_menu_item_new_with_label(_("Normal Mode"));
1797 gtk_widget_show(item);
1798 gtk_menu_append(GTK_MENU(menu), item);
1799 g_object_set_data(G_OBJECT(item), "sugmode",
1800 GINT_TO_POINTER(ASPELL_NORMALMODE));
1802 item = gtk_menu_item_new_with_label(_("Bad Spellers Mode"));
1803 gtk_widget_show(item);
1804 gtk_menu_append(GTK_MENU(menu), item);
1805 g_object_set_data(G_OBJECT(item), "sugmode",
1806 GINT_TO_POINTER(ASPELL_BADSPELLERMODE));
1811 void gtkaspell_sugmode_option_menu_set(GtkOptionMenu *optmenu, gint sugmode)
1813 g_return_if_fail(GTK_IS_OPTION_MENU(optmenu));
1815 g_return_if_fail(sugmode == ASPELL_FASTMODE ||
1816 sugmode == ASPELL_NORMALMODE ||
1817 sugmode == ASPELL_BADSPELLERMODE);
1819 gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), sugmode - 1);
1822 gint gtkaspell_get_sugmode_from_option_menu(GtkOptionMenu *optmenu)
1827 g_return_val_if_fail(GTK_IS_OPTION_MENU(optmenu), -1);
1829 item = gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(optmenu)));
1831 sugmode = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item),
1837 static void use_alternate_dict(GtkAspell *gtkaspell)
1841 tmp = gtkaspell->gtkaspeller;
1842 gtkaspell->gtkaspeller = gtkaspell->alternate_speller;
1843 gtkaspell->alternate_speller = tmp;
1845 if (gtkaspell->config_menu)
1846 populate_submenu(gtkaspell, gtkaspell->config_menu);
1849 static void destroy_menu(GtkWidget *widget,
1850 gpointer user_data) {
1852 GtkAspell *gtkaspell = (GtkAspell *)user_data;
1854 if (gtkaspell->accel_group) {
1855 gtk_window_remove_accel_group(GTK_WINDOW(gtkaspell->parent_window),
1856 gtkaspell->accel_group);
1857 gtkaspell->accel_group = NULL;
1861 static void popup_menu(GtkAspell *gtkaspell, GdkEventButton *eb)
1863 GtkTextView * gtktext;
1864 GtkMenu *menu = NULL;
1866 gtktext = gtkaspell->gtktext;
1868 gtkaspell->orig_pos = get_textview_buffer_offset(gtktext);
1870 if (!(eb->state & GDK_SHIFT_MASK)) {
1871 if (check_at(gtkaspell, gtkaspell->orig_pos)) {
1873 set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
1875 if (misspelled_suggest(gtkaspell, gtkaspell->theword)) {
1876 menu = make_sug_menu(gtkaspell);
1877 gtk_menu_popup(menu,
1878 NULL, NULL, NULL, NULL,
1879 eb->button, eb->time);
1881 g_signal_connect(G_OBJECT(menu), "deactivate",
1882 G_CALLBACK(destroy_menu),
1887 set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
1889 menu = make_config_menu(gtkaspell);
1890 gtk_menu_popup(menu, NULL, NULL, NULL, NULL,
1891 eb->button, eb->time);
1893 g_signal_connect(G_OBJECT(menu), "deactivate",
1894 G_CALLBACK(destroy_menu),
1898 static gboolean aspell_key_pressed(GtkWidget *widget,
1900 GtkAspell *gtkaspell)
1902 if (event && (isascii(event->keyval) || event->keyval == GDK_Return)) {
1903 gtk_accel_groups_activate(
1904 G_OBJECT(gtkaspell->parent_window),
1905 event->keyval, event->state);
1906 } else if (event && event->keyval == GDK_Escape) {
1907 destroy_menu(NULL, gtkaspell);
1912 /* make_sug_menu() - Add menus to accept this word for this session
1913 * and to add it to personal dictionary
1915 static GtkMenu *make_sug_menu(GtkAspell *gtkaspell)
1917 GtkWidget *menu, *item;
1918 unsigned char *caption;
1919 GtkTextView *gtktext;
1920 GtkAccelGroup *accel;
1921 GList *l = gtkaspell->suggestions_list;
1924 gtktext = gtkaspell->gtktext;
1926 accel = gtk_accel_group_new();
1927 menu = gtk_menu_new();
1929 if (gtkaspell->sug_menu)
1930 gtk_widget_destroy(gtkaspell->sug_menu);
1932 if (gtkaspell->accel_group) {
1933 gtk_window_remove_accel_group(GTK_WINDOW(gtkaspell->parent_window),
1934 gtkaspell->accel_group);
1935 gtkaspell->accel_group = NULL;
1938 gtkaspell->sug_menu = menu;
1940 g_signal_connect(G_OBJECT(menu), "cancel",
1941 G_CALLBACK(cancel_menu_cb), gtkaspell);
1943 utf8buf = conv_codeset_strdup((unsigned char*)l->data,
1944 conv_get_locale_charset_str(),
1946 caption = g_strdup_printf(_("\"%s\" unknown in %s"),
1948 gtkaspell->gtkaspeller->dictionary->dictname);
1949 item = gtk_menu_item_new_with_label(caption);
1951 gtk_widget_show(item);
1952 gtk_menu_append(GTK_MENU(menu), item);
1953 gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
1956 item = gtk_menu_item_new();
1957 gtk_widget_show(item);
1958 gtk_menu_append(GTK_MENU(menu), item);
1960 item = gtk_menu_item_new_with_label(_("Accept in this session"));
1961 gtk_widget_show(item);
1962 gtk_menu_append(GTK_MENU(menu), item);
1963 g_signal_connect(G_OBJECT(item), "activate",
1964 G_CALLBACK(add_word_to_session_cb),
1966 gtk_widget_add_accelerator(item, "activate", accel, GDK_space,
1968 GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1970 item = gtk_menu_item_new_with_label(_("Add to personal dictionary"));
1971 gtk_widget_show(item);
1972 gtk_menu_append(GTK_MENU(menu), item);
1973 g_signal_connect(G_OBJECT(item), "activate",
1974 G_CALLBACK(add_word_to_personal_cb),
1976 gtk_widget_add_accelerator(item, "activate", accel, GDK_Return,
1978 GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1980 item = gtk_menu_item_new_with_label(_("Replace with..."));
1981 gtk_widget_show(item);
1982 gtk_menu_append(GTK_MENU(menu), item);
1983 g_signal_connect(G_OBJECT(item), "activate",
1984 G_CALLBACK(replace_with_create_dialog_cb),
1986 gtk_widget_add_accelerator(item, "activate", accel, GDK_R, 0,
1987 GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
1988 gtk_widget_add_accelerator(item, "activate", accel, GDK_R,
1992 if (gtkaspell->use_alternate && gtkaspell->alternate_speller) {
1993 caption = g_strdup_printf(_("Check with %s"),
1994 gtkaspell->alternate_speller->dictionary->dictname);
1995 item = gtk_menu_item_new_with_label(caption);
1997 gtk_widget_show(item);
1998 gtk_menu_append(GTK_MENU(menu), item);
1999 g_signal_connect(G_OBJECT(item), "activate",
2000 G_CALLBACK(check_with_alternate_cb),
2002 gtk_widget_add_accelerator(item, "activate", accel, GDK_X, 0,
2003 GTK_ACCEL_LOCKED | GTK_ACCEL_VISIBLE);
2004 gtk_widget_add_accelerator(item, "activate", accel, GDK_X,
2009 item = gtk_menu_item_new();
2010 gtk_widget_show(item);
2011 gtk_menu_append(GTK_MENU(menu), item);
2015 item = gtk_menu_item_new_with_label(_("(no suggestions)"));
2016 gtk_widget_show(item);
2017 gtk_menu_append(GTK_MENU(menu), item);
2019 GtkWidget *curmenu = menu;
2023 if (count == MENUCOUNT) {
2026 item = gtk_menu_item_new_with_label(_("More..."));
2027 gtk_widget_show(item);
2028 gtk_menu_append(GTK_MENU(curmenu), item);
2030 curmenu = gtk_menu_new();
2031 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
2035 utf8buf = conv_codeset_strdup((unsigned char*)l->data,
2036 conv_get_locale_charset_str(),
2038 item = gtk_menu_item_new_with_label(utf8buf);
2040 gtk_widget_show(item);
2041 gtk_menu_append(GTK_MENU(curmenu), item);
2042 g_signal_connect(G_OBJECT(item), "activate",
2043 G_CALLBACK(replace_word_cb),
2046 if (curmenu == menu && count < MENUCOUNT) {
2047 gtk_widget_add_accelerator(item, "activate",
2052 gtk_widget_add_accelerator(item, "activate",
2061 } while ((l = l->next) != NULL);
2064 gtk_window_add_accel_group
2065 (GTK_WINDOW(gtkaspell->parent_window),
2067 gtkaspell->accel_group = accel;
2069 g_signal_connect(G_OBJECT(menu),
2071 G_CALLBACK(aspell_key_pressed), gtkaspell);
2073 return GTK_MENU(menu);
2076 static void populate_submenu(GtkAspell *gtkaspell, GtkWidget *menu)
2078 GtkWidget *item, *submenu;
2080 GtkAspeller *gtkaspeller = gtkaspell->gtkaspeller;
2082 if (GTK_MENU_SHELL(menu)->children) {
2083 GList *amenu, *alist;
2084 for (amenu = (GTK_MENU_SHELL(menu)->children); amenu; ) {
2085 alist = amenu->next;
2086 gtk_widget_destroy(GTK_WIDGET(amenu->data));
2091 dictname = g_strdup_printf(_("Dictionary: %s"),
2092 gtkaspeller->dictionary->dictname);
2093 item = gtk_menu_item_new_with_label(dictname);
2094 gtk_misc_set_alignment(GTK_MISC(GTK_BIN(item)->child), 0.5, 0.5);
2096 gtk_widget_show(item);
2097 gtk_menu_append(GTK_MENU(menu), item);
2099 item = gtk_menu_item_new();
2100 gtk_widget_show(item);
2101 gtk_menu_append(GTK_MENU(menu), item);
2103 if (gtkaspell->use_alternate && gtkaspell->alternate_speller) {
2104 dictname = g_strdup_printf(_("Use alternate (%s)"),
2105 gtkaspell->alternate_speller->dictionary->dictname);
2106 item = gtk_menu_item_new_with_label(dictname);
2108 g_signal_connect(G_OBJECT(item), "activate",
2109 G_CALLBACK(switch_to_alternate_cb),
2111 gtk_widget_show(item);
2112 gtk_menu_append(GTK_MENU(menu), item);
2115 item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
2116 if (gtkaspell->gtkaspeller->sug_mode == ASPELL_FASTMODE) {
2117 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
2118 gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
2120 g_signal_connect(G_OBJECT(item), "activate",
2121 G_CALLBACK(set_sug_mode_cb),
2123 gtk_widget_show(item);
2124 gtk_menu_append(GTK_MENU(menu), item);
2126 item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
2127 if (gtkaspell->gtkaspeller->sug_mode == ASPELL_NORMALMODE) {
2128 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
2129 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
2131 g_signal_connect(G_OBJECT(item), "activate",
2132 G_CALLBACK(set_sug_mode_cb),
2134 gtk_widget_show(item);
2135 gtk_menu_append(GTK_MENU(menu),item);
2137 item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
2138 if (gtkaspell->gtkaspeller->sug_mode == ASPELL_BADSPELLERMODE) {
2139 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
2140 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
2142 g_signal_connect(G_OBJECT(item), "activate",
2143 G_CALLBACK(set_sug_mode_cb),
2145 gtk_widget_show(item);
2146 gtk_menu_append(GTK_MENU(menu), item);
2148 item = gtk_menu_item_new();
2149 gtk_widget_show(item);
2150 gtk_menu_append(GTK_MENU(menu), item);
2152 item = gtk_check_menu_item_new_with_label(_("Check while typing"));
2153 if (gtkaspell->check_while_typing)
2154 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
2156 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
2157 g_signal_connect(G_OBJECT(item), "activate",
2158 G_CALLBACK(toggle_check_while_typing_cb),
2160 gtk_widget_show(item);
2161 gtk_menu_append(GTK_MENU(menu), item);
2163 item = gtk_menu_item_new();
2164 gtk_widget_show(item);
2165 gtk_menu_append(GTK_MENU(menu), item);
2167 submenu = gtk_menu_new();
2168 item = gtk_menu_item_new_with_label(_("Change dictionary"));
2169 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
2170 gtk_widget_show(item);
2171 gtk_menu_append(GTK_MENU(menu), item);
2174 if (gtkaspellcheckers->dictionary_list == NULL)
2175 gtkaspell_get_dictionary_list(gtkaspell->dictionary_path, FALSE);
2177 GtkWidget * curmenu = submenu;
2181 tmp = gtkaspellcheckers->dictionary_list;
2183 for (tmp = gtkaspellcheckers->dictionary_list; tmp != NULL;
2184 tmp = g_slist_next(tmp)) {
2185 if (count == MENUCOUNT) {
2188 newmenu = gtk_menu_new();
2189 item = gtk_menu_item_new_with_label(_("More..."));
2190 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),
2193 gtk_menu_append(GTK_MENU(curmenu), item);
2194 gtk_widget_show(item);
2198 dict = (Dictionary *) tmp->data;
2199 item = gtk_check_menu_item_new_with_label(dict->dictname);
2200 g_object_set_data(G_OBJECT(item), "dict_name",
2202 if (strcmp2(dict->fullname,
2203 gtkaspell->gtkaspeller->dictionary->fullname))
2204 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
2206 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
2207 gtk_widget_set_sensitive(GTK_WIDGET(item),
2210 g_signal_connect(G_OBJECT(item), "activate",
2211 G_CALLBACK(change_dict_cb),
2213 gtk_widget_show(item);
2214 gtk_menu_append(GTK_MENU(curmenu), item);
2221 static GtkMenu *make_config_menu(GtkAspell *gtkaspell)
2223 if (!gtkaspell->popup_config_menu)
2224 gtkaspell->popup_config_menu = gtk_menu_new();
2226 debug_print("Aspell: creating/using popup_config_menu %0x\n",
2227 (guint) gtkaspell->popup_config_menu);
2228 populate_submenu(gtkaspell, gtkaspell->popup_config_menu);
2230 return GTK_MENU(gtkaspell->popup_config_menu);
2233 void gtkaspell_populate_submenu(GtkAspell *gtkaspell, GtkWidget *menuitem)
2237 menu = GTK_WIDGET(GTK_MENU_ITEM(menuitem)->submenu);
2239 debug_print("Aspell: using config menu %0x\n",
2240 (guint) gtkaspell->popup_config_menu);
2241 populate_submenu(gtkaspell, menu);
2243 gtkaspell->config_menu = menu;
2247 static void set_menu_pos(GtkMenu *menu, gint *x, gint *y,
2248 gboolean *push_in, gpointer data)
2250 GtkAspell *gtkaspell = (GtkAspell *) data;
2251 gint xx = 0, yy = 0;
2254 GtkTextView *text = GTK_TEXT_VIEW(gtkaspell->gtktext);
2255 GtkTextBuffer *textbuf;
2260 textbuf = gtk_text_view_get_buffer(gtkaspell->gtktext);
2261 gtk_text_buffer_get_iter_at_mark(textbuf, &iter,
2262 gtk_text_buffer_get_insert(textbuf));
2263 gtk_text_view_get_iter_location(gtkaspell->gtktext, &iter, &rect);
2264 gtk_text_view_buffer_to_window_coords(text, GTK_TEXT_WINDOW_TEXT,
2268 gdk_window_get_origin(GTK_WIDGET(gtkaspell->gtktext)->window, &xx, &yy);
2270 sx = gdk_screen_width();
2271 sy = gdk_screen_height();
2273 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &r);
2279 gdk_char_width(gtk_style_get_font(GTK_WIDGET(text)->style), ' ');
2281 *y = rect.y + rect.height + yy;
2287 gdk_string_height(gtk_style_get_font(
2288 GTK_WIDGET(text)->style),
2289 gtkaspell->theword);
2292 /* Menu call backs */
2294 static gboolean cancel_menu_cb(GtkMenuShell *w, gpointer data)
2296 GtkAspell *gtkaspell = (GtkAspell *) data;
2298 gtkaspell->continue_check = NULL;
2299 set_point_continue(gtkaspell);
2304 gboolean gtkaspell_change_dict(GtkAspell *gtkaspell, const gchar *dictionary)
2307 GtkAspeller *gtkaspeller;
2310 g_return_val_if_fail(gtkaspell, FALSE);
2311 g_return_val_if_fail(dictionary, FALSE);
2313 sug_mode = gtkaspell->default_sug_mode;
2315 dict = g_new0(Dictionary, 1);
2316 dict->fullname = g_strdup(dictionary);
2317 dict->encoding = g_strdup(gtkaspell->gtkaspeller->dictionary->encoding);
2319 if (gtkaspell->use_alternate && gtkaspell->alternate_speller &&
2320 dict == gtkaspell->alternate_speller->dictionary) {
2321 use_alternate_dict(gtkaspell);
2322 dictionary_delete(dict);
2323 gtkaspell->alternate_speller->dictionary = NULL;
2327 gtkaspeller = gtkaspeller_new(dict);
2331 message = g_strdup_printf(_("The spell checker could not change dictionary.\n%s"),
2332 gtkaspellcheckers->error_message);
2334 alertpanel_warning(message);
2337 if (gtkaspell->use_alternate) {
2338 if (gtkaspell->alternate_speller)
2339 gtkaspeller_delete(gtkaspell->alternate_speller);
2340 gtkaspell->alternate_speller = gtkaspell->gtkaspeller;
2342 gtkaspeller_delete(gtkaspell->gtkaspeller);
2344 gtkaspell->gtkaspeller = gtkaspeller;
2345 gtkaspell_set_sug_mode(gtkaspell, sug_mode);
2348 dictionary_delete(dict);
2350 if (gtkaspell->config_menu)
2351 populate_submenu(gtkaspell, gtkaspell->config_menu);
2356 /* change_dict_cb() - Menu callback : change dict */
2357 static void change_dict_cb(GtkWidget *w, GtkAspell *gtkaspell)
2361 fullname = (gchar *) g_object_get_data(G_OBJECT(w), "dict_name");
2363 if (!strcmp2(fullname, _("None")))
2366 gtkaspell_change_dict(gtkaspell, fullname);
2369 static void switch_to_alternate_cb(GtkWidget *w,
2372 GtkAspell *gtkaspell = (GtkAspell *) data;
2373 use_alternate_dict(gtkaspell);
2376 /* Misc. helper functions */
2378 static void set_point_continue(GtkAspell *gtkaspell)
2380 GtkTextView *gtktext;
2382 gtktext = gtkaspell->gtktext;
2384 set_textview_buffer_offset(gtktext, gtkaspell->orig_pos);
2386 if (gtkaspell->continue_check)
2387 gtkaspell->continue_check((gpointer *) gtkaspell);
2390 static void allocate_color(GtkAspell *gtkaspell, gint rgbvalue)
2392 GtkTextBuffer *buffer = gtk_text_view_get_buffer(gtkaspell->gtktext);
2393 GdkColor *color = &(gtkaspell->highlight);
2395 /* Shameless copy from Sylpheed's gtkutils.c */
2397 color->red = (int) (((gdouble)((rgbvalue & 0xff0000) >> 16) / 255.0)
2399 color->green = (int) (((gdouble)((rgbvalue & 0x00ff00) >> 8) / 255.0)
2401 color->blue = (int) (((gdouble) (rgbvalue & 0x0000ff) / 255.0)
2404 gtk_text_buffer_create_tag(buffer, "misspelled",
2405 "foreground-gdk", color, NULL);
2408 static void change_color(GtkAspell * gtkaspell,
2409 gint start, gint end,
2413 GtkTextView *gtktext;
2414 GtkTextBuffer *buffer;
2415 GtkTextIter startiter, enditer;
2420 gtktext = gtkaspell->gtktext;
2422 buffer = gtk_text_view_get_buffer(gtktext);
2423 gtk_text_buffer_get_iter_at_offset(buffer, &startiter, start);
2424 gtk_text_buffer_get_iter_at_offset(buffer, &enditer, end);
2426 gtk_text_buffer_apply_tag_by_name(buffer, "misspelled",
2427 &startiter, &enditer);
2429 gtk_text_buffer_remove_tag_by_name(buffer, "misspelled",
2430 &startiter, &enditer);
2433 /* convert_to_aspell_encoding () - converts ISO-8859-* strings to iso8859-*
2434 * as needed by aspell. Returns an allocated string.
2437 static guchar *convert_to_aspell_encoding (const guchar *encoding)
2439 guchar * aspell_encoding;
2441 if (strstr2(encoding, "ISO-8859-")) {
2442 aspell_encoding = g_strdup_printf("iso8859%s", encoding+8);
2445 if (!strcmp2(encoding, "US-ASCII"))
2446 aspell_encoding = g_strdup("iso8859-1");
2448 aspell_encoding = g_strdup(encoding);
2451 return aspell_encoding;
2454 /* compare_dict () - compare 2 dict names */
2455 static gint compare_dict(Dictionary *a, Dictionary *b)
2457 guint aparts = 0, bparts = 0;
2460 for (i=0; i < strlen(a->dictname); i++)
2461 if (a->dictname[i] == '-')
2463 for (i=0; i < strlen(b->dictname); i++)
2464 if (b->dictname[i] == '-')
2467 if (aparts != bparts)
2468 return (aparts < bparts) ? -1 : +1;
2471 compare = strcmp2(a->dictname, b->dictname);
2473 compare = strcmp2(a->fullname, b->fullname);
2478 static void dictionary_delete(Dictionary *dict)
2480 g_free(dict->fullname);
2481 g_free(dict->encoding);
2485 static Dictionary *dictionary_dup(const Dictionary *dict)
2489 dict2 = g_new(Dictionary, 1);
2491 dict2->fullname = g_strdup(dict->fullname);
2492 dict2->dictname = dict->dictname - dict->fullname + dict2->fullname;
2493 dict2->encoding = g_strdup(dict->encoding);
2498 static void free_suggestions_list(GtkAspell *gtkaspell)
2502 for (list = gtkaspell->suggestions_list; list != NULL;
2506 g_list_free(gtkaspell->suggestions_list);
2508 gtkaspell->max_sug = -1;
2509 gtkaspell->suggestions_list = NULL;
2512 static void reset_theword_data(GtkAspell *gtkaspell)
2514 gtkaspell->start_pos = 0;
2515 gtkaspell->end_pos = 0;
2516 gtkaspell->theword[0] = 0;
2517 gtkaspell->max_sug = -1;
2519 free_suggestions_list(gtkaspell);
2522 static void free_checkers(gpointer elt, gpointer data)
2524 GtkAspeller *gtkaspeller = elt;
2526 g_return_if_fail(gtkaspeller);
2528 gtkaspeller_real_delete(gtkaspeller);
2531 static gint find_gtkaspeller(gconstpointer aa, gconstpointer bb)
2533 Dictionary *a = ((GtkAspeller *) aa)->dictionary;
2534 Dictionary *b = ((GtkAspeller *) bb)->dictionary;
2536 if (a && b && a->fullname && b->fullname &&
2537 strcmp(a->fullname, b->fullname) == 0 &&
2538 a->encoding && b->encoding)
2539 return strcmp(a->encoding, b->encoding);