Refactoring: move check for match in spellignore() to buffer params.

[features.git] / src / Paragraph.cpp

diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp
index cd61bb5d24dca576e39ffd64cbe9f1d2db66fdaf..e4ebf8b1f1471c4b366d750aadd45a6ea734d11b 100644 (file)
--- a/src/Paragraph.cpp
+++ b/src/Paragraph.cpp
@@ -460,10 +460,11 @@ public:
                return numskips;
        }
 
-       void markMisspelledWords(pos_type const & first, pos_type const & last,
-                                                        SpellChecker::Result result,
-                                                        docstring const & word,
-                                                        SkipPositions const & skips);
+       void markMisspelledWords(Language const * lang,
+                                pos_type const & first, pos_type const & last,
+                                SpellChecker::Result result,
+                                docstring const & word,
+                                SkipPositions const & skips);
 
        InsetCode ownerCode() const
        {
@@ -4860,7 +4861,9 @@ SpellChecker::Result Paragraph::spellCheck(pos_type & from, pos_type & to,
        docstring word = asString(from, to, AS_STR_INSETS | AS_STR_SKIPDELETE);
        Language * lang = d->getSpellLanguage(from);
 
-       if (getFontSettings(d->inset_owner_->buffer().params(), from).fontInfo().nospellcheck() == FONT_ON)
+       BufferParams const & bparams = d->inset_owner_->buffer().params();
+
+       if (getFontSettings(bparams, from).fontInfo().nospellcheck() == FONT_ON)
                return result;
 
        wl = WordLangTuple(word, lang);
@@ -4872,10 +4875,10 @@ SpellChecker::Result Paragraph::spellCheck(pos_type & from, pos_type & to,
                pos_type end = to;
                if (!d->ignoreWord(word)) {
                        bool const trailing_dot = to < size() && d->text_[to] == '.';
-                       result = speller->check(wl);
+                       result = speller->check(wl, bparams.spellignore());
                        if (SpellChecker::misspelled(result) && trailing_dot) {
                                wl = WordLangTuple(word.append(from_ascii(".")), lang);
-                               result = speller->check(wl);
+                               result = speller->check(wl, bparams.spellignore());
                                if (!SpellChecker::misspelled(result)) {
                                        LYXERR(Debug::GUI, "misspelled word is correct with dot: \"" <<
                                           word << "\" [" <<
@@ -4922,6 +4925,7 @@ void Paragraph::anonymize()
 
 
 void Paragraph::Private::markMisspelledWords(
+       Language const * lang,
        pos_type const & first, pos_type const & last,
        SpellChecker::Result result,
        docstring const & word,
@@ -4943,8 +4947,8 @@ void Paragraph::Private::markMisspelledWords(
                int wlen = 0;
                speller->misspelledWord(index, wstart, wlen);
                /// should not happen if speller supports range checks
-               if (!wlen) continue;
-               docstring const misspelled = word.substr(wstart, wlen);
+               if (!wlen)
+                       continue;
                wstart += first + numskipped;
                if (snext < wstart) {
                        /// mark the range of correct spelling
@@ -4953,12 +4957,22 @@ void Paragraph::Private::markMisspelledWords(
                                wstart - 1, SpellChecker::WORD_OK);
                }
                snext = wstart + wlen;
+               // Check whether the candidate is in the document's local dict
+               WordLangTuple const candidate(word.substr(wstart, wlen), lang);
+               SpellChecker::Result actresult = result;
+               if (inset_owner_->buffer().params().spellignored(candidate))
+                       actresult = SpellChecker::WORD_OK;
                numskipped += countSkips(it, et, snext);
                /// mark the range of misspelling
-               setMisspelled(wstart, snext, result);
-               LYXERR(Debug::GUI, "misspelled word: \"" <<
-                          misspelled << "\" [" <<
-                          wstart << ".." << (snext-1) << "]");
+               setMisspelled(wstart, snext, actresult);
+               if (actresult == SpellChecker::WORD_OK)
+                       LYXERR(Debug::GUI, "local dictionary word: \"" <<
+                                  candidate.word() << "\" [" <<
+                                  wstart << ".." << (snext-1) << "]");
+               else
+                       LYXERR(Debug::GUI, "misspelled word: \"" <<
+                                  candidate.word() << "\" [" <<
+                                  wstart << ".." << (snext-1) << "]");
                ++snext;
        }
        if (snext <= last) {
@@ -4987,9 +5001,10 @@ void Paragraph::spellCheck() const
                        // start the spell checker on the unit of meaning
                        docstring word = asString(first, last, AS_STR_INSETS + AS_STR_SKIPDELETE);
                        WordLangTuple wl = WordLangTuple(word, lang);
+                       BufferParams const & bparams = d->inset_owner_->buffer().params();
                        SpellChecker::Result result = !word.empty() ?
-                               speller->check(wl) : SpellChecker::WORD_OK;
-                       d->markMisspelledWords(first, last, result, word, skips);
+                               speller->check(wl, bparams.spellignore()) : SpellChecker::WORD_OK;
+                       d->markMisspelledWords(lang, first, last, result, word, skips);
                        first = ++last;
                }
        } else {