Move all colors into an array
[claws.git] / src / gtk / spell_entry.c
1 /*
2  * @file libsexy/sexy-icon-entry.c Entry widget
3  *
4  * @Copyright (C) 2004-2006 Christian Hammond.
5  * Some of this code is from gtkspell, Copyright (C) 2002 Evan Martin.
6  * Adapted for Claws Mail (c) 2009-2012 Pawel Pekala and the Claws Mail team
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program. If not, see <http://www.gnu.org/licenses/>.
20  * 
21  */
22
23 #ifdef HAVE_CONFIG_H
24 #  include "config.h"
25 #include "claws-features.h"
26 #endif
27
28 #ifdef USE_ENCHANT
29
30 #include <glib.h>
31 #include <glib/gi18n.h>
32
33 #include <gdk/gdk.h>
34 #include <gdk/gdkkeysyms.h>
35
36 #include <string.h>
37 #include <glib.h>
38 #include <gtk/gtk.h>
39
40 #include "spell_entry.h"
41 #include "prefs_common.h"
42 #include "codeconv.h"
43 #include "defs.h"
44 #include "gtkutils.h"
45
46 static void claws_spell_entry_init              (ClawsSpellEntry *entry);
47 static void claws_spell_entry_editable_init     (GtkEditableClass *iface);
48 static void claws_spell_entry_finalize          (GObject *object);
49 #if !GTK_CHECK_VERSION(3, 0, 0)
50 static void claws_spell_entry_destroy           (GtkObject *object);
51 static gint claws_spell_entry_expose            (GtkWidget *widget,
52                                                  GdkEventExpose *event);
53 #else
54 static void claws_spell_entry_destroy           (GtkWidget *object);
55 static gint claws_spell_entry_expose            (GtkWidget *widget,
56                                                  cairo_t *cr);
57 #endif
58 static gint claws_spell_entry_button_press      (GtkWidget *widget,
59                                                  GdkEventButton *event);
60 static gboolean claws_spell_entry_popup_menu    (GtkWidget *widget,
61                                                  ClawsSpellEntry *entry);
62 static void claws_spell_entry_populate_popup    (ClawsSpellEntry *entry,
63                                                  GtkMenu *menu,
64                                                  gpointer data);
65 static void claws_spell_entry_changed           (GtkEditable *editable,
66                                                  gpointer data);
67
68 struct _ClawsSpellEntryPriv
69 {
70         PangoAttrList        *attr_list;
71         gint                  mark_character;
72         gchar               **words;
73         gint                 *word_starts;
74         gint                 *word_ends;
75 };
76
77 static GtkEntryClass *parent_class = NULL;
78
79
80 G_DEFINE_TYPE_EXTENDED(ClawsSpellEntry, claws_spell_entry, GTK_TYPE_ENTRY, 0, G_IMPLEMENT_INTERFACE(GTK_TYPE_EDITABLE, claws_spell_entry_editable_init)); 
81
82
83 static void claws_spell_entry_class_init(ClawsSpellEntryClass *klass)
84 {
85         GObjectClass    *g_object_class;
86 #if !GTK_CHECK_VERSION(3, 0, 0)
87         GtkObjectClass  *gtk_object_class;
88 #endif
89         GtkWidgetClass  *widget_class;
90         
91         parent_class = g_type_class_peek_parent(klass);
92         
93         g_object_class = G_OBJECT_CLASS(klass);
94         g_object_class->finalize = claws_spell_entry_finalize;
95         
96 #if !GTK_CHECK_VERSION(3, 0, 0)
97         gtk_object_class = GTK_OBJECT_CLASS(klass);
98         gtk_object_class->destroy = claws_spell_entry_destroy;
99 #endif
100         
101         widget_class = GTK_WIDGET_CLASS(klass);
102         widget_class->button_press_event = claws_spell_entry_button_press;
103 #if !GTK_CHECK_VERSION(3, 0, 0)
104         widget_class->expose_event = claws_spell_entry_expose;
105 #else
106         widget_class->draw = claws_spell_entry_expose;
107         widget_class->destroy = claws_spell_entry_destroy;
108 #endif
109         
110         g_type_class_add_private(g_object_class,
111                         sizeof(struct _ClawsSpellEntryPriv));
112 }
113
114 static void claws_spell_entry_init(ClawsSpellEntry *entry)
115 {
116         entry->gtkaspell = NULL;
117         
118         entry->priv = g_new0(ClawsSpellEntryPriv, 1);
119         entry->priv->attr_list = pango_attr_list_new();
120                                         
121         g_signal_connect(G_OBJECT(entry), "popup-menu",
122                         G_CALLBACK(claws_spell_entry_popup_menu), entry);
123         g_signal_connect(G_OBJECT(entry), "populate-popup",
124                         G_CALLBACK(claws_spell_entry_populate_popup), NULL);
125         g_signal_connect(G_OBJECT(entry), "changed",
126                         G_CALLBACK(claws_spell_entry_changed), NULL);
127 }
128
129 static void claws_spell_entry_editable_init (GtkEditableClass *iface) {}
130
131 static void claws_spell_entry_finalize(GObject *object)
132 {
133         ClawsSpellEntry *entry = CLAWS_SPELL_ENTRY(object);
134
135         if (entry->priv->attr_list)
136                 pango_attr_list_unref(entry->priv->attr_list);
137         if (entry->priv->words)
138                 g_strfreev(entry->priv->words);
139
140         g_free(entry->priv->word_starts);
141         g_free(entry->priv->word_ends);
142         g_free(entry->priv);
143         entry->priv = NULL;
144         
145         G_OBJECT_CLASS(parent_class)->finalize(object);
146 }
147
148 #if !GTK_CHECK_VERSION(3, 0, 0)
149 static void claws_spell_entry_destroy(GtkObject *object)
150 {
151         GTK_OBJECT_CLASS(parent_class)->destroy(object);
152 }
153 #else
154 static void claws_spell_entry_destroy(GtkWidget *object)
155 {
156         GTK_WIDGET_CLASS(parent_class)->destroy(object);
157 }
158 #endif
159
160 GtkWidget *claws_spell_entry_new(void)
161 {
162         return GTK_WIDGET( g_object_new(CLAWS_TYPE_SPELL_ENTRY, NULL) );
163 }
164
165 void claws_spell_entry_set_gtkaspell(ClawsSpellEntry *entry, GtkAspell *gtkaspell)
166 {
167         cm_return_if_fail(CLAWS_IS_SPELL_ENTRY(entry));
168
169         entry->gtkaspell = gtkaspell;
170 }
171
172 static gint gtk_entry_find_position (GtkEntry *entry, gint x)
173 {
174         PangoLayout *layout;
175         PangoLayoutLine *line;
176         const gchar *text;
177         gint cursor_index;
178         gint index;
179         gint pos;
180         gboolean trailing;
181
182         x = x + entry->scroll_offset;
183
184         layout = gtk_entry_get_layout(entry);
185         text = pango_layout_get_text(layout);
186         cursor_index = g_utf8_offset_to_pointer(text, entry->current_pos) - text;
187
188         line = pango_layout_get_lines(layout)->data;
189         pango_layout_line_x_to_index(line, x * PANGO_SCALE, &index, &trailing);
190
191         if (index >= cursor_index && entry->preedit_length) {
192                 if (index >= cursor_index + entry->preedit_length) {
193                         index -= entry->preedit_length;
194                 } else {
195                         index = cursor_index;
196                         trailing = FALSE;
197                 }
198         }
199
200         pos = g_utf8_pointer_to_offset (text, text + index);
201         pos += trailing;
202
203         return pos;
204 }
205
206 static void get_word_extents_from_position(ClawsSpellEntry *entry, gint *start,
207                                            gint *end, guint position)
208 {
209         const gchar *text;
210         gint i, bytes_pos;
211
212         *start = -1;
213         *end = -1;
214
215         if (entry->priv->words == NULL)
216                 return;
217
218         text = gtk_entry_get_text(GTK_ENTRY(entry));
219         bytes_pos = (gint) (g_utf8_offset_to_pointer(text, position) - text);
220
221         for (i = 0; entry->priv->words[i]; i++) {
222                 if (bytes_pos >= entry->priv->word_starts[i] &&
223                     bytes_pos <= entry->priv->word_ends[i]) {
224                         *start = entry->priv->word_starts[i];
225                         *end   = entry->priv->word_ends[i];
226                         return;
227                 }
228         }
229 }
230
231 static gchar *get_word(ClawsSpellEntry *entry, const int start, const int end)
232 {
233         const gchar *text;
234         gchar *word;
235         
236         if (start >= end)
237                 return NULL;
238
239         text = gtk_entry_get_text(GTK_ENTRY(entry));
240         word = g_new0(gchar, end - start + 2);
241         g_strlcpy(word, text + start, end - start + 1);
242
243         return word;
244 }
245
246 static void replace_word(ClawsSpellEntry *entry, const gchar *newword)
247 {
248         gint cursor, start_pos, end_pos;
249         const gchar *text = gtk_entry_get_text(GTK_ENTRY(entry));
250
251         start_pos = entry->gtkaspell->start_pos;
252         end_pos = entry->gtkaspell->end_pos;
253                 
254         cursor = gtk_editable_get_position(GTK_EDITABLE(entry));
255         /* is the cursor at the end? If so, restore it there */
256         if (g_utf8_strlen(text, -1) == cursor)
257                 cursor = -1;
258         else if(cursor < entry->priv->mark_character ||
259                 cursor > entry->priv->mark_character)
260                         cursor = entry->priv->mark_character;
261
262         gtk_editable_delete_text(GTK_EDITABLE(entry), start_pos, end_pos);
263         gtk_editable_insert_text(GTK_EDITABLE(entry), newword, strlen(newword),
264                                                          &start_pos);
265         gtk_editable_set_position(GTK_EDITABLE(entry), cursor);
266 }
267
268
269 static gboolean word_misspelled(ClawsSpellEntry *entry, int start, int end)
270 {
271         gchar *word;
272         gboolean ret;
273
274         word = get_word(entry, start, end);
275         if (word == NULL || g_unichar_isdigit(word[0]))
276                 return FALSE;
277                 
278         ret = gtkaspell_misspelled_test(entry->gtkaspell, word);
279
280         g_free(word);
281         return ret;
282 }
283
284 static gboolean is_word_end (GtkEntry *entry, const int offset)
285 {
286         gchar *p = gtk_editable_get_chars(GTK_EDITABLE(entry), offset, offset+1);
287         gunichar ch;
288         
289         ch = g_utf8_get_char(p);
290         g_free(p);
291         
292         if (ch == '\0')
293                 return TRUE;
294
295         if (ch == '\'') {
296                 p = gtk_editable_get_chars(GTK_EDITABLE(entry), offset+1, offset+2);
297                 ch = g_utf8_get_char(p);
298                 g_free(p);
299                 
300                 return (g_unichar_isspace(ch) || g_unichar_ispunct(ch)
301                         || g_unichar_isdigit(ch));
302         }
303         
304         return (g_unichar_isspace(ch) || g_unichar_ispunct(ch));
305 }
306
307 static void entry_strsplit_utf8(GtkEntry *entry, gchar ***set, gint **starts, gint **ends)
308 {
309         PangoLayout   *layout;
310         PangoLogAttr  *log_attrs;
311         const gchar   *text;
312         gint           n_attrs, n_strings, i, j;
313
314         layout = gtk_entry_get_layout(GTK_ENTRY(entry));
315         text = gtk_entry_get_text(GTK_ENTRY(entry));
316         pango_layout_get_log_attrs(layout, &log_attrs, &n_attrs);
317
318         /* Find how many words we have */
319         n_strings = 0;
320         for (i = 0; i < n_attrs; i++)
321                 if (log_attrs[i].is_word_start)
322                         n_strings++;
323
324         *set    = g_new0(gchar *, n_strings + 1);
325         *starts = g_new0(gint, n_strings);
326         *ends   = g_new0(gint, n_strings);
327
328         /* Copy out strings */
329         for (i = 0, j = 0; i < n_attrs; i++) {
330                 if (log_attrs[i].is_word_start) {
331                         gint cend, bytes;
332                         gchar *start;
333
334                         /* Find the end of this string */
335                         cend = i;
336                         while (!is_word_end(entry, cend))
337                                 cend++;
338
339                         /* Copy sub-string */
340                         start = g_utf8_offset_to_pointer(text, i);
341                         bytes = (gint) (g_utf8_offset_to_pointer(text, cend) - start);
342                         (*set)[j]    = g_new0(gchar, bytes + 1);
343                         (*starts)[j] = (gint) (start - text);
344                         (*ends)[j]   = (gint) (start - text + bytes);
345                         g_utf8_strncpy((*set)[j], start, cend - i);
346
347                         /* Move on to the next word */
348                         j++;
349                 }
350         }
351
352         g_free (log_attrs);
353 }
354
355 static void insert_misspelled_marker(ClawsSpellEntry *entry, guint start, guint end)
356 {
357         guint16 red   = (guint16) (((gdouble)((prefs_common.color[COL_MISSPELLED] &
358                                         0xff0000) >> 16) / 255.0) * 65535.0);
359         guint16 green = (guint16) (((gdouble)((prefs_common.color[COL_MISSPELLED] &
360                                         0x00ff00) >> 8) / 255.0) * 65535.0);
361         guint16 blue  = (guint16) (((gdouble) (prefs_common.color[COL_MISSPELLED] &
362                                         0x0000ff) / 255.0) * 65535.0);
363         PangoAttribute *fcolor, *ucolor, *unline;
364         
365         if(prefs_common.color[COL_MISSPELLED] != 0) {
366                 fcolor = pango_attr_foreground_new(red, green, blue);
367                 fcolor->start_index = start;
368                 fcolor->end_index = end;
369                 
370                 pango_attr_list_insert(entry->priv->attr_list, fcolor);
371         } else {
372                 ucolor = pango_attr_underline_color_new (65535, 0, 0);
373                 unline = pango_attr_underline_new (PANGO_UNDERLINE_ERROR);
374
375                 ucolor->start_index = start;
376                 unline->start_index = start;
377
378                 ucolor->end_index = end;
379                 unline->end_index = end;
380
381                 pango_attr_list_insert (entry->priv->attr_list, ucolor);
382                 pango_attr_list_insert (entry->priv->attr_list, unline);
383         }
384 }
385
386 static gboolean check_word(ClawsSpellEntry *entry, int start, int end)
387 {
388         GtkAspell *gtkaspell = entry->gtkaspell;
389         PangoAttrIterator *it;
390         gint s, e;
391         gboolean misspelled;
392         gchar *text = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
393         gchar *word = NULL;
394
395         /* Check to see if we've got any attributes at this position.
396          * If so, free them, since we'll readd it if the word is misspelled */
397         it = pango_attr_list_get_iterator(entry->priv->attr_list);
398         if (it == NULL)
399                 return FALSE;
400         do {
401                 pango_attr_iterator_range(it, &s, &e);
402                 if (s == start) {
403                         GSList *attrs = pango_attr_iterator_get_attrs(it);
404                         g_slist_foreach(attrs, (GFunc) pango_attribute_destroy, NULL);
405                         g_slist_free(attrs);
406                 }
407         } while (pango_attr_iterator_next(it));
408         pango_attr_iterator_destroy(it);
409
410         if ((misspelled = word_misspelled(entry, start, end))) {
411                 insert_misspelled_marker(entry, start, end);
412         
413                 word = get_word(entry, start, end);
414                 strncpy(gtkaspell->theword, (gchar *)word, GTKASPELLWORDSIZE - 1);
415                 gtkaspell->theword[GTKASPELLWORDSIZE - 1] = 0;
416                 gtkaspell->start_pos  = g_utf8_pointer_to_offset(text, (text+start));
417                 gtkaspell->end_pos    = g_utf8_pointer_to_offset(text, (text+end));
418                 gtkaspell_free_suggestions_list(gtkaspell);
419                 g_free(word);
420         }
421         
422         g_free(text);
423         
424         return misspelled;
425 }
426
427 void claws_spell_entry_recheck_all(ClawsSpellEntry *entry)
428 {
429         GdkRectangle rect;
430         PangoLayout *layout;
431         int length, i;
432
433         cm_return_if_fail(CLAWS_IS_SPELL_ENTRY(entry));
434         cm_return_if_fail(entry->gtkaspell != NULL);
435
436         if (entry->priv->words == NULL)
437                 return;
438
439         /* Remove all existing pango attributes.  These will get readded as we check */
440         pango_attr_list_unref(entry->priv->attr_list);
441         entry->priv->attr_list = pango_attr_list_new();
442
443         /* Loop through words */
444         for (i = 0; entry->priv->words[i]; i++) {
445                 length = strlen(entry->priv->words[i]);
446                 if (length == 0)
447                         continue;
448                 check_word(entry, entry->priv->word_starts[i], entry->priv->word_ends[i]);
449         }
450
451         layout = gtk_entry_get_layout(GTK_ENTRY(entry));
452         pango_layout_set_attributes(layout, entry->priv->attr_list);
453
454         if (gtk_widget_get_realized(GTK_WIDGET(entry))) {
455                 rect.x = 0; rect.y = 0;
456                 rect.width  = GTK_WIDGET(entry)->allocation.width;
457                 rect.height = GTK_WIDGET(entry)->allocation.height;
458                 gdk_window_invalidate_rect(GTK_WIDGET(entry)->window, &rect, TRUE);
459         }
460 }
461
462 #if !GTK_CHECK_VERSION(3, 0, 0)
463 static gint claws_spell_entry_expose(GtkWidget *widget, GdkEventExpose *event)
464 #else
465 static gint claws_spell_entry_expose(GtkWidget *widget, cairo_t *cr)
466 #endif
467 {
468         ClawsSpellEntry *entry = CLAWS_SPELL_ENTRY(widget);
469         GtkEntry *gtk_entry = GTK_ENTRY(widget);
470         PangoLayout *layout;
471
472         if (entry->gtkaspell != NULL) {
473                 layout = gtk_entry_get_layout(gtk_entry);
474                 pango_layout_set_attributes(layout, entry->priv->attr_list);
475         }
476
477 #if !GTK_CHECK_VERSION(3, 0, 0)
478         return GTK_WIDGET_CLASS(parent_class)->expose_event (widget, event);
479 #else
480         return GTK_WIDGET_CLASS(parent_class)->draw (widget, cr);
481 #endif
482 }
483
484 static gint claws_spell_entry_button_press(GtkWidget *widget, GdkEventButton *event)
485 {
486         ClawsSpellEntry *entry = CLAWS_SPELL_ENTRY(widget);
487         GtkEntry *gtk_entry = GTK_ENTRY(widget);
488         gint pos;
489
490         pos = gtk_entry_find_position(gtk_entry, event->x);
491         entry->priv->mark_character = pos;
492
493         return GTK_WIDGET_CLASS(parent_class)->button_press_event (widget, event);
494 }
495
496 static gboolean claws_spell_entry_popup_menu(GtkWidget *widget, ClawsSpellEntry *entry)
497 {
498         entry->priv->mark_character = gtk_editable_get_position (GTK_EDITABLE (entry));
499         return FALSE;
500 }
501
502 static void set_position(gpointer data, gint pos)
503 {
504         gtk_editable_set_position(GTK_EDITABLE(data), pos);
505 }
506
507 static gboolean find_misspelled_cb(gpointer data, gboolean forward)
508 {
509         ClawsSpellEntry *entry = (ClawsSpellEntry *)data;
510         GtkAspell *gtkaspell = entry->gtkaspell;
511         gboolean misspelled = FALSE;
512         gint cursor, minpos, maxpos, i, words_len = 0;
513         gint start, end;
514         gchar *text;
515         
516         if (entry->priv->words == NULL)
517                 return FALSE;
518
519         gtkaspell->orig_pos = gtk_editable_get_position(GTK_EDITABLE(entry));
520         text = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
521         cursor = g_utf8_offset_to_pointer(text, gtkaspell->orig_pos) - text;
522
523         if (gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end)) {
524                 minpos = g_utf8_offset_to_pointer(text, start) - text;
525                 maxpos = g_utf8_offset_to_pointer(text, end) - text;
526         } else {
527                 minpos = forward ? cursor : 0;
528                 maxpos = forward ? strlen(text)-1 : cursor;
529         }
530         g_free(text);
531
532         while(entry->priv->words[words_len])
533                 words_len++;
534
535         if (forward) {
536                 for(i=0; i < words_len; i++)
537                         if (entry->priv->word_ends[i] > minpos &&
538                             (misspelled = check_word(entry,
539                                         entry->priv->word_starts[i],
540                                         entry->priv->word_ends[i])))
541                                 break;
542         } else {
543                 for(i=words_len-1; i >= 0; i--)
544                         if (entry->priv->word_starts[i] < maxpos &&
545                             (misspelled = check_word(entry,
546                                         entry->priv->word_starts[i],
547                                         entry->priv->word_ends[i])))
548                                 break;
549         }
550         
551         return misspelled;
552 }
553
554 static gboolean check_word_cb(gpointer data)
555 {
556         ClawsSpellEntry *entry = (ClawsSpellEntry *)data;
557         gint start, end;
558         
559         get_word_extents_from_position(entry, &start, &end, entry->priv->mark_character);
560         return check_word(entry, start, end);
561 }
562
563 static void replace_word_cb(gpointer data, const gchar *newword)
564 {
565         replace_word((ClawsSpellEntry *) data, newword);
566 }
567
568 static void set_menu_pos(GtkMenu *menu, gint *x, gint *y, 
569                          gboolean *push_in, gpointer data)
570 {
571         ClawsSpellEntry *entry = (ClawsSpellEntry *) data;
572         GtkAspell *gtkaspell = entry->gtkaspell;
573         gint pango_offset, win_x, win_y, scr_x, scr_y, text_index, entry_x;
574         gchar *text;
575         GtkRequisition subject_rq;
576         PangoLayout *layout = gtk_entry_get_layout(GTK_ENTRY(entry));
577         PangoLayoutLine *line = pango_layout_get_lines(layout)->data;
578
579         gtk_widget_get_child_requisition(GTK_WIDGET(entry), &subject_rq);
580         
581         /* screen -> compose window coords */
582         gdk_window_get_origin(GTK_WIDGET(gtkaspell->parent_window)->window,
583                                 &scr_x, &scr_y);
584
585         /* compose window -> subject entry coords */
586         gtk_widget_translate_coordinates(GTK_WIDGET(entry),
587                         gtkaspell->parent_window, 0, 0, &win_x, &win_y);
588
589         text = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
590         text_index = g_utf8_offset_to_pointer(text, gtkaspell->end_pos) - text;
591         g_free(text);
592
593         pango_offset = gtk_entry_text_index_to_layout_index(GTK_ENTRY(entry),
594                                         text_index);
595         pango_layout_line_index_to_x(line, pango_offset, TRUE, &entry_x);
596
597         *x = scr_x + win_x + PANGO_PIXELS(entry_x) + 8;
598         *y = scr_y + win_y + subject_rq.height;
599 }
600
601 void claws_spell_entry_context_set(ClawsSpellEntry *entry)
602 {
603         cm_return_if_fail(CLAWS_IS_SPELL_ENTRY(entry));
604         cm_return_if_fail(entry->gtkaspell != NULL);
605
606         entry->gtkaspell->ctx.set_position      = set_position;
607         entry->gtkaspell->ctx.set_menu_pos      = set_menu_pos;
608         entry->gtkaspell->ctx.find_misspelled   = find_misspelled_cb;
609         entry->gtkaspell->ctx.check_word        = check_word_cb;
610         entry->gtkaspell->ctx.replace_word      = replace_word_cb;
611         entry->gtkaspell->ctx.data              = (gpointer) entry;
612 }
613
614 static void claws_spell_entry_populate_popup(ClawsSpellEntry *entry, GtkMenu *menu,
615                                                 gpointer data)
616 {
617         GtkAspell *gtkaspell = entry->gtkaspell;
618         gint start, end;
619         gchar *word, *text;
620         
621         if (gtkaspell == NULL)
622                 return;
623         
624         get_word_extents_from_position(entry, &start, &end, entry->priv->mark_character);
625
626         if ((word = get_word(entry, start, end)) != NULL) {
627                 strncpy(gtkaspell->theword, word, GTKASPELLWORDSIZE - 1);
628                 g_free(word);
629         }
630
631         gtkaspell->misspelled = word_misspelled(entry, start, end);
632
633         text = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
634         gtkaspell->start_pos  = g_utf8_pointer_to_offset(text, (text+start));
635         gtkaspell->end_pos    = g_utf8_pointer_to_offset(text, (text+end));
636         g_free(text);
637
638         claws_spell_entry_context_set(entry);
639         gtkaspell_make_context_menu(menu, gtkaspell);
640 }
641
642 static void claws_spell_entry_changed(GtkEditable *editable, gpointer data)
643 {
644         ClawsSpellEntry *entry = CLAWS_SPELL_ENTRY(editable);
645
646         if (entry->gtkaspell == NULL)
647                 return;
648
649         if (entry->priv->words) {
650                 g_strfreev(entry->priv->words);
651                 g_free(entry->priv->word_starts);
652                 g_free(entry->priv->word_ends);
653         }
654         entry_strsplit_utf8(GTK_ENTRY(entry), &entry->priv->words, 
655                         &entry->priv->word_starts, &entry->priv->word_ends);
656         if(entry->gtkaspell->check_while_typing == TRUE)
657                 claws_spell_entry_recheck_all(entry);
658 }
659
660 static void continue_check(gpointer *data)
661 {
662         ClawsSpellEntry *entry = (ClawsSpellEntry *)data;
663         GtkAspell *gtkaspell = entry->gtkaspell;
664         gint pos = gtk_editable_get_position(GTK_EDITABLE(entry));
665         
666         if (gtkaspell->misspelled && pos < gtkaspell->end_check_pos)
667                 gtkaspell->misspelled = gtkaspell_check_next_prev(gtkaspell, TRUE);
668         else
669                 gtkaspell->continue_check = NULL;
670 }
671
672 void claws_spell_entry_check_all(ClawsSpellEntry *entry)
673 {
674         gint start, end;
675         gchar *text;
676         
677         cm_return_if_fail(CLAWS_IS_SPELL_ENTRY(entry));
678         cm_return_if_fail(entry->gtkaspell != NULL);
679         
680         if (!gtk_editable_get_selection_bounds(GTK_EDITABLE(entry), &start, &end)) {
681                 text = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);      
682                 
683                 start = 0;
684                 end = g_utf8_strlen(text, -1) - 1;
685                 
686                 g_free(text);
687         }
688
689         gtk_editable_set_position(GTK_EDITABLE(entry), start);
690         entry->gtkaspell->continue_check = continue_check;
691         entry->gtkaspell->end_check_pos  = end;
692
693         claws_spell_entry_context_set(entry);
694         entry->gtkaspell->misspelled = 
695                         gtkaspell_check_next_prev(entry->gtkaspell, TRUE);
696 }
697
698 void claws_spell_entry_check_backwards(ClawsSpellEntry *entry)
699 {
700         cm_return_if_fail(CLAWS_IS_SPELL_ENTRY(entry));
701         cm_return_if_fail(entry->gtkaspell != NULL);
702         
703         entry->gtkaspell->continue_check = NULL;
704         claws_spell_entry_context_set(entry);
705         gtkaspell_check_next_prev(entry->gtkaspell, FALSE);
706 }
707
708 void claws_spell_entry_check_forwards_go(ClawsSpellEntry *entry)
709 {
710         cm_return_if_fail(CLAWS_IS_SPELL_ENTRY(entry));
711         cm_return_if_fail(entry->gtkaspell != NULL);
712
713         entry->gtkaspell->continue_check = NULL;
714         claws_spell_entry_context_set(entry);
715         gtkaspell_check_next_prev(entry->gtkaspell, TRUE);
716 }
717
718 #endif  /* USE_ENCHANT */