X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=91d67776610bbff0ca207c5353890633543ae561;hb=69bee02a8901793b34ac5ca6d07e93910cef4005;hp=aaa4125d38832cff1cd2467a05321d5fe1cdf759;hpb=7ea7dabed1b72cc25dcbdc482ac006f2b61dacfd;p=lyx.git diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C index aaa4125d38..91d6777661 100644 --- a/src/paragraph_pimpl.C +++ b/src/paragraph_pimpl.C @@ -1,37 +1,39 @@ -/* This file is part of - * ====================================================== - * - * LyX, The Document Processor - * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. +/** + * \file paragraph_pimpl.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * ====================================================== */ + * \author Lars Gullik Bjønnes + * \author Jean-Marc Lasgouttes + * \author John Levon + * \author André Pönitz + * + * Full author contact details are available in file CREDITS. + */ #include -#ifdef __GNUG__ -#pragma implementation -#endif - #include "paragraph_pimpl.h" -#include "texrow.h" -#include "language.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 "lyxtextclasslist.h" +#include "outputparams.h" +#include "texrow.h" -#include "support/LAssert.h" using lyx::pos_type; + using std::endl; -using std::ostream; using std::upper_bound; using std::lower_bound; - -extern int tex_code_break_column; +using std::string; +using std::ostream; // Initialize static member. @@ -40,18 +42,24 @@ ShareContainer Paragraph::Pimpl::FontTable::container; unsigned int Paragraph::Pimpl::paragraph_id = 0; namespace { - -string special_phrases[][2] = { - { "LyX", "\\LyX{}" }, - { "TeX", "\\TeX{}" }, - { "LaTeX2e", "\\LaTeXe{}" }, - { "LaTeX", "\\LaTeX{}" }, - }; - -size_t phrases_nr = sizeof(special_phrases)/sizeof(special_phrases[0]); - + +struct special_phrase { + string phrase; + string macro; + bool builtin; +}; + +special_phrase special_phrases[] = { + { "LyX", "\\LyX{}", false }, + { "TeX", "\\TeX{}", true }, + { "LaTeX2e", "\\LaTeXe{}", true }, + { "LaTeX", "\\LaTeX{}", true }, +}; + +size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase); + } // namespace anon - + Paragraph::Pimpl::Pimpl(Paragraph * owner) : owner_(owner) @@ -61,138 +69,263 @@ Paragraph::Pimpl::Pimpl(Paragraph * owner) } -Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner, bool same_ids) +Paragraph::Pimpl::Pimpl(Pimpl const & p, Paragraph * owner) : params(p.params), 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++; + + if (p.tracking()) + changes_.reset(new Changes(*p.changes_.get())); } -void Paragraph::Pimpl::clear() +void Paragraph::Pimpl::setContentsFromPar(Paragraph const & par) { - text.clear(); + owner_->text_ = par.text_; + if (par.pimpl_->tracking()) { + changes_.reset(new Changes(*(par.pimpl_->changes_.get()))); + } } -void Paragraph::Pimpl::setContentsFromPar(Paragraph const * par) +void Paragraph::Pimpl::trackChanges(Change::Type type) { - lyx::Assert(par); - text = par->pimpl_->text; + 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()); } -Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const +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()); +} + + +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; + + return changes_->isChangeEdited(start, end); +} + + +void Paragraph::Pimpl::setChange(pos_type pos, Change::Type type) +{ + if (!tracking()) + return; + + changes_->set(type, pos); +} + + +Change::Type Paragraph::Pimpl::lookupChange(pos_type pos) const +{ + if (!tracking()) + return Change::UNCHANGED; + + return changes_->lookup(pos); +} + + +Change const Paragraph::Pimpl::lookupChangeFull(pos_type pos) const { - lyx::Assert(pos <= size()); - // 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 (!size() || pos == size()) return '\0'; - - return text[pos]; + if (!tracking()) + return Change(Change::UNCHANGED); + + return changes_->lookupFull(pos); } -void Paragraph::Pimpl::setChar(pos_type pos, value_type c) +void Paragraph::Pimpl::markErased() { - text[pos] = c; + BOOST_ASSERT(tracking()); + + // 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); +} + + +void Paragraph::Pimpl::acceptChange(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)) { + case Change::UNCHANGED: + break; + + case Change::INSERTED: + changes_->set(Change::UNCHANGED, i); + break; + + case Change::DELETED: + eraseIntern(i); + changes_->erase(i); + --end; + --i; + break; + } + } + + lyxerr << "endacceptchange" << endl; + changes_->reset(Change::UNCHANGED); +} + + +void Paragraph::Pimpl::rejectChange(pos_type start, pos_type end) +{ + if (!tracking()) + return; + + if (!size()) { + changes_.reset(new Changes(Change::UNCHANGED)); + return; + } + + pos_type i = start; + + for (; i < end; ++i) { + switch (lookupChange(i)) { + case Change::UNCHANGED: + break; + + case Change::INSERTED: + eraseIntern(i); + changes_->erase(i); + --end; + --i; + break; + + case Change::DELETED: + changes_->set(Change::UNCHANGED, i); + break; + } + } + changes_->reset(Change::UNCHANGED); +} + + +Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const +{ + return owner_->getChar(pos); } void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, - LyXFont const & font) + LyXFont const & font, Change change) { - lyx::Assert(pos <= size()); + BOOST_ASSERT(pos <= size()); - text.insert(text.begin() + pos, c); + if (tracking()) { + changes_->record(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 + owner_->text_.push_back(c); + owner_->setFont(pos, font); + return; + } + + 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()); + 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; - } + + // Update the insets + owner_->insetlist.increasePosAfterPos(pos); + owner_->setFont(pos, font); } void Paragraph::Pimpl::insertInset(pos_type pos, - Inset * inset, LyXFont const & font) + InsetOld * inset, LyXFont const & font, Change 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 <= size()); + + insertChar(pos, META_INSET, font, change); + BOOST_ASSERT(owner_->text_[pos] == META_INSET); + + // Add a new entry in the insetlist. + owner_->insetlist.insert(inset, pos); + if (inset_owner) inset->setOwner(inset_owner); } -void Paragraph::Pimpl::erase(pos_type pos) +void Paragraph::Pimpl::eraseIntern(pos_type pos) { - 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); - } + // 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()); - + FontList::iterator it = lower_bound(fontlist.begin(), fontlist.end(), search_font, matchFT()); if (it != fontlist.end() && it->pos() == pos && - (pos == 0 || - (it != fontlist.begin() + (pos == 0 || + (it != fontlist.begin() && boost::prior(it)->pos() == pos - 1))) { // If it is a multi-character font // entry, we just make it smaller @@ -207,53 +340,75 @@ void Paragraph::Pimpl::erase(pos_type pos) it = fontlist.begin() + i - 1; } } - + // 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); +} + + +bool Paragraph::Pimpl::erase(pos_type pos) +{ + BOOST_ASSERT(pos < size()); + + if (tracking()) { + Change::Type changetype(changes_->lookup(pos)); + changes_->record(Change(Change::DELETED), pos); + + // only allow the actual removal if it was /new/ text + if (changetype != Change::INSERTED) { + if (owner_->text_[pos] == Paragraph::META_INSET) { + owner_->getInset(pos)->markErased(); + } + return false; + } + } + + eraseIntern(pos); + return true; +} + + +int Paragraph::Pimpl::erase(pos_type start, pos_type end) +{ + pos_type i = start; + for (pos_type count = end - start; count; --count) { + if (!erase(i)) + ++i; + } + return end - i; } void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow, - pos_type const i, - int & column, LyXFont const & font, - LyXLayout const & style) + pos_type const i, + unsigned int & column, + LyXFont const & font, + LyXLayout const & style) { - if (style.pass_thru) return; - if (column > tex_code_break_column - && i + 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() - // In typewriter mode, we want to avoid + && !owner_->isFreeSpacing() + // In typewriter mode, we want to avoid // ! . ? : at the end of a line && !(font.family() == LyXFont::TYPEWRITER_FAMILY && (getChar(i - 1) == '.' - || getChar(i - 1) == '?' + || getChar(i - 1) == '?' || getChar(i - 1) == ':' || getChar(i - 1) == '!'))) { - if (tex_code_break_column == 0) { - // in batchmode we need LaTeX to still - // see it as a space not as an extra '\n' - os << " %\n"; - } else { - os << '\n'; - } + os << '\n'; texrow.newline(); - texrow.start(owner_, i + 1); + texrow.start(owner_->id(), i + 1); column = 0; } else if (style.free_spacing) { os << '~'; @@ -263,106 +418,163 @@ void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow, } -bool Paragraph::Pimpl::isTextAt(BufferParams const & bp, - string const & str, pos_type pos) +bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const { - LyXFont const & font = owner_->getFont(bp, pos); - + pos_type const len = str.length(); + + // is the paragraph large enough? + if (pos + len > size()) + return false; + + // does the wanted text start at point? for (string::size_type i = 0; i < str.length(); ++i) { - if (pos + static_cast(i) >= size()) - return false; - if (str[i] != getChar(pos + i)) - return false; - if (owner_->getFont(bp, pos + i) != font) + if (str[i] != owner_->text_[pos + i]) return false; } + + // is there a font change in middle of the word? + FontList::const_iterator cit = fontlist.begin(); + FontList::const_iterator end = fontlist.end(); + for (; cit != end; ++cit) { + if (cit->pos() >= pos) + break; + } + if (cit != end && pos + len - 1 > cit->pos()) + return false; + return true; } - -void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, + +void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const & buf, BufferParams const & bparams, ostream & 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 << c; + } else { + InsetOld const * inset = owner_->getInset(i); + inset->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; - } - - int tmp = inset->latex(buf, os, moving_arg, - style.free_spacing); + InsetOld * inset = owner_->getInset(i); - if (close) - os << "}"; + // FIXME: remove this check + if (!inset) + break; - if (tmp) { - for (int j = 0; j < tmp; ++j) { - texrow.newline(); - } - texrow.start(owner_, i + 1); - column = 0; + // FIXME: move this to InsetNewline::latex + if (inset->lyxCode() == InsetOld::NEWLINE_CODE) { + // newlines are handled differently here than + // the default in simpleTeXSpecialChars(). + if (!style.newline_allowed) { + os << '\n'; } else { - column += int(os.tellp()) - len; + 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; + } + + if (inset->isTextInset()) { + column += Changes::latexMarkChange(os, running_change, + Change::UNCHANGED); + running_change = Change::UNCHANGED; } - } - break; - case Paragraph::META_NEWLINE: - if (open_font) { - column += running_font.latexWriteEndChanges(os, - basefont, - basefont); + bool close = false; + ostream::pos_type const len = os.tellp(); + + if ((inset->lyxCode() == InsetOld::GRAPHICS_CODE + || inset->lyxCode() == InsetOld::MATH_CODE + || inset->lyxCode() == InsetOld::URL_CODE) + && running_font.isRightToLeft()) { + os << "\\L{"; + close = true; + } + +#ifdef WITH_WARNINGS +#warning Bug: we can have an empty font change here! +// if there has just been a font change, we are going to close it +// 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, outerfont); + running_font = basefont; } - basefont = owner_->getLayoutFont(bparams); - running_font = basefont; - break; - case Paragraph::META_HFILL: - os << "\\hfill{}"; - column += 7; - break; + int tmp = inset->latex(buf, os, runparams); + + if (close) + os << '}'; + + 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; default: // And now for the special cases within each mode switch (c) { - case '\\': + case '\\': os << "\\textbackslash{}"; column += 15; break; - - case '°': case '±': case '²': case '³': - case '×': case '÷': case '¹': case 'ª': - case 'º': case '¬': case 'µ': + + case '±': case '²': case '³': + case '×': case '÷': case '¹': + case '¬': case 'µ': if ((bparams.inputenc == "latin1" || bparams.inputenc == "latin9") || (bparams.inputenc == "auto" && @@ -378,7 +590,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, os << c; } break; - + case '|': case '<': case '>': // In T1 encoding, these characters exist if (lyxrc.fontenc == "T1") { @@ -401,7 +613,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, if (font.family() == LyXFont::TYPEWRITER_FAMILY) { os << c; break; - } + } // Otherwise, we use what LaTeX // provides us. switch (c) { @@ -419,7 +631,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, break; } break; - + case '-': // "--" in Typewriter mode -> "-{}-" if (i <= size() - 2 && getChar(i + 1) == '-' @@ -430,12 +642,12 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, os << '-'; } break; - - case '\"': + + case '\"': os << "\\char`\\\"{}"; column += 9; break; - + case '£': if (bparams.inputenc == "default") { os << "\\pounds{}"; @@ -444,24 +656,24 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, os << c; } break; - + case '$': case '&': case '%': case '#': case '{': case '}': case '_': os << '\\' << c; column += 1; break; - + case '~': os << "\\textasciitilde{}"; column += 16; break; - + case '^': os << "\\textasciicircum{}"; column += 17; break; - + case '*': case '[': case ']': // avoid being mistaken for optional arguments os << '{' << c << '}'; @@ -471,13 +683,13 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, case ' ': // Blanks are printed before font switching. // Sure? I am not! (try nice-latex) - // I am sure it's correct. LyX might be smarter - // in the future, but for now, nothing wrong is - // written. (Asger) + // I am sure it's correct. LyX might be smarter + // in the future, but for now, nothing wrong is + // written. (Asger) break; default: - + // I assume this is hack treating typewriter as verbatim if (font.family() == LyXFont::TYPEWRITER_FAMILY) { if (c != '\0') { @@ -485,20 +697,22 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, } break; } - + // LyX, LaTeX etc. - - // FIXME: if we have "LaTeX" with a font change in the middle (before - // the 'T', then the "TeX" part is still special cased. Really we - // should only operate this on "words" for some definition of word - + + // FIXME: if we have "LaTeX" with a font + // change in the middle (before the 'T', then + // the "TeX" part is still special cased. + // Really we should only operate this on + // "words" for some definition of word + size_t pnr = 0; - + for (; pnr < phrases_nr; ++pnr) { - if (isTextAt(bparams, special_phrases[pnr][0], i)) { - os << special_phrases[pnr][1]; - i += special_phrases[pnr][0].length() - 1; - column += special_phrases[pnr][1].length() - 1; + if (isTextAt(special_phrases[pnr].phrase, i)) { + os << special_phrases[pnr].macro; + i += special_phrases[pnr].phrase.length() - 1; + column += special_phrases[pnr].macro.length() - 1; break; } } @@ -512,70 +726,83 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, } - -Paragraph * Paragraph::Pimpl::TeXDeeper(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow) +void Paragraph::Pimpl::validate(LaTeXFeatures & features, + LyXLayout const & layout) const { - lyxerr[Debug::LATEX] << "TeXDeeper... " << this << endl; - Paragraph * par = owner_; - - while (par && par->params().depth() == owner_->params().depth()) { - if (textclasslist.Style(bparams.textclass, - par->layout).isEnvironment()) { - par = par->TeXEnvironment(buf, bparams, - os, texrow); - } else { - par = par->TeXOnePar(buf, bparams, - os, texrow, false); + BufferParams const & bparams = features.bufferParams(); + + // check the params. + if (!params.spacing().isDefault()) + features.require("setspace"); + + // then the layouts + features.useLayout(layout.name()); + + // then the fonts + Language const * doc_language = bparams.language; + + FontList::const_iterator fcit = fontlist.begin(); + FontList::const_iterator fend = fontlist.end(); + for (; fcit != fend; ++fcit) { + if (fcit->font().noun() == LyXFont::ON) { + lyxerr[Debug::LATEX] << "font.noun: " + << fcit->font().noun() + << endl; + features.require("noun"); + lyxerr[Debug::LATEX] << "Noun enabled. Font: " + << fcit->font().stateText(0) + << endl; + } + switch (fcit->font().color()) { + case LColor::none: + case LColor::inherit: + case LColor::ignore: + // probably we should put here all interface colors used for + // font displaying! For now I just add this ones I know of (Jug) + case LColor::latex: + case LColor::note: + break; + default: + features.require("color"); + lyxerr[Debug::LATEX] << "Color enabled. Font: " + << fcit->font().stateText(0) + << endl; } - } - lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl; - - return par; -} - -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; + Language const * language = fcit->font().language(); + if (language->babel() != doc_language->babel() && + language != ignore_language && + language != latex_language) + { + features.useLanguage(language); + lyxerr[Debug::LATEX] << "Found language " + << language->babel() << endl; + } } - 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_; - while (par && par->getDepth() && !tmpfont.resolved()) { - par = par->outerHook(); - if (par) { - tmpfont.realize(textclasslist. - Style(bparams.textclass, - par->getLayout()).font -#ifdef INHERIT_LANGUAGE - , bparams.language -#endif - ); - par_depth = par->getDepth(); + if (!params.leftIndent().zero()) + features.require("ParagraphLeftIndent"); + + // then the insets + InsetList::iterator icit = owner_->insetlist.begin(); + InsetList::iterator iend = owner_->insetlist.end(); + for (; icit != iend; ++icit) { + if (icit->inset) { + icit->inset->validate(features); + if (layout.needprotect && + icit->inset->lyxCode() == InsetOld::FOOT_CODE) + features.require("NeedLyXFootnoteCode"); } } - tmpfont.realize(textclasslist.TextClass(bparams.textclass) - .defaultfont() -#ifdef INHERIT_LANGUAGE - , bparams.language -#endif - ); - return tmpfont; + // then the contents + for (pos_type i = 0; i < size() ; ++i) { + for (size_t pnr = 0; pnr < phrases_nr; ++pnr) { + if (!special_phrases[pnr].builtin + && isTextAt(special_phrases[pnr].phrase, i)) { + features.require(special_phrases[pnr].phrase); + break; + } + } + } }