Cmake build:

[lyx.git] / src / AspellChecker.cpp

diff --git a/src/AspellChecker.cpp b/src/AspellChecker.cpp
index 7772bb70d6d49c33ef395d4808d36db7ea825c76..a03dc65759defa19989f3df214ba54fca73ead42 100644 (file)
--- a/src/AspellChecker.cpp
+++ b/src/AspellChecker.cpp
@@ -19,6 +19,7 @@
 
 #include "support/lassert.h"
 #include "support/debug.h"
+#include "support/lstrings.h"
 #include "support/docstring_list.h"
 
 #include "support/filetools.h"
@@ -41,6 +42,7 @@ namespace {
 struct Speller {
        AspellConfig * config;
        AspellCanHaveError * e_speller;
+       bool accept_compound;
        docstring_list ignored_words_;
 };
 
@@ -63,6 +65,7 @@ struct AspellChecker::Private
 
        bool isValidDictionary(AspellConfig * config,
                        string const & lang, string const & variety);
+       int numDictionaries() const;
        bool checkAspellData(AspellConfig * config,
                string const & basepath, string const & datapath, string const & dictpath,
                string const & lang, string const & variety);
@@ -264,6 +267,7 @@ AspellSpeller * AspellChecker::Private::addSpeller(Language const * lang)
                // Report run-together words as errors
                aspell_config_replace(m.config, "run-together", "false");
 
+       m.accept_compound = lyxrc.spellchecker_accept_compound;
        m.e_speller = new_aspell_speller(m.config);
        if (aspell_error_number(m.e_speller) != 0) {
                // FIXME: We should indicate somehow that this language is not supported.
@@ -287,23 +291,72 @@ AspellSpeller * AspellChecker::Private::addSpeller(Language const * lang)
 AspellSpeller * AspellChecker::Private::speller(Language const * lang)
 {
        Spellers::iterator it = spellers_.find(lang->lang());
-       if (it != spellers_.end())
-               return to_aspell_speller(it->second.e_speller);
-       
+       if (it != spellers_.end()) {
+               Speller aspell = it->second;
+               if (lyxrc.spellchecker_accept_compound != aspell.accept_compound) {
+                       // spell checker setting changed... adjust run-together
+                       aspell.accept_compound = lyxrc.spellchecker_accept_compound;
+                       if (aspell.accept_compound)
+                               // Consider run-together words as legal compounds
+                               aspell_config_replace(aspell.config, "run-together", "true");
+                       else
+                               // Report run-together words as errors
+                               aspell_config_replace(aspell.config, "run-together", "false");
+                       AspellCanHaveError * e_speller = aspell.e_speller;
+                       aspell.e_speller = new_aspell_speller(aspell.config);
+                       delete_aspell_speller(to_aspell_speller(e_speller));
+                       spellers_[lang->lang()] = aspell;
+               }
+               return to_aspell_speller(aspell.e_speller);
+       }
+
        return addSpeller(lang);
 }
 
- 
+
+int AspellChecker::Private::numDictionaries() const
+{
+       int result = 0;
+       Spellers::const_iterator it = spellers_.begin();
+       Spellers::const_iterator et = spellers_.end();
+
+       for (; it != et; ++it) {
+               Speller aspell = it->second;
+               result += aspell.e_speller != 0;
+       }
+       return result;
+}
+
+
 string AspellChecker::Private::toAspellWord(docstring const & word) const
 {
-       return to_utf8(word);
+       size_t mpos;
+       string word_str = to_utf8(word);
+       while ((mpos = word_str.find('-')) != word_str.npos) {
+               word_str.erase(mpos, 1);
+       }
+       return word_str;
 }
 
- 
+
 SpellChecker::Result AspellChecker::Private::check(
        AspellSpeller * m, WordLangTuple const & word) 
        const
 {
+       SpellChecker::Result result = WORD_OK;
+       docstring w1;
+       docstring rest = split(word.word(), w1, '-');
+       for (; result == WORD_OK;) {
+               string const word_str = toAspellWord(w1);
+               int const word_ok = aspell_speller_check(m, word_str.c_str(), -1);
+               LASSERT(word_ok != -1, /**/);
+               result = (word_ok) ? WORD_OK : UNKNOWN_WORD;
+               if (rest.empty())
+                       break;
+               rest = split(rest,w1,'-');
+       }
+       if (result == WORD_OK)
+               return result;
        string const word_str = toAspellWord(word.word());
        int const word_ok = aspell_speller_check(m, word_str.c_str(), -1);
        LASSERT(word_ok != -1, /**/);
@@ -368,7 +421,7 @@ SpellChecker::Result AspellChecker::check(WordLangTuple const & word)
        AspellSpeller * m = d->speller(word.lang());
 
        if (!m)
-               return WORD_OK;
+               return NO_DICTIONARY;
 
        if (word.word().empty())
                // MSVC compiled Aspell doesn't like it.
@@ -456,6 +509,12 @@ bool AspellChecker::hasDictionary(Language const * lang) const
 }
 
 
+int AspellChecker::numDictionaries() const
+{
+       return d->numDictionaries();
+}
+       
+       
 docstring const AspellChecker::error()
 {
        Spellers::iterator it = d->spellers_.begin();