X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=42ec28da89bfc29a2794968895aa9ea4b034bfda;hb=5091380d6bad1686800e384ed1bbb03836a15aab;hp=30de048e1d60479cc9a046b66f821e09b051195a;hpb=b6b0e583fd54516d819ef7aaaf90db1f2f6e0fe5;p=lyx.git diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C index 30de048e1d..42ec28da89 100644 --- a/src/paragraph_pimpl.C +++ b/src/paragraph_pimpl.C @@ -15,13 +15,13 @@ #endif #include "paragraph_pimpl.h" +#include "LaTeXFeatures.h" #include "texrow.h" #include "language.h" #include "bufferparams.h" #include "encoding.h" #include "lyxrc.h" #include "debug.h" -#include "lyxtextclasslist.h" #include "support/LAssert.h" @@ -31,9 +31,6 @@ using std::ostream; using std::upper_bound; using std::lower_bound; -extern int tex_code_break_column; - - // Initialize static member. ShareContainer Paragraph::Pimpl::FontTable::container; // Initialization of the counter for the paragraph id's, @@ -41,14 +38,20 @@ unsigned int Paragraph::Pimpl::paragraph_id = 0; namespace { -string special_phrases[][2] = { - { "LyX", "\\LyX{}" }, - { "TeX", "\\TeX{}" }, - { "LaTeX2e", "\\LaTeXe{}" }, - { "LaTeX", "\\LaTeX{}" }, - }; +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 phrases_nr = sizeof(special_phrases)/sizeof(special_phrases[0]); +size_t const phrases_nr = sizeof(special_phrases)/sizeof(special_phrase); } // namespace anon @@ -89,13 +92,16 @@ void Paragraph::Pimpl::setContentsFromPar(Paragraph const * par) Paragraph::value_type Paragraph::Pimpl::getChar(pos_type pos) const { - lyx::Assert(pos <= size()); + // 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 (!size() || pos == size()) return '\0'; + if (!siz || pos == siz) + return '\0'; return text[pos]; } @@ -133,15 +139,9 @@ void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, 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); } @@ -155,18 +155,9 @@ void Paragraph::Pimpl::insertInset(pos_type pos, 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_); - } + // Add a new entry in the insetlist. + owner_->insetlist.insert(inset, pos); + inset->parOwner(owner_); if (inset_owner) inset->setOwner(inset_owner); @@ -178,16 +169,7 @@ void Paragraph::Pimpl::erase(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); - } + owner_->insetlist.erase(pos); } text.erase(text.begin() + pos); @@ -222,15 +204,8 @@ void Paragraph::Pimpl::erase(pos_type pos) 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); } @@ -240,7 +215,7 @@ void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow, LyXLayout const & style) { if (style.pass_thru) return; - if (column > tex_code_break_column + if (column > lyxrc.ascii_linelen && i && getChar(i - 1) != ' ' && (i < size() - 1) @@ -254,13 +229,7 @@ void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow, || 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); column = 0; @@ -272,19 +241,30 @@ 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] != 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; } @@ -325,6 +305,23 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, 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); + running_font = basefont; + } + int tmp = inset->latex(buf, os, moving_arg, style.free_spacing); @@ -370,7 +367,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, break; case '±': case '²': case '³': - case '×': case '÷': case '¹': + case '×': case '÷': case '¹': case '¬': case 'µ': if ((bparams.inputenc == "latin1" || bparams.inputenc == "latin9") || @@ -497,17 +494,19 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, // 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; } } @@ -530,7 +529,7 @@ Paragraph * Paragraph::Pimpl::TeXDeeper(Buffer const * buf, Paragraph * par = owner_; while (par && par->params().depth() == owner_->params().depth()) { - if (textclasslist[bparams.textclass][par->layout()].isEnvironment()) { + if (par->layout()->isEnvironment()) { par = par->TeXEnvironment(buf, bparams, os, texrow); } else { @@ -544,13 +543,97 @@ Paragraph * Paragraph::Pimpl::TeXDeeper(Buffer const * buf, } +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"); + + // 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; + } + + 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; + } + } + + 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.getInset()) { + icit.getInset()->validate(features); + if (layout.needprotect && + icit.getInset()->lyxCode() == Inset::FOOT_CODE) + features.require("NeedLyXFootnoteCode"); + } + } + + // 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; + } + } + } +} + + Paragraph * Paragraph::Pimpl::getParFromID(int id) const { - InsetList::const_iterator cit = owner_->insetlist.begin(); - InsetList::const_iterator lend = owner_->insetlist.end(); + InsetList::iterator cit = owner_->insetlist.begin(); + InsetList::iterator lend = owner_->insetlist.end(); Paragraph * result; for (; cit != lend; ++cit) { - if ((result = cit->inset->getParFromID(id))) + if ((result = cit.getInset()->getParFromID(id))) return result; } return 0; @@ -565,24 +648,16 @@ LyXFont const Paragraph::Pimpl::realizeFont(LyXFont const & font, // check for environment font information char par_depth = owner_->getDepth(); Paragraph const * par = owner_; - LyXTextClass const & tclass = textclasslist[bparams.textclass]; + LyXTextClass const & tclass = bparams.getLyXTextClass(); while (par && par->getDepth() && !tmpfont.resolved()) { par = par->outerHook(); if (par) { - tmpfont.realize(tclass[par->layout()].font -#ifdef INHERIT_LANGUAGE - , bparams.language -#endif - ); + tmpfont.realize(par->layout()->font); par_depth = par->getDepth(); } } - tmpfont.realize(tclass.defaultfont() -#ifdef INHERIT_LANGUAGE - , bparams.language -#endif - ); + tmpfont.realize(tclass.defaultfont()); return tmpfont; }