X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=426862c246e3f8d04151b46d8ac03ef240cc1268;hb=35204f8f33d7400a5fefeffea533fb4cb4097211;hp=0db77625212f0b4110dab3c7035318472726f262;hpb=ce3b1fa997fd9451d627d0eae03f8a8336a1c696;p=lyx.git diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C index 0db7762521..426862c246 100644 --- a/src/paragraph_pimpl.C +++ b/src/paragraph_pimpl.C @@ -1,34 +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 "outputparams.h" +#include "texrow.h" + +#include + -#include "support/LAssert.h" +namespace lyx { -using lyx::pos_type; 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; @@ -36,15 +45,15 @@ 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); @@ -60,245 +69,172 @@ 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); -} - - -void Paragraph::Pimpl::cleanChanges() -{ - // if we're not tracking, we don't want to reset... - if (!tracking()) - return; - - changes_.reset(new Changes(Change::INSERTED)); - changes_->set(Change::INSERTED, 0, size()); + id_ = paragraph_id++; } bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const { - if (!tracking()) - return false; - - return changes_->isChange(start, end); -} - - -bool Paragraph::Pimpl::isChangeEdited(pos_type start, pos_type end) const -{ - if (!tracking()) - return false; + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end > start && end <= size() + 1); - return changes_->isChangeEdited(start, end); + return changes_.isChanged(start, end); } -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; - - return changes_->lookup(pos); -} + BOOST_ASSERT(pos >= 0 && pos <= size()); + changes_.set(change, pos); -Change const Paragraph::Pimpl::lookupChangeFull(pos_type pos) const -{ - if (!tracking()) - return Change(Change::UNCHANGED); + // see comment in setChange(Change const &) above - 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(pos_type start, pos_type end) { - if (!tracking()) - return; - - if (!size()) { - changes_.reset(new Changes(Change::UNCHANGED)); - return; - } - - lyxerr << "acceptchange" << endl; - pos_type i = start; - - for (; i < end; ++i) { - switch (lookupChange(i)) { + 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: break; case Change::INSERTED: - changes_->set(Change::UNCHANGED, i); + changes_.set(Change(Change::UNCHANGED), pos); 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); + // also accept changes in nested insets + if (pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->acceptChanges(); + } + } } -void Paragraph::Pimpl::rejectChange(pos_type start, pos_type end) +void Paragraph::Pimpl::rejectChanges(pos_type start, pos_type end) { - if (!tracking()) - return; - - if (!size()) { - changes_.reset(new Changes(Change::UNCHANGED)); - return; - } - - pos_type i = start; + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end > start && end <= size() + 1); - for (; i < end; ++i) { - switch (lookupChange(i)) { + for (pos_type pos = start; pos < end; ++pos) { + switch (lookupChange(pos).type) { case Change::UNCHANGED: + // also reject changes inside of insets + if (pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->rejectChanges(); + } 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 { - // This is in the critical path for loading! - pos_type const siz = size(); - lyx::Assert(pos <= siz); - // This is stronger, and I belive that this is the assertion - // that we should really use. (Lgb) - //Assert(pos < size()); - - // Then this has no meaning. (Lgb) - if (!siz || pos == siz) - return '\0'; - - return text[pos]; -} + 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); @@ -306,60 +242,60 @@ 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); + if (trackChanges) { + Change change = changes_.lookup(pos); - // 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(); - } + // 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()); @@ -386,54 +322,47 @@ 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; } -bool Paragraph::Pimpl::erase(pos_type start, pos_type end) +int Paragraph::Pimpl::eraseChars(pos_type start, pos_type end, bool trackChanges) { - pos_type i = start; - pos_type count = end - start; - bool any_erased = false; + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end >= start && end <= size() + 1); - while (count) { - if (!erasePos(i)) { + pos_type i = start; + for (pos_type count = end - start; count; --count) { + if (!eraseChar(i, trackChanges)) ++i; - } else { - any_erased = true; - } - --count; } - return any_erased; + return end - i; } -void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow, +void Paragraph::Pimpl::simpleTeXBlanks(odocstream & os, TexRow & texrow, pos_type const i, unsigned int & column, LyXFont const & font, LyXLayout const & style) { - if (style.pass_thru) return; + if (style.pass_thru) + return; + if (column > lyxrc.ascii_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 @@ -443,7 +372,7 @@ 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 << '~'; @@ -463,7 +392,7 @@ 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]) + if (str[i] != owner_->text_[pos + i]) return false; } @@ -481,14 +410,15 @@ 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, + odocstream & os, TexRow & texrow, - bool moving_arg, + OutputParams const & runparams, LyXFont & font, LyXFont & running_font, LyXFont & basefont, + LyXFont const & outerfont, bool & open_font, Change::Type & running_change, LyXLayout const & style, @@ -497,8 +427,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, value_type const c) { if (style.pass_thru) { - if (c != '\0') - os << c; + if (c != Paragraph::META_INSET) { + if (c != '\0') + os.put(c); + } else + owner_->getInset(i)->plaintext(buf, os, runparams); return; } @@ -507,24 +440,60 @@ 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; - if (inset->isTextInset()) { + // FIXME: move this to InsetNewline::latex + 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); + open_font = false; + } + basefont = owner_->getLayoutFont(bparams, outerfont); + running_font = basefont; + + if (font.family() == LyXFont::TYPEWRITER_FAMILY) + os << '~'; + + if (runparams.moving_arg) + os << "\\protect "; + + os << "\\\\\n"; + } + texrow.newline(); + texrow.start(owner_->id(), i + 1); + column = 0; + break; + } + + // 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; @@ -543,12 +512,11 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, basefont, basefont); open_font = false; - basefont = owner_->getLayoutFont(bparams); + 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 << '}'; @@ -557,25 +525,14 @@ 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; - case Paragraph::META_NEWLINE: - if (open_font) { - column += running_font.latexWriteEndChanges(os, - basefont, - basefont); - open_font = false; - } - basefont = owner_->getLayoutFont(bparams); - running_font = basefont; - break; - default: // And now for the special cases within each mode @@ -585,29 +542,38 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, column += 15; break; - case '±': case '²': case '³': - case '×': case '÷': case '¹': - case '¬': case 'µ': + // 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 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() + (font.language()->encoding()->latexName() == "latin1" || - font.language()->encoding()->LatexName() + font.language()->encoding()->latexName() == "latin9"))) { - os << "\\ensuremath{" - << c - << '}'; + os << "\\ensuremath{"; + os.put(c); + os << '}'; column += 13; } else { - os << c; + os.put(c); } break; 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 @@ -624,7 +590,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, } // Typewriter font also has them if (font.family() == LyXFont::TYPEWRITER_FAMILY) { - os << c; + os.put(c); break; } // Otherwise, we use what LaTeX @@ -661,19 +627,20 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, column += 9; break; - case '£': + case 0xa3: // £ POUND SIGN if (bparams.inputenc == "default") { os << "\\pounds{}"; column += 8; } else { - os << c; + os.put(c); } break; case '$': case '&': case '%': case '#': case '{': case '}': case '_': - os << '\\' << c; + os << '\\'; + os.put(c); column += 1; break; @@ -687,9 +654,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; @@ -706,7 +675,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, // I assume this is hack treating typewriter as verbatim if (font.family() == LyXFont::TYPEWRITER_FAMILY) { if (c != '\0') { - os << c; + os.put(c); } break; } @@ -731,7 +700,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, } if (pnr == phrases_nr && c != '\0') { - os << c; + os.put(c); } break; } @@ -745,8 +714,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"); @@ -799,13 +766,13 @@ 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"); } } @@ -823,24 +790,4 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, } -LyXFont const Paragraph::Pimpl::realizeFont(LyXFont const & font, - BufferParams const & bparams) const -{ - LyXFont tmpfont(font); - - // check for environment font information - char par_depth = owner_->getDepth(); - Paragraph const * par = owner_; - LyXTextClass const & tclass = bparams.getLyXTextClass(); - - while (par && par->getDepth() && !tmpfont.resolved()) { - par = par->outerHook(); - if (par) { - tmpfont.realize(par->layout()->font); - par_depth = par->getDepth(); - } - } - - tmpfont.realize(tclass.defaultfont()); - return tmpfont; -} +} // namespace lyx