X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FBufferParams.cpp;h=b177409dd17e0b341eee41836a6862b921761cd8;hb=d45ca67d1d3e2d4fdc344cd2a1517725bc91723a;hp=6f2e3ed3a9dbc18801e7beba3fa5b6842c9ac77d;hpb=148469164018b7b520088c2943dd77b3d77e821b;p=lyx.git diff --git a/src/BufferParams.cpp b/src/BufferParams.cpp index 6f2e3ed3a9..b177409dd1 100644 --- a/src/BufferParams.cpp +++ b/src/BufferParams.cpp @@ -18,21 +18,18 @@ #include "BufferParams.h" #include "Author.h" +#include "LayoutFile.h" #include "BranchList.h" #include "buffer_funcs.h" #include "Bullet.h" -#include "debug.h" +#include "Color.h" #include "Encoding.h" -#include "gettext.h" #include "Language.h" #include "LaTeXFeatures.h" -#include "Messages.h" #include "ModuleList.h" -#include "Color.h" #include "Font.h" #include "Lexer.h" #include "LyXRC.h" -#include "TextClassList.h" #include "OutputParams.h" #include "Spacing.h" #include "TexRow.h" @@ -40,33 +37,24 @@ #include "PDFOptions.h" #include "frontends/alert.h" + #include "insets/InsetListingsParams.h" #include "support/convert.h" +#include "support/debug.h" +#include "support/docstream.h" +#include "support/FileName.h" #include "support/filetools.h" +#include "support/gettext.h" +#include "support/Messages.h" #include "support/Translator.h" #include "support/lstrings.h" -#include - #include #include -using std::count; -using std::endl; -using std::find; -using std::string; -using std::istringstream; -using std::ostream; -using std::ostringstream; -using std::pair; -using std::string; -using lyx::support::FileName; -using lyx::support::libFileSearch; -using lyx::support::bformat; -using lyx::support::rtrim; -using lyx::support::tokenPos; -using lyx::support::prefixIs; +using namespace std; +using namespace lyx::support; static char const * const string_paragraph_separation[] = { @@ -80,7 +68,7 @@ static char const * const string_quotes_language[] = { static char const * const string_papersize[] = { - "default", "custom", "letterpaper", "executivepaper", "legalpaper", + "default", "custom", "letterpaper", "legalpaper", "executivepaper", "a3paper", "a4paper", "a5paper", "b3paper", "b4paper", "b5paper", "" }; @@ -96,8 +84,11 @@ static char const * const string_footnotekinds[] = { static char const * const tex_graphics[] = { - "default", "dvips", "dvitops", "emtex", - "ln", "oztex", "textures", "none", "" + "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx", + "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex", + "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex", + "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi", + "xetex", "none", "" }; @@ -107,13 +98,14 @@ namespace lyx { namespace { // Paragraph separation -typedef Translator ParSepTranslator; +typedef Translator ParSepTranslator; ParSepTranslator const init_parseptranslator() { - ParSepTranslator translator(string_paragraph_separation[0], BufferParams::PARSEP_INDENT); - translator.addPair(string_paragraph_separation[1], BufferParams::PARSEP_SKIP); + ParSepTranslator translator + (string_paragraph_separation[0], BufferParams::ParagraphIndentSeparation); + translator.addPair(string_paragraph_separation[1], BufferParams::ParagraphSkipSeparation); return translator; } @@ -126,17 +118,18 @@ ParSepTranslator const & parseptranslator() // Quotes language -typedef Translator QuotesLangTranslator; +typedef Translator QuotesLangTranslator; QuotesLangTranslator const init_quoteslangtranslator() { - QuotesLangTranslator translator(string_quotes_language[0], InsetQuotes::EnglishQ); - translator.addPair(string_quotes_language[1], InsetQuotes::SwedishQ); - translator.addPair(string_quotes_language[2], InsetQuotes::GermanQ); - translator.addPair(string_quotes_language[3], InsetQuotes::PolishQ); - translator.addPair(string_quotes_language[4], InsetQuotes::FrenchQ); - translator.addPair(string_quotes_language[5], InsetQuotes::DanishQ); + QuotesLangTranslator translator + (string_quotes_language[0], InsetQuotes::EnglishQuotes); + translator.addPair(string_quotes_language[1], InsetQuotes::SwedishQuotes); + translator.addPair(string_quotes_language[2], InsetQuotes::GermanQuotes); + translator.addPair(string_quotes_language[3], InsetQuotes::PolishQuotes); + translator.addPair(string_quotes_language[4], InsetQuotes::FrenchQuotes); + translator.addPair(string_quotes_language[5], InsetQuotes::DanishQuotes); return translator; } @@ -149,10 +142,10 @@ QuotesLangTranslator const & quoteslangtranslator() // Paper size -typedef Translator PaperSizeTranslator; +typedef Translator PaperSizeTranslator; -PaperSizeTranslator const init_papersizetranslator() +static PaperSizeTranslator initPaperSizeTranslator() { PaperSizeTranslator translator(string_papersize[0], PAPER_DEFAULT); translator.addPair(string_papersize[1], PAPER_CUSTOM); @@ -171,7 +164,7 @@ PaperSizeTranslator const init_papersizetranslator() PaperSizeTranslator const & papersizetranslator() { - static PaperSizeTranslator translator = init_papersizetranslator(); + static PaperSizeTranslator translator = initPaperSizeTranslator(); return translator; } @@ -196,13 +189,13 @@ PaperOrientationTranslator const & paperorientationtranslator() // Page sides -typedef Translator SidesTranslator; +typedef Translator SidesTranslator; SidesTranslator const init_sidestranslator() { - SidesTranslator translator(1, TextClass::OneSide); - translator.addPair(2, TextClass::TwoSides); + SidesTranslator translator(1, OneSide); + translator.addPair(2, TwoSides); return translator; } @@ -235,15 +228,15 @@ PackageTranslator const & packagetranslator() // Cite engine -typedef Translator CiteEngineTranslator; +typedef Translator CiteEngineTranslator; CiteEngineTranslator const init_citeenginetranslator() { - CiteEngineTranslator translator("basic", biblio::ENGINE_BASIC); - translator.addPair("natbib_numerical", biblio::ENGINE_NATBIB_NUMERICAL); - translator.addPair("natbib_authoryear", biblio::ENGINE_NATBIB_AUTHORYEAR); - translator.addPair("jurabib", biblio::ENGINE_JURABIB); + CiteEngineTranslator translator("basic", ENGINE_BASIC); + translator.addPair("natbib_numerical", ENGINE_NATBIB_NUMERICAL); + translator.addPair("natbib_authoryear", ENGINE_NATBIB_AUTHORYEAR); + translator.addPair("jurabib", ENGINE_JURABIB); return translator; } @@ -287,19 +280,20 @@ public: AuthorList authorlist; BranchList branchlist; - boost::array temp_bullets; - boost::array user_defined_bullets; + Bullet temp_bullets[4]; + Bullet user_defined_bullets[4]; Spacing spacing; /** This is the amount of space used for paragraph_separation "skip", * and for detached paragraphs in "indented" documents. */ VSpace defskip; PDFOptions pdfoptions; + LayoutFileIndex baseClass_; }; BufferParams::Impl::Impl() - : defskip(VSpace::MEDSKIP) + : defskip(VSpace::MEDSKIP), baseClass_(string("")) { // set initial author // FIXME UNICODE @@ -310,7 +304,7 @@ BufferParams::Impl::Impl() BufferParams::Impl * BufferParams::MemoryTraits::clone(BufferParams::Impl const * ptr) { - BOOST_ASSERT(ptr); + LASSERT(ptr, /**/); return new BufferParams::Impl(*ptr); } @@ -325,9 +319,10 @@ void BufferParams::MemoryTraits::destroy(BufferParams::Impl * ptr) BufferParams::BufferParams() : pimpl_(new Impl) { - setBaseClass(defaultTextclass()); - paragraph_separation = PARSEP_INDENT; - quotes_language = InsetQuotes::EnglishQ; + setBaseClass(defaultBaseclass()); + makeDocumentClass(); + paragraph_separation = ParagraphIndentSeparation; + quotes_language = InsetQuotes::EnglishQuotes; fontsize = "default"; /* PaperLayout */ @@ -336,10 +331,11 @@ BufferParams::BufferParams() use_geometry = false; use_amsmath = package_auto; use_esint = package_auto; - cite_engine_ = biblio::ENGINE_BASIC; + cite_engine_ = ENGINE_BASIC; use_bibtopic = false; trackChanges = false; outputChanges = false; + use_default_options = true; secnumdepth = 3; tocdepth = 3; language = default_language; @@ -353,12 +349,11 @@ BufferParams::BufferParams() fontsTypewriterScale = 100; inputenc = "auto"; graphicsDriver = "default"; - sides = TextClass::OneSide; + sides = OneSide; columns = 1; listings_params = string(); pagestyle = "default"; compressed = false; - embedded = false; for (int iter = 0; iter < 4; ++iter) { user_defined_bullet(iter) = ITEMIZE_DEFAULTS[iter]; temp_bullet(iter) = ITEMIZE_DEFAULTS[iter]; @@ -366,13 +361,9 @@ BufferParams::BufferParams() } -BufferParams::~BufferParams() -{} - - -docstring const BufferParams::B_(string const & l10n) const +docstring BufferParams::B_(string const & l10n) const { - BOOST_ASSERT(language); + LASSERT(language, /**/); return getMessages(language->code()).get(l10n); } @@ -403,28 +394,28 @@ BranchList const & BufferParams::branchlist() const Bullet & BufferParams::temp_bullet(lyx::size_type const index) { - BOOST_ASSERT(index < 4); + LASSERT(index < 4, /**/); return pimpl_->temp_bullets[index]; } Bullet const & BufferParams::temp_bullet(lyx::size_type const index) const { - BOOST_ASSERT(index < 4); + LASSERT(index < 4, /**/); return pimpl_->temp_bullets[index]; } Bullet & BufferParams::user_defined_bullet(lyx::size_type const index) { - BOOST_ASSERT(index < 4); + LASSERT(index < 4, /**/); return pimpl_->user_defined_bullets[index]; } Bullet const & BufferParams::user_defined_bullet(lyx::size_type const index) const { - BOOST_ASSERT(index < 4); + LASSERT(index < 4, /**/); return pimpl_->user_defined_bullets[index]; } @@ -465,26 +456,25 @@ void BufferParams::setDefSkip(VSpace const & vs) } -string const BufferParams::readToken(Lexer & lex, string const & token) +string BufferParams::readToken(Lexer & lex, string const & token, + FileName const & filepath) { if (token == "\\textclass") { lex.next(); string const classname = lex.getString(); - pair pp = - textclasslist.numberOfClass(classname); - if (pp.first) { - setBaseClass(pp.second); - } else { - // if text class does not exist, try to load it from filepath - pp = textclasslist.addTextClass(classname, filepath); - if (pp.first) { - setBaseClass(pp.second); - } else { - setBaseClass(defaultTextclass()); - return classname; - } - } - if (!getTextClass().isTeXClassAvailable()) { + // if there exists a local layout file, ignore the system one + // NOTE: in this case, the textclass (.cls file) is assumed to be available. + string tcp; + LayoutFileList & bcl = LayoutFileList::get(); + if (tcp.empty() && !filepath.empty()) + tcp = bcl.addLocalLayout(classname, filepath.absFilename()); + if (!tcp.empty()) + setBaseClass(tcp); + else + setBaseClass(classname); + // We assume that a tex class exists for local or unknown layouts so this warning + // will only be given for system layouts. + if (!baseClass()->isTeXClassAvailable()) { docstring const msg = bformat(_("The layout file requested by this document,\n" "%1$s.layout,\n" @@ -495,15 +485,22 @@ string const BufferParams::readToken(Lexer & lex, string const & token) frontend::Alert::warning(_("Document class not available"), msg + _("LyX will not be able to produce output.")); } - } else if (token == "\\begin_preamble") { readPreamble(lex); + } else if (token == "\\begin_local_layout") { + readLocalLayout(lex); } else if (token == "\\begin_modules") { readModules(lex); - makeTextClass(); + } else if (token == "\\begin_removed_modules") { + readRemovedModules(lex); } else if (token == "\\options") { lex.eatLine(); options = lex.getString(); + } else if (token == "\\use_default_options") { + lex >> use_default_options; + } else if (token == "\\master") { + lex.eatLine(); + master = lex.getString(); } else if (token == "\\language") { readLanguage(lex); } else if (token == "\\inputencoding") { @@ -526,13 +523,19 @@ string const BufferParams::readToken(Lexer & lex, string const & token) lex >> fontsSansScale; } else if (token == "\\font_tt_scale") { lex >> fontsTypewriterScale; + } else if (token == "\\font_cjk") { + lex >> fontsCJK; } else if (token == "\\paragraph_separation") { string parsep; lex >> parsep; paragraph_separation = parseptranslator().find(parsep); } else if (token == "\\defskip") { lex.next(); - pimpl_->defskip = VSpace(lex.getString()); + string defskip = lex.getString(); + if (defskip == "defskip") + // this is invalid + defskip = "medskip"; + pimpl_->defskip = VSpace(defskip); } else if (token == "\\quotes_language") { string quotes_lang; lex >> quotes_lang; @@ -584,7 +587,7 @@ string const BufferParams::readToken(Lexer & lex, string const & token) branch_ptr->setColor(color); // Update also the Color table: if (color == "none") - color = lcolor.getX11Name(Color::background); + color = lcolor.getX11Name(Color_background); // FIXME UNICODE lcolor.setColor(to_utf8(branch), color); @@ -618,6 +621,8 @@ string const BufferParams::readToken(Lexer & lex, string const & token) lex >> headsep; } else if (token == "\\footskip") { lex >> footskip; + } else if (token == "\\columnsep") { + lex >> columnsep; } else if (token == "\\paperfontsize") { lex >> fontsize; } else if (token == "\\papercolumns") { @@ -674,7 +679,7 @@ void BufferParams::writeFile(ostream & os) const // Prints out the buffer info into the .lyx file given by file // the textclass - os << "\\textclass " << textclasslist[baseClass_].name() << '\n'; + os << "\\textclass " << baseClass()->name() << '\n'; // then the preamble if (!preamble.empty()) { @@ -689,15 +694,44 @@ void BufferParams::writeFile(ostream & os) const if (!options.empty()) { os << "\\options " << options << '\n'; } + + // use the class options defined in the layout? + os << "\\use_default_options " + << convert(use_default_options) << "\n"; + + // the master document + if (!master.empty()) { + os << "\\master " << master << '\n'; + } - //the modules + // removed modules + if (!removedModules_.empty()) { + os << "\\begin_removed_modules" << '\n'; + set::const_iterator it = removedModules_.begin(); + set::const_iterator en = removedModules_.end(); + for (; it != en; it++) + os << *it << '\n'; + os << "\\end_removed_modules" << '\n'; + } + + // the modules if (!layoutModules_.empty()) { os << "\\begin_modules" << '\n'; LayoutModuleList::const_iterator it = layoutModules_.begin(); - for (; it != layoutModules_.end(); it++) + LayoutModuleList::const_iterator en = layoutModules_.end(); + for (; it != en; it++) os << *it << '\n'; os << "\\end_modules" << '\n'; } + + // local layout information + if (!local_layout.empty()) { + // remove '\n' from the end + string const tmplocal = rtrim(local_layout, "\n"); + os << "\\begin_local_layout\n" + << tmplocal + << "\n\\end_local_layout\n"; + } // then the text parameters if (language != ignore_language) @@ -711,7 +745,11 @@ void BufferParams::writeFile(ostream & os) const << "\n\\font_osf " << convert(fontsOSF) << "\n\\font_sf_scale " << fontsSansScale << "\n\\font_tt_scale " << fontsTypewriterScale - << "\n\\graphics " << graphicsDriver << '\n'; + << '\n'; + if (!fontsCJK.empty()) { + os << "\\font_cjk " << fontsCJK << '\n'; + } + os << "\n\\graphics " << graphicsDriver << '\n'; if (!float_placement.empty()) { os << "\\float_placement " << float_placement << '\n'; @@ -733,9 +771,9 @@ void BufferParams::writeFile(ostream & os) const BranchList::const_iterator it = branchlist().begin(); BranchList::const_iterator end = branchlist().end(); for (; it != end; ++it) { - os << "\\branch " << to_utf8(it->getBranch()) - << "\n\\selected " << it->getSelected() - << "\n\\color " << lyx::X11hexname(it->getColor()) + os << "\\branch " << to_utf8(it->branch()) + << "\n\\selected " << it->isSelected() + << "\n\\color " << lyx::X11hexname(it->color()) << "\n\\end_branch" << "\n"; } @@ -767,6 +805,9 @@ void BufferParams::writeFile(ostream & os) const if (!footskip.empty()) os << "\\footskip " << VSpace(footskip).asLyXCommand() << '\n'; + if (!columnsep.empty()) + os << "\\columnsep " + << VSpace(columnsep).asLyXCommand() << '\n'; os << "\\secnumdepth " << secnumdepth << "\n\\tocdepth " << tocdepth << "\n\\paragraph_separation " @@ -811,12 +852,146 @@ void BufferParams::writeFile(ostream & os) const } +void BufferParams::validate(LaTeXFeatures & features) const +{ + features.require(documentClass().requires()); + + if (outputChanges) { + bool dvipost = LaTeXFeatures::isAvailable("dvipost"); + bool xcolorsoul = LaTeXFeatures::isAvailable("soul") && + LaTeXFeatures::isAvailable("xcolor"); + + switch (features.runparams().flavor) { + case OutputParams::LATEX: + if (dvipost) { + features.require("ct-dvipost"); + features.require("dvipost"); + } else if (xcolorsoul) { + features.require("ct-xcolor-soul"); + features.require("soul"); + features.require("xcolor"); + } else { + features.require("ct-none"); + } + break; + case OutputParams::PDFLATEX: + if (xcolorsoul) { + features.require("ct-xcolor-soul"); + features.require("soul"); + features.require("xcolor"); + // improves color handling in PDF output + features.require("pdfcolmk"); + } else { + features.require("ct-none"); + } + break; + default: + break; + } + } + + // Floats with 'Here definitely' as default setting. + if (float_placement.find('H') != string::npos) + features.require("float"); + + // AMS Style is at document level + if (use_amsmath == package_on + || documentClass().provides("amsmath")) + features.require("amsmath"); + if (use_esint == package_on) + features.require("esint"); + + // Document-level line spacing + if (spacing().getSpace() != Spacing::Single && !spacing().isDefault()) + features.require("setspace"); + + // the bullet shapes are buffer level not paragraph level + // so they are tested here + for (int i = 0; i < 4; ++i) { + if (user_defined_bullet(i) == ITEMIZE_DEFAULTS[i]) + continue; + int const font = user_defined_bullet(i).getFont(); + if (font == 0) { + int const c = user_defined_bullet(i).getCharacter(); + if (c == 16 + || c == 17 + || c == 25 + || c == 26 + || c == 31) { + features.require("latexsym"); + } + } else if (font == 1) { + features.require("amssymb"); + } else if (font >= 2 && font <= 5) { + features.require("pifont"); + } + } + + if (pdfoptions().use_hyperref) { + features.require("hyperref"); + // due to interferences with babel and hyperref, the color package has to + // be loaded after hyperref when hyperref is used with the colorlinks + // option, see http://bugzilla.lyx.org/show_bug.cgi?id=5291 + if (pdfoptions().colorlinks) + features.require("color"); + } + + if (language->lang() == "vietnamese") + features.require("vietnamese"); + else if (language->lang() == "japanese") + features.require("japanese"); +} + +/// Find out if we need special treatment for babel. +static bool needsSpecialBabelCall(LaTeXFeatures const & features) +{ + // FIXME: don't hardcode this!! + // If Vietnamese is used, babel must directly be loaded with the + // language options, see + // http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129417.html + // + // viet = string::npos when not found + // the same is for all other languages that are not directly supported by + // babel, but where LaTeX-packages add babel support. + // this is currently the case for Latvian, Lithuanian, and Mongolian + // + // If Japanese is used, babel must directly be loaded with the + // language options, see + // http://bugzilla.lyx.org/show_bug.cgi?id=4597#c4 + return !lyxrc.language_global_options + || features.hasLanguage("vietnam") + || features.hasLanguage("latvian") + || features.hasLanguage("japanese") + || features.hasLanguage("lithuanian") + || features.hasLanguage("mongolian"); +} + +/// set up if and how babel is called +static docstring babelCall(LaTeXFeatures const & features, + string const & lang_opts) +{ + string babel_call = lyxrc.language_package; + if (babel_call != "\\usepackage{babel}") + return from_utf8(babel_call); + // suppress the babel call when there is no babel language defined + // for the document language in the lib/languages file and if no + // other languages are used (lang_opts is then empty) + if (!features.hasLanguages()) + return docstring(); + + if (needsSpecialBabelCall(features)) + babel_call = "\\usepackage[" + lang_opts + "]{babel}"; + + return from_utf8(babel_call); +} + + bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features, TexRow & texrow) const { os << "\\documentclass"; - TextClass const & tclass = getTextClass(); + DocumentClass const & tclass = documentClass(); ostringstream clsoptions; // the document class options. @@ -864,10 +1039,10 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features, // if needed if (sides != tclass.sides()) { switch (sides) { - case TextClass::OneSide: + case OneSide: clsoptions << "oneside,"; break; - case TextClass::TwoSides: + case TwoSides: clsoptions << "twoside,"; break; } @@ -900,15 +1075,15 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features, language_options << ','; language_options << language->babel(); } - // when Vietnamese is used, babel must directly be loaded with the - // language options, not in the class options - int viet = language_options.str().find("vietnam"); - // viet = string::npos when not found - if (lyxrc.language_global_options && !language_options.str().empty() - && viet == string::npos) + if (!language_options.str().empty() + && !needsSpecialBabelCall(features)) clsoptions << language_options.str() << ','; } + // the predefined options from the layout + if (use_default_options && !tclass.options().empty()) + clsoptions << tclass.options() << ','; + // the user-defined options if (!options.empty()) { clsoptions << options << ','; @@ -940,9 +1115,11 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features, // set font encoding // this one is not per buffer - // for arabic_arabi and farsi we also need to load the LAE and LFE encoding - if (lyxrc.fontenc != "default") { - if (language->lang() == "arabic_arabi" || language->lang() == "farsi") { + // for arabic_arabi and farsi we also need to load the LAE and + // LFE encoding + if (lyxrc.fontenc != "default" && language->lang() != "japanese") { + if (language->lang() == "arabic_arabi" + || language->lang() == "farsi") { os << "\\usepackage[" << from_ascii(lyxrc.fontenc) << ",LFE,LAE]{fontenc}\n"; texrow.newline(); @@ -956,13 +1133,20 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features, // handle inputenc etc. writeEncodingPreamble(os, features, texrow); - if (!listings_params.empty()) { + if (!listings_params.empty() || features.isRequired("listings")) { os << "\\usepackage{listings}\n"; texrow.newline(); + } + if (!listings_params.empty()) { os << "\\lstset{"; - // do not test validity because listings_params is supposed to be valid - string par = InsetListingsParams(listings_params).separatedParams(true); - os << from_ascii(par); + // do not test validity because listings_params is + // supposed to be valid + string par = + InsetListingsParams(listings_params).separatedParams(true); + // we can't support all packages, but we should load the color package + if (par.find("\\color", 0) != string::npos) + features.require("color"); + os << from_utf8(par); // count the number of newlines for (size_t i = 0; i < par.size(); ++i) if (par[i] == '\n') @@ -1057,8 +1241,12 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features, os << ",headsep=" << from_ascii(Length(headsep).asLatexString()); if (!footskip.empty()) os << ",footskip=" << from_ascii(Length(footskip).asLatexString()); + if (!columnsep.empty()) + os << ",columnsep=" << from_ascii(Length(columnsep).asLatexString()); os << "}\n"; texrow.newline(); + } else if (orientation == ORIENTATION_LANDSCAPE) { + features.require("papersize"); } if (tokenPos(tclass.opt_pagestyle(), @@ -1113,79 +1301,88 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features, texrow.newline(); } - // If we use jurabib, we have to call babel here. - if (use_babel && features.isRequired("jurabib")) { - os << from_ascii(babelCall(language_options.str())) - << '\n' - << from_ascii(features.getBabelOptions()); - texrow.newline(); - } - // Now insert the LyX specific LaTeX commands... + docstring lyxpreamble; + + // due to interferences with babel and hyperref, the color package has to + // be loaded (when it is not already loaded) before babel when hyperref + // is used with the colorlinks option, see + // http://bugzilla.lyx.org/show_bug.cgi?id=5291 + // we decided therefore to load color always before babel, see + // http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg144349.html + lyxpreamble += from_ascii(features.getColorOptions()); + + // If we use hyperref, jurabib, japanese, or vietnamese, we have to call babel before them. + if (use_babel + && (features.isRequired("jurabib") + || features.isRequired("hyperref") + || features.isRequired("vietnamese") + || features.isRequired("japanese") ) ) { + // FIXME UNICODE + lyxpreamble += babelCall(features, language_options.str()) + '\n'; + lyxpreamble += from_utf8(features.getBabelOptions()) + '\n'; + } // The optional packages; - docstring lyxpreamble(from_ascii(features.getPackages())); - - // We try to load babel late, in case it interferes - // with other packages. But some packages also need babel to be loaded - // before, e.g. jurabib has to be called after babel. - // So load babel after the optional packages but before the user-defined - // preamble. This allows the users to redefine babel commands, e.g. to - // translate the word "Index" to the German "Stichwortverzeichnis". - // For more infos why this place was chosen, see - // http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg128425.html - // if you encounter problem, you can shift babel to its old place behind - // the user-defined preamble - if (use_babel && !features.isRequired("jurabib")) { - // FIXME UNICODE - lyxpreamble += from_utf8(babelCall(language_options.str())) + '\n'; - lyxpreamble += from_utf8(features.getBabelOptions()); - } + lyxpreamble += from_ascii(features.getPackages()); - // When the language "japanese-plain" is used, the package "japanese" must - // be loaded behind babel (it provides babel support for Japanese) - // see http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129680.html - if (language->lang() == "japanese-plain") - lyxpreamble += "\\usepackage{japanese}\n"; + // Line spacing + lyxpreamble += from_utf8(spacing().writePreamble(tclass.provides("SetSpace"))); // PDF support. // * Hyperref manual: "Make sure it comes last of your loaded // packages, to give it a fighting chance of not being over-written, - // since its job is to redefine many LATEX commands." + // since its job is to redefine many LaTeX commands." // * Email from Heiko Oberdiek: "It is usually better to load babel // before hyperref. Then hyperref has a chance to detect babel. // * Has to be loaded before the "LyX specific LaTeX commands" to // avoid errors with algorithm floats. - odocstringstream oss; - pdfoptions().writeLaTeX(oss); - lyxpreamble += oss.str(); - - // this might be useful... - lyxpreamble += "\n\\makeatletter\n"; + // use hyperref explicitely when it is required + if (features.isRequired("hyperref")) { + odocstringstream oss; + pdfoptions().writeLaTeX(oss, documentClass().provides("hyperref")); + lyxpreamble += oss.str(); + } + + // Will be surrounded by \makeatletter and \makeatother when needed + docstring atlyxpreamble; // Some macros LyX will need docstring tmppreamble(from_ascii(features.getMacros())); - if (!tmppreamble.empty()) { - lyxpreamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " + if (!tmppreamble.empty()) + atlyxpreamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " "LyX specific LaTeX commands.\n" + tmppreamble + '\n'; - } // the text class specific preamble tmppreamble = features.getTClassPreamble(); - if (!tmppreamble.empty()) { - lyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " + if (!tmppreamble.empty()) + atlyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " "Textclass specific LaTeX commands.\n" + tmppreamble + '\n'; - } /* the user-defined preamble */ - if (!preamble.empty()) { + if (!preamble.empty()) // FIXME UNICODE - lyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " + atlyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " "User specified LaTeX commands.\n" + from_utf8(preamble) + '\n'; + + // subfig loads internally the LaTeX package "caption". As + // caption is a very popular package, users will load it in + // the preamble. Therefore we must load subfig behind the + // user-defined preamble and check if the caption package was + // loaded or not. For the case that caption is loaded before + // subfig, there is the subfig option "caption=false". This + // option also works when a koma-script class is used and + // koma's own caption commands are used instead of caption. We + // use \PassOptionsToPackage here because the user could have + // already loaded subfig in the preamble. + if (features.isRequired("subfig")) { + atlyxpreamble += "\\@ifundefined{showcaptionsetup}{}{%\n" + " \\PassOptionsToPackage{caption=false}{subfig}}\n" + "\\usepackage{subfig}\n"; } // Itemize bullet settings need to be last in case the user @@ -1221,9 +1418,24 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features, } if (!bullets_def.empty()) - lyxpreamble += bullets_def + "}\n\n"; - - lyxpreamble += "\\makeatother\n\n"; + atlyxpreamble += bullets_def + "}\n\n"; + + if (atlyxpreamble.find(from_ascii("@")) != docstring::npos) + lyxpreamble += "\n\\makeatletter\n" + + atlyxpreamble + "\\makeatother\n\n"; + else + lyxpreamble += '\n' + atlyxpreamble; + + // We try to load babel late, in case it interferes with other packages. + // Jurabib and Hyperref have to be called after babel, though. + if (use_babel && !features.isRequired("jurabib") + && !features.isRequired("hyperref") + && !features.isRequired("vietnamese") + && !features.isRequired("japanese")) { + // FIXME UNICODE + lyxpreamble += babelCall(features, language_options.str()) + '\n'; + lyxpreamble += from_utf8(features.getBabelOptions()) + '\n'; + } int const nlines = int(count(lyxpreamble.begin(), lyxpreamble.end(), '\n')); @@ -1238,12 +1450,12 @@ bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features, void BufferParams::useClassDefaults() { - TextClass const & tclass = textclasslist[baseClass_]; + DocumentClass const & tclass = documentClass(); sides = tclass.sides(); columns = tclass.columns(); pagestyle = tclass.pagestyle(); - options = tclass.options(); + use_default_options = true; // Only if class has a ToC hierarchy if (tclass.hasTocLevels()) { secnumdepth = tclass.secnumdepth(); @@ -1254,68 +1466,134 @@ void BufferParams::useClassDefaults() bool BufferParams::hasClassDefaults() const { - TextClass const & tclass = textclasslist[baseClass_]; + DocumentClass const & tclass = documentClass(); - return (sides == tclass.sides() + return sides == tclass.sides() && columns == tclass.columns() && pagestyle == tclass.pagestyle() - && options == tclass.options() + && use_default_options && secnumdepth == tclass.secnumdepth() - && tocdepth == tclass.tocdepth()); + && tocdepth == tclass.tocdepth(); } -TextClass const & BufferParams::getTextClass() const +DocumentClass const & BufferParams::documentClass() const { - return *textClass_; + return *doc_class_; } -TextClassPtr BufferParams::getTextClassPtr() const { - return textClass_; +DocumentClass const * BufferParams::documentClassPtr() const { + return doc_class_; } -void BufferParams::setTextClass(TextClassPtr tc) { - textClass_ = tc; +void BufferParams::setDocumentClass(DocumentClass const * const tc) { + // evil, but this function is evil + doc_class_ = const_cast(tc); } -bool BufferParams::setBaseClass(textclass_type tc) +bool BufferParams::setBaseClass(string const & classname) { - bool retVal = true; - if (textclasslist[tc].load()) - baseClass_ = tc; - else { + LYXERR(Debug::TCLASS, "setBaseClass: " << classname); + LayoutFileList & bcl = LayoutFileList::get(); + if (!bcl.haveClass(classname)) { + docstring s = + bformat(_("The document class %1$s could not be found. " + "A default textclass with default layouts will be used. " + "LyX might not be able to produce output unless a correct " + "textclass is selected from the document settings dialog."), + from_utf8(classname)); + frontend::Alert::error(_("Document class not found"), s); + bcl.addEmptyClass(classname); + } + + bool const success = bcl[classname].load(); + if (!success) { docstring s = bformat(_("The document class %1$s could not be loaded."), - from_utf8(textclasslist[tc].name())); + from_utf8(classname)); frontend::Alert::error(_("Could not load class"), s); - retVal = false; + return false; } - makeTextClass(); - return retVal; + + pimpl_->baseClass_ = classname; + + // add any required modules not already in use + list const & mods = baseClass()->defaultModules(); + list::const_iterator mit = mods.begin(); + list::const_iterator men = mods.end(); + for (; mit != men; mit++) { + string const & modName = *mit; + // see if we're already in use + if (find(layoutModules_.begin(), layoutModules_.end(), modName) != + layoutModules_.end()) { + LYXERR(Debug::TCLASS, "Default module `" << modName << + "' not added because already used."); + continue; + } + // make sure the user hasn't removed it + if (find(removedModules_.begin(), removedModules_.end(), modName) != + removedModules_.end()) { + LYXERR(Debug::TCLASS, "Default module `" << modName << + "' not added because removed by user."); + continue; + } + // Now we want to check the list of selected modules to see if any of them + // exclude this one. + bool foundit = false; + // so iterate over the selected modules... + LayoutModuleList::const_iterator lit = layoutModules_.begin(); + LayoutModuleList::const_iterator len = layoutModules_.end(); + for (; lit != len; lit++) { + LyXModule * lm = moduleList[*lit]; + if (!lm) + continue; + vector const & exc = lm->getExcludedModules(); + // ...and see if this one excludes us. + if (find(exc.begin(), exc.end(), modName) != exc.end()) { + foundit = true; + LYXERR(Debug::TCLASS, "Default module `" << modName << + "' not added because excluded by loaded module `" << + *lit << "'."); + break; + } + } + if (!foundit) { + LYXERR(Debug::TCLASS, "Default module `" << modName << "' added."); + layoutModules_.push_back(modName); + } + } + return true; } -void BufferParams::setJustBaseClass(textclass_type tc) -{ - baseClass_ = tc; +LayoutFile const * BufferParams::baseClass() const +{ + if (LayoutFileList::get().haveClass(pimpl_->baseClass_)) + return &(LayoutFileList::get()[pimpl_->baseClass_]); + else + return 0; } -textclass_type BufferParams::getBaseClass() const +LayoutFileIndex const & BufferParams::baseClassID() const { - return baseClass_; + return pimpl_->baseClass_; } -void BufferParams::makeTextClass() +void BufferParams::makeDocumentClass() { - textClass_.reset(new TextClass(textclasslist[getBaseClass()])); - //FIXME It might be worth loading the children's modules here, - //just as we load their bibliographies and such, instead of just - //doing a check in InsetInclude. + if (!baseClass()) + return; + + doc_class_ = &(DocumentClassBundle::get().newClass(*baseClass())); + + // FIXME It might be worth loading the children's modules here, + // just as we load their bibliographies and such, instead of just + // doing a check in InsetInclude. LayoutModuleList::const_iterator it = layoutModules_.begin(); for (; it != layoutModules_.end(); it++) { string const modName = *it; @@ -1325,71 +1603,58 @@ void BufferParams::makeTextClass() bformat(_("The module %1$s has been requested by\n" "this document but has not been found in the list of\n" "available modules. If you recently installed it, you\n" - "probalby need to reconfigure LyX.\n"), from_utf8(modName)); + "probably need to reconfigure LyX.\n"), from_utf8(modName)); frontend::Alert::warning(_("Module not available"), msg + _("Some layouts may not be available.")); - lyxerr << "BufferParams::makeTextClass(): Module " << - modName << " requested but not found in module list." << - endl; + LYXERR0("BufferParams::makeDocumentClass(): Module " << + modName << " requested but not found in module list."); continue; } - FileName layout_file = libFileSearch("layouts", lm->filename); - textClass_->read(layout_file, TextClass::MODULE); + if (!lm->isAvailable()) { + docstring const msg = + bformat(_("The module %1$s requires a package that is\n" + "not available in your LaTeX installation. LaTeX output\n" + "may not be possible.\n"), from_utf8(modName)); + frontend::Alert::warning(_("Package not available"), msg); + } + FileName layout_file = libFileSearch("layouts", lm->getFilename()); + if (!doc_class_->read(layout_file, TextClass::MODULE)) { + docstring const msg = + bformat(_("Error reading module %1$s\n"), from_utf8(modName)); + frontend::Alert::warning(_("Read Error"), msg); + } + } + if (!local_layout.empty()) { + if (!doc_class_->read(local_layout, TextClass::MODULE)) { + docstring const msg = _("Error reading internal layout information"); + frontend::Alert::warning(_("Read Error"), msg); + } } } -std::vector const & BufferParams::getModules() const { - return layoutModules_; -} - - - -bool BufferParams::addLayoutModule(string modName, bool makeClass) { +bool BufferParams::addLayoutModule(string const & modName) +{ LayoutModuleList::const_iterator it = layoutModules_.begin(); LayoutModuleList::const_iterator end = layoutModules_.end(); - for (; it != end; it++) { + for (; it != end; it++) if (*it == modName) - break; - } - if (it != layoutModules_.end()) - return false; + return false; layoutModules_.push_back(modName); - if (makeClass) - makeTextClass(); return true; } -bool BufferParams::addLayoutModules(std::vectormodNames) -{ - bool retval = true; - std::vector::const_iterator it = modNames.begin(); - std::vector::const_iterator end = modNames.end(); - for (; it != end; ++it) - retval &= addLayoutModule(*it, false); - makeTextClass(); - return retval; -} - - -void BufferParams::clearLayoutModules() { - layoutModules_.clear(); - makeTextClass(); -} - - Font const BufferParams::getFont() const { - Font f = getTextClass().defaultfont(); - f.setLanguage(language); + FontInfo f = documentClass().defaultfont(); if (fontsDefaultFamily == "rmdefault") - f.setFamily(Font::ROMAN_FAMILY); + f.setFamily(ROMAN_FAMILY); else if (fontsDefaultFamily == "sfdefault") - f.setFamily(Font::SANS_FAMILY); + f.setFamily(SANS_FAMILY); else if (fontsDefaultFamily == "ttdefault") - f.setFamily(Font::TYPEWRITER_FAMILY); - return f; + f.setFamily(TYPEWRITER_FAMILY); + return Font(f, language); } @@ -1403,6 +1668,16 @@ void BufferParams::readPreamble(Lexer & lex) } +void BufferParams::readLocalLayout(Lexer & lex) +{ + if (lex.getString() != "\\begin_local_layout") + lyxerr << "Error (BufferParams::readLocalLayout):" + "consistency check failed." << endl; + + local_layout = lex.getLongString("\\end_local_layout"); +} + + void BufferParams::readLanguage(Lexer & lex) { if (!lex.next()) return; @@ -1423,7 +1698,8 @@ void BufferParams::readLanguage(Lexer & lex) void BufferParams::readGraphicsDriver(Lexer & lex) { - if (!lex.next()) return; + if (!lex.next()) + return; string const tmptok = lex.getString(); // check if tmptok is part of tex_graphics in tex_defs.h @@ -1434,7 +1710,8 @@ void BufferParams::readGraphicsDriver(Lexer & lex) if (test == tmptok) { graphicsDriver = tmptok; break; - } else if (test == "") { + } + if (test.empty()) { lex.printError( "Warning: graphics driver `$$Token' not recognized!\n" " Setting graphics driver to `default'.\n"); @@ -1447,7 +1724,8 @@ void BufferParams::readGraphicsDriver(Lexer & lex) void BufferParams::readBullets(Lexer & lex) { - if (!lex.next()) return; + if (!lex.next()) + return; int const index = lex.getInteger(); lex.next(); @@ -1466,7 +1744,8 @@ void BufferParams::readBullets(Lexer & lex) void BufferParams::readBulletsLaTeX(Lexer & lex) { // The bullet class should be able to read this. - if (!lex.next()) return; + if (!lex.next()) + return; int const index = lex.getInteger(); lex.next(true); docstring const temp_str = lex.getDocString(); @@ -1493,27 +1772,93 @@ void BufferParams::readModules(Lexer & lex) } -string const BufferParams::paperSizeName() const +void BufferParams::readRemovedModules(Lexer & lex) +{ + if (!lex.eatLine()) { + lyxerr << "Error (BufferParams::readRemovedModules):" + "Unexpected end of input." << endl; + return; + } + while (true) { + string mod = lex.getString(); + if (mod == "\\end_removed_modules") + break; + removedModules_.insert(mod); + lex.eatLine(); + } + // now we want to remove any removed modules that were previously + // added. normally, that will be because default modules were added in + // setBaseClass(), which gets called when \textclass is read at the + // start of the read. + set::const_iterator rit = removedModules_.begin(); + set::const_iterator const ren = removedModules_.end(); + for (; rit != ren; rit++) { + LayoutModuleList::iterator const mit = layoutModules_.begin(); + LayoutModuleList::iterator const men = layoutModules_.end(); + LayoutModuleList::iterator found = find(mit, men, *rit); + if (found == men) + continue; + layoutModules_.erase(found); + } +} + + +string BufferParams::paperSizeName(PapersizePurpose purpose) const { char real_papersize = papersize; if (real_papersize == PAPER_DEFAULT) real_papersize = lyxrc.default_papersize; switch (real_papersize) { + case PAPER_DEFAULT: + // could be anything, so don't guess + return string(); + case PAPER_CUSTOM: { + if (purpose == XDVI && !paperwidth.empty() && + !paperheight.empty()) { + // heightxwidth + string first = paperwidth; + string second = paperheight; + if (orientation == ORIENTATION_LANDSCAPE) + first.swap(second); + // cut off unit. + return first.erase(first.length() - 2) + + "x" + second; + } + return string(); + } case PAPER_A3: return "a3"; case PAPER_A4: return "a4"; case PAPER_A5: return "a5"; + case PAPER_B3: + // dvips and dvipdfm do not know this + if (purpose == DVIPS || purpose == DVIPDFM) + return string(); + return "b3"; + case PAPER_B4: + // dvipdfm does not know this + if (purpose == DVIPDFM) + return string(); + return "b4"; case PAPER_B5: + // dvipdfm does not know this + if (purpose == DVIPDFM) + return string(); return "b5"; case PAPER_USEXECUTIVE: + // dvipdfm does not know this + if (purpose == DVIPDFM) + return string(); return "foolscap"; case PAPER_USLEGAL: return "legal"; case PAPER_USLETTER: default: + if (purpose == XDVI) + return "us"; return "letter"; } } @@ -1533,9 +1878,9 @@ string const BufferParams::dvips_options() const result += ' ' + paperwidth; result += ',' + paperheight; } else { - string const paper_option = paperSizeName(); - if (paper_option != "letter" || - orientation != ORIENTATION_LANDSCAPE) { + string const paper_option = paperSizeName(DVIPS); + if (!paper_option.empty() && (paper_option != "letter" || + orientation != ORIENTATION_LANDSCAPE)) { // dvips won't accept -t letter -t landscape. // In all other cases, include the paper size // explicitly. @@ -1550,26 +1895,6 @@ string const BufferParams::dvips_options() const } -string const BufferParams::babelCall(string const & lang_opts) const -{ - string lang_pack = lyxrc.language_package; - if (lang_pack != "\\usepackage{babel}") - return lang_pack; - // suppress the babel call when there is no babel language defined - // for the document language in the lib/languages file and if no - // other languages are used (lang_opts is then empty) - if (lang_opts.empty()) - return string(); - // when Vietnamese is used, babel must directly be loaded with the - // language options - int viet = lang_opts.find("vietnam"); - // viet = string::npos when not found - if (!lyxrc.language_global_options || viet != string::npos) - return "\\usepackage[" + lang_opts + "]{babel}"; - return lang_pack; -} - - void BufferParams::writeEncodingPreamble(odocstream & os, LaTeXFeatures & features, TexRow & texrow) const { @@ -1581,20 +1906,20 @@ void BufferParams::writeEncodingPreamble(odocstream & os, // Create a list with all the input encodings used // in the document - std::set encodings = + set encodings = features.getEncodingSet(doc_encoding); - // When the encodings EUC-JP-plain, JIS-plain, or SJIS-plainare used, the - // package inputenc must be omitted. Therefore set the encoding to empty. + // If the "japanese" package (i.e. pLaTeX) is used, + // inputenc must be omitted. // see http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129680.html - if (doc_encoding == "EUC-JP-plain" || doc_encoding == "JIS-plain" || - doc_encoding == "SJIS-plain") - encodings.clear(); + if (package == Encoding::japanese) + features.require("japanese"); - if (!encodings.empty() || package == Encoding::inputenc) { + if ((!encodings.empty() || package == Encoding::inputenc) + && !features.isRequired("japanese")) { os << "\\usepackage["; - std::set::const_iterator it = encodings.begin(); - std::set::const_iterator const end = encodings.end(); + set::const_iterator it = encodings.begin(); + set::const_iterator const end = encodings.end(); if (it != end) { os << from_ascii(*it); ++it; @@ -1609,15 +1934,19 @@ void BufferParams::writeEncodingPreamble(odocstream & os, os << "]{inputenc}\n"; texrow.newline(); } - if (package == Encoding::CJK) { + if (package == Encoding::CJK || features.mustProvide("CJK")) { os << "\\usepackage{CJK}\n"; texrow.newline(); } } else if (inputenc != "default") { switch (encoding().package()) { case Encoding::none: + case Encoding::japanese: break; case Encoding::inputenc: + // do not load inputenc if japanese is used + if (features.isRequired("japanese")) + break; os << "\\usepackage[" << from_ascii(inputenc) << "]{inputenc}\n"; texrow.newline(); @@ -1629,9 +1958,10 @@ void BufferParams::writeEncodingPreamble(odocstream & os, } } - // The encoding "armscii8" is only available when the package "armtex" is loaded. - // armscii8 is used for Armenian. - if (language->encoding()->latexName() == "armscii8" || inputenc == "armscii8") { + // The encoding "armscii8" (for Armenian) is only available when + // the package "armtex" is loaded. + if (language->encoding()->latexName() == "armscii8" + || inputenc == "armscii8") { os << "\\usepackage{armtex}\n"; texrow.newline(); } @@ -1768,7 +2098,7 @@ string const BufferParams::loadFonts(string const & rm, else if (tt == "courier" ) os << "\\usepackage{" << tt << "}\n"; // Computer Modern, Latin Modern, CM Bright - else if (tt != "default") + else if (tt != "default") os << "\\renewcommand{\\ttdefault}{" << tt << "}\n"; return os.str(); @@ -1778,29 +2108,28 @@ string const BufferParams::loadFonts(string const & rm, Encoding const & BufferParams::encoding() const { if (inputenc == "auto" || inputenc == "default") - return *(language->encoding()); - Encoding const * const enc = - encodings.getFromLaTeXName(inputenc); + return *language->encoding(); + Encoding const * const enc = encodings.fromLaTeXName(inputenc); if (enc) return *enc; - lyxerr << "Unknown inputenc value `" << inputenc - << "'. Using `auto' instead." << endl; - return *(language->encoding()); + LYXERR0("Unknown inputenc value `" << inputenc + << "'. Using `auto' instead."); + return *language->encoding(); } -biblio::CiteEngine BufferParams::getEngine() const +CiteEngine BufferParams::citeEngine() const { // FIXME the class should provide the numerical/ // authoryear choice - if (getTextClass().provides("natbib") - && cite_engine_ != biblio::ENGINE_NATBIB_NUMERICAL) - return biblio::ENGINE_NATBIB_AUTHORYEAR; + if (documentClass().provides("natbib") + && cite_engine_ != ENGINE_NATBIB_NUMERICAL) + return ENGINE_NATBIB_AUTHORYEAR; return cite_engine_; } -void BufferParams::setCiteEngine(biblio::CiteEngine const cite_engine) +void BufferParams::setCiteEngine(CiteEngine cite_engine) { cite_engine_ = cite_engine; }