X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=6e3c63cb5538af80d8be44c7e7ab40cbe96428db;hb=e94889a041628203c50b66b9a4add63210de6928;hp=de5185747e83653c97c95a50044a4d64bb12f6e4;hpb=7cf094f99eea8341d421bc3b3f9baa023cc48b97;p=lyx.git diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C index de5185747e..6e3c63cb55 100644 --- a/src/paragraph_pimpl.C +++ b/src/paragraph_pimpl.C @@ -1,35 +1,64 @@ -/* 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 "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 "support/LAssert.h" +#include "outputparams.h" +#include "texrow.h" -extern int tex_code_break_column; +#include + +using lyx::pos_type; + +using std::endl; +using std::upper_bound; +using std::lower_bound; +using std::string; +using std::ostream; // Initialization of the counter for the paragraph id's, unsigned int Paragraph::Pimpl::paragraph_id = 0; -// Initialize static member. -ShareContainer Paragraph::Pimpl::FontTable::container; +namespace { + +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) @@ -40,138 +69,277 @@ Paragraph::Pimpl::Pimpl(Paragraph * owner) } -Paragraph::Pimpl::Pimpl(Paragraph::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::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() + 1); } -void Paragraph::Pimpl::setContentsFromPar(Paragraph const * par) +void Paragraph::Pimpl::untrackChanges() { - lyx::Assert(par); - text = par->pimpl_->text; + changes_.reset(0); } -Paragraph::value_type -Paragraph::Pimpl::getChar(Paragraph::size_type pos) const +void Paragraph::Pimpl::cleanChanges(Paragraph::ChangeTracking ct) { - lyx::Assert(pos <= size()); - // This is stronger, and I belive that this is the assertion - // that we should really use. (Lgb) - //Assert(pos < size()); + // if the paragraph was not tracked and we don't know the buffer's + // change tracking state, we do nothing + if ((ct == Paragraph::trackingUnknown) && !tracking()) + return; - // Then this has no meaning. (Lgb) - if (!size() || pos == size()) return '\0'; + // untrack everything if we are in a buffer where ct is disabled + else if (ct == Paragraph::trackingOff) { + untrackChanges(); + return; + } - return text[pos]; + // in a buffer where ct is enabled, set everything to INSERTED + changes_.reset(new Changes(Change::INSERTED)); + changes_->set(Change::INSERTED, 0, size() + 1); +} + + +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::setChangeType(pos_type pos, Change::Type type) +{ + if (!tracking()) + return; + + changes_->set(type, pos); +} + + +void Paragraph::Pimpl::setChange(pos_type pos, Change change) +{ + if (!tracking()) + return; + + changes_->set(change, pos); +} + + +Change const Paragraph::Pimpl::lookupChange(pos_type pos) const +{ + if (!tracking()) + return Change(Change::UNCHANGED); + + return changes_->lookup(pos); +} + + +void Paragraph::Pimpl::markErased(bool erased) +{ + BOOST_ASSERT(tracking()); + + if (erased) { + erase(0, size()); + } else { + for (pos_type i = 0; i < size(); ++i) { + changes_->set(Change::UNCHANGED, i); + if (owner_->isInset(i)) + owner_->getInset(i)->markErased(false); + } + } } -void Paragraph::Pimpl::setChar(Paragraph::size_type pos, - Paragraph::value_type c) +void Paragraph::Pimpl::acceptChange(pos_type start, pos_type end) { - text[pos] = c; + if (!tracking()) + return; + + if (!size()) { + changes_.reset(new Changes(Change::UNCHANGED)); + return; + } + + lyxerr[Debug::CHANGES] << "acceptchange" << endl; + pos_type i = start; + + for (; i < end; ++i) { + switch (lookupChange(i).type) { + case Change::UNCHANGED: + break; + + case Change::INSERTED: + changes_->set(Change::UNCHANGED, i); + break; + + case Change::DELETED: + // Suppress access to nonexistent + // "end-of-paragraph char": + if (i < size()) { + eraseIntern(i); + changes_->erase(i); + --end; + --i; + } + break; + } + } + + lyxerr[Debug::CHANGES] << "endacceptchange" << endl; + changes_->reset(Change::UNCHANGED); } -void Paragraph::Pimpl::insertChar(Paragraph::size_type pos, - Paragraph::value_type c, - LyXFont const & font) +void Paragraph::Pimpl::rejectChange(pos_type start, pos_type end) { - lyx::Assert(pos <= size()); + if (!tracking()) + return; + + if (!size()) { + changes_.reset(new Changes(Change::UNCHANGED)); + return; + } - text.insert(text.begin() + pos, c); + pos_type i = start; + + for (; i < end; ++i) { + switch (lookupChange(i).type) { + case Change::UNCHANGED: + break; + + case Change::INSERTED: + if (i < size()) { + eraseIntern(i); + changes_->erase(i); + --end; + --i; + } + break; + + case Change::DELETED: + changes_->set(Change::UNCHANGED, i); + // No real char at position size(): + if (i < size() && owner_->isInset(i)) + owner_->getInset(i)->markErased(false); + 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, Change change) +{ + BOOST_ASSERT(pos <= size()); + + 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); + return; + } + + owner_->text_.insert(owner_->text_.begin() + pos, c); // Update the font table. FontTable search_font(pos, LyXFont()); - for (FontList::iterator it = std::lower_bound(fontlist.begin(), + 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 = std::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(Paragraph::size_type pos, - Inset * inset, LyXFont const & font) +void Paragraph::Pimpl::insertInset(pos_type pos, + InsetBase * inset, 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 = std::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 << std::endl; - } else { - owner_->insetlist.insert(it, InsetTable(pos, inset)); - } - - if (inset_owner) - inset->setOwner(inset_owner); + BOOST_ASSERT(inset); + BOOST_ASSERT(pos <= size()); + + 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(Paragraph::size_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 = - std::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 = - std::lower_bound(fontlist.begin(), + 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 @@ -186,52 +354,79 @@ void Paragraph::Pimpl::erase(Paragraph::size_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 = - std::upper_bound(owner_->insetlist.begin(), - lend, - search_inset, matchIT()); - it != lend; ++it) - --it->pos; + + // Update the insetlist. + owner_->insetlist.decreasePosAfterPos(pos); } -void Paragraph::Pimpl::simpleTeXBlanks(std::ostream & os, TexRow & texrow, - Paragraph::size_type const i, - int & column, LyXFont const & font, +bool Paragraph::Pimpl::erase(pos_type pos) +{ + BOOST_ASSERT(pos <= size()); + + if (tracking()) { + Change::Type changetype(changes_->lookup(pos).type); + changes_->record(Change(Change::DELETED), pos); + + // only allow the actual removal if it was /new/ text + if (changetype != Change::INSERTED) { + if (pos < size() && owner_->isInset(pos)) + owner_->getInset(pos)->markErased(true); + return false; + } + } + + // Don't physically access nonexistent end-of-paragraph char + if (pos < size()) { + eraseIntern(pos); + return true; + } + + return false; +} + + +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, + 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 - // 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 << '~'; @@ -241,94 +436,176 @@ void Paragraph::Pimpl::simpleTeXBlanks(std::ostream & os, TexRow & texrow, } -void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, +bool Paragraph::Pimpl::isTextAt(string const & str, pos_type pos) const +{ + 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 (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, BufferParams const & bparams, - std::ostream & os, + 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, - Paragraph::size_type & i, - int & column, - Paragraph::value_type const c) + pos_type & i, + 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 { + 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; - } - - int tmp = inset->latex(buf, os, moving_arg, - style.free_spacing); + InsetBase * inset = owner_->getInset(i); - if (close) - os << "}"; + // FIXME: remove this check + if (!inset) + break; - if (tmp) { - column = 0; + // 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 { - column += int(os.tellp()) - len; - } - for (; tmp--;) { - texrow.newline(); + 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; } - } - break; - case Paragraph::META_NEWLINE: - if (open_font) { - column += running_font.latexWriteEndChanges(os, - basefont, - basefont); + // 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.output_changes + && 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; + ostream::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! +// 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" && - (font.language()->encoding()->LatexName() + (font.language()->encoding()->latexName() == "latin1" || - font.language()->encoding()->LatexName() + font.language()->encoding()->latexName() == "latin9"))) { os << "\\ensuremath{" << c @@ -338,7 +615,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, os << c; } break; - + case '|': case '<': case '>': // In T1 encoding, these characters exist if (lyxrc.fontenc == "T1") { @@ -361,7 +638,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) { @@ -379,7 +656,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, break; } break; - + case '-': // "--" in Typewriter mode -> "-{}-" if (i <= size() - 2 && getChar(i + 1) == '-' @@ -390,12 +667,12 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, os << '-'; } break; - - case '\"': + + case '\"': os << "\\char`\\\"{}"; column += 9; break; - + case '£': if (bparams.inputenc == "default") { os << "\\pounds{}"; @@ -404,25 +681,25 @@ 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 ']': + + case '*': case '[': // avoid being mistaken for optional arguments os << '{' << c << '}'; column += 2; @@ -431,60 +708,41 @@ 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: - /* idea for labels --- begin*/ - // Check for "LyX" - if (c == 'L' - && i <= size() - 3 - && font.family() != LyXFont::TYPEWRITER_FAMILY - && getChar(i + 1) == 'y' - && getChar(i + 2) == 'X') { - os << "\\LyX{}"; - i += 2; - column += 5; - } - // Check for "TeX" - else if (c == 'T' - && i <= size() - 3 - && font.family() != LyXFont::TYPEWRITER_FAMILY - && getChar(i + 1) == 'e' - && getChar(i + 2) == 'X') { - os << "\\TeX{}"; - i += 2; - column += 5; + + // I assume this is hack treating typewriter as verbatim + if (font.family() == LyXFont::TYPEWRITER_FAMILY) { + if (c != '\0') { + os << c; + } + break; } - // Check for "LaTeX2e" - else if (c == 'L' - && i <= size() - 7 - && font.family() != LyXFont::TYPEWRITER_FAMILY - && getChar(i + 1) == 'a' - && getChar(i + 2) == 'T' - && getChar(i + 3) == 'e' - && getChar(i + 4) == 'X' - && getChar(i + 5) == '2' - && getChar(i + 6) == 'e') { - os << "\\LaTeXe{}"; - i += 6; - column += 8; + + // 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 + + size_t pnr = 0; + + for (; pnr < phrases_nr; ++pnr) { + 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; + } } - // Check for "LaTeX" - else if (c == 'L' - && i <= size() - 5 - && font.family() != LyXFont::TYPEWRITER_FAMILY - && getChar(i + 1) == 'a' - && getChar(i + 2) == 'T' - && getChar(i + 3) == 'e' - && getChar(i + 4) == 'X') { - os << "\\LaTeX{}"; - i += 4; - column += 7; - /* idea for labels --- end*/ - } else if (c != '\0') { + + if (pnr == phrases_nr && c != '\0') { os << c; } break; @@ -493,73 +751,83 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, } - -Paragraph * Paragraph::Pimpl::TeXDeeper(Buffer const * buf, - BufferParams const & bparams, - std::ostream & os, TexRow & texrow) +void Paragraph::Pimpl::validate(LaTeXFeatures & features, + LyXLayout const & layout) const { - lyxerr[Debug::LATEX] << "TeXDeeper... " << this << std::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 << std::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) { -#ifndef INHERIT_LANGUAGE - tmpfont.realize(textclasslist. - Style(bparams.textclass, - par->getLayout()).font); -#else - tmpfont.realize(textclasslist. - Style(bparams.textclass, - par->getLayout()).font, bparams.language); -#endif - par_depth = par->getDepth(); + if (!params.leftIndent().zero()) + features.require("ParagraphLeftIndent"); + + // then the insets + InsetList::const_iterator icit = owner_->insetlist.begin(); + InsetList::const_iterator iend = owner_->insetlist.end(); + for (; icit != iend; ++icit) { + if (icit->inset) { + icit->inset->validate(features); + if (layout.needprotect && + icit->inset->lyxCode() == InsetBase::FOOT_CODE) + features.require("NeedLyXFootnoteCode"); } } -#ifndef INHERIT_LANGUAGE - tmpfont.realize(textclasslist.TextClass(bparams.textclass) - .defaultfont()); -#else - tmpfont.realize(textclasslist.TextClass(bparams.textclass) - .defaultfont(), 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; + } + } + } }