#include "insets/InsetBibitem.h"
#include "insets/InsetLabel.h"
+#include "insets/InsetSpecialChar.h"
#include "support/debug.h"
#include "support/docstring_list.h"
namespace {
/// Inset identifier (above 0x10ffff, for ucs-4)
char_type const META_INSET = 0x200001;
+}
+
+
+/////////////////////////////////////////////////////////////////////
+//
+// 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_ ;
};
{
eraseCoveredRanges(fp);
if (state != SpellChecker::WORD_OK)
- ranges_[fp] = state;
+ ranges_.push_back(SpellResultRange(fp, state));
}
void increasePosAfterPos(pos_type pos)
needsRefresh(pos);
}
+ void refreshLast(pos_type pos)
+ {
+ if (pos < refresh_.last)
+ refresh_.last = pos;
+ }
+
SpellChecker::Result getState(pos_type pos) const
{
SpellChecker::Result result = SpellChecker::WORD_OK;
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;
}
+ FontSpan const & getRange(pos_type pos) const
+ {
+ /// empty span to indicate mismatch
+ static FontSpan empty_;
+ RangesIterator et = ranges_.end();
+ RangesIterator it = ranges_.begin();
+ for (; it != et; ++it) {
+ if(it->inside(pos)) {
+ return it->range();
+ }
+ }
+ return empty_;
+ }
+
bool needsRefresh() const {
return needs_refresh_;
}
}
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;
}
};
/// match a string against a particular point in the paragraph
bool isTextAt(string const & str, pos_type pos) const;
- /// a vector of inset positions
- typedef vector<pos_type> Positions;
- typedef Positions::const_iterator PositionsIterator;
+ /// a vector of speller skip positions
+ typedef vector<FontSpan> SkipPositions;
+ typedef SkipPositions::const_iterator SkipPositionsIterator;
+ void appendSkipPosition(SkipPositions & skips, pos_type const pos) const;
+
Language * getSpellLanguage(pos_type const from) const;
Language * locateSpellRange(pos_type & from, pos_type & to,
- Positions & softbreaks) const;
+ SkipPositions & skips) const;
bool hasSpellerChange() const {
SpellChecker::ChangeNumber speller_change_number = 0;
return speller_change_number > speller_state_.currentChangeNumber();
}
+ bool ignoreWord(docstring const & word) const ;
+
void setMisspelled(pos_type from, pos_type to, SpellChecker::Result state)
{
pos_type textsize = owner_->size();
last = endpos;
}
- int countSoftbreaks(PositionsIterator & it, PositionsIterator const et,
+ int countSkips(SkipPositionsIterator & it, SkipPositionsIterator const et,
int & start) const
{
- int numbreaks = 0;
- while (it != et && *it < start) {
- ++start;
- ++numbreaks;
+ int numskips = 0;
+ while (it != et && it->first < start) {
+ int skip = it->last - it->first + 1;
+ start += skip;
+ numskips += skip;
++it;
}
- return numbreaks;
+ return numskips;
}
void markMisspelledWords(pos_type const & first, pos_type const & last,
SpellChecker::Result result,
docstring const & word,
- Positions const & softbreaks);
+ SkipPositions const & skips);
InsetCode ownerCode() const
{
: owner_(owner), inset_owner_(p.inset_owner_), fontlist_(p.fontlist_),
params_(p.params_), changes_(p.changes_), insetlist_(p.insetlist_),
begin_of_body_(p.begin_of_body_), text_(p.text_), words_(p.words_),
- layout_(p.layout_), speller_state_(p.speller_state_)
+ layout_(p.layout_)
{
id_ = ++paragraph_id;
requestSpellCheck(p.text_.size());
params_(p.params_), changes_(p.changes_),
insetlist_(p.insetlist_, beg, end),
begin_of_body_(p.begin_of_body_), words_(p.words_),
- layout_(p.layout_), speller_state_(p.speller_state_)
+ layout_(p.layout_)
{
id_ = ++paragraph_id;
if (beg >= pos_type(p.text_.size()))
if (!change.changed() ||
(change.inserted() && !change.currentAuthor())) {
setChange(pos, Change(Change::DELETED));
+ // request run of spell checker
+ requestSpellCheck(pos);
return false;
}
// Update list of misspelled positions
d->speller_state_.decreasePosAfterPos(pos);
+ d->speller_state_.refreshLast(size());
return true;
}
texrow.start(owner_->id(), i + 1);
column = 0;
} else {
- column += os.tellp() - len;
+ column += (unsigned int)(os.tellp() - len);
}
if (owner_->isDeleted(i))
void Paragraph::Private::validate(LaTeXFeatures & features) const
{
if (layout_->inpreamble && inset_owner_) {
+ bool const is_command = layout_->latextype == LATEX_COMMAND;
Buffer const & buf = inset_owner_->buffer();
BufferParams const & bp = buf.params();
Font f;
TexRow tr;
+ // Using a string stream here circumvents the encoding
+ // switching machinery of odocstream. Therefore the
+ // output is wrong if this paragraph contains content
+ // that needs to switch encoding.
odocstringstream ods;
- // we have to provide all the optional arguments here, even though
- // the last one is the only one we care about.
+ if (is_command) {
+ ods << '\\' << from_ascii(layout_->latexname());
+ // we have to provide all the optional arguments here, even though
+ // the last one is the only one we care about.
+ // Separate handling of optional argument inset.
+ if (layout_->optargs != 0 || layout_->reqargs != 0)
+ latexArgInsets(*owner_, ods, features.runparams(),
+ layout_->reqargs, layout_->optargs);
+ else
+ ods << from_ascii(layout_->latexparam());
+ }
+ docstring::size_type const length = ods.str().length();
+ // this will output "{" at the beginning, but not at the end
owner_->latex(bp, f, ods, tr, features.runparams(), 0, -1, true);
- docstring const d = ods.str();
- if (!d.empty()) {
- // this will have "{" at the beginning, but not at the end
- string const content = to_utf8(d);
- string const cmd = layout_->latexname();
- features.addPreambleSnippet("\\" + cmd + content + "}");
+ if (ods.str().length() > length) {
+ if (is_command)
+ ods << '}';
+ string const snippet = to_utf8(ods.str());
+ features.addPreambleSnippet(snippet);
}
}
open_font = false;
}
+ string const running_lang = runparams.use_polyglossia ?
+ running_font.language()->polyglossia() : running_font.language()->babel();
// close babel's font environment before opening CJK.
- if (!running_font.language()->babel().empty() &&
+ string const lang_end_command = runparams.use_polyglossia ?
+ "\\end{$$lang}" : lyxrc.language_command_end;
+ if (!running_lang.empty() &&
font.language()->encoding()->package() == Encoding::CJK) {
- string end_tag = subst(lyxrc.language_command_end,
+ string end_tag = subst(lang_end_command,
"$$lang",
- running_font.language()->babel());
+ running_lang);
os << from_ascii(end_tag);
column += end_tag.length();
}
if (allowcust && d->endTeXParParams(bparams, os, texrow, runparams)
&& runparams.encoding != prev_encoding) {
runparams.encoding = prev_encoding;
- if (!bparams.useXetex)
+ if (!runparams.isFullUnicode())
os << setEncoding(prev_encoding->iconvName());
}
Inset const * inset = getInset(i);
if (inset) {
- InsetCommand const * ic = inset->asInsetCommand();
- InsetLayout const & il = inset->getLayout();
- InsetMath const * im = inset->asInsetMath();
- if (!runparams.for_toc
- || im || il.isInToc() || (ic && ic->isInToc())) {
+ if (!runparams.for_toc || inset->isInToc()) {
OutputParams np = runparams;
- if (!il.htmlisblock())
+ if (!inset->getLayout().htmlisblock())
np.html_in_par = true;
retval += inset->xhtml(xs, np);
}
// We don't want to escape the entities. Note that
// it is safe to do this, since str can otherwise
// only be "-". E.g., it can't be "<".
- xs << XHTMLStream::NextRaw() << str;
+ xs << XHTMLStream::ESCAPE_NONE << str;
} else
xs << c;
}
char_type const c = d->text_[pos];
// We want to pass the ' and escape chars to the spellchecker
static docstring const quote = from_utf8(lyxrc.spellchecker_esc_chars + '\'');
- return (!isLetterChar(c) && !isDigit(c) && !contains(quote, c))
+ return (!isLetterChar(c) && !isDigitASCII(c) && !contains(quote, c))
|| pos == size();
}
+bool Paragraph::isSameSpellRange(pos_type pos1, pos_type pos2) const
+{
+ return pos1 == pos2
+ || d->speller_state_.getRange(pos1) == d->speller_state_.getRange(pos2);
+}
+
+
bool Paragraph::isChar(pos_type pos) const
{
if (Inset const * inset = getInset(pos))
return inset->isChar();
char_type const c = d->text_[pos];
- return !isLetterChar(c) && !isDigit(c) && !lyx::isSpace(c);
+ return !isLetterChar(c) && !isDigitASCII(c) && !lyx::isSpace(c);
}
os << d->params_.labelString() << ' ';
for (pos_type i = beg; i < end; ++i) {
+ if ((options & AS_STR_SKIPDELETE) && isDeleted(i))
+ continue;
char_type const c = d->text_[i];
if (isPrintable(c) || c == '\t'
|| (c == '\n' && (options & AS_STR_NEWLINES)))
os.put(c);
else if (c == META_INSET && (options & AS_STR_INSETS)) {
- getInset(i)->tocString(os);
+ getInset(i)->toString(os);
if (getInset(i)->asInsetMath())
os << " ";
}
}
+void Paragraph::forToc(docstring & os, size_t maxlen) const
+{
+ if (!d->params_.labelString().empty())
+ os += d->params_.labelString() + ' ';
+ for (pos_type i = 0; i < size() && os.length() < maxlen; ++i) {
+ if (isDeleted(i))
+ continue;
+ char_type const c = d->text_[i];
+ if (isPrintable(c))
+ os += c;
+ else if (c == '\t' || c == '\n')
+ os += ' ';
+ else if (c == META_INSET)
+ getInset(i)->forToc(os, maxlen);
+ }
+}
+
+
docstring Paragraph::stringify(pos_type beg, pos_type end, int options, OutputParams & runparams) const
{
odocstringstream os;
{
// FIXME From JS:
// This is getting more and more a mess. ...We really should clean
- // up this bibitem issue for 1.6. See also bug 2743.
+ // up this bibitem issue for 1.6.
// Add bibitem insets if necessary
if (d->layout_->labeltype != LABEL_BIBLIO)
InsetList::iterator end = d->insetlist_.end();
for (; it != end; ++it)
if (it->inset->lyxCode() == BIBITEM_CODE
- && it->pos > 0) {
- InsetBibitem * olditem = static_cast<InsetBibitem *>(it->inset);
+ && it->pos > 0) {
+ InsetCommand * olditem = it->inset->asInsetCommand();
oldkey = olditem->getParam("key");
oldlabel = olditem->getParam("label");
erasedInsetPosition = it->pos;
// There was an InsetBibitem at the beginning and we did have to
// erase one. So we give its properties to the beginning inset.
if (hasbibitem) {
- InsetBibitem * inset =
- static_cast<InsetBibitem *>(d->insetlist_.begin()->inset);
+ InsetCommand * inset = d->insetlist_.begin()->inset->asInsetCommand();
if (!oldkey.empty())
inset->setParam("key", oldkey);
inset->setParam("label", oldlabel);
if (!oldkey.empty())
inset->setParam("key", oldkey);
inset->setParam("label", oldlabel);
- insertInset(0, static_cast<Inset *>(inset),
+ insertInset(0, inset,
Change(track_changes ? Change::INSERTED : Change::UNCHANGED));
return 1;
}
-bool Paragraph::find(docstring const & str, bool cs, bool mw,
- pos_type pos, bool del) const
+int Paragraph::find(docstring const & str, bool cs, bool mw,
+ pos_type start_pos, bool del) const
{
+ pos_type pos = start_pos;
int const strsize = str.length();
int i = 0;
pos_type const parsize = d->text_.size();
- for (i = 0; pos + i < parsize; ++i) {
- if (i >= strsize)
- break;
- if (cs && str[i] != d->text_[pos + i])
+ for (i = 0; i < strsize && pos < parsize; ++i, ++pos) {
+ // Ignore ligature break and hyphenation chars while searching
+ while (pos < parsize - 1 && isInset(pos)) {
+ const InsetSpecialChar *isc = dynamic_cast<const InsetSpecialChar*>(getInset(pos));
+ if (isc == 0
+ || (isc->kind() != InsetSpecialChar::HYPHENATION
+ && isc->kind() != InsetSpecialChar::LIGATURE_BREAK))
+ break;
+ pos++;
+ }
+ if (cs && str[i] != d->text_[pos])
break;
- if (!cs && uppercase(str[i]) != uppercase(d->text_[pos + i]))
+ if (!cs && uppercase(str[i]) != uppercase(d->text_[pos]))
break;
- if (!del && isDeleted(pos + i))
+ if (!del && isDeleted(pos))
break;
}
if (i != strsize)
- return false;
+ return 0;
// if necessary, check whether string matches word
if (mw) {
- if (pos > 0 && !isWordSeparator(pos - 1))
- return false;
- if (pos + strsize < parsize
- && !isWordSeparator(pos + strsize))
- return false;
+ if (start_pos > 0 && !isWordSeparator(start_pos - 1))
+ return 0;
+ if (pos < parsize
+ && !isWordSeparator(pos))
+ return 0;
}
- return true;
+ return pos - start_pos;
}
}
+void Paragraph::Private::appendSkipPosition(SkipPositions & skips, pos_type const pos) const
+{
+ SkipPositionsIterator begin = skips.begin();
+ SkipPositions::iterator end = skips.end();
+ if (pos > 0 && begin < end) {
+ --end;
+ if (end->last == pos - 1) {
+ end->last = pos;
+ return;
+ }
+ }
+ skips.insert(end, FontSpan(pos, pos));
+}
+
+
Language * Paragraph::Private::locateSpellRange(
pos_type & from, pos_type & to,
- Positions & softbreaks) const
+ SkipPositions & skips) const
{
// skip leading white space
while (from < to && owner_->isWordSeparator(from))
// hop to end of word
while (last < to && !owner_->isWordSeparator(last)) {
if (owner_->getInset(last)) {
- softbreaks.insert(softbreaks.end(), last);
+ appendSkipPosition(skips, last);
+ } else if (owner_->isDeleted(last)) {
+ appendSkipPosition(skips, last);
}
++last;
}
while (sameinset && last < to && owner_->isWordSeparator(last)) {
if (Inset const * inset = owner_->getInset(last))
sameinset = inset->isChar() && inset->isLetter();
+ if (sameinset && owner_->isDeleted(last)) {
+ appendSkipPosition(skips, last);
+ }
if (sameinset)
last++;
}
}
+bool Paragraph::Private::ignoreWord(docstring const & word) const
+{
+ // Ignore words with digits
+ // FIXME: make this customizable
+ // (note that some checkers ignore words with digits by default)
+ docstring::const_iterator cit = word.begin();
+ docstring::const_iterator const end = word.end();
+ for (; cit != end; ++cit) {
+ if (isNumber((*cit)))
+ return true;
+ }
+ return false;
+}
+
+
SpellChecker::Result Paragraph::spellCheck(pos_type & from, pos_type & to,
WordLangTuple & wl, docstring_list & suggestions,
bool do_suggestion, bool check_learned) const
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);
+ docstring word = asString(from, to, AS_STR_INSETS | AS_STR_SKIPDELETE);
Language * lang = d->getSpellLanguage(from);
wl = WordLangTuple(word, lang);
return result;
if (needsSpellCheck() || check_learned) {
- // Ignore words with digits
- // FIXME: make this customizable
- // (note that some checkers ignore words with digits by default)
- if (!hasDigit(word))
+ if (!d->ignoreWord(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 << "]");
+ } else {
+ // spell check with dot appended failed
+ // restore original word/lang value
+ word = asString(from, to, AS_STR_INSETS | AS_STR_SKIPDELETE);
+ wl = WordLangTuple(word, lang);
+ }
+ }
+ }
d->setMisspelled(from, to, result);
} else {
result = d->speller_state_.getState(from);
pos_type const & first, pos_type const & last,
SpellChecker::Result result,
docstring const & word,
- Positions const & softbreaks)
+ SkipPositions const & skips)
{
if (!SpellChecker::misspelled(result)) {
setMisspelled(first, last, SpellChecker::WORD_OK);
SpellChecker * speller = theSpellChecker();
// locate and enumerate the error positions
int nerrors = speller->numMisspelledWords();
- int numbreaks = 0;
- PositionsIterator it = softbreaks.begin();
- PositionsIterator et = softbreaks.end();
+ int numskipped = 0;
+ SkipPositionsIterator it = skips.begin();
+ SkipPositionsIterator et = skips.end();
for (int index = 0; index < nerrors; ++index) {
int wstart;
int wlen = 0;
/// should not happen if speller supports range checks
if (!wlen) continue;
docstring const misspelled = word.substr(wstart, wlen);
- wstart += first + numbreaks;
+ wstart += first + numskipped;
if (snext < wstart) {
/// mark the range of correct spelling
- numbreaks += countSoftbreaks(it, et, wstart);
+ numskipped += countSkips(it, et, wstart);
setMisspelled(snext,
wstart - 1, SpellChecker::WORD_OK);
}
snext = wstart + wlen;
- numbreaks += countSoftbreaks(it, et, snext);
+ numskipped += countSkips(it, et, snext);
/// mark the range of misspelling
setMisspelled(wstart, snext, result);
LYXERR(Debug::GUI, "misspelled word: \"" <<
// loop until we leave the range
for (pos_type first = start; first < endpos; ) {
pos_type last = endpos;
- Private::Positions softbreaks;
- Language * lang = d->locateSpellRange(first, last, softbreaks);
+ Private::SkipPositions skips;
+ Language * lang = d->locateSpellRange(first, last, skips);
if (first >= endpos)
break;
// start the spell checker on the unit of meaning
- docstring word = asString(first, last, AS_STR_INSETS);
+ docstring word = asString(first, last, AS_STR_INSETS + AS_STR_SKIPDELETE);
WordLangTuple wl = WordLangTuple(word, lang);
SpellChecker::Result result = word.size() ?
speller->check(wl) : SpellChecker::WORD_OK;
- d->markMisspelledWords(first, last, result, word, softbreaks);
+ d->markMisspelledWords(first, last, result, word, skips);
first = ++last;
}
} else {
projects / lyx.git / blobdiff