src/EnchantChecker.cpp

   1 /**
   2  * \file EnchantChecker.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Caolán McNamara
   7  * \author Jürgen Spitzmüller
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include <enchant++.h>
  15
  16 #include "EnchantChecker.h"
  17 #include "LyXRC.h"
  18 #include "WordLangTuple.h"
  19
  20 #include "support/lassert.h"
  21 #include "support/debug.h"
  22 #include "support/docstring_list.h"
  23
  24 #include <map>
  25 #include <string>
  26
  27 using namespace std;
  28
  29 namespace lyx {
  30
  31 namespace {
  32
  33 struct Speller {
  34         enchant::Dict * speller;
  35 };
  36
  37 typedef std::map<std::string, Speller> Spellers;
  38
  39 } // anon namespace
  40
  41 struct EnchantChecker::Private
  42 {
  43         Private() {}
  44
  45         ~Private();
  46
  47         /// add a speller of the given language
  48         enchant::Dict * addSpeller(string const & lang);
  49
  50         ///
  51         enchant::Dict * speller(string const & lang);
  52
  53         /// the spellers
  54         Spellers spellers_;
  55 };
  56
  57
  58 EnchantChecker::Private::~Private()
  59 {
  60         Spellers::iterator it = spellers_.begin();
  61         Spellers::iterator end = spellers_.end();
  62
  63         for (; it != end; ++it) {
  64                 delete it->second.speller;
  65         }
  66 }
  67
  68
  69 enchant::Dict * EnchantChecker::Private::addSpeller(string const & lang)
  70 {
  71         enchant::Broker * instance = enchant::Broker::instance();
  72         enchant::Dict * dict = instance->request_dict(lang);
  73
  74         if (dict) {
  75                 Speller m;
  76                 m.speller = dict;
  77                 spellers_[lang] = m;
  78                 return m.speller;
  79         }
  80         // FIXME error handling?
  81         return 0;
  82 }
  83
  84
  85 enchant::Dict * EnchantChecker::Private::speller(string const & lang)
  86 {
  87         Spellers::iterator it = spellers_.find(lang);
  88         if (it != spellers_.end())
  89                 return it->second.speller;
  90
  91         return addSpeller(lang);
  92 }
  93
  94
  95 EnchantChecker::EnchantChecker(): d(new Private)
  96 {
  97 }
  98
  99
 100 EnchantChecker::~EnchantChecker()
 101 {
 102         delete d;
 103 }
 104
 105
 106 SpellChecker::Result EnchantChecker::check(WordLangTuple const & word)
 107 {
 108         enchant::Dict * m = d->speller(word.lang()->code());
 109
 110         if (!m)
 111                 return OK;
 112
 113         std::string utf8word(to_utf8(word.word()));
 114
 115         if (m->check(utf8word))
 116                 return OK;
 117
 118         return UNKNOWN_WORD;
 119 }
 120
 121
 122 void EnchantChecker::insert(WordLangTuple const & word)
 123 {
 124         Spellers::iterator it = d->spellers_.find(word.lang()->code());
 125         if (it != d->spellers_.end())
 126                 it->second.speller->add(to_utf8(word.word()));
 127 }
 128
 129
 130 void EnchantChecker::accept(WordLangTuple const & word)
 131 {
 132         Spellers::iterator it = d->spellers_.find(word.lang()->code());
 133         if (it != d->spellers_.end())
 134                 it->second.speller->add_to_session(to_utf8(word.word()));
 135 }
 136
 137
 138 void EnchantChecker::suggest(WordLangTuple const & wl,
 139         docstring_list & suggestions)
 140 {
 141         suggestions.clear();
 142         enchant::Dict * m = d->speller(wl.lang()->code());
 143
 144         if (!m)
 145                 return;
 146
 147         string utf8word = to_utf8(wl.word());
 148
 149         vector<string> suggs = m->suggest(utf8word);
 150         vector<string>::const_iterator it = suggs.begin();
 151
 152         for (; it != suggs.end(); ++it)
 153                 suggestions.push_back(from_utf8(*it));
 154 }
 155
 156
 157 docstring const EnchantChecker::error()
 158 {
 159         return docstring();
 160 }
 161
 162
 163 } // namespace lyx