Whitespace

[lyx.git] / src / HunspellChecker.cpp

diff --git a/src/HunspellChecker.cpp b/src/HunspellChecker.cpp
index 2105e7b93f84fff912d3e8e0d8f8a96262eaa055..a2d2c95e05250c6976d25bdef81f57e42faac338 100644 (file)
--- a/src/HunspellChecker.cpp
+++ b/src/HunspellChecker.cpp
@@ -55,10 +55,13 @@ struct HunspellChecker::Private
        Private();
        ~Private();
 
+       void cleanCache();
+       void setUserPath(std::string path);
        const string dictPath(int selector);
        bool haveLanguageFiles(string const & hpath);
        bool haveDictionary(Language const * lang, string & hpath);
        bool haveDictionary(Language const * lang);
+       int numDictionaries() const;
        Hunspell * addSpeller(Language const * lang, string & hpath);
        Hunspell * addSpeller(Language const * lang);
        Hunspell * speller(Language const * lang);
@@ -74,26 +77,53 @@ struct HunspellChecker::Private
        IgnoreList ignored_;
        ///
        LangPersonalWordList personal_;
+       ///
+       std::string user_path_;
 
        /// the location below system/user directory
        /// there the aff+dic files lookup will happen
        const string dictDirectory(void) const { return "dicts"; }
-       int maxLookupSelector(void) const { return 3; }
+       int maxLookupSelector(void) const { return 4; }
+       const string HunspellDictionaryName(Language const * lang) {
+               return lang->variety().empty() 
+                       ? lang->code()
+                       : lang->code() + "-" + lang->variety();
+       }
+       const string osPackageDictDirectory(void) {
+               return "/usr/share/myspell";
+       }
 };
 
 
 HunspellChecker::Private::Private()
 {
+       setUserPath(lyxrc.hunspelldir_path);
 }
 
 
 HunspellChecker::Private::~Private()
+{
+       cleanCache();
+}
+
+
+void HunspellChecker::Private::setUserPath(std::string path)
+{
+       if (user_path_ != lyxrc.hunspelldir_path) {
+               cleanCache();
+               user_path_ = path;
+       }
+}
+
+
+void HunspellChecker::Private::cleanCache()
 {
        Spellers::iterator it = spellers_.begin();
        Spellers::iterator end = spellers_.end();
 
        for (; it != end; ++it) {
-               if ( 0 != it->second) delete it->second;
+               delete it->second;
+               it->second = 0;
        }
 
        LangPersonalWordList::const_iterator pdit = personal_.begin();
@@ -120,6 +150,9 @@ bool HunspellChecker::Private::haveLanguageFiles(string const & hpath)
 const string HunspellChecker::Private::dictPath(int selector)
 {
        switch (selector) {
+       case 3:
+               return addName(osPackageDictDirectory(),dictDirectory());
+               break;
        case 2:
                return addName(package().system_support().absFileName(),dictDirectory());
                break;
@@ -127,7 +160,7 @@ const string HunspellChecker::Private::dictPath(int selector)
                return addName(package().user_support().absFileName(),dictDirectory());
                break;
        default:
-               return lyxrc.hunspelldir_path;
+               return user_path_;
        }
 }
 
@@ -138,24 +171,22 @@ bool HunspellChecker::Private::haveDictionary(Language const * lang, string & hp
                return false;
        }
 
-       LYXERR(Debug::FILES, "check hunspell path: " << hpath << " for language " << lang);
-       string h_path = addName(hpath, lang->code() + "-" + lang->variety());
+       LYXERR(Debug::FILES, "check hunspell path: " << hpath
+                               << " for language " << (lang ? lang->lang() : "NULL" ));
+
+       string h_path = addName(hpath, HunspellDictionaryName(lang));
        // first we try lang code+variety
-       if (!lang->variety().empty() && haveLanguageFiles(h_path)) {
-               hpath = h_path;
-               return true;
-       }
-       // next we try lang code only
-       h_path = addName(hpath, lang->code());
        if (haveLanguageFiles(h_path)) {
+               LYXERR(Debug::FILES, "  found " << h_path);
                hpath = h_path;
                return true;
        }
-       // last try with '_' replaced by '-'
+       // another try with code, '_' replaced by '-'
        h_path = addName(hpath, subst(lang->code(), '_', '-'));
        if (!haveLanguageFiles(h_path)) {
                return false;
        }
+       LYXERR(Debug::FILES, "  found " << h_path);
        hpath = h_path;
        return true;
 }
@@ -164,6 +195,8 @@ bool HunspellChecker::Private::haveDictionary(Language const * lang, string & hp
 bool HunspellChecker::Private::haveDictionary(Language const * lang)
 {
        bool result = false;
+
+       setUserPath(lyxrc.hunspelldir_path);
        for ( int p = 0; !result && p < maxLookupSelector(); p++ ) {
                string lpath = dictPath(p);
                result = haveDictionary(lang, lpath);
@@ -178,10 +211,11 @@ bool HunspellChecker::Private::haveDictionary(Language const * lang)
 
 Hunspell * HunspellChecker::Private::speller(Language const * lang)
 {
-       Spellers::iterator it = spellers_.find(lang->id());
-       if (it != spellers_.end())
+       setUserPath(lyxrc.hunspelldir_path);
+       Spellers::iterator it = spellers_.find(lang->lang());
+       if (it != spellers_.end()) {
                return it->second;
-
+       }
        return addSpeller(lang);
 }
 
@@ -189,7 +223,7 @@ Hunspell * HunspellChecker::Private::speller(Language const * lang)
 Hunspell * HunspellChecker::Private::addSpeller(Language const * lang,string & path)
 {
        if (!haveDictionary(lang, path)) {
-               spellers_[lang->id()] = 0;
+               spellers_[lang->lang()] = 0;
                return 0;
        }
 
@@ -197,7 +231,7 @@ Hunspell * HunspellChecker::Private::addSpeller(Language const * lang,string & p
        FileName const dict(path + ".dic");
        Hunspell * h = new Hunspell(affix.absFileName().c_str(), dict.absFileName().c_str());
        LYXERR(Debug::FILES, "Hunspell speller for langage " << lang << " at " << dict << " found");
-       spellers_[lang->id()] = h;
+       spellers_[lang->lang()] = h;
        return h;
 }
 
@@ -225,6 +259,19 @@ Hunspell * HunspellChecker::Private::addSpeller(Language const * lang)
 }
 
 
+int HunspellChecker::Private::numDictionaries() const
+{
+       int result = 0;
+       Spellers::const_iterator it = spellers_.begin();
+       Spellers::const_iterator et = spellers_.end();
+
+       for (; it != et; ++it) {
+               result += it->second != 0;
+       }
+       return result;
+}
+
+
 bool HunspellChecker::Private::isIgnored(WordLangTuple const & wl) const
 {
        IgnoreList::const_iterator it = ignored_.begin();
@@ -295,7 +342,7 @@ SpellChecker::Result HunspellChecker::check(WordLangTuple const & wl)
 
        Hunspell * h = d->speller(wl.lang());
        if (!h)
-               return WORD_OK;
+               return NO_DICTIONARY;
        int info;
 
        string const encoding = h->get_dic_encoding();
@@ -366,6 +413,25 @@ void HunspellChecker::suggest(WordLangTuple const & wl,
 }
 
 
+void HunspellChecker::stem(WordLangTuple const & wl,
+       docstring_list & suggestions)
+{
+       suggestions.clear();
+       Hunspell * h = d->speller(wl.lang());
+       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->stem(&suggestion_list, word_to_check.c_str());
+       if (suggestion_number <= 0)
+               return;
+       for (int i = 0; i != suggestion_number; ++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)
@@ -374,6 +440,12 @@ bool HunspellChecker::hasDictionary(Language const * lang) const
 }
 
 
+int HunspellChecker::numDictionaries() const
+{
+       return d->numDictionaries();
+}
+
+
 docstring const HunspellChecker::error()
 {
        return docstring();