X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FParagraph.cpp;h=150c28d6a9adafe53b8be2cdc7d224dbf3d297e9;hb=69036ced3765f40048d62be800c98af3ea2d1b4a;hp=e65ac22cabbf535b8f8487ee2b94e1bbf429214a;hpb=30c70c167018545139ee27cb965a26bef5914a57;p=lyx.git diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp index e65ac22cab..150c28d6a9 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 @@ -35,13 +36,15 @@ #include "LyXRC.h" #include "OutputParams.h" #include "output_latex.h" -#include "paragraph_funcs.h" +#include "output_xhtml.h" #include "ParagraphParameters.h" +#include "SpellChecker.h" #include "sgml.h" #include "TextClass.h" #include "TexRow.h" #include "Text.h" #include "VSpace.h" +#include "WordLangTuple.h" #include "WordList.h" #include "frontends/alert.h" @@ -49,13 +52,12 @@ #include "insets/InsetBibitem.h" #include "insets/InsetLabel.h" -#include "support/lassert.h" -#include "support/convert.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 @@ -93,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). @@ -162,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, @@ -171,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_; @@ -182,9 +189,8 @@ public: FontList fontlist_; /// - unsigned int id_; - /// - static unsigned int paragraph_id; + int id_; + /// ParagraphParameters params_; @@ -201,17 +207,15 @@ public: /// TextContainer text_; - typedef std::set Words; + typedef set Words; + typedef map LangWordsMap; /// - Words words_; + LangWordsMap words_; /// Layout const * layout_; }; -// Initialization of the counter for the paragraph id's, -unsigned int Paragraph::Private::paragraph_id = 0; - namespace { struct special_phrase { @@ -233,20 +237,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; } @@ -258,7 +268,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); @@ -286,6 +296,15 @@ void Paragraph::addChangesToToc(DocIterator const & cdit, } +bool Paragraph::isDeleted(pos_type start, pos_type end) const +{ + LASSERT(start >= 0 && start <= size(), /**/); + LASSERT(end > start && end <= size() + 1, /**/); + + return d->changes_.isDeleted(start, end); +} + + bool Paragraph::isChanged(pos_type start, pos_type end) const { LASSERT(start >= 0 && start <= size(), /**/); @@ -302,7 +321,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(); } @@ -323,7 +342,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); @@ -338,7 +357,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); } @@ -351,8 +370,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, /**/); @@ -362,14 +380,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: @@ -387,8 +405,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, /**/); @@ -398,7 +415,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: @@ -482,13 +499,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; } @@ -533,7 +550,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 @@ -542,12 +559,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; @@ -567,15 +590,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())) @@ -745,24 +767,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 @@ -824,16 +847,14 @@ void Paragraph::Private::latexInset( } if (tmp) { - for (int j = 0; j < tmp; ++j) - texrow.newline(); - + texrow.newlines(tmp); texrow.start(owner_->id(), i + 1); column = 0; } else { column += os.tellp() - len; } - if (owner_->lookupChange(i).type == Change::DELETED) + if (owner_->isDeleted(i)) --runparams.inDeletedInset; } @@ -951,7 +972,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; } @@ -1050,15 +1071,37 @@ 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; + // we have to provide all the optional arguments here, even though + // the last one is the only one we care about. + 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 (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); @@ -1073,7 +1116,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"); } @@ -1148,6 +1191,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 { @@ -1175,19 +1230,27 @@ 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 change = lookupChange(i); - Changes::lyxMarkChange(os, column, running_change, change); + Change const change = lookupChange(i); + if (change != running_change) + flushString(os, write_buffer); + Changes::lyxMarkChange(os, bparams, column, running_change, change); running_change = change; if (i == size()) break; - // Write font changes - Font const & font2 = getFontSettings(bparams, i); + // Write font changes (ignore spelling markers) + Font font2 = getFontSettings(bparams, i); + font2.setMisspelled(false); if (font2 != font1) { + flushString(os, write_buffer); font2.lyxWriteChanges(font1, os); column = 0; font1 = font2; @@ -1197,6 +1260,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 @@ -1213,10 +1277,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; @@ -1226,13 +1292,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; @@ -1240,13 +1307,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); } @@ -1579,7 +1647,8 @@ docstring const & Paragraph::labelString() const // the next two functions are for the manual labels docstring const Paragraph::getLabelWidthString() const { - if (d->layout_->margintype == MARGIN_MANUAL) + if (d->layout_->margintype == MARGIN_MANUAL + || d->layout_->latextype == LATEX_BIB_ENVIRONMENT) return d->params_.labelWidthString(); else return _("Senseless with this layout!"); @@ -1592,35 +1661,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}' @@ -1631,14 +1696,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); } @@ -1696,12 +1761,6 @@ void Paragraph::setBeginOfBody() } -bool Paragraph::forcePlainLayout() const -{ - return inInset().forcePlainLayout(); -} - - bool Paragraph::allowParagraphCustomization() const { return inInset().allowParagraphCustomization(); @@ -1796,6 +1855,7 @@ int Paragraph::Private::startTeXParParams(BufferParams const & bparams, case LYX_ALIGN_BLOCK: case LYX_ALIGN_LAYOUT: case LYX_ALIGN_SPECIAL: + case LYX_ALIGN_DECIMAL: break; case LYX_ALIGN_LEFT: case LYX_ALIGN_RIGHT: @@ -1808,7 +1868,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) { @@ -1816,6 +1876,7 @@ int Paragraph::Private::startTeXParParams(BufferParams const & bparams, case LYX_ALIGN_BLOCK: case LYX_ALIGN_LAYOUT: case LYX_ALIGN_SPECIAL: + case LYX_ALIGN_DECIMAL: break; case LYX_ALIGN_LEFT: { string output; @@ -1854,11 +1915,17 @@ int Paragraph::Private::endTeXParParams(BufferParams const & bparams, { int column = 0; - switch (params_.align()) { + LyXAlignment const curAlign = params_.align(); + + if (curAlign == layout_->align) + return column; + + switch (curAlign) { case LYX_ALIGN_NONE: case LYX_ALIGN_BLOCK: case LYX_ALIGN_LAYOUT: case LYX_ALIGN_SPECIAL: + case LYX_ALIGN_DECIMAL: break; case LYX_ALIGN_LEFT: case LYX_ALIGN_RIGHT: @@ -1871,14 +1938,15 @@ 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 (params_.align()) { + switch (curAlign) { case LYX_ALIGN_NONE: case LYX_ALIGN_BLOCK: case LYX_ALIGN_LAYOUT: case LYX_ALIGN_SPECIAL: + case LYX_ALIGN_DECIMAL: break; case LYX_ALIGN_LEFT: { string output; @@ -1912,23 +1980,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); - 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_; + 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. @@ -1958,6 +2027,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 @@ -1985,7 +2056,8 @@ 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 << "}] "; @@ -2014,13 +2086,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; } @@ -2079,9 +2152,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 @@ -2154,9 +2232,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, @@ -2171,21 +2248,22 @@ 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 << "}]~"; - 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); - return return_value; } @@ -2194,6 +2272,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 && @@ -2230,7 +2310,7 @@ string Paragraph::getID(Buffer const & buf, OutputParams const & runparams) } -pos_type Paragraph::firstWord(odocstream & os, OutputParams const & runparams) +pos_type Paragraph::firstWordDocBook(odocstream & os, OutputParams const & runparams) const { pos_type i; @@ -2248,6 +2328,24 @@ pos_type Paragraph::firstWord(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(xs, runparams); + } else { + char_type c = d->text_[i]; + if (c == ' ') + break; + xs << c; + } + } + return i; +} + + bool Paragraph::Private::onlyText(Buffer const & buf, Font const & outerfont, pos_type initial) const { Font font_old; @@ -2319,6 +2417,107 @@ void Paragraph::simpleDocBookOnePar(Buffer const & buf, } +docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf, + XHTMLStream & xs, + OutputParams const & runparams, + Font const & outerfont, + pos_type initial) const +{ + docstring retval; + + bool emph_flag = false; + bool bold_flag = false; + 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; + + // 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) { + xs << html::StartTag("em"); + emph_flag = true; + } else if (emph_flag && i != initial) { + xs << html::EndTag("em"); + emph_flag = false; + } + } + // bold + if (font_old.series() != font.fontInfo().series()) { + if (font.fontInfo().series() == BOLD_SERIES) { + xs << html::StartTag("strong"); + bold_flag = true; + } else if (bold_flag && i != initial) { + xs << html::EndTag("strong"); + bold_flag = false; + } + } + // 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) + xs << c; + else if (c == '-') { + docstring str; + int j = i + 1; + if (j < size() && d->text_[j] == '-') { + j += 1; + if (j < size() && d->text_[j] == '-') { + str += from_ascii("—"); + i += 2; + } else { + str += from_ascii("–"); + i += 1; + } + } + else + str += c; + // 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 + xs << c; + } + font_old = font.fontInfo(); + } + + xs.closeFontTags(); + return retval; +} + + bool Paragraph::isHfill(pos_type pos) const { Inset const * inset = getInset(pos); @@ -2344,13 +2543,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]; - return isLetterChar(c) || isDigit(c); + // 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)) + || pos == size(); } @@ -2386,8 +2587,7 @@ bool Paragraph::isRTL(BufferParams const & bparams) const { return lyxrc.rtl_support && getParLanguage(bparams)->rightToLeft() - && ownerCode() != ERT_CODE - && ownerCode() != LISTINGS_CODE; + && !inInset().getLayout().forceLTR(); } @@ -2407,7 +2607,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(); @@ -2420,6 +2620,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); @@ -2431,17 +2645,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(); @@ -2460,9 +2677,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); } } @@ -2483,6 +2700,12 @@ int Paragraph::id() const } +void Paragraph::setId(int id) +{ + d->id_ = id; +} + + Layout const & Paragraph::layout() const { return *d->layout_; @@ -2524,12 +2747,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_; @@ -2656,7 +2873,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); @@ -2674,21 +2891,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(); } @@ -2761,33 +2978,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(); } } @@ -2814,10 +3030,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; } @@ -2858,10 +3074,15 @@ bool Paragraph::isSeparator(pos_type pos) const void Paragraph::deregisterWords() { - Private::Words::const_iterator it; - WordList & wl = theWordList(); - for (it = d->words_.begin(); it != d->words_.end(); ++it) - wl.remove(*it); + 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(); + Private::Words::const_iterator et = (itl->second).end(); + for (; it != et; ++it) + wl->remove(*it); + } d->words_.clear(); } @@ -2872,8 +3093,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; } @@ -2881,13 +3102,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: @@ -2898,56 +3119,129 @@ 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(CursorSlice const & sl) +void Paragraph::collectWords() { - // find new words - bool inword = false; - - //lyxerr << "Words: "; + // 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 (isDeleted(pos)) + if (isWordSeparator(pos)) continue; - if (!isLetter(pos)) { - inword = false; - continue; - } - if (inword) - continue; - - inword = true; pos_type from = pos; locateWord(from, pos, WHOLE_WORD); - if (pos - from < 6) - continue; - docstring word = asString(from, pos, false); - d->words_.insert(word); - //lyxerr << word << " "; + 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()) + return; + Language const * lang = cit->font().language(); + d->words_[*lang].insert(word); + } } - //lyxerr << std::endl; } void Paragraph::registerWords() { - Private::Words::const_iterator it; - WordList & wl = theWordList(); - for (it = d->words_.begin(); it != d->words_.end(); ++it) - wl.insert(*it); + 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(); + Private::Words::const_iterator et = (itl->second).end(); + for (; it != et; ++it) + wl->insert(*it); + } } -void Paragraph::updateWords(CursorSlice const & sl) +void Paragraph::updateWords() { - LASSERT(&sl.paragraph() == this, /**/); deregisterWords(); - collectWords(sl); + collectWords(); registerWords(); } + +bool Paragraph::spellCheck(pos_type & from, pos_type & to, WordLangTuple & wl, + docstring_list & suggestions, bool do_suggestion) const +{ + SpellChecker * speller = theSpellChecker(); + if (!speller) + return false; + + 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, 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