X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=900837a49a80d2c26e790ef0de5d81f4f2f965e5;hb=ba62665f966508db5a4de6864f4aa7374c5a5356;hp=e7b1b57102ef57a663405505745550f8642746fb;hpb=62b09e3dbde8d38b8eff2aaff3e8b95341d6b336;p=lyx.git diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C index e7b1b57102..900837a49a 100644 --- a/src/paragraph_pimpl.C +++ b/src/paragraph_pimpl.C @@ -58,6 +58,18 @@ special_phrase const special_phrases[] = { size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase); + +/// Get the real encoding of a character with font \p font. +/// doc_encoding == bparams.encoding(), but we use a precomputed variable +/// since bparams.encoding() is expensive +inline Encoding const & getEncoding(BufferParams const & bparams, + Encoding const & doc_encoding, LyXFont const & font) +{ + if (bparams.inputenc == "auto" || bparams.inputenc == "default") + return *(font.language()->encoding()); + return doc_encoding; +} + } // namespace anon @@ -78,15 +90,6 @@ Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner) } -void Paragraph::Pimpl::setContentsFromPar(Paragraph const & par) -{ - owner_->text_ = par.text_; - // FIXME: change tracking (MG) - // check whether this method is really needed - changes_ = par.pimpl_->changes_; -} - - bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const { BOOST_ASSERT(start >= 0 && start <= size()); @@ -96,6 +99,19 @@ bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const } +bool Paragraph::Pimpl::isMergedOnEndOfParDeletion(bool trackChanges) const { + // keep the logic here in sync with the logic of eraseChars() + + if (!trackChanges) { + return true; + } + + Change change = changes_.lookup(size()); + + return change.type == Change::INSERTED && change.author == 0; +} + + void Paragraph::Pimpl::setChange(Change const & change) { // beware of the imaginary end-of-par character! @@ -138,7 +154,7 @@ void Paragraph::Pimpl::setChange(pos_type pos, Change const & change) } -Change const Paragraph::Pimpl::lookupChange(pos_type pos) const +Change const & Paragraph::Pimpl::lookupChange(pos_type pos) const { BOOST_ASSERT(pos >= 0 && pos <= size()); @@ -146,18 +162,27 @@ Change const Paragraph::Pimpl::lookupChange(pos_type pos) const } -void Paragraph::Pimpl::acceptChanges(pos_type start, pos_type end) +void Paragraph::Pimpl::acceptChanges(BufferParams const & bparams, pos_type start, pos_type end) { BOOST_ASSERT(start >= 0 && start <= size()); BOOST_ASSERT(end > start && end <= size() + 1); - + for (pos_type pos = start; pos < end; ++pos) { switch (lookupChange(pos).type) { case Change::UNCHANGED: + // accept changes in nested inset + if (pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->acceptChanges(bparams); + } + break; case Change::INSERTED: changes_.set(Change(Change::UNCHANGED), pos); + // also accept changes in nested inset + if (pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->acceptChanges(bparams); + } break; case Change::DELETED: @@ -171,15 +196,11 @@ void Paragraph::Pimpl::acceptChanges(pos_type start, pos_type end) break; } - // also accept changes in nested insets - if (pos < size() && owner_->isInset(pos)) { - owner_->getInset(pos)->acceptChanges(); - } } } -void Paragraph::Pimpl::rejectChanges(pos_type start, pos_type end) +void Paragraph::Pimpl::rejectChanges(BufferParams const & bparams, pos_type start, pos_type end) { BOOST_ASSERT(start >= 0 && start <= size()); BOOST_ASSERT(end > start && end <= size() + 1); @@ -187,6 +208,10 @@ void Paragraph::Pimpl::rejectChanges(pos_type start, pos_type end) for (pos_type pos = start; pos < end; ++pos) { switch (lookupChange(pos).type) { case Change::UNCHANGED: + // reject changes in nested inset + if (pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->rejectChanges(bparams); + } break; case Change::INSERTED: @@ -201,12 +226,11 @@ void Paragraph::Pimpl::rejectChanges(pos_type start, pos_type end) case Change::DELETED: changes_.set(Change(Change::UNCHANGED), pos); - break; - } - // also reject changes in nested insets - if (pos < size() && owner_->isInset(pos)) { - owner_->getInset(pos)->rejectChanges(); + // Do NOT reject changes within a deleted inset! + // There may be insertions of a co-author inside of it! + + break; } } } @@ -269,22 +293,29 @@ bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges) { BOOST_ASSERT(pos >= 0 && pos <= size()); + // keep the logic here in sync with the logic of isMergedOnEndOfParDeletion() + if (trackChanges) { - Change::Type changetype(changes_.lookup(pos).type); + Change change = changes_.lookup(pos); + + // set the character to DELETED if + // a) it was previously unchanged or + // b) it was inserted by a co-author - if (changetype == Change::UNCHANGED) { + if (change.type == Change::UNCHANGED || + (change.type == Change::INSERTED && change.author != 0)) { setChange(pos, Change(Change::DELETED)); return false; } - if (changetype == Change::DELETED) + if (change.type == Change::DELETED) return false; } - // Don't physically access nonexistent end-of-paragraph char + // Don't physically access the imaginary end-of-paragraph character. + // eraseChar() can only mark it as DELETED. A physical deletion of + // end-of-par must be handled externally. if (pos == size()) { - // FIXME: change tracking (MG) - // how do we handle end-of-pars previously marked inserted? return false; } @@ -338,7 +369,7 @@ bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges) int Paragraph::Pimpl::eraseChars(pos_type start, pos_type end, bool trackChanges) { BOOST_ASSERT(start >= 0 && start <= size()); - BOOST_ASSERT(end > start && end <= size() + 1); + BOOST_ASSERT(end >= start && end <= size() + 1); pos_type i = start; for (pos_type count = end - start; count; --count) { @@ -349,16 +380,47 @@ int Paragraph::Pimpl::eraseChars(pos_type start, pos_type end, bool trackChanges } -void Paragraph::Pimpl::simpleTeXBlanks(odocstream & os, TexRow & texrow, - pos_type const i, +int Paragraph::Pimpl::latexSurrogatePair(odocstream & os, value_type c, + value_type next, Encoding const & encoding) +{ + // Writing next here may circumvent a possible font change between + // c and next. Since next is only output if it forms a surrogate pair + // with c we can ignore this: + // A font change inside a surrogate pair does not make sense and is + // hopefully impossible to input. + // FIXME: change tracking + // Is this correct WRT change tracking? + docstring const latex1 = encoding.latexChar(next); + docstring const latex2 = encoding.latexChar(c); + os << latex1 << '{' << latex2 << '}'; + return latex1.length() + latex2.length() + 2; +} + + +bool Paragraph::Pimpl::simpleTeXBlanks(BufferParams const & bparams, + Encoding const & doc_encoding, + odocstream & os, TexRow & texrow, + pos_type & i, unsigned int & column, LyXFont const & font, LyXLayout const & style) { if (style.pass_thru) - return; + return false; - if (column > lyxrc.ascii_linelen + if (i < size() - 1) { + char_type next = getChar(i + 1); + if (Encodings::isCombiningChar(next)) { + // This space has an accent, so we must always output it. + Encoding const & encoding = getEncoding(bparams, doc_encoding, font); + column += latexSurrogatePair(os, ' ', next, encoding) - 1; + ++i; + return true; + } + } + + if (lyxrc.plaintext_linelen > 0 + && column > lyxrc.plaintext_linelen && i && getChar(i - 1) != ' ' && (i < size() - 1) @@ -380,6 +442,7 @@ void Paragraph::Pimpl::simpleTeXBlanks(odocstream & os, TexRow & texrow, } else { os << ' '; } + return false; } @@ -393,6 +456,8 @@ bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const // does the wanted text start at point? for (string::size_type i = 0; i < str.length(); ++i) { + // Caution: direct comparison of characters works only + // because str is pure ASCII. if (str[i] != owner_->text_[pos + i]) return false; } @@ -413,6 +478,7 @@ bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, BufferParams const & bparams, + Encoding const & doc_encoding, odocstream & os, TexRow & texrow, OutputParams const & runparams, @@ -430,6 +496,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, if (style.pass_thru) { if (c != Paragraph::META_INSET) { if (c != '\0') + // FIXME UNICODE: This can fail if c cannot + // be encoded in the current encoding. os.put(c); } else owner_->getInset(i)->plaintext(buf, os, runparams); @@ -455,7 +523,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, os << '\n'; } else { if (open_font) { - column += running_font.latexWriteEndChanges(os, basefont, basefont); + column += running_font.latexWriteEndChanges( + os, basefont, basefont, bparams); open_font = false; } basefont = owner_->getLayoutFont(bparams, outerfont); @@ -508,10 +577,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, #endif // some insets cannot be inside a font change command if (open_font && inset->noFontChange()) { - column +=running_font. - latexWriteEndChanges(os, - basefont, - basefont); + column += running_font.latexWriteEndChanges( + os, basefont, basefont, bparams); open_font = false; basefont = owner_->getLayoutFont(bparams, outerfont); running_font = basefont; @@ -547,30 +614,6 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, // would be wrongly converted on systems where char is signed, so we give // the code points. // This also makes us independant from the encoding of this source file. - case 0xb1: // ± PLUS-MINUS SIGN - case 0xb2: // ² SUPERSCRIPT TWO - case 0xb3: // ³ SUPERSCRIPT THREE - case 0xd7: // × MULTIPLICATION SIGN - case 0xf7: // ÷ DIVISION SIGN - case 0xb9: // ¹ SUPERSCRIPT ONE - case 0xac: // ¬ NOT SIGN - case 0xb5: // µ MICRO SIGN - if ((bparams.inputenc == "latin1" || - bparams.inputenc == "latin9") || - (bparams.inputenc == "auto" && - (font.language()->encoding()->latexName() - == "latin1" || - font.language()->encoding()->latexName() - == "latin9"))) { - os << "\\ensuremath{"; - os.put(c); - os << '}'; - column += 13; - } else { - os.put(c); - } - break; - case '|': case '<': case '>': // In T1 encoding, these characters exist if (lyxrc.fontenc == "T1") { @@ -580,12 +623,13 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, && i <= size() - 2 && getChar(i + 1) == c) { //os << "\\textcompwordmark{}"; + //column += 19; // Jean-Marc, have a look at // this. I think this works // equally well: os << "\\,{}"; // Lgb - column += 19; + column += 3; } break; } @@ -628,15 +672,6 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, column += 9; break; - case 0xa3: // £ POUND SIGN - if (bparams.inputenc == "default") { - os << "\\pounds{}"; - column += 8; - } else { - os.put(c); - } - break; - case '$': case '&': case '%': case '#': case '{': case '}': case '_': @@ -674,6 +709,8 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, default: // I assume this is hack treating typewriter as verbatim + // FIXME UNICODE: This can fail if c cannot be encoded + // in the current encoding. if (font.family() == LyXFont::TYPEWRITER_FAMILY) { if (c != '\0') { os.put(c); @@ -701,7 +738,27 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, } if (pnr == phrases_nr && c != '\0') { - os.put(c); + Encoding const & encoding = getEncoding(bparams, doc_encoding, font); + if (i < size() - 1) { + char_type next = getChar(i + 1); + if (Encodings::isCombiningChar(next)) { + column += latexSurrogatePair(os, c, next, encoding) - 1; + ++i; + break; + } + } + docstring const latex = encoding.latexChar(c); + if (latex.length() > 1 && + latex[latex.length() - 1] != '}') { + // Prevent eating of a following + // space or command corruption by + // following characters + column += latex.length() + 1; + os << latex << "{}"; + } else { + column += latex.length() - 1; + os << latex; + } } break; } @@ -733,7 +790,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, << endl; features.require("noun"); lyxerr[Debug::LATEX] << "Noun enabled. Font: " - << fcit->font().stateText(0) + << to_utf8(fcit->font().stateText(0)) << endl; } switch (fcit->font().color()) { @@ -748,7 +805,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, default: features.require("color"); lyxerr[Debug::LATEX] << "Color enabled. Font: " - << fcit->font().stateText(0) + << to_utf8(fcit->font().stateText(0)) << endl; } @@ -779,6 +836,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, } // then the contents + Encoding const & doc_encoding = bparams.encoding(); for (pos_type i = 0; i < size() ; ++i) { for (size_t pnr = 0; pnr < phrases_nr; ++pnr) { if (!special_phrases[pnr].builtin @@ -787,6 +845,12 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, break; } } + // We do not need the completely realized font, since we are + // only interested in the language, and that is never inherited. + // Therefore we can use getFontSettings instead of getFont. + LyXFont const & font = owner_->getFontSettings(bparams, i); + Encoding const & encoding = getEncoding(bparams, doc_encoding, font); + encoding.validate(getChar(i), features); } }