]> git.0d.be Git - empathy.git/blob - libempathy-gtk/empathy-spell.c
Move empathy-conf to libempathy-gtk. libempathy do not depend directly on gconf anymore.
[empathy.git] / libempathy-gtk / empathy-spell.c
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 /*
3  * Copyright (C) 2004-2007 Imendio AB
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation; either version 2 of the
8  * License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public
16  * License along with this program; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18  * Boston, MA 02111-1307, USA.
19  *
20  * Authors: Martyn Russell <martyn@imendio.com>
21  *          Richard Hult <richard@imendio.com>
22  */
23
24 #include "config.h"
25
26 #include <string.h>
27 #include <stdlib.h>
28
29 #include <glib/gi18n.h>
30
31 #ifdef HAVE_ASPELL
32 #include <aspell.h>
33 #endif
34
35 #include <libempathy/empathy-debug.h>
36
37 #include "empathy-spell.h"
38 #include "empathy-conf.h"
39 #include "empathy-preferences.h"
40
41 #define DEBUG_DOMAIN "Spell"
42
43 #ifdef HAVE_ASPELL
44
45 /* Note: We could use aspell_reset_cache (NULL); periodically if we wanted
46  * to...
47  */
48
49 typedef struct {
50         AspellConfig       *spell_config;
51         AspellCanHaveError *spell_possible_err;
52         AspellSpeller      *spell_checker;
53 } SpellLanguage;
54
55 #define ISO_CODES_DATADIR    ISO_CODES_PREFIX "/share/xml/iso-codes"
56 #define ISO_CODES_LOCALESDIR ISO_CODES_PREFIX "/share/locale"
57
58 static GHashTable  *iso_code_names = NULL;
59 static GList       *languages = NULL;
60 static gboolean     empathy_conf_notify_inited = FALSE;
61
62 static void
63 spell_iso_codes_parse_start_tag (GMarkupParseContext  *ctx,
64                                  const gchar          *element_name,
65                                  const gchar         **attr_names,
66                                  const gchar         **attr_values,
67                                  gpointer              data,
68                                  GError              **error)
69 {
70         const gchar *ccode_longB, *ccode_longT, *ccode;
71         const gchar *lang_name;
72
73         if (!g_str_equal (element_name, "iso_639_entry") ||
74             attr_names == NULL || attr_values == NULL) {
75                 return;
76         }
77
78         ccode = NULL;
79         ccode_longB = NULL;
80         ccode_longT = NULL;
81         lang_name = NULL;
82
83         while (*attr_names && *attr_values) {
84                 if (g_str_equal (*attr_names, "iso_639_1_code")) {
85                         if (**attr_values) {
86                                 ccode = *attr_values;
87                         }
88                 }
89                 else if (g_str_equal (*attr_names, "iso_639_2B_code")) {
90                         if (**attr_values) {
91                                 ccode_longB = *attr_values;
92                         }
93                 }
94                 else if (g_str_equal (*attr_names, "iso_639_2T_code")) {
95                         if (**attr_values) {
96                                 ccode_longT = *attr_values;
97                         }
98                 }
99                 else if (g_str_equal (*attr_names, "name")) {
100                         lang_name = *attr_values;
101                 }
102
103                 attr_names++;
104                 attr_values++;
105         }
106
107         if (!lang_name) {
108                 return;
109         }
110
111         if (ccode) {
112                 g_hash_table_insert (iso_code_names,
113                                      g_strdup (ccode),
114                                      g_strdup (lang_name));
115         }
116
117         if (ccode_longB) {
118                 g_hash_table_insert (iso_code_names,
119                                      g_strdup (ccode_longB),
120                                      g_strdup (lang_name));
121         }
122
123         if (ccode_longT) {
124                 g_hash_table_insert (iso_code_names,
125                                      g_strdup (ccode_longT),
126                                      g_strdup (lang_name));
127         }
128 }
129
130 static void
131 spell_iso_code_names_init (void)
132 {
133         GError *err = NULL;
134         gchar  *buf;
135         gsize   buf_len;
136
137         iso_code_names = g_hash_table_new_full (g_str_hash, g_str_equal,
138                                                 g_free, g_free);
139
140         bindtextdomain ("iso_639", ISO_CODES_LOCALESDIR);
141         bind_textdomain_codeset ("iso_639", "UTF-8");
142
143         /* FIXME: We should read this in chunks and pass to the parser. */
144         if (g_file_get_contents (ISO_CODES_DATADIR "/iso_639.xml", &buf, &buf_len, &err)) {
145                 GMarkupParseContext *ctx;
146                 GMarkupParser        parser = {
147                         spell_iso_codes_parse_start_tag,
148                         NULL, NULL, NULL, NULL
149                 };
150
151                 ctx = g_markup_parse_context_new (&parser, 0, NULL, NULL);
152                 if (!g_markup_parse_context_parse (ctx, buf, buf_len, &err)) {
153                         g_warning ("Failed to parse '%s': %s",
154                                    ISO_CODES_DATADIR"/iso_639.xml",
155                                    err->message);
156                         g_error_free (err);
157                 }
158
159                 g_markup_parse_context_free (ctx);
160                 g_free (buf);
161         } else {
162                 g_warning ("Failed to load '%s': %s",
163                                 ISO_CODES_DATADIR"/iso_639.xml", err->message);
164                 g_error_free (err);
165         }
166 }
167
168 static void
169 spell_notify_languages_cb (EmpathyConf  *conf,
170                            const gchar *key,
171                            gpointer     user_data)
172 {
173         GList *l;
174
175         empathy_debug (DEBUG_DOMAIN, "Resetting languages due to config change");
176
177         /* We just reset the languages list. */
178         for (l = languages; l; l = l->next) {
179                 SpellLanguage *lang;
180
181                 lang = l->data;
182
183                 delete_aspell_config (lang->spell_config);
184                 delete_aspell_speller (lang->spell_checker);
185
186                 g_slice_free (SpellLanguage, lang);
187         }
188
189         g_list_free (languages);
190         languages = NULL;
191 }
192
193 static void
194 spell_setup_languages (void)
195 {
196         gchar  *str;
197
198         if (!empathy_conf_notify_inited) {
199                 empathy_conf_notify_add (empathy_conf_get (),
200                                          EMPATHY_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
201                                          spell_notify_languages_cb, NULL);
202
203                 empathy_conf_notify_inited = TRUE;
204         }
205
206         if (languages) {
207                 return;
208         }
209
210         if (empathy_conf_get_string (empathy_conf_get (),
211                                      EMPATHY_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
212                                      &str) && str) {
213                 gchar **strv;
214                 gint    i;
215
216                 strv = g_strsplit (str, ",", -1);
217
218                 i = 0;
219                 while (strv && strv[i]) {
220                         SpellLanguage *lang;
221
222                         empathy_debug (DEBUG_DOMAIN, "Setting up language:'%s'", strv[i]);
223
224                         lang = g_slice_new0 (SpellLanguage);
225
226                         lang->spell_config = new_aspell_config();
227
228                         aspell_config_replace (lang->spell_config, "encoding", "utf-8");
229                         aspell_config_replace (lang->spell_config, "lang", strv[i++]);
230
231                         lang->spell_possible_err = new_aspell_speller (lang->spell_config);
232
233                         if (aspell_error_number (lang->spell_possible_err) == 0) {
234                                 lang->spell_checker = to_aspell_speller (lang->spell_possible_err);
235                                 languages = g_list_append (languages, lang);
236                         } else {
237                                 delete_aspell_config (lang->spell_config);
238                                 g_slice_free (SpellLanguage, lang);
239                         }
240                 }
241
242                 if (strv) {
243                         g_strfreev (strv);
244                 }
245
246                 g_free (str);
247         }
248 }
249
250 const char *
251 empathy_spell_get_language_name (const char *code)
252 {
253         const gchar *name;
254
255         g_return_val_if_fail (code != NULL, NULL);
256
257         if (!iso_code_names) {
258                 spell_iso_code_names_init ();
259         }
260
261         name = g_hash_table_lookup (iso_code_names, code);
262         if (!name) {
263                 return NULL;
264         }
265
266         return dgettext ("iso_639", name);
267 }
268
269 GList *
270 empathy_spell_get_language_codes (void)
271 {
272         AspellConfig              *config;
273         AspellDictInfoList        *dlist;
274         AspellDictInfoEnumeration *dels;
275         const AspellDictInfo      *entry;
276         GList                     *codes = NULL;
277
278         config = new_aspell_config ();
279         dlist = get_aspell_dict_info_list (config);
280         dels = aspell_dict_info_list_elements (dlist);
281
282         while ((entry = aspell_dict_info_enumeration_next (dels)) != 0) {
283                 if (g_list_find_custom (codes, entry->code, (GCompareFunc) strcmp)) {
284                         continue;
285                 }
286
287                 codes = g_list_append (codes, g_strdup (entry->code));
288         }
289
290         delete_aspell_dict_info_enumeration (dels);
291         delete_aspell_config (config);
292
293         return codes;
294 }
295
296 void
297 empathy_spell_free_language_codes (GList *codes)
298 {
299         g_list_foreach (codes, (GFunc) g_free, NULL);
300         g_list_free (codes);
301 }
302
303 gboolean
304 empathy_spell_check (const gchar *word)
305 {
306         GList       *l;
307         gint         n_langs;
308         gboolean     correct = FALSE;
309         gint         len;
310         const gchar *p;
311         gunichar     c;
312         gboolean     digit;
313
314         g_return_val_if_fail (word != NULL, FALSE);
315
316         spell_setup_languages ();
317
318         if (!languages) {
319                 empathy_debug (DEBUG_DOMAIN, "No languages to check against");
320                 return TRUE;
321         }
322
323         /* Ignore certain cases like numbers, etc. */
324         for (p = word, digit = TRUE; *p && digit; p = g_utf8_next_char (p)) {
325                 c = g_utf8_get_char (p);
326                 digit = g_unichar_isdigit (c);
327         }
328
329         if (digit) {
330                 /* We don't spell check digits. */
331                 empathy_debug (DEBUG_DOMAIN, "Not spell checking word:'%s', it is all digits", word);
332                 return TRUE;
333         }
334
335         len = strlen (word);
336         n_langs = g_list_length (languages);
337         for (l = languages; l; l = l->next) {
338                 SpellLanguage *lang;
339
340                 lang = l->data;
341
342                 correct = aspell_speller_check (lang->spell_checker, word, len);
343                 if (n_langs > 1 && correct) {
344                         break;
345                 }
346         }
347
348         return correct;
349 }
350
351 GList *
352 empathy_spell_get_suggestions (const gchar *word)
353 {
354         GList                   *l1;
355         GList                   *l2 = NULL;
356         const AspellWordList    *suggestions;
357         AspellStringEnumeration *elements;
358         const char              *next;
359         gint                     len;
360
361         g_return_val_if_fail (word != NULL, NULL);
362
363         spell_setup_languages ();
364
365         len = strlen (word);
366
367         for (l1 = languages; l1; l1 = l1->next) {
368                 SpellLanguage *lang;
369
370                 lang = l1->data;
371
372                 suggestions = aspell_speller_suggest (lang->spell_checker,
373                                                       word, len);
374
375                 elements = aspell_word_list_elements (suggestions);
376
377                 while ((next = aspell_string_enumeration_next (elements))) {
378                         l2 = g_list_append (l2, g_strdup (next));
379                 }
380
381                 delete_aspell_string_enumeration (elements);
382         }
383
384         return l2;
385 }
386
387 gboolean
388 empathy_spell_supported (void)
389 {
390         if (g_getenv ("EMPATHY_SPELL_DISABLED")) {
391                 empathy_debug (DEBUG_DOMAIN, "EMPATHY_SPELL_DISABLE env variable defined");
392                 return FALSE;
393         }
394
395         return TRUE;
396 }
397
398 #else /* not HAVE_ASPELL */
399
400 gboolean
401 empathy_spell_supported (void)
402 {
403         return FALSE;
404 }
405
406 GList *
407 empathy_spell_get_suggestions (const gchar *word)
408 {
409         empathy_debug (DEBUG_DOMAIN, "Support disabled, could not get suggestions");
410
411         return NULL;
412 }
413
414 gboolean
415 empathy_spell_check (const gchar *word)
416 {
417         empathy_debug (DEBUG_DOMAIN, "Support disabled, could not check spelling");
418
419         return TRUE;
420 }
421
422 const char *
423 empathy_spell_get_language_name (const char *lang)
424 {
425         empathy_debug (DEBUG_DOMAIN, "Support disabled, could not get language name");
426
427         return NULL;
428 }
429
430 GList *
431 empathy_spell_get_language_codes (void)
432 {
433         empathy_debug (DEBUG_DOMAIN, "Support disabled, could not get language codes");
434
435         return NULL;
436 }
437
438 void
439 empathy_spell_free_language_codes (GList *codes)
440 {
441 }
442
443 #endif /* HAVE_ASPELL */
444
445
446 void
447 empathy_spell_free_suggestions (GList *suggestions)
448 {
449         g_list_foreach (suggestions, (GFunc) g_free, NULL);
450         g_list_free (suggestions);
451 }
452