};
+/////////////////////////////////////////////////////////////////////
+//
+// SpellResultRange
+//
+/////////////////////////////////////////////////////////////////////
+
+class SpellResultRange {
+public:
+ SpellResultRange(FontSpan range, SpellChecker::Result result)
+ : range_(range), result_(result)
+ {}
+ ///
+ FontSpan const & range() const { return range_; }
+ ///
+ void range(FontSpan const & r) { range_ = r; }
+ ///
+ SpellChecker::Result result() const { return result_; }
+ ///
+ void result(SpellChecker::Result r) { result_ = r; }
+ ///
+ bool inside(pos_type pos) const { return range_.inside(pos); }
+ ///
+ bool covered(FontSpan const & r) const
+ {
+ // 1. first of new range inside current range or
+ // 2. last of new range inside current range or
+ // 3. first of current range inside new range or
+ // 4. last of current range inside new range
+ return range_.inside(r.first) || range_.inside(r.last) ||
+ r.inside(range_.first) || r.inside(range_.last);
+ }
+ ///
+ void shift(pos_type pos, int offset)
+ {
+ if (range_.first > pos) {
+ range_.first += offset;
+ range_.last += offset;
+ } else if (range_.last > pos) {
+ range_.last += offset;
+ }
+ }
+private:
+ FontSpan range_ ;
+ SpellChecker::Result result_ ;
+};
+
+
/////////////////////////////////////////////////////////////////////
//
// SpellCheckerState
{
eraseCoveredRanges(fp);
if (state != SpellChecker::WORD_OK)
- ranges_[fp] = state;
+ ranges_.push_back(SpellResultRange(fp, state));
}
void increasePosAfterPos(pos_type pos)
RangesIterator et = ranges_.end();
RangesIterator it = ranges_.begin();
for (; it != et; ++it) {
- FontSpan fc = it->first;
- if(fc.first <= pos && pos <= fc.last) {
- result = it->second;
- break;
+ if(it->inside(pos)) {
+ return it->result();
}
}
return result;
}
private:
- /// store the ranges as map of FontSpan and spell result pairs
- typedef map<FontSpan, SpellChecker::Result> Ranges;
+ typedef vector<SpellResultRange> Ranges;
typedef Ranges::const_iterator RangesIterator;
Ranges ranges_;
- ///
+ /// the area of the paragraph with pending spell check
FontSpan refresh_;
bool needs_refresh_;
+ /// spell state cache version number
SpellChecker::ChangeNumber current_change_number_;
+
void eraseCoveredRanges(FontSpan const fp)
{
Ranges result;
RangesIterator et = ranges_.end();
RangesIterator it = ranges_.begin();
for (; it != et; ++it) {
- FontSpan fc = it->first;
- // 1. first of new range inside current range or
- // 2. last of new range inside current range or
- // 3. first of current range inside new range or
- // 4. last of current range inside new range
- if (fc.inside(fp.first) || fc.inside(fp.last) ||
- fp.inside(fc.first) || fp.inside(fc.last))
- {
- continue;
- }
- result[fc] = it->second;
+ if (!it->covered(fp))
+ result.push_back(SpellResultRange(it->range(), it->result()));
}
ranges_ = result;
}
void correctRangesAfterPos(pos_type pos, int offset)
{
- Ranges result;
RangesIterator et = ranges_.end();
- RangesIterator it = ranges_.begin();
+ Ranges::iterator it = ranges_.begin();
for (; it != et; ++it) {
- FontSpan m = it->first;
- if (m.first > pos) {
- m.first += offset;
- m.last += offset;
- } else if (m.last > pos) {
- m.last += offset;
- }
- result[m] = it->second;
+ it->shift(pos, offset);
}
- ranges_ = result;
}
};
return result;
locateWord(from, to, WHOLE_WORD);
- if (from == to || from >= pos_type(d->text_.size()))
+ if (from == to || from >= size())
return result;
docstring word = asString(from, to, AS_STR_INSETS);
// Ignore words with digits
// FIXME: make this customizable
// (note that some checkers ignore words with digits by default)
- if (!hasDigit(word))
+ if (!hasDigit(word)) {
+ bool const trailing_dot = to < size() && d->text_[to] == '.';
result = speller->check(wl);
+ if (SpellChecker::misspelled(result) && trailing_dot) {
+ wl = WordLangTuple(word.append(from_ascii(".")), lang);
+ result = speller->check(wl);
+ if (!SpellChecker::misspelled(result)) {
+ LYXERR(Debug::GUI, "misspelled word is correct with dot: \"" <<
+ word << "\" [" <<
+ from << ".." << to << "]");
+ }
+ }
+ }
d->setMisspelled(from, to, result);
} else {
result = d->speller_state_.getState(from);