lib/ephy-spell-check.c

   1 /*
   2  *  Copyright © 2006 Christian Persch
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU Lesser General Public License as published by
   6  *  the Free Software Foundation; either version 2.1, or (at your option)
   7  *  any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU Lesser General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU Lesser General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  *  $Id: ephy-spell-check.c 6952 2007-03-11 19:42:02Z chpe $
  19  */
  20
  21 #include "config.h"
  22
  23 #include <string.h>
  24
  25 #include <glib/gi18n.h>
  26
  27 #include <enchant.h>
  28
  29 #include "ephy-debug.h"
  30
  31 #include "ephy-spell-check.h"
  32
  33 #define EPHY_SPELL_CHECK_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_SPELL_CHECK, EphySpellCheckPrivate))
  34
  35 struct _EphySpellCheckPrivate
  36 {
  37         EnchantBroker *broker;
  38         EnchantDict *dict;
  39 };
  40
  41 enum
  42 {
  43         LAST_SIGNAL
  44 };
  45
  46 /* static guint signals[LAST_SIGNAL]; */
  47 static GObjectClass *parent_class;
  48
  49 /* Helper functions */
  50
  51 /* Class implementation */
  52
  53 static void
  54 ephy_spell_check_init (EphySpellCheck *speller)
  55 {
  56         EphySpellCheckPrivate *priv;
  57         const gchar * const *locale;
  58
  59         priv = speller->priv = EPHY_SPELL_CHECK_GET_PRIVATE (speller);
  60
  61         priv->broker = enchant_broker_init ();
  62
  63         /* We don't want to check against C so we get a useful message
  64            in case of no available dictionary */
  65         for (locale = g_get_language_names ();
  66              *locale != NULL && g_ascii_strcasecmp (*locale, "C") != 0;
  67              ++locale)
  68         {
  69                 priv->dict = enchant_broker_request_dict (priv->broker, *locale);
  70                 if (priv->dict != NULL) break;
  71         }
  72         if (priv->dict == NULL)
  73                 g_warning (enchant_broker_get_error (priv->broker));
  74 }
  75
  76 static void
  77 ephy_spell_check_finalize (GObject *object)
  78 {
  79         EphySpellCheck *speller = EPHY_SPELL_CHECK (object);
  80         EphySpellCheckPrivate *priv = speller->priv;
  81
  82
  83         LOG ("EphySpellCheck finalised");
  84
  85         if (priv->dict != NULL)
  86         {
  87                 enchant_broker_free_dict (priv->broker, priv->dict);
  88                 priv->dict = NULL;
  89         }
  90
  91         enchant_broker_free (priv->broker);
  92
  93         parent_class->finalize (object);
  94 }
  95
  96 static void
  97 ephy_spell_check_class_init (EphySpellCheckClass *klass)
  98 {
  99         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 100
 101         parent_class = g_type_class_peek_parent (klass);
 102
 103         object_class->finalize = ephy_spell_check_finalize;
 104
 105 #if 0
 106         signals[CANCEL] =
 107                 g_signal_new ("cancel",
 108                               G_OBJECT_CLASS_TYPE (klass),
 109                               G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 110                               G_STRUCT_OFFSET (EphySpellCheckClass, cancel),
 111                               g_signal_accumulator_true_handled, NULL,
 112                               ephy_marshal_BOOLEAN__VOID,
 113                               G_TYPE_BOOLEAN,
 114                               0);
 115 #endif
 116
 117         g_type_class_add_private (object_class, sizeof (EphySpellCheckPrivate));
 118 }
 119
 120 GType
 121 ephy_spell_check_get_type (void)
 122 {
 123         static GType type = 0;
 124
 125         if (G_UNLIKELY (type == 0))
 126         {
 127                 const GTypeInfo our_info =
 128                 {
 129                         sizeof (EphySpellCheckClass),
 130                         NULL,
 131                         NULL,
 132                         (GClassInitFunc) ephy_spell_check_class_init,
 133                         NULL,
 134                         NULL,
 135                         sizeof (EphySpellCheck),
 136                         0,
 137                         (GInstanceInitFunc) ephy_spell_check_init
 138                 };
 139
 140                 type = g_type_register_static (G_TYPE_OBJECT,
 141                                                "EphySpellCheck",
 142                                                &our_info, 0);
 143         }
 144
 145         return type;
 146 }
 147
 148 /* Public API */
 149
 150 /**
 151  * ephy_spell_check_get_default:
 152  *
 153  * Returns: a reference to the default #EphySpellCheck object
 154  */
 155 EphySpellCheck *
 156 ephy_spell_check_get_default (void)
 157 {
 158         static EphySpellCheck *instance = NULL;
 159
 160         if (instance == NULL)
 161         {
 162                 EphySpellCheck **instanceptr = &instance;
 163
 164                 instance = g_object_new (EPHY_TYPE_SPELL_CHECK, NULL);
 165                 g_object_add_weak_pointer (G_OBJECT (instance),
 166                                            (gpointer) instanceptr);
 167
 168                 return instance;
 169         }
 170
 171         return g_object_ref (instance);
 172 }
 173
 174 int
 175 ephy_spell_check_check_word (EphySpellCheck *speller,
 176                              const char *word,
 177                              gssize len,
 178                              gboolean *correct)
 179 {
 180         EphySpellCheckPrivate *priv = speller->priv;
 181         int result;
 182
 183         g_return_val_if_fail (word != NULL, -1);
 184
 185         if (priv->dict == NULL)
 186                 return FALSE;
 187
 188         if (len < 0)
 189                 len = strlen (word);
 190
 191         result = enchant_dict_check (priv->dict, word, len);
 192         if (result < 0)
 193                 return FALSE;
 194
 195         *correct = result == 0;
 196
 197         return TRUE;
 198 }
 199
 200 char **
 201 ephy_spell_check_get_suggestions (EphySpellCheck *speller,
 202                                   const char *word,
 203                                   gssize len,
 204                                   gsize *_count)
 205 {
 206         EphySpellCheckPrivate *priv = speller->priv;
 207         char **suggestions;
 208         size_t count;
 209
 210         g_return_val_if_fail (word != NULL, NULL);
 211
 212         if (priv->dict == NULL)
 213                 return FALSE;
 214
 215         if (len < 0)
 216                 len = strlen (word);
 217
 218         suggestions =  enchant_dict_suggest (priv->dict, word, len, &count);
 219
 220         *_count = count;
 221         return suggestions;
 222 }
 223
 224 void
 225 ephy_spell_check_free_suggestions (EphySpellCheck *speller,
 226                                    char **suggestions)
 227 {
 228         EphySpellCheckPrivate *priv = speller->priv;
 229
 230         if (suggestions != NULL)
 231         {
 232                 g_return_if_fail (priv->dict != NULL);
 233
 234                 /* FIXME!! What if inbetween there has been a change of dict!? */
 235                 enchant_dict_free_suggestions (priv->dict, suggestions);
 236         }
 237 }
 238
 239 gboolean
 240 ephy_spell_check_set_language (EphySpellCheck *speller,
 241                                const char *lang)
 242 {
 243         EphySpellCheckPrivate *priv = speller->priv;
 244         char *code;
 245
 246         if (priv->dict != NULL)
 247         {
 248                 enchant_broker_free_dict (priv->broker, priv->dict);
 249                 priv->dict = NULL;
 250         }
 251
 252         /* Enchant expects ab_CD codes, not ab-CD */
 253         code = g_strdup (lang);
 254         g_strdelimit (code, "-", '_');
 255         priv->dict = enchant_broker_request_dict (priv->broker, code);
 256         g_free (code);
 257
 258         return priv->dict != NULL;
 259 }
 260
 261 static void
 262 describe_cb (const char * const lang_tag,
 263              const char * const provider_name,
 264              const char * const provider_desc,
 265              const char * const provider_file,
 266              char **_language)
 267 {
 268         *_language = g_strdup (lang_tag);
 269 }
 270
 271 char *
 272 ephy_spell_check_get_language (EphySpellCheck *speller)
 273 {
 274         EphySpellCheckPrivate *priv = speller->priv;
 275         char *code = NULL;
 276
 277         if (priv->dict == NULL) return NULL;
 278
 279         enchant_dict_describe (priv->dict, (EnchantDictDescribeFn) describe_cb, &code);
 280         return code;
 281 }