X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FParagraph.cpp;h=67965ef4c5950da18f47d9143db248161b87d68b;hb=68fe13dfa1ed24891d930b0d9b8b79e217c7f1e4;hp=9faead6ef58639e9ca981fb5acf1d1b26b163723;hpb=d205cd4b68ba171b943e1f1c3c6c16c736fff295;p=lyx.git diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp index 9faead6ef5..67965ef4c5 100644 --- a/src/Paragraph.cpp +++ b/src/Paragraph.cpp @@ -51,6 +51,7 @@ #include "insets/InsetBibitem.h" #include "insets/InsetLabel.h" +#include "insets/InsetSpecialChar.h" #include "support/debug.h" #include "support/docstring_list.h" @@ -71,6 +72,186 @@ namespace lyx { 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_ ; +}; + + +///////////////////////////////////////////////////////////////////// +// +// SpellCheckerState +// +///////////////////////////////////////////////////////////////////// + +class SpellCheckerState { +public: + SpellCheckerState() { + needs_refresh_ = true; + current_change_number_ = 0; + } + + void setRange(FontSpan const fp, SpellChecker::Result state) + { + eraseCoveredRanges(fp); + if (state != SpellChecker::WORD_OK) + ranges_.push_back(SpellResultRange(fp, state)); + } + + void increasePosAfterPos(pos_type pos) + { + correctRangesAfterPos(pos, 1); + needsRefresh(pos); + } + + void decreasePosAfterPos(pos_type pos) + { + correctRangesAfterPos(pos, -1); + 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) { + 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_; + } + + SpellChecker::ChangeNumber currentChangeNumber() const { + return current_change_number_; + } + + void refreshRange(pos_type & first, pos_type & last) const { + first = refresh_.first; + last = refresh_.last; + } + + void needsRefresh(pos_type pos) { + if (needs_refresh_ && pos != -1) { + if (pos < refresh_.first) + refresh_.first = pos; + if (pos > refresh_.last) + refresh_.last = pos; + } else if (pos != -1) { + refresh_.first = pos; + refresh_.last = pos; + } + needs_refresh_ = pos != -1; + } + + void needsCompleteRefresh(SpellChecker::ChangeNumber change_number) { + needs_refresh_ = true; + refresh_.first = 0; + refresh_.last = -1; + current_change_number_ = change_number; + } + +private: + typedef vector 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) { + if (!it->covered(fp)) + result.push_back(SpellResultRange(it->range(), it->result())); + } + ranges_ = result; + } + + void correctRangesAfterPos(pos_type pos, int offset) + { + RangesIterator et = ranges_.end(); + Ranges::iterator it = ranges_.begin(); + for (; it != et; ++it) { + it->shift(pos, offset); + } + } + }; ///////////////////////////////////////////////////////////////////// @@ -173,12 +354,91 @@ public: /// match a string against a particular point in the paragraph bool isTextAt(string const & str, pos_type pos) const; + /// a vector of speller skip positions + typedef vector 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, + SkipPositions & skips) const; + + bool hasSpellerChange() const { + SpellChecker::ChangeNumber speller_change_number = 0; + if (theSpellChecker()) + speller_change_number = theSpellChecker()->changeNumber(); + 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(); + // check for sane arguments + if (to < from || from >= textsize) + return; + FontSpan fp = FontSpan(from, to); + // don't mark end of paragraph + if (fp.last >= textsize) + fp.last = textsize - 1; + speller_state_.setRange(fp, state); + } + + void requestSpellCheck(pos_type pos) { + speller_state_.needsRefresh(pos); + } + + void readySpellCheck() { + speller_state_.needsRefresh(-1); + } + + bool needsSpellCheck() const + { + return speller_state_.needsRefresh(); + } + + void rangeOfSpellCheck(pos_type & first, pos_type & last) const + { + speller_state_.refreshRange(first, last); + if (last == -1) { + last = owner_->size(); + return; + } + pos_type endpos = last; + owner_->locateWord(first, endpos, WHOLE_WORD); + if (endpos < last) { + endpos = last; + owner_->locateWord(last, endpos, WHOLE_WORD); + } + last = endpos; + } + + int countSkips(SkipPositionsIterator & it, SkipPositionsIterator const et, + int & start) const + { + int numskips = 0; + while (it != et && it->first < start) { + int skip = it->last - it->first + 1; + start += skip; + numskips += skip; + ++it; + } + return numskips; + } + + void markMisspelledWords(pos_type const & first, pos_type const & last, + SpellChecker::Result result, + docstring const & word, + SkipPositions const & skips); InsetCode ownerCode() const { return inset_owner_ ? inset_owner_->lyxCode() : NO_CODE; } - + /// Which Paragraph owns us? Paragraph * owner_; @@ -206,12 +466,15 @@ public: typedef docstring TextContainer; /// TextContainer text_; - + typedef set Words; + typedef map LangWordsMap; /// - map words_; + LangWordsMap words_; /// Layout const * layout_; + /// + SpellCheckerState speller_state_; }; @@ -250,12 +513,13 @@ Paragraph::Private::Private(Paragraph * owner, Layout const & layout) static int paragraph_id = -1; Paragraph::Private::Private(Private const & p, Paragraph * owner) - : owner_(owner), inset_owner_(p.inset_owner_), fontlist_(p.fontlist_), + : 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_) { id_ = ++paragraph_id; + requestSpellCheck(p.text_.size()); } @@ -285,6 +549,7 @@ Paragraph::Private::Private(Private const & p, Paragraph * owner, // Add a new entry in the fontlist_. fontlist_.set(fcit->pos() - beg, fcit->font()); } + requestSpellCheck(p.text_.size()); } @@ -452,6 +717,8 @@ void Paragraph::Private::insertChar(pos_type pos, char_type c, if (pos == pos_type(text_.size())) { // when appending characters, no need to update tables text_.push_back(c); + // but we want spell checking + requestSpellCheck(pos); return; } @@ -462,6 +729,9 @@ void Paragraph::Private::insertChar(pos_type pos, char_type c, // Update the insets insetlist_.increasePosAfterPos(pos); + + // Update list of misspelled positions + speller_state_.increasePosAfterPos(pos); } @@ -481,6 +751,9 @@ bool Paragraph::insertInset(pos_type pos, Inset * inset, // Add a new entry in the insetlist_. d->insetlist_.insert(inset, pos); + + // Some insets require run of spell checker + requestSpellCheck(pos); return true; } @@ -501,6 +774,8 @@ bool Paragraph::eraseChar(pos_type pos, bool trackChanges) if (!change.changed() || (change.inserted() && !change.currentAuthor())) { setChange(pos, Change(Change::DELETED)); + // request run of spell checker + requestSpellCheck(pos); return false; } @@ -530,6 +805,10 @@ bool Paragraph::eraseChar(pos_type pos, bool trackChanges) // Update the insetlist_ d->insetlist_.decreasePosAfterPos(pos); + // Update list of misspelled positions + d->speller_state_.decreasePosAfterPos(pos); + d->speller_state_.refreshLast(size()); + return true; } @@ -583,7 +862,7 @@ bool Paragraph::Private::simpleTeXBlanks(OutputParams const & runparams, Font const & font, Layout const & style) { - if (style.pass_thru || runparams.verbatim) + if (style.pass_thru || runparams.pass_thru) return false; if (i + 1 < int(text_.size())) { @@ -715,19 +994,18 @@ bool Paragraph::Private::isTextAt(string const & str, pos_type pos) const } -void Paragraph::Private::latexInset( - BufferParams const & bparams, - odocstream & os, - TexRow & texrow, - OutputParams & runparams, - Font & running_font, - Font & basefont, - Font const & outerfont, - bool & open_font, - Change & running_change, - Layout const & style, - pos_type & i, - unsigned int & column) +void Paragraph::Private::latexInset(BufferParams const & bparams, + odocstream & os, + TexRow & texrow, + OutputParams & runparams, + Font & running_font, + Font & basefont, + Font const & outerfont, + bool & open_font, + Change & running_change, + Layout const & style, + pos_type & i, + unsigned int & column) { Inset * inset = owner_->getInset(i); LASSERT(inset, /**/); @@ -785,7 +1063,7 @@ void Paragraph::Private::latexInset( // ERT is an exception, it should be output with no // decorations at all && inset->lyxCode() != ERT_CODE) { - if (running_font.language()->lang() == "farsi") + if (running_font.language()->lang() == "farsi") os << "\\beginL{}"; else os << "\\L{"; @@ -810,10 +1088,10 @@ void Paragraph::Private::latexInset( unsigned int count = running_font.latexWriteEndChanges(os, bparams, runparams, basefont, basefont, closeLanguage); column += count; - // if any font properties were closed, update the running_font, + // if any font properties were closed, update the running_font, // making sure, however, to leave the language as it was if (count > 0) { - // FIXME: probably a better way to keep track of the old + // FIXME: probably a better way to keep track of the old // language, than copying the entire font? Font const copy_font(running_font); basefont = owner_->getLayoutFont(bparams, outerfont); @@ -850,7 +1128,7 @@ void Paragraph::Private::latexInset( texrow.start(owner_->id(), i + 1); column = 0; } else { - column += os.tellp() - len; + column += (unsigned int)(os.tellp() - len); } if (owner_->isDeleted(i)) @@ -869,7 +1147,7 @@ void Paragraph::Private::latexSpecialChar( { char_type const c = text_[i]; - if (style.pass_thru) { + if (style.pass_thru || runparams.pass_thru) { if (c != '\0') // FIXME UNICODE: This can fail if c cannot // be encoded in the current encoding. @@ -877,13 +1155,6 @@ void Paragraph::Private::latexSpecialChar( return; } - if (runparams.verbatim) { - // FIXME UNICODE: This can fail if c cannot - // be encoded in the current encoding. - os.put(c); - return; - } - // If T1 font encoding is used, use the special // characters it provides. // NOTE: some languages reset the font encoding @@ -1073,22 +1344,43 @@ bool Paragraph::Private::latexSpecialPhrase(odocstream & os, pos_type & 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; - owner_->latex(bp, f, ods, tr, features.runparams()); - docstring d = ods.str(); - if (!d.empty()) - features.addPreambleSnippet(to_utf8(d)); + 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); + if (ods.str().length() > length) { + if (is_command) + ods << '}'; + string const snippet = to_utf8(ods.str()); + features.addPreambleSnippet(snippet); + } } - - if (features.runparams().flavor == OutputParams::HTML + + if (features.runparams().flavor == OutputParams::HTML && layout_->htmltitle()) { features.setHTMLTitle(owner_->asString(AS_STR_INSETS)); } - + // check the params. if (!params_.spacing().isDefault()) features.require("setspace"); @@ -1138,7 +1430,7 @@ namespace { Layout const emptyParagraphLayout; } -Paragraph::Paragraph() +Paragraph::Paragraph() : d(new Paragraph::Private(this, emptyParagraphLayout)) { itemdepth = 0; @@ -1239,9 +1531,8 @@ void Paragraph::write(ostream & os, BufferParams const & bparams, if (i == size()) break; - // Write font changes (ignore spelling markers) + // Write font changes Font font2 = getFontSettings(bparams, i); - font2.setMisspelled(false); if (font2 != font1) { flushString(os, write_buffer); font2.lyxWriteChanges(font1, os); @@ -1569,7 +1860,7 @@ void Paragraph::setFont(pos_type pos, Font const & font) // First, reduce font against layout/label font // Update: The setCharFont() routine in text2.cpp already // reduces font, so we don't need to do that here. (Asger) - + d->fontlist_.set(pos, font); } @@ -1654,14 +1945,14 @@ void Paragraph::setLabelWidthString(docstring const & s) } -docstring Paragraph::expandLabel(Layout const & layout, +docstring Paragraph::expandLabel(Layout const & layout, BufferParams const & bparams) const -{ - return expandParagraphLabel(layout, bparams, true); +{ + return expandParagraphLabel(layout, bparams, true); } -docstring Paragraph::expandDocBookLabel(Layout const & layout, +docstring Paragraph::expandDocBookLabel(Layout const & layout, BufferParams const & bparams) const { return expandParagraphLabel(layout, bparams, false); @@ -1676,7 +1967,7 @@ docstring Paragraph::expandParagraphLabel(Layout const & layout, bool const in_appendix = process_appendix && d->params_.appendix(); docstring fmt = translateIfPossible(layout.labelstring(in_appendix), lang); - if (fmt.empty() && layout.labeltype == LABEL_COUNTER + if (fmt.empty() && layout.labeltype == LABEL_COUNTER && !layout.counter.empty()) return tclass.counters().theCounter(layout.counter, lang); @@ -1691,7 +1982,7 @@ docstring Paragraph::expandParagraphLabel(Layout const & layout, if (tclass.hasLayout(parent)) docstring label = expandParagraphLabel(tclass[parent], bparams, process_appendix); - fmt = docstring(fmt, 0, i) + label + fmt = docstring(fmt, 0, i) + label + docstring(fmt, j + 1, docstring::npos); } } @@ -1704,9 +1995,9 @@ void Paragraph::applyLayout(Layout const & new_layout) { d->layout_ = &new_layout; LyXAlignment const oldAlign = d->params_.align(); - + if (!(oldAlign & d->layout_->alignpossible)) { - frontend::Alert::warning(_("Alignment not permitted"), + frontend::Alert::warning(_("Alignment not permitted"), _("The new layout does not permit the alignment previously used.\nSetting to default.")); d->params_.align(LYX_ALIGN_LAYOUT); } @@ -1837,7 +2128,7 @@ int Paragraph::Private::startTeXParParams(BufferParams const & bparams, os << "\\noindent "; column += 10; } - + LyXAlignment const curAlign = params_.align(); if (curAlign == layout_->align) @@ -1973,26 +2264,24 @@ int Paragraph::Private::endTeXParParams(BufferParams const & bparams, // This one spits out the text of the paragraph -bool Paragraph::latex(BufferParams const & bparams, +void Paragraph::latex(BufferParams const & bparams, Font const & outerfont, odocstream & os, TexRow & texrow, OutputParams const & runparams, - int start_pos, int end_pos) const + int start_pos, int end_pos, bool force) const { LYXERR(Debug::LATEX, "Paragraph::latex... " << this); - if (layout().inpreamble) - return true; - - bool return_value = false; - - bool const allowcust = allowParagraphCustomization(); - // FIXME This check should not be needed. Perhaps issue an // error if it triggers. Layout const & style = inInset().forcePlainLayout() ? bparams.documentClass().plainLayout() : *d->layout_; + if (!force && style.inpreamble) + return; + + bool const allowcust = allowParagraphCustomization(); + // Current base font for all inherited font changes, without any // change caused by an individual character, except for the language: // It is set to the language of the first character. @@ -2070,7 +2359,7 @@ bool Paragraph::latex(BufferParams const & bparams, } Change const & change = runparams.inDeletedInset ? runparams.changeOfDeletedInset - : lookupChange(i); + : lookupChange(i); if (bparams.outputChanges && runningChange != change) { if (open_font) { @@ -2111,18 +2400,22 @@ bool Paragraph::latex(BufferParams const & bparams, 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(); } // Switch file encoding if necessary (and allowed) - if (!runparams.verbatim && + if (!runparams.pass_thru && !style.pass_thru && runparams.encoding->package() != Encoding::none && font.language()->encoding()->package() != Encoding::none) { pair const enc_switch = switchEncoding(os, bparams, @@ -2155,7 +2448,7 @@ bool Paragraph::latex(BufferParams const & bparams, // check if the fontchange ends with a trailing blank // (like "\small " (see bug 3382) else if (suffixIs(fontchange, ' ') && c == ' ') - os << fontchange.substr(0, fontchange.size() - 1) + os << fontchange.substr(0, fontchange.size() - 1) << from_ascii("{}"); else os << fontchange; @@ -2227,9 +2520,8 @@ bool Paragraph::latex(BufferParams const & bparams, if (open_font) { #ifdef FIXED_LANGUAGE_END_DETECTION if (next_) { - running_font - .latexWriteEndChanges(os, bparams, runparams, - basefont, + running_font.latexWriteEndChanges(os, bparams, + runparams, basefont, next_->getFont(bparams, 0, outerfont)); } else { running_font.latexWriteEndChanges(os, bparams, @@ -2250,18 +2542,16 @@ bool Paragraph::latex(BufferParams const & bparams, // Needed if there is an optional argument but no contents. if (body_pos > 0 && body_pos == size()) { os << "}]~"; - return_value = false; } 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()); } LYXERR(Debug::LATEX, "Paragraph::latex... done " << this); - return return_value; } @@ -2443,7 +2733,7 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf, // let's not show deleted material in the output if (isDeleted(i)) continue; - + Font font = getFont(buf.params(), i, outerfont); // emphasis @@ -2471,13 +2761,9 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf, 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); } @@ -2504,7 +2790,7 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf, // 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; } @@ -2548,17 +2834,24 @@ bool Paragraph::isWordSeparator(pos_type pos) const 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); } @@ -2600,6 +2893,7 @@ void Paragraph::changeLanguage(BufferParams const & bparams, setFont(i, font); } } + d->requestSpellCheck(size()); } @@ -2642,18 +2936,20 @@ docstring Paragraph::asString(pos_type beg, pos_type end, int options) const { odocstringstream os; - if (beg == 0 + if (beg == 0 && options & AS_STR_LABEL && !d->params_.labelString().empty()) 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 << " "; } @@ -2663,11 +2959,29 @@ docstring Paragraph::asString(pos_type beg, pos_type end, int options) const } +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; - if (beg == 0 + if (beg == 0 && options & AS_STR_LABEL && !d->params_.labelString().empty()) os << d->params_.labelString() << ' '; @@ -2717,14 +3031,14 @@ void Paragraph::setLayout(Layout const & layout) void Paragraph::setDefaultLayout(DocumentClass const & tc) -{ - setLayout(tc.defaultLayout()); +{ + setLayout(tc.defaultLayout()); } void Paragraph::setPlainLayout(DocumentClass const & tc) -{ - setLayout(tc.plainLayout()); +{ + setLayout(tc.plainLayout()); } @@ -2817,7 +3131,7 @@ int Paragraph::checkBiblio(Buffer const & buffer) { // 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) @@ -2843,8 +3157,8 @@ int Paragraph::checkBiblio(Buffer const & buffer) InsetList::iterator end = d->insetlist_.end(); for (; it != end; ++it) if (it->inset->lyxCode() == BIBITEM_CODE - && it->pos > 0) { - InsetBibitem * olditem = static_cast(it->inset); + && it->pos > 0) { + InsetCommand * olditem = it->inset->asInsetCommand(); oldkey = olditem->getParam("key"); oldlabel = olditem->getParam("label"); erasedInsetPosition = it->pos; @@ -2860,8 +3174,7 @@ int Paragraph::checkBiblio(Buffer const & buffer) // 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(d->insetlist_.begin()->inset); + InsetCommand * inset = d->insetlist_.begin()->inset->asInsetCommand(); if (!oldkey.empty()) inset->setParam("key", oldkey); inset->setParam("label", oldlabel); @@ -2870,13 +3183,13 @@ int Paragraph::checkBiblio(Buffer const & buffer) // There was no inset at the beginning, so we need to create one with // the key and label of the one we erased. - InsetBibitem * inset = + InsetBibitem * inset = new InsetBibitem(const_cast(&buffer), InsetCommandParams(BIBITEM_CODE)); // restore values of previously deleted item in this par. if (!oldkey.empty()) inset->setParam("key", oldkey); inset->setParam("label", oldlabel); - insertInset(0, static_cast(inset), + insertInset(0, inset, Change(track_changes ? Change::INSERTED : Change::UNCHANGED)); return 1; @@ -3006,36 +3319,44 @@ void Paragraph::changeCase(BufferParams const & bparams, pos_type pos, } -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(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; } @@ -3072,8 +3393,8 @@ bool Paragraph::isSeparator(pos_type pos) const void Paragraph::deregisterWords() { - map::const_iterator itl = d->words_.begin(); - map::const_iterator ite = d->words_.end(); + Private::LangWordsMap::const_iterator itl = d->words_.begin(); + Private::LangWordsMap::const_iterator ite = d->words_.end(); for (; itl != ite; ++itl) { WordList * wl = theWordList(itl->first); Private::Words::const_iterator it = (itl->second).begin(); @@ -3124,13 +3445,16 @@ void Paragraph::locateWord(pos_type & from, pos_type & to, void Paragraph::collectWords() { + // This is the value that needs to be exposed in the preferences + // to resolve bug #6760. + static int minlength = 6; pos_type n = size(); for (pos_type pos = 0; pos < n; ++pos) { if (isWordSeparator(pos)) continue; pos_type from = pos; locateWord(from, pos, WHOLE_WORD); - if (pos - from >= 6) { + if (pos - from >= minlength) { docstring word = asString(from, pos, AS_STR_NONE); FontList::const_iterator cit = d->fontlist_.fontIterator(pos); if (cit == d->fontlist_.end()) @@ -3144,11 +3468,13 @@ void Paragraph::collectWords() void Paragraph::registerWords() { - map::const_iterator itl; - Private::Words::const_iterator it; - for (itl = d->words_.begin(); itl != d->words_.end(); ++itl) { + Private::LangWordsMap::const_iterator itl = d->words_.begin(); + Private::LangWordsMap::const_iterator ite = d->words_.end(); + for (; itl != ite; ++itl) { WordList * wl = theWordList(itl->first); - for (it = (itl->second).begin(); it != (itl->second).end(); ++it) + Private::Words::const_iterator it = (itl->second).begin(); + Private::Words::const_iterator et = (itl->second).end(); + for (; it != et; ++it) wl->insert(*it); } } @@ -3162,70 +3488,268 @@ void Paragraph::updateWords() } -bool Paragraph::spellCheck(pos_type & from, pos_type & to, WordLangTuple & wl, - docstring_list & suggestions, bool do_suggestion) const +void Paragraph::Private::appendSkipPosition(SkipPositions & skips, pos_type const pos) const { - SpellChecker * speller = theSpellChecker(); - if (!speller) - return false; + 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)); +} - if (!d->layout_->spellcheck || !inInset().allowSpellCheck()) - return false; - locateWord(from, to, WHOLE_WORD); - if (from == to || from >= pos_type(d->text_.size())) - return false; +Language * Paragraph::Private::locateSpellRange( + pos_type & from, pos_type & to, + SkipPositions & skips) const +{ + // skip leading white space + while (from < to && owner_->isWordSeparator(from)) + ++from; + // don't check empty range + if (from >= to) + return 0; + // get current language + Language * lang = getSpellLanguage(from); + pos_type last = from; + bool samelang = true; + bool sameinset = true; + while (last < to && samelang && sameinset) { + // hop to end of word + while (last < to && !owner_->isWordSeparator(last)) { + if (owner_->getInset(last)) { + appendSkipPosition(skips, last); + } else if (owner_->isDeleted(last)) { + appendSkipPosition(skips, last); + } + ++last; + } + // hop to next word while checking for insets + 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++; + } + if (sameinset && last < to) { + // now check for language change + samelang = lang == getSpellLanguage(last); + } + } + // if language change detected backstep is needed + if (!samelang) + --last; + to = last; + return lang; +} - docstring word = asString(from, to, AS_STR_INSETS); - // Ignore words with digits - // FIXME: make this customizable - // (note that hunspell ignores words with digits by default) - bool const ignored = hasDigit(word); - Language * lang = const_cast(getFontSettings( - d->inset_owner_->buffer().params(), from).language()); - if (lang == d->inset_owner_->buffer().params().language - && !lyxrc.spellchecker_alt_lang.empty()) { + +Language * Paragraph::Private::getSpellLanguage(pos_type const from) const +{ + Language * lang = + const_cast(owner_->getFontSettings( + inset_owner_->buffer().params(), from).language()); + if (lang == inset_owner_->buffer().params().language + && !lyxrc.spellchecker_alt_lang.empty()) { string lang_code; string const lang_variety = split(lyxrc.spellchecker_alt_lang, lang_code, '-'); lang->setCode(lang_code); lang->setVariety(lang_variety); } - wl = WordLangTuple(word, lang); - SpellChecker::Result res = ignored ? - SpellChecker::OK : speller->check(wl); -#if 0 -// FIXME: the code below makes aspell abort if a word in an unknown -// language is checked. - // Just ignore any error that the spellchecker reports. - // FIXME: we should through out an exception and catch it in the GUI to - // display the error. - if (!speller->error().empty()) - return false; -#endif + return lang; +} + + +void Paragraph::requestSpellCheck(pos_type pos) +{ + d->requestSpellCheck(pos == -1 ? size() : pos); +} + + +bool Paragraph::needsSpellCheck() const +{ + SpellChecker::ChangeNumber speller_change_number = 0; + if (theSpellChecker()) + speller_change_number = theSpellChecker()->changeNumber(); + if (speller_change_number > d->speller_state_.currentChangeNumber()) { + d->speller_state_.needsCompleteRefresh(speller_change_number); + } + return d->needsSpellCheck(); +} + + +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 +{ + SpellChecker::Result result = SpellChecker::WORD_OK; + SpellChecker * speller = theSpellChecker(); + if (!speller) + return result; - bool const misspelled = res != SpellChecker::OK - && res != SpellChecker::IGNORED_WORD; + if (!d->layout_->spellcheck || !inInset().allowSpellCheck()) + return result; + + locateWord(from, to, WHOLE_WORD); + if (from == to || from >= size()) + return result; - if (lyxrc.spellcheck_continuously) - d->fontlist_.setMisspelled(from, to, misspelled); + docstring word = asString(from, to, AS_STR_INSETS | AS_STR_SKIPDELETE); + Language * lang = d->getSpellLanguage(from); + + wl = WordLangTuple(word, lang); - if (misspelled && do_suggestion) + if (!word.size()) + return result; + + if (needsSpellCheck() || check_learned) { + 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); + } + + bool const misspelled_ = SpellChecker::misspelled(result) ; + if (misspelled_ && do_suggestion) speller->suggest(wl, suggestions); + else if (misspelled_) + LYXERR(Debug::GUI, "misspelled word: \"" << + word << "\" [" << + from << ".." << to << "]"); else suggestions.clear(); - return misspelled; + return result; +} + + +void Paragraph::Private::markMisspelledWords( + pos_type const & first, pos_type const & last, + SpellChecker::Result result, + docstring const & word, + SkipPositions const & skips) +{ + if (!SpellChecker::misspelled(result)) { + setMisspelled(first, last, SpellChecker::WORD_OK); + return; + } + int snext = first; + SpellChecker * speller = theSpellChecker(); + // locate and enumerate the error positions + int nerrors = speller->numMisspelledWords(); + int numskipped = 0; + SkipPositionsIterator it = skips.begin(); + SkipPositionsIterator et = skips.end(); + for (int index = 0; index < nerrors; ++index) { + int wstart; + 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); + wstart += first + numskipped; + if (snext < wstart) { + /// mark the range of correct spelling + numskipped += countSkips(it, et, wstart); + setMisspelled(snext, + wstart - 1, SpellChecker::WORD_OK); + } + snext = wstart + wlen; + numskipped += countSkips(it, et, snext); + /// mark the range of misspelling + setMisspelled(wstart, snext, result); + LYXERR(Debug::GUI, "misspelled word: \"" << + misspelled << "\" [" << + wstart << ".." << (snext-1) << "]"); + ++snext; + } + if (snext <= last) { + /// mark the range of correct spelling at end + setMisspelled(snext, last, SpellChecker::WORD_OK); + } +} + + +void Paragraph::spellCheck() const +{ + SpellChecker * speller = theSpellChecker(); + if (!speller || !size() ||!needsSpellCheck()) + return; + pos_type start; + pos_type endpos; + d->rangeOfSpellCheck(start, endpos); + if (speller->canCheckParagraph()) { + // loop until we leave the range + for (pos_type first = start; first < endpos; ) { + pos_type last = endpos; + 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 + 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, skips); + first = ++last; + } + } else { + static docstring_list suggestions; + pos_type to = endpos; + while (start < endpos) { + WordLangTuple wl; + spellCheck(start, to, wl, suggestions, false); + start = to + 1; + } + } + d->readySpellCheck(); } bool Paragraph::isMisspelled(pos_type pos) const { - pos_type from = pos; - pos_type to = pos; - WordLangTuple wl; - docstring_list suggestions; - return spellCheck(from, to, wl, suggestions, false); + return SpellChecker::misspelled(d->speller_state_.getState(pos)); }