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