* src/LaTeXFeatures.cpp: simplify greektext definition. Patch by G. Milde (bug #6458)

[lyx.git] / src / HunspellChecker.cpp

diff --git a/src/HunspellChecker.cpp b/src/HunspellChecker.cpp
index 9e9ea15990f795074cf8777b8f950e4c88397115..e85338ddd4a169d1afbd4172d977d04baded6a31 100644 (file)
--- a/src/HunspellChecker.cpp
+++ b/src/HunspellChecker.cpp
@@ -19,6 +19,7 @@
 
 #include "support/debug.h"
 #include "support/docstring_list.h"
+#include "support/filetools.h"
 #include "support/FileName.h"
 #include "support/gettext.h"
 #include "support/lassert.h"
@@ -29,6 +30,7 @@
 
 #include <map>
 #include <string>
+#include <vector>
 
 using namespace std;
 using namespace lyx::support;
@@ -39,6 +41,7 @@ namespace lyx {
 namespace {
 
 typedef map<std::string, Hunspell *> Spellers;
+typedef vector<WordLangTuple> IgnoreList;
 
 } // anon namespace
 
@@ -48,11 +51,16 @@ struct HunspellChecker::Private
 
        ~Private();
 
+       bool haveDictionary(string const & lang, string & hpath);
        Hunspell * addSpeller(string const & lang);
        Hunspell * speller(string const & lang);
+       /// ignored words
+       bool isIgnored(WordLangTuple const & wl) const;
 
        /// the spellers
        Spellers spellers_;
+       ///
+       IgnoreList ignored_;
 };
 
 
@@ -87,10 +95,9 @@ bool haveLanguageFiles(string const & hpath)
 }
 
 
-Hunspell * HunspellChecker::Private::addSpeller(string const & lang)
+bool HunspellChecker::Private::haveDictionary(string const & lang, string & hunspell_path)
 {
-       string hunspell_path = external_path(lyxrc.hunspelldir_path);
-       LYXERR(Debug::FILES, "hunspell path: " << hunspell_path);
+       LYXERR(Debug::FILES, "hunspell path: " << external_path(hunspell_path));
        if (hunspell_path.empty()) {
                // FIXME We'd like to issue a better error message here, but there seems
                // to be a problem about thread safety, or something of the sort. If
@@ -104,10 +111,10 @@ Hunspell * HunspellChecker::Private::addSpeller(string const & lang)
                        //frontend::Alert::error(_("Hunspell Path Not Found"), 
                        //              _("You must set the Hunspell dictionary path in Tools>Preferences>Paths."));
                }
-               return 0;
+               return false;
        }
 
-       addName(hunspell_path, lang);
+       hunspell_path = external_path(addName(hunspell_path, lang));
        if (!haveLanguageFiles(hunspell_path)) {
                // try with '_' replaced by '-'
                hunspell_path = subst(hunspell_path, '_', '-');
@@ -115,9 +122,20 @@ Hunspell * HunspellChecker::Private::addSpeller(string const & lang)
                        // FIXME: We should indicate somehow that this language is not
                        // supported, probably by popping a warning. But we'll need to
                        // remember which warnings we've issued.
-                       return 0;
+                       return false;
                }
        }
+       return true;
+}
+
+
+Hunspell * HunspellChecker::Private::addSpeller(string const & lang)
+{
+       string hunspell_path = lyxrc.hunspelldir_path;
+
+       if (!haveDictionary(lang, hunspell_path))
+               return 0;
+
        FileName const affix(hunspell_path + ".aff");
        FileName const dict(hunspell_path + ".dic");
        Hunspell * h = new Hunspell(affix.absFilename().c_str(), dict.absFilename().c_str());
@@ -136,6 +154,19 @@ Hunspell * HunspellChecker::Private::speller(string const & lang)
 }
 
 
+bool HunspellChecker::Private::isIgnored(WordLangTuple const & wl) const
+{
+       IgnoreList::const_iterator it = ignored_.begin();
+       for (; it != ignored_.end(); ++it) {
+               if ((*it).lang()->code() != wl.lang()->code())
+                       continue;
+               if ((*it).word() == wl.word())
+                       return true;
+       }
+       return false;
+}
+
+
 HunspellChecker::HunspellChecker(): d(new Private)
 {
 }
@@ -149,11 +180,17 @@ HunspellChecker::~HunspellChecker()
 
 SpellChecker::Result HunspellChecker::check(WordLangTuple const & wl)
 {
-       string const word_to_check = to_utf8(wl.word());
-       Hunspell * h = d->speller(wl.lang_code());
+       if (d->isIgnored(wl))
+               return OK;
+
+       Hunspell * h = d->speller(wl.lang()->code());
        if (!h)
                return OK;
        int info;
+
+       string const encoding = h->get_dic_encoding();
+       string const word_to_check = to_iconv_encoding(wl.word(), encoding);
+       
        if (h->spell(word_to_check.c_str(), &info))
                return OK;
 
@@ -173,16 +210,16 @@ SpellChecker::Result HunspellChecker::check(WordLangTuple const & wl)
 void HunspellChecker::insert(WordLangTuple const & wl)
 {
        string const word_to_check = to_utf8(wl.word());
-       Hunspell * h = d->speller(wl.lang_code());
+       Hunspell * h = d->speller(wl.lang()->code());
        if (!h)
                return;
        h->add(word_to_check.c_str());
 }
 
 
-void HunspellChecker::accept(WordLangTuple const &)
+void HunspellChecker::accept(WordLangTuple const & wl)
 {
-       // FIXME: not implemented!
+       d->ignored_.push_back(wl);
 }
 
 
@@ -190,20 +227,30 @@ void HunspellChecker::suggest(WordLangTuple const & wl,
        docstring_list & suggestions)
 {
        suggestions.clear();
-       string const word_to_check = to_utf8(wl.word());
-       Hunspell * h = d->speller(wl.lang_code());
+       Hunspell * h = d->speller(wl.lang()->code());
        if (!h)
                return;
+       string const encoding = h->get_dic_encoding();
+       string const word_to_check = to_iconv_encoding(wl.word(), encoding);
        char ** suggestion_list;
        int const suggestion_number = h->suggest(&suggestion_list, word_to_check.c_str());
        if (suggestion_number <= 0)
                return;
        for (int i = 0; i != suggestion_number; ++i)
-               suggestions.push_back(from_utf8(suggestion_list[i]));
+               suggestions.push_back(from_iconv_encoding(suggestion_list[i], encoding));
        h->free_list(&suggestion_list, suggestion_number);
 }
 
 
+bool HunspellChecker::hasDictionary(Language const * lang) const
+{
+       if (!lang)
+               return false;
+       string hunspell_path = lyxrc.hunspelldir_path;
+       return (d->haveDictionary(lang->code(), hunspell_path));
+}
+
+
 docstring const HunspellChecker::error()
 {
        return docstring();