X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=900837a49a80d2c26e790ef0de5d81f4f2f965e5;hb=9e1ce30ff75b0282f428738aa3f3562c21ceb9df;hp=a29dd641853c56de9e50feecb52b4f07afe059cb;hpb=76d84c61fd406f9c0c12969e1d2b182e7039e912;p=lyx.git diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C index a29dd64185..900837a49a 100644 --- a/src/paragraph_pimpl.C +++ b/src/paragraph_pimpl.C @@ -1,35 +1,43 @@ -/* This file is part of - * ====================================================== +/** + * \file paragraph_pimpl.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \author Lars Gullik Bjønnes + * \author Jean-Marc Lasgouttes + * \author John Levon + * \author André Pönitz * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. - * - * ====================================================== */ + * Full author contact details are available in file CREDITS. + */ #include #include "paragraph_pimpl.h" -#include "LaTeXFeatures.h" -#include "texrow.h" -#include "language.h" +#include "paragraph.h" + #include "bufferparams.h" +#include "debug.h" #include "encoding.h" +#include "language.h" +#include "LaTeXFeatures.h" +#include "LColor.h" +#include "lyxlength.h" #include "lyxrc.h" -#include "debug.h" -#include "paragraph_funcs.h" +#include "outputparams.h" +#include "texrow.h" + +#include -#include "support/LAssert.h" -using lyx::pos_type; +namespace lyx { + using std::endl; -using std::ostream; using std::upper_bound; using std::lower_bound; +using std::string; + -// Initialize static member. -ShareContainer Paragraph::Pimpl::FontTable::container; // Initialization of the counter for the paragraph id's, unsigned int Paragraph::Pimpl::paragraph_id = 0; @@ -37,19 +45,31 @@ namespace { struct special_phrase { string phrase; - string macro; + docstring macro; bool builtin; }; -special_phrase special_phrases[] = { - { "LyX", "\\LyX{}", false }, - { "TeX", "\\TeX{}", true }, - { "LaTeX2e", "\\LaTeXe{}", true }, - { "LaTeX", "\\LaTeX{}", true }, +special_phrase const special_phrases[] = { + { "LyX", from_ascii("\\LyX{}"), false }, + { "TeX", from_ascii("\\TeX{}"), true }, + { "LaTeX2e", from_ascii("\\LaTeXe{}"), true }, + { "LaTeX", from_ascii("\\LaTeX{}"), true }, }; 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 @@ -61,251 +81,190 @@ Paragraph::Pimpl::Pimpl(Paragraph * owner) } -Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner, bool same_ids) - : params(p.params), owner_(owner) +Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner) + : params(p.params), changes_(p.changes_), owner_(owner) { inset_owner = p.inset_owner; - text = p.text; fontlist = p.fontlist; - if (same_ids) - id_ = p.id_; - else - id_ = paragraph_id++; - - if (p.tracking()) - changes_.reset(new Changes(*p.changes_.get())); -} - - -void Paragraph::Pimpl::clear() -{ - text.clear(); -#warning changes ? -} - - -void Paragraph::Pimpl::setContentsFromPar(Paragraph const * par) -{ - lyx::Assert(par); - text = par->pimpl_->text; - if (par->pimpl_->tracking()) { - changes_.reset(new Changes(*(par->pimpl_->changes_.get()))); - } -} - - -void Paragraph::Pimpl::trackChanges(Change::Type type) -{ - if (tracking()) { - lyxerr[Debug::CHANGES] << "already tracking for par " << id_ << endl; - return; - } - - lyxerr[Debug::CHANGES] << "track changes for par " - << id_ << " type " << type << endl; - changes_.reset(new Changes(type)); - changes_->set(type, 0, size()); -} - - -void Paragraph::Pimpl::untrackChanges() -{ - changes_.reset(0); + id_ = paragraph_id++; } -void Paragraph::Pimpl::cleanChanges() +bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const { - // if we're not tracking, we don't want to reset... - if (!tracking()) - return; + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end > start && end <= size() + 1); - changes_.reset(new Changes(Change::INSERTED)); - changes_->set(Change::INSERTED, 0, size()); + return changes_.isChanged(start, end); } -bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const -{ - if (!tracking()) - return false; - - return changes_->isChange(start, end); -} +bool Paragraph::Pimpl::isMergedOnEndOfParDeletion(bool trackChanges) const { + // keep the logic here in sync with the logic of eraseChars() + if (!trackChanges) { + return true; + } -bool Paragraph::Pimpl::isChangeEdited(pos_type start, pos_type end) const -{ - if (!tracking()) - return false; + Change change = changes_.lookup(size()); - return changes_->isChangeEdited(start, end); + return change.type == Change::INSERTED && change.author == 0; } -void Paragraph::Pimpl::setChange(pos_type pos, Change::Type type) +void Paragraph::Pimpl::setChange(Change const & change) { - if (!tracking()) - return; - - changes_->set(type, pos); + // beware of the imaginary end-of-par character! + changes_.set(change, 0, size() + 1); + + /* + * Propagate the change recursively - but not in case of DELETED! + * + * Imagine that your co-author makes changes in an existing inset. He + * sends your document to you and you come to the conclusion that the + * inset should go completely. If you erase it, LyX must not delete all + * text within the inset. Otherwise, the change tracked insertions of + * your co-author get lost and there is no way to restore them later. + * + * Conclusion: An inset's content should remain untouched if you delete it + */ + + if (change.type != Change::DELETED) { + for (pos_type pos = 0; pos < size(); ++pos) { + if (owner_->isInset(pos)) { + owner_->getInset(pos)->setChange(change); + } + } + } } -Change::Type Paragraph::Pimpl::lookupChange(pos_type pos) const +void Paragraph::Pimpl::setChange(pos_type pos, Change const & change) { - if (!tracking()) - return Change::UNCHANGED; + BOOST_ASSERT(pos >= 0 && pos <= size()); - return changes_->lookup(pos); -} + changes_.set(change, pos); + // see comment in setChange(Change const &) above -Change const Paragraph::Pimpl::lookupChangeFull(pos_type pos) const -{ - if (!tracking()) - return Change(Change::UNCHANGED); - - return changes_->lookupFull(pos); + if (change.type != Change::DELETED && + pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->setChange(change); + } } -void Paragraph::Pimpl::markErased() +Change const & Paragraph::Pimpl::lookupChange(pos_type pos) const { - lyx::Assert(tracking()); + BOOST_ASSERT(pos >= 0 && pos <= size()); - // FIXME: we should actually remove INSERTED chars. - // difficult because owning insettexts/tabulars need - // to update themselves when rows etc. change - changes_->set(Change::DELETED, 0, size()); - changes_->reset(Change::DELETED); + return changes_.lookup(pos); } -void Paragraph::Pimpl::acceptChange(pos_type start, pos_type end) +void Paragraph::Pimpl::acceptChanges(BufferParams const & bparams, pos_type start, pos_type end) { - if (!tracking()) - return; + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end > start && end <= size() + 1); - if (!size()) { - changes_.reset(new Changes(Change::UNCHANGED)); - return; - } - - lyxerr << "acceptchange" << endl; - pos_type i = start; - - for (; i < end; ++i) { - switch (lookupChange(i)) { + 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::UNCHANGED, i); + 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: - eraseIntern(i); - changes_->erase(i); - --end; - --i; + // Suppress access to non-existent + // "end-of-paragraph char" + if (pos < size()) { + eraseChar(pos, false); + --end; + --pos; + } break; } - } - lyxerr << "endacceptchange" << endl; - changes_->reset(Change::UNCHANGED); + } } -void Paragraph::Pimpl::rejectChange(pos_type start, pos_type end) +void Paragraph::Pimpl::rejectChanges(BufferParams const & bparams, pos_type start, pos_type end) { - if (!tracking()) - return; + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end > start && end <= size() + 1); - if (!size()) { - changes_.reset(new Changes(Change::UNCHANGED)); - return; - } - - pos_type i = start; - - for (; i < end; ++i) { - switch (lookupChange(i)) { + 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: - eraseIntern(i); - changes_->erase(i); - --end; - --i; + // Suppress access to non-existent + // "end-of-paragraph char" + if (pos < size()) { + eraseChar(pos, false); + --end; + --pos; + } break; case Change::DELETED: - changes_->set(Change::UNCHANGED, i); + changes_.set(Change(Change::UNCHANGED), pos); + + // Do NOT reject changes within a deleted inset! + // There may be insertions of a co-author inside of it! + break; } } - changes_->reset(Change::UNCHANGED); } Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const { -#if 1 - // This is in the critical path for loading! - pos_type const siz = size(); - - lyx::Assert(pos <= siz); - - if (pos == siz) { - lyxerr << "getChar() on pos " << pos << " in par id " - << owner_->id() << " of size " << siz - << " is a bit silly !" << endl; - return '\0'; - } - - return text[pos]; -#else - lyx::Assert(pos < size()); - return text[pos]; -#endif -} - + BOOST_ASSERT(pos >= 0 && pos <= size()); -void Paragraph::Pimpl::setChar(pos_type pos, value_type c) -{ -#warning changes - text[pos] = c; + return owner_->getChar(pos); } -void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, - LyXFont const & font, Change change) +void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & change) { - lyx::Assert(pos <= size()); + BOOST_ASSERT(pos >= 0 && pos <= size()); - if (tracking()) { - changes_->record(change, pos); - } + // track change + changes_.insert(change, pos); // This is actually very common when parsing buffers (and // maybe inserting ascii text) if (pos == size()) { // when appending characters, no need to update tables - text.push_back(c); - owner_->setFont(pos, font); + owner_->text_.push_back(c); return; } - text.insert(text.begin() + pos, c); + owner_->text_.insert(owner_->text_.begin() + pos, c); // Update the font table. FontTable search_font(pos, LyXFont()); - for (FontList::iterator it = lower_bound(fontlist.begin(), - fontlist.end(), - search_font, matchFT()); + for (FontList::iterator it + = lower_bound(fontlist.begin(), fontlist.end(), search_font, matchFT()); it != fontlist.end(); ++it) { it->pos(it->pos() + 1); @@ -313,60 +272,62 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, // Update the insets owner_->insetlist.increasePosAfterPos(pos); - - owner_->setFont(pos, font); } -void Paragraph::Pimpl::insertInset(pos_type pos, - Inset * inset, LyXFont const & font, Change change) +void Paragraph::Pimpl::insertInset(pos_type pos, InsetBase * inset, + Change const & change) { - lyx::Assert(inset); - lyx::Assert(pos <= size()); + BOOST_ASSERT(inset); + BOOST_ASSERT(pos >= 0 && pos <= size()); - insertChar(pos, META_INSET, font, change); - lyx::Assert(text[pos] == META_INSET); + insertChar(pos, META_INSET, change); + BOOST_ASSERT(owner_->text_[pos] == META_INSET); // Add a new entry in the insetlist. owner_->insetlist.insert(inset, pos); - inset->parOwner(owner_); - - if (inset_owner) - inset->setOwner(inset_owner); } -bool Paragraph::Pimpl::erasePos(pos_type pos) +bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges) { - lyx::Assert(pos < size()); + BOOST_ASSERT(pos >= 0 && pos <= size()); - if (tracking()) { - Change::Type changetype(changes_->lookup(pos)); - changes_->record(Change(Change::DELETED), pos); + // keep the logic here in sync with the logic of isMergedOnEndOfParDeletion() - // only allow the actual removal if it was /new/ text - if (changetype != Change::INSERTED) { - if (text[pos] == Paragraph::META_INSET) { - Inset * i(owner_->getInset(pos)); - i->markErased(); - } + if (trackChanges) { + 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 (change.type == Change::UNCHANGED || + (change.type == Change::INSERTED && change.author != 0)) { + setChange(pos, Change(Change::DELETED)); return false; } + + if (change.type == Change::DELETED) + return false; } - eraseIntern(pos); - return true; -} + // 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()) { + return false; + } + // track change + changes_.erase(pos); -void Paragraph::Pimpl::eraseIntern(pos_type pos) -{ // if it is an inset, delete the inset entry - if (text[pos] == Paragraph::META_INSET) { + if (owner_->text_[pos] == Paragraph::META_INSET) { owner_->insetlist.erase(pos); } - text.erase(text.begin() + pos); + owner_->text_.erase(owner_->text_.begin() + pos); // Erase entries in the tables. FontTable search_font(pos, LyXFont()); @@ -393,52 +354,78 @@ void Paragraph::Pimpl::eraseIntern(pos_type pos) } } - // Update all other entries. + // Update all other entries FontList::iterator fend = fontlist.end(); for (; it != fend; ++it) it->pos(it->pos() - 1); - // Update the insetlist. + // Update the insetlist owner_->insetlist.decreasePosAfterPos(pos); -} - -void Paragraph::Pimpl::erase(pos_type pos) -{ - erasePos(pos); + return true; } -int Paragraph::Pimpl::erase(pos_type start, pos_type end) +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); + pos_type i = start; - pos_type count = end - start; - while (count) { - if (!erasePos(i)) { + for (pos_type count = end - start; count; --count) { + if (!eraseChar(i, trackChanges)) ++i; - } - --count; } return end - i; } -void Paragraph::Pimpl::simpleTeXBlanks(ostream & 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 (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 (column > lyxrc.ascii_linelen + if (lyxrc.plaintext_linelen > 0 + && column > lyxrc.plaintext_linelen && i && getChar(i - 1) != ' ' && (i < size() - 1) // same in FreeSpacing mode - && !style.free_spacing - && !owner_->isFreeSpacing() + && !owner_->isFreeSpacing() // In typewriter mode, we want to avoid // ! . ? : at the end of a line && !(font.family() == LyXFont::TYPEWRITER_FAMILY @@ -448,13 +435,14 @@ void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow, || getChar(i - 1) == '!'))) { os << '\n'; texrow.newline(); - texrow.start(owner_, i + 1); + texrow.start(owner_->id(), i + 1); column = 0; } else if (style.free_spacing) { os << '~'; } else { os << ' '; } + return false; } @@ -468,7 +456,9 @@ 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) { - if (str[i] != text[pos + i]) + // Caution: direct comparison of characters works only + // because str is pure ASCII. + if (str[i] != owner_->text_[pos + i]) return false; } @@ -486,11 +476,12 @@ bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const } -void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, +void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, BufferParams const & bparams, - ostream & os, + Encoding const & doc_encoding, + odocstream & os, TexRow & texrow, - bool moving_arg, + OutputParams const & runparams, LyXFont & font, LyXFont & running_font, LyXFont & basefont, @@ -505,11 +496,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, if (style.pass_thru) { if (c != Paragraph::META_INSET) { if (c != '\0') - os << c; - } else { - Inset const * inset = owner_->getInset(i); - inset->ascii(buf, os, 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); return; } @@ -518,21 +509,22 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, // and then split to handle the two modes separately. switch (c) { case Paragraph::META_INSET: { - Inset * inset = owner_->getInset(i); + InsetBase * inset = owner_->getInset(i); // FIXME: remove this check if (!inset) break; // FIXME: move this to InsetNewline::latex - if (inset->lyxCode() == Inset::NEWLINE_CODE) { + if (inset->lyxCode() == InsetBase::NEWLINE_CODE) { // newlines are handled differently here than // the default in simpleTeXSpecialChars(). if (!style.newline_allowed) { 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); @@ -541,29 +533,37 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, if (font.family() == LyXFont::TYPEWRITER_FAMILY) os << '~'; - if (moving_arg) + if (runparams.moving_arg) os << "\\protect "; os << "\\\\\n"; } texrow.newline(); - texrow.start(owner_, i + 1); + texrow.start(owner_->id(), i + 1); column = 0; break; } - if (inset->isTextInset()) { + // output change tracking marks only if desired, + // if dvipost is installed, + // and with dvi/ps (other formats don't work) + LaTeXFeatures features(buf, bparams, runparams); + bool const output = bparams.outputChanges + && runparams.flavor == OutputParams::LATEX + && features.isAvailable("dvipost"); + + if (inset->canTrackChanges()) { column += Changes::latexMarkChange(os, running_change, - Change::UNCHANGED); + Change::UNCHANGED, output); running_change = Change::UNCHANGED; } bool close = false; - int const len = os.tellp(); - //ostream::pos_type const len = os.tellp(); - if ((inset->lyxCode() == Inset::GRAPHICS_CODE - || inset->lyxCode() == Inset::MATH_CODE - || inset->lyxCode() == Inset::URL_CODE) + odocstream::pos_type const len = os.tellp(); + + if ((inset->lyxCode() == InsetBase::GRAPHICS_CODE + || inset->lyxCode() == InsetBase::MATH_CODE + || inset->lyxCode() == InsetBase::URL_CODE) && running_font.isRightToLeft()) { os << "\\L{"; close = true; @@ -577,17 +577,14 @@ 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; } - int tmp = inset->latex(buf, os, moving_arg, - style.free_spacing); + int tmp = inset->latex(buf, os, runparams); if (close) os << '}'; @@ -596,10 +593,10 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, for (int j = 0; j < tmp; ++j) { texrow.newline(); } - texrow.start(owner_, i + 1); + texrow.start(owner_->id(), i + 1); column = 0; } else { - column += int(os.tellp()) - len; + column += os.tellp() - len; } } break; @@ -613,46 +610,32 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, column += 15; break; - case '±': case '²': case '³': - case '×': case '÷': case '¹': - case '¬': case 'µ': - if ((bparams.inputenc == "latin1" || - bparams.inputenc == "latin9") || - (bparams.inputenc == "auto" && - (font.language()->encoding()->LatexName() - == "latin1" || - font.language()->encoding()->LatexName() - == "latin9"))) { - os << "\\ensuremath{" - << c - << '}'; - column += 13; - } else { - os << c; - } - break; - + // The following characters could be written literally in latin1, but they + // 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 '|': case '<': case '>': // In T1 encoding, these characters exist if (lyxrc.fontenc == "T1") { - os << c; + os.put(c); //... but we should avoid ligatures if ((c == '>' || c == '<') && 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; } // Typewriter font also has them if (font.family() == LyXFont::TYPEWRITER_FAMILY) { - os << c; + os.put(c); break; } // Otherwise, we use what LaTeX @@ -689,19 +672,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, column += 9; break; - case '£': - if (bparams.inputenc == "default") { - os << "\\pounds{}"; - column += 8; - } else { - os << c; - } - break; - case '$': case '&': case '%': case '#': case '{': case '}': case '_': - os << '\\' << c; + os << '\\'; + os.put(c); column += 1; break; @@ -715,9 +690,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, column += 17; break; - case '*': case '[': case ']': + case '*': case '[': // avoid being mistaken for optional arguments - os << '{' << c << '}'; + os << '{'; + os.put(c); + os << '}'; column += 2; break; @@ -732,9 +709,11 @@ 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 << c; + os.put(c); } break; } @@ -759,7 +738,27 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, } if (pnr == phrases_nr && c != '\0') { - os << 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; } @@ -773,8 +772,6 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, BufferParams const & bparams = features.bufferParams(); // check the params. - if (params.lineTop() || params.lineBottom()) - features.require("lyxline"); if (!params.spacing().isDefault()) features.require("setspace"); @@ -793,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()) { @@ -808,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; } @@ -827,18 +824,19 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, features.require("ParagraphLeftIndent"); // then the insets - InsetList::iterator icit = owner_->insetlist.begin(); - InsetList::iterator iend = owner_->insetlist.end(); + InsetList::const_iterator icit = owner_->insetlist.begin(); + InsetList::const_iterator iend = owner_->insetlist.end(); for (; icit != iend; ++icit) { - if (icit.getInset()) { - icit.getInset()->validate(features); + if (icit->inset) { + icit->inset->validate(features); if (layout.needprotect && - icit.getInset()->lyxCode() == Inset::FOOT_CODE) + icit->inset->lyxCode() == InsetBase::FOOT_CODE) features.require("NeedLyXFootnoteCode"); } } // 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 @@ -847,5 +845,14 @@ 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); } } + + +} // namespace lyx