X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FParagraph.cpp;h=c47718c3d5a8eedf9d14d8040b1d10769600465a;hb=f3711d8a651445a61e1a759ac7493a9c5c7800e2;hp=d5a607753b2224b043475fef1aff68f6730a3d6e;hpb=2eaac90ca5854d8197324d18937bd71b65b79b08;p=lyx.git diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp index d5a607753b..c47718c3d5 100644 --- a/src/Paragraph.cpp +++ b/src/Paragraph.cpp @@ -5,6 +5,7 @@ * * \author Asger Alstrup * \author Lars Gullik Bjønnes + * \author Richard Heck (XHTML output) * \author Jean-Marc Lasgouttes * \author Angus Leeming * \author John Levon @@ -36,7 +37,6 @@ #include "OutputParams.h" #include "output_latex.h" #include "output_xhtml.h" -#include "paragraph_funcs.h" #include "ParagraphParameters.h" #include "SpellChecker.h" #include "sgml.h" @@ -52,12 +52,12 @@ #include "insets/InsetBibitem.h" #include "insets/InsetLabel.h" -#include "support/lassert.h" #include "support/debug.h" +#include "support/docstring_list.h" #include "support/ExceptionMessage.h" #include "support/gettext.h" +#include "support/lassert.h" #include "support/lstrings.h" -#include "support/Messages.h" #include "support/textutils.h" #include @@ -95,7 +95,7 @@ public: /// Output the surrogate pair formed by \p c and \p next to \p os. /// \return the number of characters written. int latexSurrogatePair(odocstream & os, char_type c, char_type next, - Encoding const &); + OutputParams const &); /// Output a space in appropriate formatting (or a surrogate pair /// if the next character is a combining character). @@ -164,8 +164,7 @@ public: OutputParams const & runparams); /// - void validate(LaTeXFeatures & features, - Layout const & layout) const; + void validate(LaTeXFeatures & features) const; /// Checks if the paragraph contains only text and no inset or font change. bool onlyText(Buffer const & buf, Font const & outerfont, @@ -173,6 +172,12 @@ public: /// match a string against a particular point in the paragraph bool isTextAt(string const & str, pos_type pos) const; + + + InsetCode ownerCode() const + { + return inset_owner_ ? inset_owner_->lyxCode() : NO_CODE; + } /// Which Paragraph owns us? Paragraph * owner_; @@ -184,9 +189,8 @@ public: FontList fontlist_; /// - unsigned int id_; - /// - static unsigned int paragraph_id; + int id_; + /// ParagraphParameters params_; @@ -203,17 +207,14 @@ public: /// TextContainer text_; - typedef std::set Words; + typedef set Words; /// - Words words_; + map words_; /// Layout const * layout_; }; -// Initialization of the counter for the paragraph id's, -unsigned int Paragraph::Private::paragraph_id = 0; - namespace { struct special_phrase { @@ -235,20 +236,26 @@ size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase); Paragraph::Private::Private(Paragraph * owner, Layout const & layout) - : owner_(owner), inset_owner_(0), begin_of_body_(0), layout_(&layout) + : owner_(owner), inset_owner_(0), id_(-1), begin_of_body_(0), layout_(&layout) { - id_ = paragraph_id++; text_.reserve(100); } +// Initialization of the counter for the paragraph id's, +// +// FIXME: There should be a more intelligent way to generate and use the +// paragraph ids per buffer instead a global static counter for all InsetText +// in the running program. +static int paragraph_id = -1; + Paragraph::Private::Private(Private const & p, Paragraph * owner) : 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++; + id_ = ++paragraph_id; } @@ -260,7 +267,7 @@ Paragraph::Private::Private(Private const & p, Paragraph * owner, begin_of_body_(p.begin_of_body_), words_(p.words_), layout_(p.layout_) { - id_ = paragraph_id++; + id_ = ++paragraph_id; if (beg >= pos_type(p.text_.size())) return; text_ = p.text_.substr(beg, end - beg); @@ -288,12 +295,12 @@ void Paragraph::addChangesToToc(DocIterator const & cdit, } -bool Paragraph::isFullyDeleted(pos_type start, pos_type end) const +bool Paragraph::isDeleted(pos_type start, pos_type end) const { LASSERT(start >= 0 && start <= size(), /**/); LASSERT(end > start && end <= size() + 1, /**/); - return d->changes_.isFullyDeleted(start, end); + return d->changes_.isDeleted(start, end); } @@ -313,7 +320,7 @@ bool Paragraph::isMergedOnEndOfParDeletion(bool trackChanges) const return true; Change const change = d->changes_.lookup(size()); - return change.type == Change::INSERTED && change.author == 0; + return change.inserted() && change.currentAuthor(); } @@ -334,7 +341,7 @@ void Paragraph::setChange(Change const & change) * Conclusion: An inset's content should remain untouched if you delete it */ - if (change.type != Change::DELETED) { + if (!change.deleted()) { for (pos_type pos = 0; pos < size(); ++pos) { if (Inset * inset = getInset(pos)) inset->setChange(change); @@ -349,7 +356,7 @@ void Paragraph::setChange(pos_type pos, Change const & change) d->changes_.set(change, pos); // see comment in setChange(Change const &) above - if (change.type != Change::DELETED && pos < size()) + if (!change.deleted() && pos < size()) if (Inset * inset = getInset(pos)) inset->setChange(change); } @@ -362,8 +369,7 @@ Change const & Paragraph::lookupChange(pos_type pos) const } -void Paragraph::acceptChanges(BufferParams const & bparams, pos_type start, - pos_type end) +void Paragraph::acceptChanges(pos_type start, pos_type end) { LASSERT(start >= 0 && start <= size(), /**/); LASSERT(end > start && end <= size() + 1, /**/); @@ -373,14 +379,14 @@ void Paragraph::acceptChanges(BufferParams const & bparams, pos_type start, case Change::UNCHANGED: // accept changes in nested inset if (Inset * inset = getInset(pos)) - inset->acceptChanges(bparams); + inset->acceptChanges(); break; case Change::INSERTED: d->changes_.set(Change(Change::UNCHANGED), pos); // also accept changes in nested inset if (Inset * inset = getInset(pos)) - inset->acceptChanges(bparams); + inset->acceptChanges(); break; case Change::DELETED: @@ -398,8 +404,7 @@ void Paragraph::acceptChanges(BufferParams const & bparams, pos_type start, } -void Paragraph::rejectChanges(BufferParams const & bparams, - pos_type start, pos_type end) +void Paragraph::rejectChanges(pos_type start, pos_type end) { LASSERT(start >= 0 && start <= size(), /**/); LASSERT(end > start && end <= size() + 1, /**/); @@ -409,7 +414,7 @@ void Paragraph::rejectChanges(BufferParams const & bparams, case Change::UNCHANGED: // reject changes in nested inset if (Inset * inset = getInset(pos)) - inset->rejectChanges(bparams); + inset->rejectChanges(); break; case Change::INSERTED: @@ -493,13 +498,13 @@ bool Paragraph::eraseChar(pos_type pos, bool trackChanges) // a) it was previously unchanged or // b) it was inserted by a co-author - if (change.type == Change::UNCHANGED || - (change.type == Change::INSERTED && change.author != 0)) { + if (!change.changed() || + (change.inserted() && !change.currentAuthor())) { setChange(pos, Change(Change::DELETED)); return false; } - if (change.type == Change::DELETED) + if (change.deleted()) return false; } @@ -544,7 +549,7 @@ int Paragraph::eraseChars(pos_type start, pos_type end, bool trackChanges) int Paragraph::Private::latexSurrogatePair(odocstream & os, char_type c, - char_type next, Encoding const & encoding) + char_type next, OutputParams const & runparams) { // Writing next here may circumvent a possible font change between // c and next. Since next is only output if it forms a surrogate pair @@ -553,12 +558,18 @@ int Paragraph::Private::latexSurrogatePair(odocstream & os, char_type c, // hopefully impossible to input. // FIXME: change tracking // Is this correct WRT change tracking? + Encoding const & encoding = *(runparams.encoding); docstring const latex1 = encoding.latexChar(next); docstring const latex2 = encoding.latexChar(c); if (docstring(1, next) == latex1) { // the encoding supports the combination os << latex2 << latex1; return latex1.length() + latex2.length(); + } else if (runparams.local_font && + runparams.local_font->language()->lang() == "polutonikogreek") { + // polutonikogreek only works without the brackets + os << latex1 << latex2; + return latex1.length() + latex2.length(); } else os << latex1 << '{' << latex2 << '}'; return latex1.length() + latex2.length() + 2; @@ -578,15 +589,14 @@ bool Paragraph::Private::simpleTeXBlanks(OutputParams const & runparams, if (i + 1 < int(text_.size())) { char_type next = text_[i + 1]; if (Encodings::isCombiningChar(next)) { - Encoding const & encoding = *(runparams.encoding); // This space has an accent, so we must always output it. - column += latexSurrogatePair(os, ' ', next, encoding) - 1; + column += latexSurrogatePair(os, ' ', next, runparams) - 1; return true; } } - if (lyxrc.plaintext_linelen > 0 - && column > lyxrc.plaintext_linelen + if (runparams.linelen > 0 + && column > runparams.linelen && i && text_[i - 1] != ' ' && (i + 1 < int(text_.size())) @@ -756,24 +766,25 @@ void Paragraph::Private::latexInset( column = 0; } - if (owner_->lookupChange(i).type == Change::DELETED) { + if (owner_->isDeleted(i)) { if( ++runparams.inDeletedInset == 1) runparams.changeOfDeletedInset = owner_->lookupChange(i); } if (inset->canTrackChanges()) { column += Changes::latexMarkChange(os, bparams, running_change, - Change(Change::UNCHANGED)); + Change(Change::UNCHANGED), runparams); running_change = Change(Change::UNCHANGED); } bool close = false; odocstream::pos_type const len = os.tellp(); - if (inset->forceLTR() + if (inset->forceLTR() && running_font.isRightToLeft() - // ERT is an exception, it should be output with no decorations at all - && inset->lyxCode() != ERT_CODE) { + // ERT is an exception, it should be output with no + // decorations at all + && inset->lyxCode() != ERT_CODE) { if (running_font.language()->lang() == "farsi") os << "\\beginL{}"; else @@ -844,7 +855,7 @@ void Paragraph::Private::latexInset( column += os.tellp() - len; } - if (owner_->lookupChange(i).type == Change::DELETED) + if (owner_->isDeleted(i)) --runparams.inDeletedInset; } @@ -962,7 +973,7 @@ void Paragraph::Private::latexSpecialChar( if (i + 1 < int(text_.size())) { char_type next = text_[i + 1]; if (Encodings::isCombiningChar(next)) { - column += latexSurrogatePair(os, c, next, encoding) - 1; + column += latexSurrogatePair(os, c, next, runparams) - 1; ++i; break; } @@ -1061,15 +1072,31 @@ bool Paragraph::Private::latexSpecialPhrase(odocstream & os, pos_type & i, } -void Paragraph::Private::validate(LaTeXFeatures & features, - Layout const & layout) const +void Paragraph::Private::validate(LaTeXFeatures & features) const { + if (layout_->inpreamble && inset_owner_) { + Buffer const & buf = inset_owner_->buffer(); + BufferParams const & bp = buf.params(); + Font f; + TexRow tr; + odocstringstream ods; + owner_->latex(bp, f, ods, tr, features.runparams()); + docstring d = ods.str(); + if (!d.empty()) + features.addPreambleSnippet(to_utf8(d)); + } + + 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"); // then the layouts - features.useLayout(layout.name()); + features.useLayout(layout_->name()); // then the fonts fontlist_.validate(features); @@ -1084,7 +1111,7 @@ void Paragraph::Private::validate(LaTeXFeatures & features, for (; icit != iend; ++icit) { if (icit->inset) { icit->inset->validate(features); - if (layout.needprotect && + if (layout_->needprotect && icit->inset->lyxCode() == FOOT_CODE) features.require("NeedLyXFootnoteCode"); } @@ -1159,6 +1186,18 @@ Paragraph::~Paragraph() } +namespace { + +// this shall be called just before every "os << ..." action. +void flushString(ostream & os, docstring & s) +{ + os << to_utf8(s); + s.erase(); +} + +} + + void Paragraph::write(ostream & os, BufferParams const & bparams, depth_type & dth) const { @@ -1186,11 +1225,17 @@ void Paragraph::write(ostream & os, BufferParams const & bparams, Change running_change = Change(Change::UNCHANGED); + // this string is used as a buffer to avoid repetitive calls + // to to_utf8(), which turn out to be expensive (JMarc) + docstring write_buffer; + int column = 0; for (pos_type i = 0; i <= size(); ++i) { Change const change = lookupChange(i); - Changes::lyxMarkChange(os, column, running_change, change); + if (change != running_change) + flushString(os, write_buffer); + Changes::lyxMarkChange(os, bparams, column, running_change, change); running_change = change; if (i == size()) @@ -1200,6 +1245,7 @@ void Paragraph::write(ostream & os, BufferParams const & bparams, Font font2 = getFontSettings(bparams, i); font2.setMisspelled(false); if (font2 != font1) { + flushString(os, write_buffer); font2.lyxWriteChanges(font1, os); column = 0; font1 = font2; @@ -1209,6 +1255,7 @@ void Paragraph::write(ostream & os, BufferParams const & bparams, switch (c) { case META_INSET: if (Inset const * inset = getInset(i)) { + flushString(os, write_buffer); if (inset->directWrite()) { // international char, let it write // code directly so it's shorter in @@ -1225,10 +1272,12 @@ void Paragraph::write(ostream & os, BufferParams const & bparams, } break; case '\\': + flushString(os, write_buffer); os << "\n\\backslash\n"; column = 0; break; case '.': + flushString(os, write_buffer); if (i + 1 < size() && d->text_[i + 1] == ' ') { os << ".\n"; column = 0; @@ -1238,13 +1287,14 @@ void Paragraph::write(ostream & os, BufferParams const & bparams, default: if ((column > 70 && c == ' ') || column > 79) { + flushString(os, write_buffer); os << '\n'; column = 0; } // this check is to amend a bug. LyX sometimes // inserts '\0' this could cause problems. if (c != '\0') - os << to_utf8(docstring(1, c)); + write_buffer.push_back(c); else LYXERR0("NUL char in structure."); ++column; @@ -1252,13 +1302,14 @@ void Paragraph::write(ostream & os, BufferParams const & bparams, } } + flushString(os, write_buffer); os << "\n\\end_layout\n"; } void Paragraph::validate(LaTeXFeatures & features) const { - d->validate(features, *d->layout_); + d->validate(features); } @@ -1605,35 +1656,31 @@ void Paragraph::setLabelWidthString(docstring const & s) } -docstring const Paragraph::translateIfPossible(docstring const & s, +docstring Paragraph::expandLabel(Layout const & layout, + BufferParams const & bparams) const +{ + return expandParagraphLabel(layout, bparams, true); +} + + +docstring Paragraph::expandDocBookLabel(Layout const & layout, BufferParams const & bparams) const { - if (!isAscii(s) || s.empty()) { - // This must be a user defined layout. We cannot translate - // this, since gettext accepts only ascii keys. - return s; - } - // Probably standard layout, try to translate - Messages & m = getMessages(getParLanguage(bparams)->code()); - return m.get(to_ascii(s)); + return expandParagraphLabel(layout, bparams, false); } -docstring Paragraph::expandLabel(Layout const & layout, +docstring Paragraph::expandParagraphLabel(Layout const & layout, BufferParams const & bparams, bool process_appendix) const { DocumentClass const & tclass = bparams.documentClass(); - - docstring fmt; - if (process_appendix && d->params_.appendix()) - fmt = translateIfPossible(layout.labelstring_appendix(), - bparams); - else - fmt = translateIfPossible(layout.labelstring(), bparams); + string const & lang = getParLanguage(bparams)->code(); + bool const in_appendix = process_appendix && d->params_.appendix(); + docstring fmt = translateIfPossible(layout.labelstring(in_appendix), lang); if (fmt.empty() && layout.labeltype == LABEL_COUNTER && !layout.counter.empty()) - return tclass.counters().theCounter(layout.counter); + return tclass.counters().theCounter(layout.counter, lang); // handle 'inherited level parts' in 'fmt', // i.e. the stuff between '@' in '@Section@.\arabic{subsection}' @@ -1644,14 +1691,14 @@ docstring Paragraph::expandLabel(Layout const & layout, docstring parent(fmt, i + 1, j - i - 1); docstring label = from_ascii("??"); if (tclass.hasLayout(parent)) - docstring label = expandLabel(tclass[parent], bparams, + docstring label = expandParagraphLabel(tclass[parent], bparams, process_appendix); fmt = docstring(fmt, 0, i) + label + docstring(fmt, j + 1, docstring::npos); } } - return tclass.counters().counterLabel(fmt); + return tclass.counters().counterLabel(fmt, lang); } @@ -1709,12 +1756,6 @@ void Paragraph::setBeginOfBody() } -bool Paragraph::forcePlainLayout() const -{ - return inInset().forcePlainLayout(); -} - - bool Paragraph::allowParagraphCustomization() const { return inInset().allowParagraphCustomization(); @@ -1821,7 +1862,7 @@ int Paragraph::Private::startTeXParParams(BufferParams const & bparams, } string const begin_tag = "\\begin"; - InsetCode code = owner_->ownerCode(); + InsetCode code = ownerCode(); bool const lastpar = runparams.isLastPar; switch (curAlign) { @@ -1889,7 +1930,7 @@ int Paragraph::Private::endTeXParParams(BufferParams const & bparams, } string const end_tag = "\n\\par\\end"; - InsetCode code = owner_->ownerCode(); + InsetCode code = ownerCode(); bool const lastpar = runparams.isLastPar; switch (curAlign) { @@ -1938,13 +1979,16 @@ bool Paragraph::latex(BufferParams const & bparams, { 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 = forcePlainLayout() ? + Layout const & style = inInset().forcePlainLayout() ? bparams.documentClass().plainLayout() : *d->layout_; // Current base font for all inherited font changes, without any @@ -1960,8 +2004,10 @@ bool Paragraph::latex(BufferParams const & bparams, unsigned int column = 0; if (body_pos > 0) { - os << '['; - column += 1; + // the optional argument is kept in curly brackets in + // case it contains a ']' + os << "[{"; + column += 2; basefont = getLabelFont(bparams, outerfont); } else { basefont = getLayoutFont(bparams, outerfont); @@ -1974,6 +2020,8 @@ bool Paragraph::latex(BufferParams const & bparams, Change runningChange = Change(Change::UNCHANGED); + Encoding const * const prev_encoding = runparams.encoding; + texrow.start(id(), 0); // if the paragraph is empty, the loop will not be entered at all @@ -2001,11 +2049,12 @@ bool Paragraph::latex(BufferParams const & bparams, running_font = basefont; column += Changes::latexMarkChange(os, bparams, - runningChange, Change(Change::UNCHANGED)); + runningChange, Change(Change::UNCHANGED), + runparams); runningChange = Change(Change::UNCHANGED); - os << "] "; - column +=2; + os << "}] "; + column +=3; } if (style.isCommand()) { os << '{'; @@ -2030,13 +2079,14 @@ bool Paragraph::latex(BufferParams const & bparams, basefont = getLayoutFont(bparams, outerfont); running_font = basefont; - column += Changes::latexMarkChange(os, bparams, runningChange, change); + column += Changes::latexMarkChange(os, bparams, runningChange, + change, runparams); runningChange = change; } // do not output text which is marked deleted // if change tracking output is disabled - if (!bparams.outputChanges && change.type == Change::DELETED) { + if (!bparams.outputChanges && change.deleted()) { continue; } @@ -2095,9 +2145,14 @@ bool Paragraph::latex(BufferParams const & bparams, running_font = font; open_font = true; docstring fontchange = ods.str(); + // check whether the fontchange ends with a \\textcolor + // modifier and the text starts with a space (bug 4473) + docstring const last_modifier = rsplit(fontchange, '\\'); + if (prefixIs(last_modifier, from_ascii("textcolor")) && c == ' ') + os << fontchange << from_ascii("{}"); // check if the fontchange ends with a trailing blank // (like "\small " (see bug 3382) - if (suffixIs(fontchange, ' ') && c == ' ') + else if (suffixIs(fontchange, ' ') && c == ' ') os << fontchange.substr(0, fontchange.size() - 1) << from_ascii("{}"); else @@ -2187,17 +2242,20 @@ bool Paragraph::latex(BufferParams const & bparams, #endif } - column += Changes::latexMarkChange(os, bparams, runningChange, Change(Change::UNCHANGED)); + column += Changes::latexMarkChange(os, bparams, runningChange, + Change(Change::UNCHANGED), runparams); // Needed if there is an optional argument but no contents. if (body_pos > 0 && body_pos == size()) { - os << "]~"; + os << "}]~"; return_value = false; } - if (allowcust) { - column += d->endTeXParParams(bparams, os, texrow, - runparams); + if (allowcust && d->endTeXParParams(bparams, os, texrow, runparams) + && runparams.encoding != prev_encoding) { + runparams.encoding = prev_encoding; + if (!bparams.useXetex) + os << setEncoding(prev_encoding->iconvName()); } LYXERR(Debug::LATEX, "Paragraph::latex... done " << this); @@ -2210,6 +2268,8 @@ bool Paragraph::emptyTag() const for (pos_type i = 0; i < size(); ++i) { if (Inset const * inset = getInset(i)) { InsetCode lyx_code = inset->lyxCode(); + // FIXME testing like that is wrong. What is + // the intent? if (lyx_code != TOC_CODE && lyx_code != INCLUDE_CODE && lyx_code != GRAPHICS_CODE && @@ -2264,18 +2324,18 @@ pos_type Paragraph::firstWordDocBook(odocstream & os, OutputParams const & runpa } -pos_type Paragraph::firstWordLyXHTML(odocstream & os, OutputParams const & runparams) +pos_type Paragraph::firstWordLyXHTML(XHTMLStream & xs, OutputParams const & runparams) const { pos_type i; for (i = 0; i < size(); ++i) { if (Inset const * inset = getInset(i)) { - inset->xhtml(os, runparams); + inset->xhtml(xs, runparams); } else { char_type c = d->text_[i]; if (c == ' ') break; - os << html::escapeChar(c); + xs << c; } } return i; @@ -2354,59 +2414,76 @@ void Paragraph::simpleDocBookOnePar(Buffer const & buf, docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf, - odocstream & os, + XHTMLStream & xs, OutputParams const & runparams, Font const & outerfont, pos_type initial) const { docstring retval; - // FIXME We really need to manage the tag nesting here. - // Probably in the same sort of way as in output_xhtml. bool emph_flag = false; bool bold_flag = false; - std::string closing_tag; + string closing_tag; Layout const & style = *d->layout_; + + if (!runparams.for_toc && runparams.html_make_pars) { + // generate a magic label for this paragraph + string const attr = "id='" + magicLabel() + "'"; + xs << html::CompTag("a", attr); + } + FontInfo font_old = style.labeltype == LABEL_MANUAL ? style.labelfont : style.font; - //if (style.pass_thru && !d->onlyText(buf, outerfont, initial)) - // os << "]]>"; - // parsing main loop for (pos_type i = initial; i < size(); ++i) { + // let's not show deleted material in the output + if (isDeleted(i)) + continue; + Font font = getFont(buf.params(), i, outerfont); // emphasis if (font_old.emph() != font.fontInfo().emph()) { if (font.fontInfo().emph() == FONT_ON) { - os << ""; + xs << html::StartTag("em"); emph_flag = true; } else if (emph_flag && i != initial) { - os << ""; + xs << html::EndTag("em"); emph_flag = false; } } // bold if (font_old.series() != font.fontInfo().series()) { if (font.fontInfo().series() == BOLD_SERIES) { - os << ""; + xs << html::StartTag("strong"); bold_flag = true; } else if (bold_flag && i != initial) { - os << ""; + xs << html::EndTag("strong"); bold_flag = false; } } - // FIXME Other such tags? - - if (Inset const * inset = getInset(i)) { - retval += inset->xhtml(os, runparams); + // FIXME XHTML + // Other such tags? What about the other text ranges? + + 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())) { + OutputParams np = runparams; + if (!il.htmlisblock()) + np.html_in_par = true; + retval += inset->xhtml(xs, np); + } } else { char_type c = d->text_[i]; if (style.pass_thru) - os.put(c); + xs << c; else if (c == '-') { docstring str; int j = i + 1; @@ -2422,19 +2499,17 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf, } else str += c; - os << str; + // 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; } else - os << html::escapeChar(c); + xs << c; } font_old = font.fontInfo(); } - // FIXME This could be out of order. See above. - if (emph_flag) - os << ""; - if (bold_flag) - os << ""; - + xs.closeFontTags(); return retval; } @@ -2464,18 +2539,15 @@ bool Paragraph::isLineSeparator(pos_type pos) const } -/// Used by the spellchecker -bool Paragraph::isLetter(pos_type pos) const +bool Paragraph::isWordSeparator(pos_type pos) const { if (Inset const * inset = getInset(pos)) - return inset->isLetter(); + return !inset->isLetter(); char_type const c = d->text_[pos]; - // We want to pass the ' and escape chars to the spellchecker + // 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)) - && (!d->inset_owner_ || d->inset_owner_->allowSpellCheck()) - && pos != size() - && !isDeleted(pos); + return (!isLetterChar(c) && !isDigit(c) && !contains(quote, c)) + || pos == size(); } @@ -2511,8 +2583,7 @@ bool Paragraph::isRTL(BufferParams const & bparams) const { return lyxrc.rtl_support && getParLanguage(bparams)->rightToLeft() - && ownerCode() != ERT_CODE - && ownerCode() != LISTINGS_CODE; + && !inInset().getLayout().forceLTR(); } @@ -2532,7 +2603,7 @@ void Paragraph::changeLanguage(BufferParams const & bparams, bool Paragraph::isMultiLingual(BufferParams const & bparams) const { - Language const * doc_language = bparams.language; + Language const * doc_language = bparams.language; FontList::const_iterator cit = d->fontlist_.begin(); FontList::const_iterator end = d->fontlist_.end(); @@ -2545,6 +2616,20 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams) const } +void Paragraph::getLanguages(std::set & languages) const +{ + FontList::const_iterator cit = d->fontlist_.begin(); + FontList::const_iterator end = d->fontlist_.end(); + + for (; cit != end; ++cit) { + Language const * lang = cit->font().language(); + if (lang != ignore_language && + lang != latex_language) + languages.insert(lang); + } +} + + docstring Paragraph::asString(int options) const { return asString(0, size(), options); @@ -2556,17 +2641,20 @@ docstring Paragraph::asString(pos_type beg, pos_type end, int options) const odocstringstream os; if (beg == 0 - && options & AS_STR_LABEL - && !d->params_.labelString().empty()) + && options & AS_STR_LABEL + && !d->params_.labelString().empty()) os << d->params_.labelString() << ' '; for (pos_type i = beg; i < end; ++i) { char_type const c = d->text_[i]; if (isPrintable(c) || c == '\t' - || (c == '\n' && options & AS_STR_NEWLINES)) + || (c == '\n' && (options & AS_STR_NEWLINES))) os.put(c); - else if (c == META_INSET && options & AS_STR_INSETS) + else if (c == META_INSET && (options & AS_STR_INSETS)) { getInset(i)->tocString(os); + if (getInset(i)->asInsetMath()) + os << " "; + } } return os.str(); @@ -2585,9 +2673,9 @@ docstring Paragraph::stringify(pos_type beg, pos_type end, int options, OutputPa for (pos_type i = beg; i < end; ++i) { char_type const c = d->text_[i]; if (isPrintable(c) || c == '\t' - || (c == '\n' && options & AS_STR_NEWLINES)) + || (c == '\n' && (options & AS_STR_NEWLINES))) os.put(c); - else if (c == META_INSET && options & AS_STR_INSETS) { + else if (c == META_INSET && (options & AS_STR_INSETS)) { getInset(i)->plaintext(os, runparams); } } @@ -2608,6 +2696,12 @@ int Paragraph::id() const } +void Paragraph::setId(int id) +{ + d->id_ = id; +} + + Layout const & Paragraph::layout() const { return *d->layout_; @@ -2649,12 +2743,6 @@ Inset const & Paragraph::inInset() const } -InsetCode Paragraph::ownerCode() const -{ - return d->inset_owner_ ? d->inset_owner_->lyxCode() : NO_CODE; -} - - ParagraphParameters & Paragraph::params() { return d->params_; @@ -2781,7 +2869,7 @@ 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 = - new InsetBibitem(buffer, InsetCommandParams(BIBITEM_CODE)); + new InsetBibitem(const_cast(&buffer), InsetCommandParams(BIBITEM_CODE)); // restore values of previously deleted item in this par. if (!oldkey.empty()) inset->setParam("key", oldkey); @@ -2799,21 +2887,21 @@ void Paragraph::checkAuthors(AuthorList const & authorList) } -bool Paragraph::isUnchanged(pos_type pos) const +bool Paragraph::isChanged(pos_type pos) const { - return lookupChange(pos).type == Change::UNCHANGED; + return lookupChange(pos).changed(); } bool Paragraph::isInserted(pos_type pos) const { - return lookupChange(pos).type == Change::INSERTED; + return lookupChange(pos).inserted(); } bool Paragraph::isDeleted(pos_type pos) const { - return lookupChange(pos).type == Change::DELETED; + return lookupChange(pos).deleted(); } @@ -2886,33 +2974,32 @@ void Paragraph::changeCase(BufferParams const & bparams, pos_type pos, } } - if (!isLetter(pos) || isDeleted(pos)) { + if (isWordSeparator(pos) || isDeleted(pos)) { // permit capitalization again capitalize = true; } - if (oldChar != newChar) + if (oldChar != newChar) { changes += newChar; + if (pos != right - 1) + continue; + // step behind the changing area + pos++; + } - if (oldChar == newChar || pos == right - 1) { - if (oldChar != newChar) { - // step behind the changing area - pos++; + int erasePos = pos - changes.size(); + for (size_t i = 0; i < changes.size(); i++) { + insertChar(pos, changes[i], + getFontSettings(bparams, + erasePos), + trackChanges); + if (!eraseChar(erasePos, trackChanges)) { + ++erasePos; + ++pos; // advance + ++right; // expand selection } - int erasePos = pos - changes.size(); - for (size_t i = 0; i < changes.size(); i++) { - insertChar(pos, changes[i], - getFontSettings(bparams, - erasePos), - trackChanges); - if (!eraseChar(erasePos, trackChanges)) { - ++erasePos; - ++pos; // advance - ++right; // expand selection - } - } - changes.clear(); } + changes.clear(); } } @@ -2939,10 +3026,10 @@ bool Paragraph::find(docstring const & str, bool cs, bool mw, // if necessary, check whether string matches word if (mw) { - if (pos > 0 && isLetter(pos - 1)) + if (pos > 0 && !isWordSeparator(pos - 1)) return false; if (pos + strsize < parsize - && isLetter(pos + strsize)) + && !isWordSeparator(pos + strsize)) return false; } @@ -2983,10 +3070,13 @@ bool Paragraph::isSeparator(pos_type pos) const void Paragraph::deregisterWords() { + map::const_iterator itl; Private::Words::const_iterator it; - WordList & wl = theWordList(); - for (it = d->words_.begin(); it != d->words_.end(); ++it) - wl.remove(*it); + for (itl = d->words_.begin(); itl != d->words_.end(); ++itl) { + WordList * wl = theWordList(itl->first); + for (it = (itl->second).begin(); it != (itl->second).end(); ++it) + wl->remove(*it); + } d->words_.clear(); } @@ -2997,8 +3087,8 @@ void Paragraph::locateWord(pos_type & from, pos_type & to, switch (loc) { case WHOLE_WORD_STRICT: if (from == 0 || from == size() - || !isLetter(from) - || !isLetter(from - 1)) { + || isWordSeparator(from) + || isWordSeparator(from - 1)) { to = from; return; } @@ -3006,13 +3096,13 @@ void Paragraph::locateWord(pos_type & from, pos_type & to, case WHOLE_WORD: // If we are already at the beginning of a word, do nothing - if (!from || !isLetter(from - 1)) + if (!from || isWordSeparator(from - 1)) break; // no break here, we go to the next case PREVIOUS_WORD: // always move the cursor to the beginning of previous word - while (from && isLetter(from - 1)) + while (from && !isWordSeparator(from - 1)) --from; break; case NEXT_WORD: @@ -3023,56 +3113,40 @@ void Paragraph::locateWord(pos_type & from, pos_type & to, break; } to = from; - while (to < size() && isLetter(to)) + while (to < size() && !isWordSeparator(to)) ++to; } void Paragraph::collectWords() { - SpellChecker * speller = theSpellChecker(); - - //lyxerr << "Words: "; pos_type n = size(); for (pos_type pos = 0; pos < n; ++pos) { - if (!isLetter(pos)) + if (isWordSeparator(pos)) continue; pos_type from = pos; locateWord(from, pos, WHOLE_WORD); - if (!lyxrc.spellcheck_continuously && pos - from < 6) - continue; - - docstring word = asString(from, pos, false); - if (pos - from >= 6) - d->words_.insert(word); - - if (!lyxrc.spellcheck_continuously || !speller) - continue; - - string const lang_code = lyxrc.spellchecker_alt_lang.empty() - ? getFontSettings(d->inset_owner_->buffer().params(), from).language()->code() - : lyxrc.spellchecker_alt_lang; - WordLangTuple wl(word, lang_code); - SpellChecker::Result res = speller->check(wl); - // ... just ignore any error that the spellchecker reports. - if (!speller->error().empty()) - continue; - bool const misspelled = res != SpellChecker::OK - && res != SpellChecker::IGNORED_WORD; - d->fontlist_.setMisspelled(from, pos, misspelled); - - //lyxerr << word << " "; + if (pos - from >= 6) { + docstring word = asString(from, pos, AS_STR_NONE); + FontList::const_iterator cit = d->fontlist_.fontIterator(pos); + if (cit == d->fontlist_.end()) + return; + Language const * lang = cit->font().language(); + d->words_[*lang].insert(word); + } } - //lyxerr << std::endl; } void Paragraph::registerWords() { + map::const_iterator itl; Private::Words::const_iterator it; - WordList & wl = theWordList(); - for (it = d->words_.begin(); it != d->words_.end(); ++it) - wl.insert(*it); + for (itl = d->words_.begin(); itl != d->words_.end(); ++itl) { + WordList * wl = theWordList(itl->first); + for (it = (itl->second).begin(); it != (itl->second).end(); ++it) + wl->insert(*it); + } } @@ -3084,31 +3158,79 @@ void Paragraph::updateWords() } -bool Paragraph::isMisspelled(pos_type pos) const +bool Paragraph::spellCheck(pos_type & from, pos_type & to, WordLangTuple & wl, + docstring_list & suggestions, bool do_suggestion) const { SpellChecker * speller = theSpellChecker(); - pos_type from = pos; - pos_type to = pos; - locateWord(from, to, WHOLE_WORD); - docstring word = asString(from, to, false); if (!speller) return false; - - string const lang_code = lyxrc.spellchecker_alt_lang.empty() - ? getFontSettings(d->inset_owner_->buffer().params(), from).language()->code() - : lyxrc.spellchecker_alt_lang; - WordLangTuple wl(word, lang_code); - SpellChecker::Result res = speller->check(wl); - // ... just ignore any error that the spellchecker reports. + + if (!d->layout_->spellcheck || !inInset().allowSpellCheck()) + return false; + + locateWord(from, to, WHOLE_WORD); + if (from == to || from >= pos_type(d->text_.size())) + return false; + + 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()) { + 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 bool const misspelled = res != SpellChecker::OK && res != SpellChecker::IGNORED_WORD; + if (lyxrc.spellcheck_continuously) - d->fontlist_.setMisspelled(from, pos, misspelled); + d->fontlist_.setMisspelled(from, to, misspelled); + + if (misspelled && do_suggestion) + speller->suggest(wl, suggestions); + else + suggestions.clear(); + return misspelled; } +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); +} + + +string Paragraph::magicLabel() const +{ + stringstream ss; + ss << "magicparlabel-" << id(); + return ss.str(); +} + + } // namespace lyx