X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph_pimpl.C;h=42ec28da89bfc29a2794968895aa9ea4b034bfda;hb=5091380d6bad1686800e384ed1bbb03836a15aab;hp=c28db75b3316c85d8a8a3028c44f0e169b7d6b38;hpb=b8e78dc35f527143f2d51ba1e5f103decdeae6ad;p=lyx.git diff --git a/src/paragraph_pimpl.C b/src/paragraph_pimpl.C index c28db75b33..42ec28da89 100644 --- a/src/paragraph_pimpl.C +++ b/src/paragraph_pimpl.C @@ -1,10 +1,10 @@ /* This file is part of - * ====================================================== - * + * ====================================================== + * * LyX, The Document Processor - * + * * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. + * Copyright 1995-2001 The LyX Team. * * ====================================================== */ @@ -15,18 +15,21 @@ #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 "support/LAssert.h" using lyx::pos_type; - -extern int tex_code_break_column; - +using std::endl; +using std::ostream; +using std::upper_bound; +using std::lower_bound; // Initialize static member. ShareContainer Paragraph::Pimpl::FontTable::container; @@ -34,18 +37,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) @@ -83,14 +92,17 @@ 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]; } @@ -102,31 +114,34 @@ void Paragraph::Pimpl::setChar(pos_type pos, value_type c) void Paragraph::Pimpl::insertChar(pos_type pos, value_type c, - LyXFont const & font) + LyXFont const & font) { lyx::Assert(pos <= size()); + // 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); + return; + } + text.insert(text.begin() + pos, c); // Update the font table. FontTable search_font(pos, LyXFont()); - for (FontList::iterator it = std::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 = std::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); } @@ -136,22 +151,14 @@ void Paragraph::Pimpl::insertInset(pos_type pos, { 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)); - } - + + // Add a new entry in the insetlist. + owner_->insetlist.insert(inset, pos); + inset->parOwner(owner_); + if (inset_owner) inset->setOwner(inset_owner); } @@ -160,32 +167,23 @@ void Paragraph::Pimpl::insertInset(pos_type pos, void Paragraph::Pimpl::erase(pos_type pos) { lyx::Assert(pos < size()); - // if it is an inset, delete the inset entry + // 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); - } + owner_->insetlist.erase(pos); } - + text.erase(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 @@ -200,50 +198,38 @@ 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 = - 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, +void Paragraph::Pimpl::simpleTeXBlanks(ostream & os, TexRow & texrow, pos_type const i, int & column, LyXFont const & font, LyXLayout const & style) { if (style.pass_thru) return; - if (column > tex_code_break_column - && i + 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); column = 0; @@ -255,24 +241,37 @@ void Paragraph::Pimpl::simpleTeXBlanks(std::ostream & os, TexRow & texrow, } -bool Paragraph::Pimpl::isTextAt(BufferParams const & bp, LyXFont & font, - string const & str, pos_type pos) +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 (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; } - + void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, BufferParams const & bparams, - std::ostream & os, + ostream & os, TexRow & texrow, bool moving_arg, LyXFont & font, @@ -306,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); @@ -336,7 +352,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, running_font = basefont; break; - case Paragraph::META_HFILL: + case Paragraph::META_HFILL: os << "\\hfill{}"; column += 7; break; @@ -345,14 +361,14 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, // 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" && @@ -368,7 +384,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, os << c; } break; - + case '|': case '<': case '>': // In T1 encoding, these characters exist if (lyxrc.fontenc == "T1") { @@ -391,7 +407,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) { @@ -409,7 +425,7 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, break; } break; - + case '-': // "--" in Typewriter mode -> "-{}-" if (i <= size() - 2 && getChar(i + 1) == '-' @@ -420,12 +436,12 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, os << '-'; } break; - - case '\"': + + case '\"': os << "\\char`\\\"{}"; column += 9; break; - + case '£': if (bparams.inputenc == "default") { os << "\\pounds{}"; @@ -434,24 +450,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 << '}'; @@ -461,13 +477,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') { @@ -475,20 +491,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, font, 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; } } @@ -505,14 +523,13 @@ void Paragraph::Pimpl::simpleTeXSpecialChars(Buffer const * buf, Paragraph * Paragraph::Pimpl::TeXDeeper(Buffer const * buf, BufferParams const & bparams, - std::ostream & os, TexRow & texrow) + ostream & os, TexRow & texrow) { - lyxerr[Debug::LATEX] << "TeXDeeper... " << this << std::endl; + 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()) { + if (par->layout()->isEnvironment()) { par = par->TeXEnvironment(buf, bparams, os, texrow); } else { @@ -520,19 +537,103 @@ Paragraph * Paragraph::Pimpl::TeXDeeper(Buffer const * buf, os, texrow, false); } } - lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << std::endl; + 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"); + + // 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; @@ -543,29 +644,20 @@ 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(textclasslist. - Style(bparams.textclass, - par->getLayout()).font -#ifdef INHERIT_LANGUAGE - , bparams.language -#endif - ); + tmpfont.realize(par->layout()->font); par_depth = par->getDepth(); } } - tmpfont.realize(textclasslist.TextClass(bparams.textclass) - .defaultfont() -#ifdef INHERIT_LANGUAGE - , bparams.language -#endif - ); - return tmpfont; + tmpfont.realize(tclass.defaultfont()); + return tmpfont; }