X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=426862c246e3f8d04151b46d8ac03ef240cc1268;hb=35204f8f33d7400a5fefeffea533fb4cb4097211;hp=c375f8105035b36cf549be8403b9c02e4ac9b32e;hpb=116dbc66eba9a0774db8cb318ea4802004c02ee9;p=lyx.git diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C index c375f81050..426862c246 100644 --- a/src/paragraph_pimpl.C +++ b/src/paragraph_pimpl.C @@ -1,38 +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 -#ifdef __GNUG__ -#pragma implementation -#endif - #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; @@ -40,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); @@ -64,139 +69,233 @@ 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++; + id_ = paragraph_id++; +} + + +bool Paragraph::Pimpl::isChanged(pos_type start, pos_type end) const +{ + BOOST_ASSERT(start >= 0 && start <= size()); + BOOST_ASSERT(end > start && end <= size() + 1); + + return changes_.isChanged(start, end); +} + + +void Paragraph::Pimpl::setChange(Change const & change) +{ + // 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); + } + } + } } -void Paragraph::Pimpl::clear() +void Paragraph::Pimpl::setChange(pos_type pos, Change const & change) { - text.clear(); + BOOST_ASSERT(pos >= 0 && pos <= size()); + + changes_.set(change, pos); + + // see comment in setChange(Change const &) above + + if (change.type != Change::DELETED && + pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->setChange(change); + } } -void Paragraph::Pimpl::setContentsFromPar(Paragraph const * par) +Change const Paragraph::Pimpl::lookupChange(pos_type pos) const { - lyx::Assert(par); - text = par->pimpl_->text; + BOOST_ASSERT(pos >= 0 && pos <= size()); + + return changes_.lookup(pos); } -Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const +void Paragraph::Pimpl::acceptChanges(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: + break; + + case Change::INSERTED: + changes_.set(Change(Change::UNCHANGED), pos); + break; + + case Change::DELETED: + // Suppress access to non-existent + // "end-of-paragraph char" + if (pos < size()) { + eraseChar(pos, false); + --end; + --pos; + } + 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) { - // 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(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: + // also reject changes inside of insets + if (pos < size() && owner_->isInset(pos)) { + owner_->getInset(pos)->rejectChanges(); + } + break; + + case Change::INSERTED: + // Suppress access to non-existent + // "end-of-paragraph char" + if (pos < size()) { + eraseChar(pos, false); + --end; + --pos; + } + break; + + case Change::DELETED: + 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; + } + } } -void Paragraph::Pimpl::setChar(pos_type pos, value_type c) +Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const { - text[pos] = c; + BOOST_ASSERT(pos >= 0 && pos <= size()); + + return owner_->getChar(pos); } -void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, - LyXFont const & font) +void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, Change const & change) { - lyx::Assert(pos <= size()); + BOOST_ASSERT(pos >= 0 && pos <= size()); + + // 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); } - // Update the inset table. - InsetTable search_inset(pos, 0); - for (InsetList::iterator it = lower_bound(owner_->insetlist.begin(), - owner_->insetlist.end(), - search_inset, matchIT()); - it != owner_->insetlist.end(); ++it) - { - ++it->pos; - } - owner_->setFont(pos, font); + // Update the insets + owner_->insetlist.increasePosAfterPos(pos); } -void Paragraph::Pimpl::insertInset(pos_type pos, - Inset * inset, LyXFont const & font) +void Paragraph::Pimpl::insertInset(pos_type pos, InsetBase * inset, + Change const & change) { - lyx::Assert(inset); - lyx::Assert(pos <= size()); - - insertChar(pos, META_INSET, font); - lyx::Assert(text[pos] == META_INSET); - - // Add a new entry in the inset table. - InsetTable search_inset(pos, 0); - InsetList::iterator it = lower_bound(owner_->insetlist.begin(), - owner_->insetlist.end(), - search_inset, matchIT()); - if (it != owner_->insetlist.end() && it->pos == pos) { - lyxerr << "ERROR (Paragraph::InsertInset): " - "there is an inset in position: " << pos << endl; - } else { - owner_->insetlist.insert(it, InsetTable(pos, inset)); - inset->parOwner(owner_); - } + BOOST_ASSERT(inset); + BOOST_ASSERT(pos >= 0 && pos <= size()); - if (inset_owner) - inset->setOwner(inset_owner); + insertChar(pos, META_INSET, change); + BOOST_ASSERT(owner_->text_[pos] == META_INSET); + + // Add a new entry in the insetlist. + owner_->insetlist.insert(inset, pos); } -void Paragraph::Pimpl::erase(pos_type pos) +bool Paragraph::Pimpl::eraseChar(pos_type pos, bool trackChanges) { - lyx::Assert(pos < size()); - // if it is an inset, delete the inset entry - if (text[pos] == Paragraph::META_INSET) { - // find the entry - InsetTable search_inset(pos, 0); - InsetList::iterator it = - lower_bound(owner_->insetlist.begin(), - owner_->insetlist.end(), - search_inset, matchIT()); - if (it != owner_->insetlist.end() && it->pos == pos) { - delete it->inset; - owner_->insetlist.erase(it); + BOOST_ASSERT(pos >= 0 && pos <= size()); + + 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; + } + + // 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); + + // if it is an inset, delete the inset entry + 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()); @@ -223,36 +322,47 @@ void Paragraph::Pimpl::erase(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 inset table. - InsetTable search_inset(pos, 0); - InsetList::iterator lend = owner_->insetlist.end(); - for (InsetList::iterator it = - upper_bound(owner_->insetlist.begin(), - lend, - search_inset, matchIT()); - it != lend; ++it) - --it->pos; + // Update the insetlist + owner_->insetlist.decreasePosAfterPos(pos); + + return true; +} + + +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; + for (pos_type count = end - start; count; --count) { + if (!eraseChar(i, trackChanges)) + ++i; + } + return end - i; } -void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow, +void Paragraph::Pimpl::simpleTeXBlanks(odocstream & os, TexRow & texrow, pos_type const i, - int & column, LyXFont const & font, + 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 @@ -262,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 << '~'; @@ -282,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; } @@ -300,41 +410,94 @@ 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, pos_type & i, - int & column, + unsigned int & column, 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; } + // Two major modes: LaTeX or plain // Handle here those cases common to both modes // and then split to handle the two modes separately. switch (c) { case Paragraph::META_INSET: { - Inset * inset = owner_->getInset(i); - if (inset) { - 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) - && running_font.isRightToLeft()) { - os << "\\L{"; - close = true; + InsetBase * inset = owner_->getInset(i); + + // FIXME: remove this check + if (!inset) + break; + + // 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, output); + running_change = Change::UNCHANGED; + } + + bool close = false; + 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; + } #ifdef WITH_WARNINGS #warning Bug: we can have an empty font change here! @@ -342,52 +505,34 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, // right now, which means stupid latex code like \textsf{}. AFAIK, // this does not harm dvi output. A minor bug, thus (JMarc) #endif - // some insets cannot be inside a font change command - if (open_font && inset->noFontChange()) { - column +=running_font. - latexWriteEndChanges(os, - basefont, - basefont); - open_font = false; - basefont = owner_->getLayoutFont(bparams); - running_font = basefont; - } + // some insets cannot be inside a font change command + if (open_font && inset->noFontChange()) { + column +=running_font. + latexWriteEndChanges(os, + basefont, + basefont); + 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 << "}"; + if (close) + os << '}'; - if (tmp) { - for (int j = 0; j < tmp; ++j) { - texrow.newline(); - } - texrow.start(owner_, i + 1); - column = 0; - } else { - column += int(os.tellp()) - len; + if (tmp) { + for (int j = 0; j < tmp; ++j) { + texrow.newline(); } + texrow.start(owner_->id(), i + 1); + column = 0; + } else { + 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; - - case Paragraph::META_HFILL: - os << "\\hfill{}"; - column += 7; - break; - default: // And now for the special cases within each mode @@ -397,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 @@ -436,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 @@ -473,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; @@ -499,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; @@ -518,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; } @@ -543,7 +700,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, } if (pnr == phrases_nr && c != '\0') { - os << c; + os.put(c); } break; } @@ -551,37 +708,12 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, } - -Paragraph * Paragraph::Pimpl::TeXDeeper(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow) -{ - lyxerr[Debug::LATEX] << "TeXDeeper... " << this << endl; - Paragraph * par = owner_; - - while (par && par->params().depth() == owner_->params().depth()) { - if (par->layout()->isEnvironment()) { - par = par->TeXEnvironment(buf, bparams, - os, texrow); - } else { - par = par->TeXOnePar(buf, bparams, - os, texrow, false); - } - } - lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl; - - return par; -} - - void Paragraph::Pimpl::validate(LaTeXFeatures & features, LyXLayout const & layout) const { BufferParams const & bparams = features.bufferParams(); // check the params. - if (params.lineTop() || params.lineBottom()) - features.require("lyxline"); if (!params.spacing().isDefault()) features.require("setspace"); @@ -622,9 +754,6 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, Language const * language = fcit->font().language(); if (language->babel() != doc_language->babel() && language != ignore_language && -#ifdef INHERIT_LANGUAGE - language != inherit_language && -#endif language != latex_language) { features.useLanguage(language); @@ -643,7 +772,7 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, if (icit->inset) { icit->inset->validate(features); if (layout.needprotect && - icit->inset->lyxCode() == Inset::FOOT_CODE) + icit->inset->lyxCode() == InsetBase::FOOT_CODE) features.require("NeedLyXFootnoteCode"); } } @@ -661,45 +790,4 @@ void Paragraph::Pimpl::validate(LaTeXFeatures & features, } -Paragraph * Paragraph::Pimpl::getParFromID(int id) const -{ - InsetList::const_iterator cit = owner_->insetlist.begin(); - InsetList::const_iterator lend = owner_->insetlist.end(); - Paragraph * result; - for (; cit != lend; ++cit) { - if ((result = cit->inset->getParFromID(id))) - return result; - } - return 0; -} - - -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 -#ifdef INHERIT_LANGUAGE - , bparams.language -#endif - ); - par_depth = par->getDepth(); - } - } - - tmpfont.realize(tclass.defaultfont() -#ifdef INHERIT_LANGUAGE - , bparams.language -#endif - ); - return tmpfont; -} +} // namespace lyx