1 /* gtkpspell - a spell-checking addon for GtkText
2 * Copyright (c) 2000 Evan Martin.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * Stuphead: (C) 2000,2001 Grigroy Bakunov, Sergey Pinaev
21 * Adapted for Sylpheed (Claws) (c) 2001 by Hiroyuki Yamamoto &
22 * The Sylpheed Claws Team.
23 * Adapted for pspell (c) 2001 Melvin Hadasht
26 #if defined(HAVE_CONFIG_H)
34 #include <sys/types.h>
47 #include <prefs_common.h>
52 #include <gtk/gtkoptionmenu.h>
53 #include <gtk/gtkmenu.h>
54 #include <gtk/gtkmenuitem.h>
60 #include <pspell/pspell.h>
62 /* size of the text buffer used in various word-processing routines. */
65 /* number of suggestions to display on each menu. */
68 /******************************************************************************/
70 /* Function called from menus */
72 static void add_word_to_session (GtkWidget *w, GtkPspell *d);
73 static void add_word_to_personal (GtkWidget *w, GtkPspell *d);
74 static void set_sug_mode (GtkWidget *w, GtkPspell *gtkpspell);
75 static void set_learn_mode (GtkWidget *w, GtkPspell *gtkpspell);
76 static void check_all (GtkWidget *w, GtkPspell *gtkpspell);
77 static void menu_change_dict (GtkWidget *w, GtkPspell *gtkpspell);
78 static void entry_insert_cb (GtkXText *gtktext, gchar *newtext,
79 guint len, guint *ppos,
80 GtkPspell *gtkpspell);
81 static gint compare_dict (Dictionary *a, Dictionary *b);
84 /* gtkspellconfig - only one config per session */
85 GtkPspellConfig * gtkpspellconfig;
87 /* TODO: configurable */
88 static GdkColor highlight = { 0, 255 * 256, 0, 0 };
90 /******************************************************************************/
92 /* gtkspell_init() - run the first pspell_config from which every
93 * new config is cloned
95 GtkPspellConfig * gtkpspell_init()
97 return new_pspell_config();
100 /* gtkspell_finished() - Finish all. No more spelling. Called when the
103 void gtkpspell_finished(GtkPspellConfig *gtkpspellconfig)
105 if (gtkpspellconfig) {
106 delete_pspell_config(gtkpspellconfig);
107 gtkpspellconfig = NULL;
111 /* gtkspell_running - Test if there is a manager running
113 int gtkpspell_running(GtkPspell * gtkpspell)
115 return (gtkpspell->config!=NULL);
118 /* gtkspell_new() - creates a new session if a gtkpspellconfig exists. The
119 * settings are defaults. If no path/dict is set afterwards, the default
122 GtkPspell * gtkpspell_new(GtkPspellConfig *gtkpspellconfig)
124 GtkPspell *gtkpspell;
126 if (gtkpspellconfig == NULL) {
127 gtkpspellconfig = gtkpspell_init();
128 if (gtkpspellconfig == NULL) {
129 debug_print(_("Pspell could not be started."));
130 prefs_common.enable_pspell=FALSE;
135 gtkpspell = g_new(GtkPspell ,1);
136 gtkpspell->config = gtkpspellconfig;
137 gtkpspell->possible_err = new_pspell_manager(gtkpspell->config);
138 gtkpspell->checker = NULL;
140 if (pspell_error_number(gtkpspell->possible_err) != 0) {
141 debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err));
142 delete_pspell_can_have_error( gtkpspell->possible_err );
145 gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err);
148 gtkpspell->dictionary_list = NULL;
149 gtkpspell->path = NULL;
150 gtkpspell->dict = NULL;
151 gtkpspell->mode = PSPELL_FASTMODE;
152 gtkpspell->learn = TRUE;
153 gtkpspell->gtktext = NULL;
157 /* gtkspell_new_with_config() - Creates a new session and set path/dic
159 GtkPspell *gtkpspell_new_with_config(GtkPspellConfig *gtkpspellconfig,
160 guchar *path, guchar *dict,
161 guint mode, guchar *encoding)
163 GtkPspell *gtkpspell;
165 if (gtkpspellconfig == NULL) {
166 gtkpspellconfig=gtkpspell_init();
167 if (gtkpspellconfig == NULL) {
168 debug_print(_("Pspell could not be started."));
169 prefs_common.enable_pspell = FALSE;
174 gtkpspell = g_new( GtkPspell ,1);
175 gtkpspell->path = NULL;
176 gtkpspell->dict = NULL;
177 gtkpspell->dictionary_list = NULL;
178 gtkpspell->gtktext = NULL;
180 gtkpspell->config = pspell_config_clone(gtkpspellconfig);
181 gtkpspell->mode = PSPELL_FASTMODE;
182 gtkpspell->learn = TRUE;
184 if (!set_path_and_dict(gtkpspell, gtkpspell->config, path, dict)) {
185 debug_print(_("Pspell could not be configured."));
186 gtkpspell = gtkpspell_delete(gtkpspell);
191 pspell_config_replace(gtkpspell->config,"encoding",encoding);
193 gtkpspell->possible_err = new_pspell_manager(gtkpspell->config);
194 gtkpspell->checker = NULL;
196 if (pspell_error_number(gtkpspell->possible_err) != 0) {
197 debug_print(_("Pspell error : %s\n"), pspell_error_message(gtkpspell->possible_err));
198 delete_pspell_can_have_error(gtkpspell->possible_err);
199 gtkpspell = gtkpspell_delete(gtkpspell);
202 gtkpspell->checker = to_pspell_manager( gtkpspell->possible_err );
207 /* gtkspell_delete() - Finishes a session
209 GtkPspell *gtkpspell_delete( GtkPspell *gtkpspell )
211 if ( gtkpspell->checker ) {
212 /* First save all word lists */
213 pspell_manager_save_all_word_lists(gtkpspell->checker);
214 delete_pspell_manager(gtkpspell->checker);
215 gtkpspell->checker = NULL;
216 gtkpspell->possible_err = NULL; /* checker is a cast from possible_err */
219 if (gtkpspell->dictionary_list)
220 gtkpspell_free_dictionary_list(gtkpspell->dictionary_list);
222 g_free(gtkpspell->path);
223 g_free(gtkpspell->dict);
224 gtkpspell->path = NULL;
225 gtkpspell->dict = NULL;
231 int set_path_and_dict(GtkPspell *gtkpspell, PspellConfig *config,
232 guchar *path, guchar * dict)
234 guchar *module = NULL;
235 guchar *language = NULL;
236 guchar *spelling = NULL;
237 guchar *jargon = NULL;
243 /* Change nothing if any of path/dict/config is NULL */
244 g_return_val_if_fail(path, 0);
245 g_return_val_if_fail(dict, 0);
246 g_return_val_if_fail(config, 0);
248 /* This is done, so we can free gtkpspell->path, even if it was
249 * given as an argument of the function */
250 temppath = g_strdup(path);
251 g_free(gtkpspell->path);
253 /* pspell dict name format : */
254 /* <lang>[[-<spelling>[-<jargon>]]-<module>.pwli */
257 if (!strrchr(dict,G_DIR_SEPARATOR)) {
258 /* plain dict name */
259 strncpy(buf,dict,BUFSIZE-1);
263 strncpy(buf, strrchr(dict, G_DIR_SEPARATOR)+1, BUFSIZE-1);
266 g_free(gtkpspell->dict);
268 /* Ensure no buffers overflows if the dict is to long */
269 buf[BUFSIZE-1] = 0x00;
272 if ((module = strrchr(buf, '-')) != NULL) {
274 if ((end = strrchr(module, '.')) != NULL)
278 /* In tempdict, we have only the dict name, without path nor
279 extension. Useful in the popup menus */
281 tempdict = g_strdup(buf);
283 /* Probably I am too paranoied... */
284 if (!(language[0] != 0x00 && language[1] != 0x00))
287 spelling = strchr(language, '-');
288 if (spelling != NULL) {
292 if (spelling != module) {
293 if ((end = strchr(spelling, '-')) != NULL) {
296 if (jargon != module)
297 if ((end = strchr(jargon, '-')) != NULL)
311 debug_print(_("Language : %s\nSpelling: %s\nJargon: %s\nModule: %s\n"),
312 language, spelling, jargon, module);
315 pspell_config_replace(config, "language-tag", language);
317 pspell_config_replace(config, "spelling", spelling);
319 pspell_config_replace(config, "jargon", jargon);
321 pspell_config_replace(config, "module", module);
323 pspell_config_replace(config, "word-list-path", temppath);
325 switch(gtkpspell->mode) {
326 case PSPELL_FASTMODE:
327 pspell_config_replace(config, "sug_mode", "fast");
329 case PSPELL_NORMALMODE:
330 pspell_config_replace(config, "sug_mode", "normal");
332 case PSPELL_BADSPELLERMODE:
333 pspell_config_replace(config, "sug_mode", "bad-spellers");
337 gtkpspell->path = g_strdup(temppath);
338 gtkpspell->dict = g_strdup(tempdict);
346 /* gtkpspell_set_path_and_dict() - Set path and dict. The session is
348 * FALSE on error, TRUE on success */
349 int gtkpspell_set_path_and_dict(GtkPspell * gtkpspell, guchar * path,
352 PspellConfig * config2;
354 /* It seems changing an already running config is not the way to go
357 config2 = pspell_config_clone(gtkpspell->config);
359 if (gtkpspell->checker) {
360 pspell_manager_save_all_word_lists(gtkpspell->checker);
361 delete_pspell_manager(gtkpspell->checker);
364 gtkpspell->checker = NULL;
365 gtkpspell->possible_err = NULL;
367 if (set_path_and_dict(gtkpspell,config2,path,dict) == 0) {
368 debug_print(_("Pspell set_path_and_dict error."));
372 gtkpspell->possible_err = new_pspell_manager(config2);
374 delete_pspell_config(config2);
377 if (pspell_error_number(gtkpspell->possible_err) != 0) {
378 debug_print(_("Pspell path & dict. error %s\n"),
379 pspell_error_message(gtkpspell->possible_err));
380 delete_pspell_can_have_error(gtkpspell->possible_err);
381 gtkpspell->possible_err = NULL;
385 gtkpspell->checker=to_pspell_manager(gtkpspell->possible_err);
390 /* gtkpspell_get_dict() - What dict are we using ? language-spelling-jargon-module format */
391 /* Actually, this function is not used and hence not tested. */
392 /* Returns an allocated string */
393 guchar *gtkpspell_get_dict(GtkPspell *gtkpspell)
401 g_return_val_if_fail(gtkpspell->config, NULL);
403 language = g_strdup(pspell_config_retrieve(gtkpspell->config, "language"));
404 spelling = g_strdup(pspell_config_retrieve(gtkpspell->config, "spelling"));
405 jargon = g_strdup(pspell_config_retrieve(gtkpspell->config, "jargon" ));
406 len = strlen(language) + strlen(spelling) + strlen(jargon);
409 dict = g_new(char,len + 4);
410 strcpy(dict, language);
413 strcat(dict, spelling);
427 /* gtkpspell_get_path() - Return the dict path as an allocated string */
428 /* Not used = not tested */
429 guchar *gtkpspell_get_path(GtkPspell *gtkpspell)
434 g_return_val_if_fail(gtkpspell->config, NULL);
436 path = g_strdup(pspell_config_retrieve(gtkpspell->config,"word-list-path"));
441 /* menu_change_dict() - Menu callback : change dict */
442 static void menu_change_dict(GtkWidget *w, GtkPspell *gtkpspell)
447 /* Dict is simply the menu label */
449 gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &thelabel);
450 thedict = g_strdup(thelabel);
452 /* Set path, dict, (and sug_mode ?) */
453 gtkpspell_set_path_and_dict(gtkpspell, gtkpspell->path, thedict);
457 /* set_sug_mode() - Menu callback : Set the suggestion mode */
458 static void set_sug_mode(GtkWidget *w, GtkPspell *gtkpspell)
460 unsigned char *themode;
462 gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar **) &themode);
464 if (!strcmp(themode, _("Fast Mode"))) {
465 gtkpspell_set_sug_mode(gtkpspell, "fast");
466 gtkpspell->mode = PSPELL_FASTMODE;
468 if (!strcmp(themode,_("Normal Mode"))) {
469 gtkpspell_set_sug_mode(gtkpspell, "normal");
470 gtkpspell->mode = PSPELL_NORMALMODE;
472 if (!strcmp( themode,_("Bad Spellers Mode"))) {
473 gtkpspell_set_sug_mode(gtkpspell, "bad-spellers");
474 gtkpspell->mode = PSPELL_BADSPELLERMODE;
478 /* gtkpspell_set_sug_mode() - Set the suggestion mode */
479 /* Actually, the session is resetted and everything is reset. */
480 /* We take the used path/dict pair and create a new config with them */
481 int gtkpspell_set_sug_mode(GtkPspell *gtkpspell, gchar *themode)
483 PspellConfig *config2;
487 pspell_manager_save_all_word_lists(gtkpspell->checker);
488 delete_pspell_manager(gtkpspell->checker);
490 gtkpspell->checker = NULL;
492 config2 = pspell_config_clone(gtkpspell->config);
494 if (!set_path_and_dict(gtkpspell, config2, gtkpspell->path, gtkpspell->dict)) {
495 debug_print(_("Pspell set_sug_mod could not reset path & dict\n"));
499 pspell_config_replace(config2, "sug-mode", themode);
501 gtkpspell->possible_err = new_pspell_manager(config2);
502 delete_pspell_config(config2);
505 if (pspell_error_number(gtkpspell->possible_err) != 0) {
506 debug_print(_("Pspell set sug-mode error %s\n"),
507 pspell_error_message(gtkpspell->possible_err));
508 delete_pspell_can_have_error(gtkpspell->possible_err);
509 gtkpspell->possible_err = NULL;
512 gtkpspell->checker = to_pspell_manager(gtkpspell->possible_err);
516 /* set_learn_mode() - menu callback to toggle learn mode */
517 static void set_learn_mode (GtkWidget *w, GtkPspell *gtkpspell)
519 gtkpspell->learn = gtkpspell->learn == FALSE ;
522 /* misspelled_suggest() - Create a suggestion list for word */
523 static GList *misspelled_suggest(GtkPspell *gtkpspell, guchar *word)
525 const guchar *newword;
528 const PspellWordList *suggestions;
529 PspellStringEmulation *elements;
531 g_return_val_if_fail(word, NULL);
533 if (!pspell_manager_check(gtkpspell->checker, word, -1)) {
534 suggestions = pspell_manager_suggest(gtkpspell->checker, (const char *)word, -1);
535 elements = pspell_word_list_elements(suggestions);
536 /* First one must be the misspelled (why this ?) */
537 list = g_list_append(list, g_strdup(word));
539 while ((newword = pspell_string_emulation_next(elements)) != NULL)
540 list = g_list_append(list, g_strdup(newword));
546 /* misspelled_test() - Just test if word is correctly spelled */
547 static int misspelled_test(GtkPspell *gtkpspell, unsigned char *word)
549 return pspell_manager_check(gtkpspell->checker, word, -1) ? 0 : 1;
553 static gboolean iswordsep(unsigned char c)
555 return !isalpha(c) && c != '\'';
558 static guchar get_text_index_whar(GtkPspell *gtkpspell, int pos)
563 text = gtk_editable_get_chars(GTK_EDITABLE(gtkpspell->gtktext), pos, pos + 1);
571 /* get_word_from_pos () - return the word pointed to. */
572 /* Handles correctly the quotes. */
573 static gboolean get_word_from_pos(GtkPspell *gtkpspell, int pos,
575 int *pstart, int *pend)
578 /* TODO : when correcting a word into quotes, change the color of */
579 /* the quotes too, as may be they were highlighted before. To do */
580 /* so, we can use two others pointers that points to the whole */
581 /* word including quotes. */
588 gtktext = gtkpspell->gtktext;
589 if (iswordsep(get_text_index_whar(gtkpspell, pos)))
592 /* The apostrophe character is somtimes used for quotes
593 * So include it in the word only if it is not surrounded
594 * by other characters.
597 for (start = pos; start >= 0; --start) {
598 c = get_text_index_whar(gtkpspell, start);
601 if (!isalpha(get_text_index_whar(gtkpspell, start - 1))) {
602 /* start_quote = TRUE; */
607 /* start_quote = TRUE; */
617 for (end = pos; end < gtk_xtext_get_length(gtktext); end++) {
618 c = get_text_index_whar(gtkpspell, end);
620 if (end < gtk_xtext_get_length(gtktext)) {
621 if (!isalpha(get_text_index_whar(gtkpspell, end + 1))) {
622 /* end_quote = TRUE; */
627 /* end_quote = TRUE; */
637 for (pos = start; pos < end; pos++)
638 buf[pos - start] = get_text_index_whar(gtkpspell, pos);
639 buf[pos - start] = 0;
650 static gboolean get_curword(GtkPspell *gtkpspell, unsigned char* buf,
651 int *pstart, int *pend)
653 int pos = gtk_editable_get_position(GTK_EDITABLE(gtkpspell->gtktext));
654 return get_word_from_pos(gtkpspell, pos, buf, pstart, pend);
657 static void change_color(GtkPspell * gtkpspell,
664 g_return_if_fail(start < end);
666 gtktext = gtkpspell->gtktext;
668 gtk_xtext_freeze(gtktext);
669 newtext = gtk_editable_get_chars(GTK_EDITABLE(gtktext), start, end);
671 gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
672 GTK_SIGNAL_FUNC(entry_insert_cb),
674 gtk_xtext_set_point(gtktext, start);
675 gtk_xtext_forward_delete(gtktext, end - start);
677 gtk_xtext_insert(gtktext, NULL, color, NULL, newtext, end - start);
678 gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
679 GTK_SIGNAL_FUNC(entry_insert_cb),
682 gtk_xtext_thaw(gtktext);
685 static gboolean check_at(GtkPspell *gtkpspell, int from_pos)
688 unsigned char buf[BUFSIZE];
691 g_return_val_if_fail(from_pos >= 0, FALSE);
693 gtktext = gtkpspell->gtktext;
695 if (!get_word_from_pos(gtkpspell, from_pos, buf, &start, &end))
698 strncpy(gtkpspell->theword, buf, BUFSIZE - 1);
699 gtkpspell->theword[BUFSIZE - 1] = 0;
701 if (misspelled_test(gtkpspell, buf)) {
702 if (highlight.pixel == 0) {
703 /* add an entry for the highlight in the color map. */
704 GdkColormap *gc = gtk_widget_get_colormap(GTK_WIDGET(gtktext));
705 gdk_colormap_alloc_color(gc, &highlight, FALSE, TRUE);
707 change_color(gtkpspell, start, end, &highlight);
710 change_color(gtkpspell, start, end,
711 &(GTK_WIDGET(gtktext)->style->fg[0]));
717 static void check_all(GtkWidget *w, GtkPspell *gtkpspell)
719 gtkpspell_check_all(gtkpspell);
723 void gtkpspell_check_all(GtkPspell *gtkpspell)
732 if (!gtkpspell_running(gtkpspell)) return ;
733 gtktext = gtkpspell->gtktext;
735 len = gtk_xtext_get_length(gtktext);
737 adj_value = gtktext->vadj->value;
738 gtk_xtext_freeze(gtktext);
739 origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
740 gtk_editable_set_position(GTK_EDITABLE(gtktext),0);
742 while (pos < len && iswordsep(get_text_index_whar(gtkpspell, pos)))
744 while (pos < len && !iswordsep(get_text_index_whar(gtkpspell, pos)))
747 check_at(gtkpspell, pos - 1);
749 gtk_xtext_thaw(gtktext);
750 gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
751 gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
754 static void entry_insert_cb(GtkXText *gtktext, gchar *newtext,
755 guint len, guint *ppos,
756 GtkPspell * gtkpspell)
759 if (!gtkpspell_running(gtkpspell))
762 /* We must insert ourself the character to impose the */
763 /* color of the inserted character to be default */
764 /* Never mess with set_insertion when frozen */
765 gtk_xtext_freeze(gtktext);
766 gtk_xtext_backward_delete(GTK_XTEXT(gtktext), len);
767 gtk_xtext_insert(GTK_XTEXT(gtktext), NULL,
768 &(GTK_WIDGET(gtktext)->style->fg[0]), NULL, newtext, len);
769 *ppos = gtk_xtext_get_point(GTK_XTEXT(gtktext));
771 if (iswordsep(newtext[0])) {
772 /* did we just end a word? */
774 check_at(gtkpspell, *ppos - 2);
776 /* did we just split a word? */
777 if (*ppos < gtk_xtext_get_length(gtktext))
778 check_at(gtkpspell, *ppos + 1);
780 /* check as they type, *except* if they're typing at the end (the most
783 if (*ppos < gtk_xtext_get_length(gtktext)
784 && !iswordsep(get_text_index_whar(gtkpspell, *ppos)))
785 check_at(gtkpspell, *ppos - 1);
787 gtk_xtext_thaw(gtktext);
788 gtk_editable_set_position(GTK_EDITABLE(gtktext), *ppos);
791 static void entry_delete_cb(GtkXText *gtktext, gint start, gint end,
792 GtkPspell *gtkpspell)
796 if (!gtkpspell_running(gtkpspell))
799 origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
801 check_at(gtkpspell, start - 1);
802 gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
803 gtk_editable_select_region(GTK_EDITABLE(gtktext), origpos, origpos);
804 /* this is to *UNDO* the selection, in case they were holding shift
805 * while hitting backspace. */
808 static void replace_word(GtkWidget *w, GtkPspell *gtkpspell)
810 int start, end,oldlen, newlen;
812 unsigned char *newword;
813 unsigned char buf[BUFSIZE];
817 gtktext = gtkpspell->gtktext;
819 gtk_xtext_freeze(GTK_XTEXT(gtktext));
820 origpos = gtkpspell->orig_pos;
823 gtk_label_get(GTK_LABEL(GTK_BIN(w)->child), (gchar**) &newword);
824 newlen = strlen(newword);
826 get_curword(gtkpspell, buf, &start, &end);
827 oldlen = end - start;
829 gtk_xtext_set_point(GTK_XTEXT(gtktext), end);
830 gtk_xtext_backward_delete(GTK_XTEXT(gtktext), end - start);
831 gtk_xtext_insert(GTK_XTEXT(gtktext), NULL, NULL, NULL, newword, strlen(newword));
833 if (end-start > 0 && gtkpspell->learn) {
834 /* Just be sure the buffer ends somewhere... */
836 /* Learn from common misspellings */
837 pspell_manager_store_replacement(gtkpspell->checker, buf,
842 /* Put the point and the position where we clicked with the mouse */
843 /* It seems to be a hack, as I must thaw,freeze,thaw the widget */
844 /* to let it update correctly the word insertion and then the */
845 /* point & position position. If not, SEGV after the first replacement */
846 /* If the new word ends before point, put the point at its end*/
848 if (origpos-start <= oldlen && origpos-start >= 0) {
849 /* Original point was in the word. */
850 /* Put the insertion point in the same location */
851 /* with respect to the new length */
852 /* If the original position is still within the word, */
853 /* then keep the original position. If not, move to the */
854 /* end of the word */
855 if (origpos-start > newlen)
856 pos = start + newlen;
858 else if (origpos > end) {
859 /* move the position according to the change of length */
860 pos = origpos + newlen - oldlen;
862 gtk_xtext_thaw(GTK_XTEXT(gtktext));
863 gtk_xtext_freeze(GTK_XTEXT(gtktext));
864 if (GTK_XTEXT(gtktext)->text_len < pos)
865 pos = gtk_xtext_get_length(GTK_XTEXT(gtktext));
866 gtkpspell->orig_pos = pos;
867 gtk_editable_set_position(GTK_EDITABLE(gtktext), gtkpspell->orig_pos);
868 gtk_xtext_set_point(GTK_XTEXT(gtktext),
869 gtk_editable_get_position(GTK_EDITABLE(gtktext)));
870 gtk_xtext_thaw(GTK_XTEXT(gtktext));
873 /* Accept this word for this session */
875 static void add_word_to_session(GtkWidget *w, GtkPspell *gtkpspell)
880 gtkxtext = gtkpspell->gtktext;
881 gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
882 pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
884 pspell_manager_add_to_session(gtkpspell->checker,gtkpspell->theword, strlen(gtkpspell->theword));
886 check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
888 gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
889 gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
890 gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
891 gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
892 gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
895 /* add_word_to_personal() - add word to personal dict. */
897 static void add_word_to_personal(GtkWidget *w, GtkPspell *gtkpspell)
902 gtkxtext = gtkpspell->gtktext;
904 gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
905 pos = gtk_editable_get_position(GTK_EDITABLE(gtkxtext));
907 pspell_manager_add_to_personal(gtkpspell->checker,gtkpspell->theword,strlen(gtkpspell->theword));
909 check_at(gtkpspell,gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
910 gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
911 gtk_xtext_freeze(GTK_XTEXT(gtkxtext));
912 gtk_editable_set_position(GTK_EDITABLE(gtkxtext),pos);
913 gtk_xtext_set_point(GTK_XTEXT(gtkxtext), gtk_editable_get_position(GTK_EDITABLE(gtkxtext)));
914 gtk_xtext_thaw(GTK_XTEXT(gtkxtext));
918 static GtkMenu *make_menu_config(GtkPspell *gtkpspell)
920 GtkWidget *menu, *item, *submenu;
923 menu = gtk_menu_new();
925 item = gtk_menu_item_new_with_label(_("Spell check all"));
926 gtk_widget_show(item);
927 gtk_menu_append(GTK_MENU(menu), item);
928 gtk_signal_connect(GTK_OBJECT(item),"activate",
929 GTK_SIGNAL_FUNC(check_all),
933 item = gtk_menu_item_new();
934 gtk_widget_show(item);
935 gtk_menu_append(GTK_MENU(menu),item);
937 submenu = gtk_menu_new();
938 item = gtk_menu_item_new_with_label(_("Change dictionary"));
939 gtk_widget_show(item);
940 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item),submenu);
941 gtk_menu_append(GTK_MENU(menu), item);
944 if (gtkpspell->dictionary_list==NULL)
945 gtkpspell->dictionary_list = gtkpspell_get_dictionary_list(gtkpspell->path);
948 GtkWidget * curmenu = submenu;
953 tmp = gtkpspell->dictionary_list;
954 for (tmp = gtkpspell->dictionary_list; tmp != NULL; tmp =g_slist_next(tmp)) {
955 dict = (Dictionary *) tmp->data;
956 item = gtk_check_menu_item_new_with_label(dict->name);
957 if (strcmp2(dict->name, gtkpspell->dict))
958 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
960 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
961 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
963 gtk_menu_append(GTK_MENU(curmenu), item);
964 gtk_signal_connect(GTK_OBJECT(item), "activate",
965 GTK_SIGNAL_FUNC(menu_change_dict),
967 gtk_widget_show(item);
969 if (count == MENUCOUNT) {
971 newmenu = gtk_menu_new();
972 item = gtk_menu_item_new_with_label(_("More..."));
973 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), newmenu);
974 gtk_menu_append(GTK_MENU(curmenu), item);
975 gtk_widget_show(item);
982 item = gtk_menu_item_new();
983 gtk_widget_show(item);
984 gtk_menu_append(GTK_MENU(menu), item);
986 item = gtk_check_menu_item_new_with_label(_("Fast Mode"));
987 gtk_widget_show(item);
988 gtk_menu_append(GTK_MENU(menu), item);
989 if (gtkpspell->mode == PSPELL_FASTMODE) {
990 gtk_widget_set_sensitive(GTK_WIDGET(item),FALSE);
991 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),TRUE);
994 gtk_signal_connect(GTK_OBJECT(item), "activate",
995 GTK_SIGNAL_FUNC(set_sug_mode),
998 item = gtk_check_menu_item_new_with_label(_("Normal Mode"));
999 gtk_widget_show(item);
1000 gtk_menu_append(GTK_MENU(menu),item);
1001 if (gtkpspell->mode == PSPELL_NORMALMODE) {
1002 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1003 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1006 gtk_signal_connect(GTK_OBJECT(item), "activate",
1007 GTK_SIGNAL_FUNC(set_sug_mode),
1010 item = gtk_check_menu_item_new_with_label(_("Bad Spellers Mode"));
1011 gtk_widget_show(item);
1012 gtk_menu_append(GTK_MENU(menu), item);
1013 if (gtkpspell->mode==PSPELL_BADSPELLERMODE) {
1014 gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
1015 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
1018 gtk_signal_connect(GTK_OBJECT(item), "activate",
1019 GTK_SIGNAL_FUNC(set_sug_mode),
1021 item = gtk_menu_item_new();
1022 gtk_widget_show(item);
1023 gtk_menu_append(GTK_MENU(menu), item);
1025 item = gtk_check_menu_item_new_with_label(_("Learn from mistakes"));
1026 gtk_widget_show(item);
1027 gtk_menu_append(GTK_MENU(menu), item);
1028 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),
1030 gtk_signal_connect(GTK_OBJECT(item), "activate",
1031 GTK_SIGNAL_FUNC(set_learn_mode), gtkpspell);
1034 return GTK_MENU(menu);
1037 /* make_menu() - Add menus to accept this word for this session and to add it to
1038 * personal dictionary */
1039 static GtkMenu *make_menu(GList *l, GtkPspell *gtkpspell)
1041 GtkWidget *menu, *item;
1042 unsigned char *caption;
1045 gtktext = gtkpspell->gtktext;
1047 menu = gtk_menu_new();
1048 caption = g_strdup_printf(_("Accept `%s' for this session"), (unsigned char*)l->data);
1049 item = gtk_menu_item_new_with_label(caption);
1051 gtk_widget_show(item);
1052 gtk_menu_append(GTK_MENU(menu), item);
1054 gtk_signal_connect(GTK_OBJECT(item), "activate",
1055 GTK_SIGNAL_FUNC(add_word_to_session),
1058 caption = g_strdup_printf(_("Add `%s' to personal dictionary"), (char*)l->data);
1059 item = gtk_menu_item_new_with_label(caption);
1061 gtk_widget_show(item);
1062 gtk_menu_append(GTK_MENU(menu), item);
1064 gtk_signal_connect(GTK_OBJECT(item), "activate",
1065 GTK_SIGNAL_FUNC(add_word_to_personal),
1068 item = gtk_menu_item_new();
1069 gtk_widget_show(item);
1070 gtk_menu_append(GTK_MENU(menu), item);
1074 item = gtk_menu_item_new_with_label(_("(no suggestions)"));
1075 gtk_widget_show(item);
1076 gtk_menu_append(GTK_MENU(menu), item);
1078 GtkWidget *curmenu = menu;
1082 if (l->data == NULL && l->next != NULL) {
1084 curmenu = gtk_menu_new();
1085 item = gtk_menu_item_new_with_label(_("Others..."));
1086 gtk_widget_show(item);
1087 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
1088 gtk_menu_append(GTK_MENU(curmenu), item);
1090 } else if (count > MENUCOUNT) {
1092 item = gtk_menu_item_new_with_label(_("More..."));
1093 gtk_widget_show(item);
1094 gtk_menu_append(GTK_MENU(curmenu), item);
1095 curmenu = gtk_menu_new();
1096 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
1098 item = gtk_menu_item_new_with_label((unsigned char*)l->data);
1099 gtk_signal_connect(GTK_OBJECT(item), "activate",
1100 GTK_SIGNAL_FUNC(replace_word), gtkpspell);
1101 gtk_widget_show(item);
1102 gtk_menu_append(GTK_MENU(curmenu), item);
1104 } while ((l = l->next) != NULL);
1106 return GTK_MENU(menu);
1109 static void popup_menu(GtkPspell *gtkpspell, GdkEventButton *eb)
1111 unsigned char buf[BUFSIZE];
1115 gtktext = gtkpspell->gtktext;
1116 gtkpspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1118 if (!(eb->state & GDK_SHIFT_MASK))
1119 if (get_curword(gtkpspell, buf, NULL, NULL)) {
1121 strncpy(gtkpspell->theword, buf, BUFSIZE - 1);
1122 gtkpspell->theword[BUFSIZE - 1] = 0;
1123 list = misspelled_suggest(gtkpspell, buf);
1125 gtk_menu_popup(make_menu(list, gtkpspell), NULL, NULL, NULL, NULL,
1126 eb->button, eb->time);
1127 for (l = list; l != NULL; l = l->next)
1134 gtk_menu_popup(make_menu_config(gtkpspell),NULL,NULL,NULL,NULL,
1135 eb->button,eb->time);
1138 /* ok, this is pretty wacky:
1139 * we need to let the right-mouse-click go through, so it moves the cursor,
1140 * but we *can't* let it go through, because GtkText interprets rightclicks as
1141 * weird selection modifiers.
1143 * so what do we do? forge rightclicks as leftclicks, then popup the menu.
1146 static gint button_press_intercept_cb(GtkXText *gtktext, GdkEvent *e, GtkPspell *gtkpspell)
1151 if (!gtkpspell_running(gtkpspell))
1154 if (e->type != GDK_BUTTON_PRESS)
1156 eb = (GdkEventButton*) e;
1158 if (eb->button != 3)
1161 /* forge the leftclick */
1164 gtk_signal_handler_block_by_func(GTK_OBJECT(gtktext),
1165 GTK_SIGNAL_FUNC(button_press_intercept_cb),
1167 gtk_signal_emit_by_name(GTK_OBJECT(gtktext), "button-press-event",
1169 gtk_signal_handler_unblock_by_func(GTK_OBJECT(gtktext),
1170 GTK_SIGNAL_FUNC(button_press_intercept_cb),
1172 gtk_signal_emit_stop_by_name(GTK_OBJECT(gtktext), "button-press-event");
1174 /* now do the menu wackiness */
1175 popup_menu(gtkpspell, eb);
1176 gtk_grab_remove(GTK_WIDGET(gtktext));
1180 void gtkpspell_uncheck_all(GtkPspell * gtkpspell)
1183 unsigned char *text;
1187 gtktext=gtkpspell->gtktext;
1189 adj_value = gtktext->vadj->value;
1190 gtk_xtext_freeze(gtktext);
1191 origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext));
1192 text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1);
1193 gtk_xtext_set_point(gtktext, 0);
1194 gtk_xtext_forward_delete(gtktext, gtk_xtext_get_length(gtktext));
1195 gtk_xtext_insert(gtktext, NULL, NULL, NULL, text, strlen(text));
1196 gtk_xtext_thaw(gtktext);
1198 gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos);
1199 gtk_adjustment_set_value(gtktext->vadj, adj_value);
1202 void gtkpspell_attach(GtkPspell *gtkpspell, GtkXText *gtktext)
1204 gtkpspell->gtktext=gtktext;
1205 gtk_signal_connect_after(GTK_OBJECT(gtktext), "insert-text",
1206 GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
1207 gtk_signal_connect_after(GTK_OBJECT(gtktext), "delete-text",
1208 GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
1209 gtk_signal_connect(GTK_OBJECT(gtktext), "button-press-event",
1210 GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
1214 void gtkpspell_detach(GtkPspell * gtkpspell)
1218 gtktext =gtkpspell->gtktext;
1219 /* if (prefs_common.auto_makepspell) { */
1220 gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
1221 GTK_SIGNAL_FUNC(entry_insert_cb), gtkpspell);
1222 gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
1223 GTK_SIGNAL_FUNC(entry_delete_cb), gtkpspell);
1225 gtk_signal_disconnect_by_func(GTK_OBJECT(gtktext),
1226 GTK_SIGNAL_FUNC(button_press_intercept_cb), gtkpspell);
1228 gtkpspell_uncheck_all(gtkpspell);
1231 /*** Sylpheed (Claws) ***/
1233 static GSList *create_empty_dictionary_list(void)
1235 GSList *list = NULL;
1238 dict = g_new0(Dictionary, 1);
1239 dict->name = g_strdup(_("None"));
1240 return g_slist_append(list, dict);
1243 /* gtkpspell_get_dictionary_list() - returns list of dictionary names */
1244 GSList *gtkpspell_get_dictionary_list(const gchar *pspell_path)
1247 gchar *dict_path, *tmp, *prevdir;
1256 #warning TODO: no directory change
1258 dict_path=g_strdup(pspell_path);
1259 prevdir = g_get_current_dir();
1260 if (chdir(dict_path) <0) {
1261 FILE_OP_ERROR(dict_path, "chdir");
1264 return create_empty_dictionary_list();
1267 debug_print(_("Checking for dictionaries in %s\n"), dict_path);
1269 if (NULL != (dir = opendir("."))) {
1270 while (NULL != (ent = readdir(dir))) {
1271 /* search for pwli */
1272 if (NULL != (tmp = strstr(ent->d_name, ".pwli"))) {
1273 dict = g_new0(Dictionary, 1);
1274 dict->name = g_strndup(ent->d_name, tmp - ent->d_name);
1275 debug_print(_("Found dictionary %s\n"), dict->name);
1276 list = g_slist_insert_sorted(list, dict, (GCompareFunc) compare_dict);
1282 FILE_OP_ERROR(dict_path, "opendir");
1283 debug_print(_("No dictionary found\n"));
1284 list = create_empty_dictionary_list();
1287 debug_print(_("No dictionary found"));
1288 list = create_empty_dictionary_list();
1296 /* compare_dict () - compare 2 dict names */
1298 static gint compare_dict(Dictionary *a, Dictionary *b)
1300 guchar *alanguage, *blanguage,
1301 *aspelling, *bspelling,
1302 *ajargon , *bjargon ,
1303 *amodule , *bmodule ;
1304 guint aparts = 0, bparts = 0, i;
1306 for (i=0; i < strlen(a->name) ; i++)
1307 if (a->name[i]=='-')
1309 for (i=0; i < strlen(b->name) ; i++)
1310 if (b->name[i]=='-')
1313 if (aparts != bparts)
1314 return (aparts < bparts) ? -1 : +1 ;
1316 return strcmp2(a->name, b->name);
1318 void gtkpspell_free_dictionary_list(GSList *list)
1322 for (walk = list; walk != NULL; walk = g_slist_next(walk))
1324 dict = (Dictionary *) walk->data;
1332 static void dictionary_option_menu_item_data_destroy(gpointer data)
1334 gchar *str = (gchar *) data;
1340 GtkWidget *gtkpspell_dictionary_option_menu_new(const gchar *pspell_path)
1342 GSList *dict_list, *tmp;
1347 dict_list = gtkpspell_get_dictionary_list(pspell_path);
1348 g_return_val_if_fail(dict_list, NULL);
1350 menu = gtk_menu_new();
1352 for (tmp = dict_list; tmp != NULL; tmp = g_slist_next(tmp)) {
1353 dict = (Dictionary *) tmp->data;
1354 item = gtk_menu_item_new_with_label(dict->name);
1356 gtk_object_set_data_full(GTK_OBJECT(item), "dict_name",
1357 g_strdup(dict->name),
1358 dictionary_option_menu_item_data_destroy);
1359 gtk_menu_append(GTK_MENU(menu), item);
1360 gtk_widget_show(item);
1363 gtk_widget_show(menu);
1365 gtkpspell_free_dictionary_list(dict_list);
1372 gchar *gtkpspell_get_dictionary_menu_active_item(GtkWidget *menu)
1374 GtkWidget *menuitem;
1377 g_return_val_if_fail(GTK_IS_MENU(menu), NULL);
1378 menuitem = gtk_menu_get_active(GTK_MENU(menu));
1379 result = gtk_object_get_data(GTK_OBJECT(menuitem), "dict_name");
1380 g_return_val_if_fail(result, NULL);
1381 return g_strdup(result);