#include "ColorSet.h"
#include "Converter.h"
#include "Encoding.h"
-#include "HSpace.h"
#include "IndicesList.h"
#include "Language.h"
#include "LaTeXFeatures.h"
#include "LaTeXFonts.h"
+#include "Length.h"
#include "ModuleList.h"
#include "Font.h"
#include "Lexer.h"
return false;
}
-} // anon namespace
+} // namespace
class BufferParams::Impl
Bullet user_defined_bullets[4];
IndicesList indiceslist;
Spacing spacing;
+ Length parindent;
+ Length mathindent;
/** This is the amount of space used for paragraph_separation "skip",
* and for detached paragraphs in "indented" documents.
*/
- HSpace indentation;
VSpace defskip;
PDFOptions pdfoptions;
LayoutFileIndex baseClass_;
: pimpl_(new Impl)
{
setBaseClass(defaultBaseclass());
- cite_engine_.push_back("basic");
+ cite_engine_ = "basic";
cite_engine_type_ = ENGINE_TYPE_DEFAULT;
makeDocumentClass();
paragraph_separation = ParagraphIndentSeparation;
+ is_math_indent = false;
+ math_numbering_side = DEFAULT;
quotes_style = InsetQuotesParams::EnglishQuotes;
dynamic_quotes = false;
fontsize = "default";
papersize = PAPER_DEFAULT;
orientation = ORIENTATION_PORTRAIT;
use_geometry = false;
- biblio_style = "plain";
+ biblio_style = string();
use_bibtopic = false;
multibib = string();
use_indices = false;
secnumdepth = 3;
tocdepth = 3;
language = default_language;
- fontenc = "global";
+ fontenc = "auto";
fonts_roman[0] = "default";
fonts_roman[1] = "default";
fonts_sans[0] = "default";
fonts_default_family = "default";
useNonTeXFonts = false;
use_microtype = false;
+ use_dash_ligatures = true;
fonts_expert_sc = false;
fonts_old_figures = false;
fonts_sans_scale[0] = 100;
html_css_as_file = false;
display_pixel_ratio = 1.0;
+ shell_escape = false;
output_sync = false;
use_refstyle = true;
+ use_minted = false;
// map current author
author_map_[pimpl_->authorlist.get(0).bufferId()] = 0;
}
-HSpace const & BufferParams::getIndentation() const
+Length const & BufferParams::getMathIndent() const
{
- return pimpl_->indentation;
+ return pimpl_->mathindent;
}
-void BufferParams::setIndentation(HSpace const & indent)
+void BufferParams::setMathIndent(Length const & indent)
{
- pimpl_->indentation = indent;
+ pimpl_->mathindent = indent;
+}
+
+
+Length const & BufferParams::getParIndent() const
+{
+ return pimpl_->parindent;
+}
+
+
+void BufferParams::setParIndent(Length const & indent)
+{
+ pimpl_->parindent = indent;
}
}
+BufferParams::MathNumber BufferParams::getMathNumber() const
+{
+ if (math_numbering_side != DEFAULT)
+ return math_numbering_side;
+ // FIXME: do not hardcode language here
+ else if (language->lang() == "arabic_arabi"
+ || documentClass().provides("leqno"))
+ return LEFT;
+ else
+ return RIGHT;
+}
+
+
string BufferParams::readToken(Lexer & lex, string const & token,
FileName const & filepath)
{
lex >> fonts_cjk;
} else if (token == "\\use_microtype") {
lex >> use_microtype;
+ } else if (token == "\\use_dash_ligatures") {
+ lex >> use_dash_ligatures;
} else if (token == "\\paragraph_separation") {
string parsep;
lex >> parsep;
paragraph_separation = parseptranslator().find(parsep);
} else if (token == "\\paragraph_indentation") {
lex.next();
- string indentation = lex.getString();
- pimpl_->indentation = HSpace(indentation);
+ string parindent = lex.getString();
+ if (parindent == "default")
+ pimpl_->parindent = Length();
+ else
+ pimpl_->parindent = Length(parindent);
} else if (token == "\\defskip") {
lex.next();
string const defskip = lex.getString();
if (pimpl_->defskip.kind() == VSpace::DEFSKIP)
// that is invalid
pimpl_->defskip = VSpace(VSpace::MEDSKIP);
+ } else if (token == "\\is_math_indent") {
+ lex >> is_math_indent;
+ } else if (token == "\\math_indentation") {
+ lex.next();
+ string mathindent = lex.getString();
+ if (mathindent == "default")
+ pimpl_->mathindent = Length();
+ else
+ pimpl_->mathindent = Length(mathindent);
+ } else if (token == "\\math_numbering_side") {
+ string tmp;
+ lex >> tmp;
+ if (tmp == "left")
+ math_numbering_side = LEFT;
+ else if (tmp == "right")
+ math_numbering_side = RIGHT;
+ else
+ math_numbering_side = DEFAULT;
} else if (token == "\\quotes_style") {
string qstyle;
lex >> qstyle;
use_package(package, packagetranslator().find(use));
} else if (token == "\\cite_engine") {
lex.eatLine();
- vector<string> engine = getVectorFromString(lex.getString());
- setCiteEngine(engine);
+ cite_engine_ = lex.getString();
} else if (token == "\\cite_engine_type") {
string engine_type;
lex >> engine_type;
spacing().set(spacetranslator().find(nspacing), tmp_val);
} else if (token == "\\float_placement") {
lex >> float_placement;
+ } else if (token == "\\float_alignment") {
+ lex >> float_alignment;
} else if (prefixIs(token, "\\pdf_") || token == "\\use_hyperref") {
string toktmp = pdfoptions().readToken(lex, token);
lex >> output_sync_macro;
} else if (token == "\\use_refstyle") {
lex >> use_refstyle;
+ } else if (token == "\\use_minted") {
+ lex >> use_minted;
} else {
lyxerr << "BufferParams::readToken(): Unknown token: " <<
token << endl;
return "\"" + str + "\"";
return str;
}
-}
+} // namespace
void BufferParams::writeFile(ostream & os, Buffer const * buf) const
os << "\\font_cjk " << fonts_cjk << '\n';
}
os << "\\use_microtype " << convert<string>(use_microtype) << '\n';
+ os << "\\use_dash_ligatures " << convert<string>(use_dash_ligatures) << '\n';
os << "\\graphics " << graphics_driver << '\n';
os << "\\default_output_format " << default_output_format << '\n';
os << "\\output_sync " << output_sync << '\n';
os << "\\bibtex_command " << bibtex_command << '\n';
os << "\\index_command " << index_command << '\n';
- if (!float_placement.empty()) {
+ if (!float_placement.empty())
os << "\\float_placement " << float_placement << '\n';
- }
+ if (!float_alignment.empty())
+ os << "\\float_alignment " << float_alignment << '\n';
os << "\\paperfontsize " << fontsize << '\n';
spacing().writeFile(os);
os << "\n\\cite_engine ";
- if (!cite_engine_.empty()) {
- LayoutModuleList::const_iterator be = cite_engine_.begin();
- LayoutModuleList::const_iterator en = cite_engine_.end();
- for (LayoutModuleList::const_iterator it = be; it != en; ++it) {
- if (it != be)
- os << ',';
- os << *it;
- }
- } else {
+ if (!cite_engine_.empty())
+ os << cite_engine_;
+ else
os << "basic";
- }
os << "\n\\cite_engine_type " << theCiteEnginesList.getTypeAsString(cite_engine_type_);
<< "\n\\suppress_date " << convert<string>(suppress_date)
<< "\n\\justification " << convert<string>(justification)
<< "\n\\use_refstyle " << use_refstyle
+ << "\n\\use_minted " << use_minted
<< '\n';
if (isbackgroundcolor == true)
os << "\\backgroundcolor " << lyx::X11hexname(backgroundcolor) << '\n';
<< "\n\\paragraph_separation "
<< string_paragraph_separation[paragraph_separation];
if (!paragraph_separation)
- os << "\n\\paragraph_indentation " << getIndentation().asLyXCommand();
+ os << "\n\\paragraph_indentation "
+ << (getParIndent().empty() ? "default" : getParIndent().asString());
else
os << "\n\\defskip " << getDefSkip().asLyXCommand();
+ os << "\n\\is_math_indent " << is_math_indent;
+ if (is_math_indent)
+ os << "\n\\math_indentation "
+ << (getMathIndent().empty() ? "default" : getMathIndent().asString());
+ os << "\n\\math_numbering_side ";
+ switch(math_numbering_side) {
+ case LEFT:
+ os << "left";
+ break;
+ case RIGHT:
+ os << "right";
+ break;
+ case DEFAULT:
+ os << "default";
+ }
os << "\n\\quotes_style "
<< string_quotes_style[quotes_style]
<< "\n\\dynamic_quotes " << dynamic_quotes
if (useNonTeXFonts && fontsMath() != "auto")
features.require("unicode-math");
-
+
if (use_microtype)
features.require("microtype");
&& orientation == ORIENTATION_LANDSCAPE)
clsoptions << "landscape,";
+ if (is_math_indent)
+ clsoptions << "fleqn,";
+
+ switch(math_numbering_side) {
+ case LEFT:
+ clsoptions << "leqno,";
+ break;
+ case RIGHT:
+ clsoptions << "reqno,";
+ features.require("amsmath");
+ break;
+ case DEFAULT:
+ break;
+ }
+
// language should be a parameter to \documentclass
if (language->babel() == "hebrew"
&& default_language->babel() != "hebrew")
bool const use_babel = features.useBabel() && !features.isProvided("babel");
bool const use_polyglossia = features.usePolyglossia();
bool const global = lyxrc.language_global_options;
- if (use_babel || (use_polyglossia && global)) {
+ if (features.useBabel() || (use_polyglossia && global)) {
language_options << features.getBabelLanguages();
if (!language->babel().empty()) {
if (!language_options.str().empty())
os << "\\usepackage{unicode-math}\n";
}
+ // load CJK support package before font selection
+ // (see autotests/export/latex/CJK/micro-sign_utf8-cjk-libertine.lyx)
+ if (!useNonTeXFonts && encoding().package() != Encoding::none
+ && (encoding().package() == Encoding::CJK || features.mustProvide("CJK"))) {
+ if (encoding().iconvName() == "UTF-8"
+ && LaTeXFeatures::isAvailable("CJKutf8"))
+ os << "\\usepackage{CJKutf8}\n";
+ else
+ os << "\\usepackage[encapsulated]{CJK}\n";
+ }
+
// font selection must be done before loading fontenc.sty
string const fonts = loadFonts(features);
if (!fonts.empty())
} else {
// when separation by indentation
// only output something when a width is given
- if (getIndentation().asLyXCommand() != "default") {
+ if (!getParIndent().empty()) {
os << "\\setlength{\\parindent}{"
- << from_utf8(getIndentation().asLatexCommand())
+ << from_utf8(getParIndent().asLatexString())
+ << "}\n";
+ }
+ }
+
+ if (is_math_indent) {
+ // when formula indentation
+ // only output something when it is not the default
+ if (!getMathIndent().empty()) {
+ os << "\\setlength{\\mathindent}{"
+ << from_utf8(getMathIndent().asString())
<< "}\n";
}
}
// http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg144349.html
os << from_ascii(features.getColorOptions());
- // If we use hyperref, jurabib, japanese, varioref or vietnamese,
+ // If we use hyperref, jurabib, japanese or varioref,
// we have to call babel before
if (use_babel
&& (features.isRequired("jurabib")
|| features.isRequired("hyperref")
|| features.isRequired("varioref")
- || features.isRequired("vietnamese")
|| features.isRequired("japanese"))) {
os << features.getBabelPresettings();
// FIXME UNICODE
OutputParams tmp_params = features.runparams();
pdfoptions().writeLaTeX(tmp_params, os,
features.isProvided("hyperref"));
- // correctly break URLs with hyperref and dvi output
- if (features.runparams().flavor == OutputParams::LATEX
+ // correctly break URLs with hyperref and dvi/ps output
+ if (features.runparams().hyperref_driver == "dvips"
&& features.isAvailable("breakurl"))
os << "\\usepackage{breakurl}\n";
} else if (features.isRequired("nameref"))
<< "\\makeatother\n\n";
// We try to load babel late, in case it interferes with other packages.
- // Jurabib, hyperref, varioref, bicaption and listings (bug 8995) have to be
- // called after babel, though.
+ // Jurabib, hyperref, varioref, bicaption, menukeys and listings (bug 8995)
+ // have to be called after babel, though.
if (use_babel && !features.isRequired("jurabib")
&& !features.isRequired("hyperref")
- && !features.isRequired("varioref")
- && !features.isRequired("vietnamese")
+ && !features.isRequired("varioref")
&& !features.isRequired("japanese")) {
os << features.getBabelPresettings();
// FIXME UNICODE
}
if (features.isRequired("bicaption"))
os << "\\usepackage{bicaption}\n";
- if (!listings_params.empty() || features.mustProvide("listings"))
- os << "\\usepackage{listings}\n";
- if (!listings_params.empty()) {
- os << "\\lstset{";
+ if (!listings_params.empty()
+ || features.mustProvide("listings")
+ || features.mustProvide("minted")) {
+ if (use_minted)
+ os << "\\usepackage{minted}\n";
+ else
+ os << "\\usepackage{listings}\n";
+ }
+ string lst_params = listings_params;
+ // If minted, do not output the language option (bug 11203)
+ if (use_minted && contains(lst_params, "language=")) {
+ vector<string> opts =
+ getVectorFromString(lst_params, ",", false);
+ for (size_t i = 0; i < opts.size(); ++i) {
+ if (prefixIs(opts[i], "language="))
+ opts.erase(opts.begin() + i--);
+ }
+ lst_params = getStringFromVector(opts, ",");
+ }
+ if (!lst_params.empty()) {
+ if (use_minted)
+ os << "\\setminted{";
+ else
+ os << "\\lstset{";
// do not test validity because listings_params is
// supposed to be valid
string par =
- InsetListingsParams(listings_params).separatedParams(true);
+ InsetListingsParams(lst_params).separatedParams(true);
os << from_utf8(par);
os << "}\n";
}
// (the rest is obsoleted by the new TU encoding).
// It needs to be loaded at least after amsmath, amssymb,
// esint and the other packages that provide special glyphs
- if (features.mustProvide("tipa") && useNonTeXFonts) {
+ if (features.mustProvide("tipa") && useNonTeXFonts
+ && !features.isProvided("xunicode")) {
// The package officially only supports XeTeX, but also works
// with LuaTeX. Thus we work around its XeTeX test.
if (features.runparams().flavor != OutputParams::XETEX) {
os << "\\usepackage{xunicode}\n";
}
+ // covington must be loaded after beamerarticle
+ if (features.isRequired("covington"))
+ os << "\\usepackage{covington}\n";
+
// Polyglossia must be loaded last ...
if (use_polyglossia) {
// call the package
}
// ... but before biblatex (see #7065)
- if (features.mustProvide("biblatex")) {
+ if (features.mustProvide("biblatex")
+ && !features.isProvided("biblatex-natbib")
+ && !features.isProvided("natbib-internal")
+ && !features.isProvided("natbib")
+ && !features.isProvided("jurabib")) {
string delim = "";
string opts;
os << "\\usepackage";
opts += delim + "backend=bibtex";
delim = ",";
}
+ if (!bib_encoding.empty() && encodings.fromLyXName(bib_encoding)) {
+ opts += delim + "bibencoding="
+ + encodings.fromLyXName(bib_encoding)->latexName();
+ delim = ",";
+ }
if (!biblio_opts.empty())
opts += delim + biblio_opts;
if (!opts.empty())
os << '\n';
}
+ // Since menukeys uses catoptions, which does some heavy changes on key-value options,
+ // it is recommended to load menukeys as the last package (even after hyperref)
+ if (features.isRequired("menukeys"))
+ os << "\\usepackage{menukeys}\n";
+
docstring const i18npreamble =
- features.getTClassI18nPreamble(use_babel, use_polyglossia);
+ features.getTClassI18nPreamble(use_babel, use_polyglossia,
+ use_minted);
if (!i18npreamble.empty())
os << i18npreamble + '\n';
}
-bool BufferParams::setBaseClass(string const & classname)
+bool BufferParams::setBaseClass(string const & classname, string const & path)
{
LYXERR(Debug::TCLASS, "setBaseClass: " << classname);
LayoutFileList & bcl = LayoutFileList::get();
bcl.addEmptyClass(classname);
}
- bool const success = bcl[classname].load();
+ bool const success = bcl[classname].load(path);
if (!success) {
docstring s =
bformat(_("Due to some error in it, the layout file:\n"
invalidateConverterCache();
LayoutModuleList mods;
- LayoutModuleList ces;
LayoutModuleList::iterator it = layout_modules_.begin();
LayoutModuleList::iterator en = layout_modules_.end();
for (; it != en; ++it)
mods.push_back(*it);
- it = cite_engine_.begin();
- en = cite_engine_.end();
- for (; it != en; ++it)
- ces.push_back(*it);
-
- doc_class_ = getDocumentClass(*baseClass(), mods, ces, clone);
+ doc_class_ = getDocumentClass(*baseClass(), mods, cite_engine_, clone);
TextClass::ReturnValues success = TextClass::OK;
if (!forced_local_layout_.empty())
}
-bool BufferParams::citationModuleCanBeAdded(string const & modName) const
-{
- return cite_engine_.moduleCanBeAdded(modName, baseClass());
-}
-
-
docstring BufferParams::getLocalLayout(bool forced) const
{
if (forced)
{
FormatList & cached = only_viewable ?
pimpl_->viewableFormatList : pimpl_->exportableFormatList;
- bool & valid = only_viewable ?
+ bool & valid = only_viewable ?
pimpl_->isViewCacheValid : pimpl_->isExportCacheValid;
if (valid)
return cached;
theConverters().getReachable(backs[0], only_viewable, true, excludes);
for (vector<string>::const_iterator it = backs.begin() + 1;
it != backs.end(); ++it) {
- FormatList r = theConverters().getReachable(*it, only_viewable,
+ FormatList r = theConverters().getReachable(*it, only_viewable,
false, excludes);
result.insert(result.end(), r.begin(), r.end());
}
v.push_back("luatex");
v.push_back("dviluatex");
}
- } else
- v.push_back(buffmt);
+ } else {
+ string rbuffmt = buffmt;
+ // If we use an OutputFormat in Japanese docs,
+ // we need special format in order to get the path
+ // via pLaTeX (#8823)
+ if (documentClass().hasOutputFormat()
+ && encoding().package() == Encoding::japanese)
+ rbuffmt += "-ja";
+ v.push_back(rbuffmt);
+ }
v.push_back("xhtml");
v.push_back("text");
if (find(backs.begin(), backs.end(), dformat) == backs.end()) {
// Get shortest path to format
Graph::EdgePath path;
- for (vector<string>::const_iterator it = backs.begin();
- it != backs.end(); ++it) {
- Graph::EdgePath p = theConverters().getPath(*it, dformat);
+ for (auto const & bvar : backs) {
+ Graph::EdgePath p = theConverters().getPath(bvar, dformat);
if (!p.empty() && (path.empty() || p.size() < path.size())) {
path = p;
}
if (!default_output_format.empty()
&& default_output_format != "default")
return default_output_format;
- if (isDocBook()
- || encoding().package() == Encoding::japanese) {
+ if (isDocBook()) {
FormatList const & formats = exportableFormats(true);
if (formats.empty())
return string();
// return the first we find
return formats.front()->name();
}
+ if (encoding().package() == Encoding::japanese)
+ return lyxrc.default_platex_view_format;
if (useNonTeXFonts)
return lyxrc.default_otf_view_format;
return lyxrc.default_view_format;
string const BufferParams::main_font_encoding() const
{
- return font_encodings().empty() ? "default" : font_encodings().back();
+ if (font_encodings().empty()) {
+ if (ascii_lowercase(language->fontenc(*this)) == "none")
+ return "none";
+ return "default";
+ }
+ return font_encodings().back();
}
vector<string> const BufferParams::font_encodings() const
{
- string doc_fontenc = (fontenc == "global") ? lyxrc.fontenc : fontenc;
+ string doc_fontenc = (fontenc == "auto") ? string() : fontenc;
vector<string> fontencs;
// "default" means "no explicit font encoding"
if (doc_fontenc != "default") {
- fontencs = getVectorFromString(doc_fontenc);
- if (!language->fontenc().empty()
- && ascii_lowercase(language->fontenc()) != "none") {
- vector<string> fencs = getVectorFromString(language->fontenc());
- vector<string>::const_iterator fit = fencs.begin();
- for (; fit != fencs.end(); ++fit) {
- if (find(fontencs.begin(), fontencs.end(), *fit) == fontencs.end())
- fontencs.push_back(*fit);
+ if (!doc_fontenc.empty())
+ // If we have a custom setting, we use only that!
+ return getVectorFromString(doc_fontenc);
+ if (!language->fontenc(*this).empty()
+ && ascii_lowercase(language->fontenc(*this)) != "none") {
+ vector<string> fencs = getVectorFromString(language->fontenc(*this));
+ for (auto & fe : fencs) {
+ if (find(fontencs.begin(), fontencs.end(), fe) == fontencs.end())
+ fontencs.push_back(fe);
}
}
}
language->encoding()->package();
// Create list of inputenc options:
- set<string> encodings;
+ set<string> encoding_set;
// luainputenc fails with more than one encoding
if (!features.runparams().isFullUnicode()) // if we reach this point, this means LuaTeX with TeX fonts
// list all input encodings used in the document
- encodings = features.getEncodingSet(doc_encoding);
+ encoding_set = features.getEncodingSet(doc_encoding);
// 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 ((!encodings.empty() || package == Encoding::inputenc)
+ if ((!encoding_set.empty() || package == Encoding::inputenc)
&& !features.isRequired("japanese")
&& !features.isProvided("inputenc")) {
os << "\\usepackage[";
- set<string>::const_iterator it = encodings.begin();
- set<string>::const_iterator const end = encodings.end();
+ set<string>::const_iterator it = encoding_set.begin();
+ set<string>::const_iterator const end = encoding_set.end();
if (it != end) {
os << from_ascii(*it);
++it;
for (; it != end; ++it)
os << ',' << from_ascii(*it);
if (package == Encoding::inputenc) {
- if (!encodings.empty())
+ if (!encoding_set.empty())
os << ',';
os << from_ascii(doc_encoding);
}
else
os << "]{inputenc}\n";
}
- if (package == Encoding::CJK || features.mustProvide("CJK")) {
- if (language->encoding()->name() == "utf8-cjk"
- && LaTeXFeatures::isAvailable("CJKutf8"))
- os << "\\usepackage{CJKutf8}\n";
- else
- os << "\\usepackage{CJK}\n";
- }
} else if (inputenc != "default") {
switch (encoding().package()) {
case Encoding::none:
+ case Encoding::CJK:
case Encoding::japanese:
break;
case Encoding::inputenc:
else
os << "]{inputenc}\n";
break;
- case Encoding::CJK:
- if (encoding().name() == "utf8-cjk"
- && LaTeXFeatures::isAvailable("CJKutf8"))
- os << "\\usepackage{CJKutf8}\n";
- else
- os << "\\usepackage{CJK}\n";
- break;
- }
- // Load the CJK package if needed by a secondary language.
- // If the main encoding is some variant of UTF8, use CJKutf8.
- if (encoding().package() != Encoding::CJK && features.mustProvide("CJK")) {
- if (encoding().iconvName() == "UTF-8"
- && LaTeXFeatures::isAvailable("CJKutf8"))
- os << "\\usepackage{CJKutf8}\n";
- else
- os << "\\usepackage{CJK}\n";
}
}
}
Encoding const & BufferParams::encoding() const
{
// Main encoding for LaTeX output.
- //
+ //
// Exception: XeTeX with 8-bit TeX fonts requires ASCII (see #9740).
// As the "flavor" is only known once export started, this
// cannot be handled here. Instead, runparams.encoding is set
}
-bool BufferParams::addCiteEngine(string const & engine)
-{
- LayoutModuleList::const_iterator it = cite_engine_.begin();
- LayoutModuleList::const_iterator en = cite_engine_.end();
- for (; it != en; ++it)
- if (*it == engine)
- return false;
- cite_engine_.push_back(engine);
- return true;
-}
-
-
-bool BufferParams::addCiteEngine(vector<string> const & engine)
-{
- vector<string>::const_iterator it = engine.begin();
- vector<string>::const_iterator en = engine.end();
- bool ret = true;
- for (; it != en; ++it)
- if (!addCiteEngine(*it))
- ret = false;
- return ret;
-}
-
-
string const & BufferParams::defaultBiblioStyle() const
{
+ if (!biblio_style.empty())
+ return biblio_style;
+
map<string, string> const & bs = documentClass().defaultBiblioStyle();
auto cit = bs.find(theCiteEnginesList.getTypeAsString(citeEngineType()));
if (cit != bs.end())
}
-void BufferParams::setCiteEngine(string const & engine)
-{
- clearCiteEngine();
- addCiteEngine(engine);
-}
-
-
-void BufferParams::setCiteEngine(vector<string> const & engine)
-{
- clearCiteEngine();
- addCiteEngine(engine);
-}
-
-
vector<string> BufferParams::citeCommands() const
{
static CitationStyle const default_style;
bool BufferParams::useBiblatex() const
{
- return theCiteEnginesList[citeEngine().list().front()]
- ->getCiteFramework() == "biblatex";
+ return theCiteEnginesList[citeEngine()]->getCiteFramework() == "biblatex";
}
pimpl_->isViewCacheValid = false;
}
+
+// We shouldn't need to reset the params here, since anything
+// we need will be recopied.
+void BufferParams::copyForAdvFR(const BufferParams & bp)
+{
+ string const & lang = bp.language->lang();
+ setLanguage(lang);
+ layout_modules_ = bp.layout_modules_;
+ string const & doc_class = bp.documentClass().name();
+ setBaseClass(doc_class);
+}
+
} // namespace lyx