};
-
namespace lyx {
+// XeTeX with TeX fonts:
+// run in 8-bit emulation mode and trick `inputenc` into working with XeTeX
+static docstring const xetex_pre_inputenc = from_ascii(
+ "\\XeTeXinputencoding \"bytes\" % current file\n"
+ "\\XeTeXdefaultencoding \"bytes\" % included files\n"
+ "\\makeatletter\n"
+ "\\let\\origUmathchar\\Umathchar\n"
+ "\\let\\Umathchar\\@undefined\n");
+static docstring const xetex_post_inputenc = from_ascii(
+ "\\let\\Umathchar\\origUmathchar\n"
+ "\\makeatother\n");
+
// Local translators
namespace {
string dir = document_dir.absFileName();
- for (int i = 0; i < 2; ++i) {
+ for (int i = 0; i < 3; ++i) {
dir = addPath(dir, "..");
if (!fileSearch(dir, "configure.py").empty() &&
!fileSearch(dir, "chkconfig.ltx").empty()) {
: pimpl_(new Impl)
{
setBaseClass(defaultBaseclass());
- cite_engine_.push_back("basic");
+ cite_engine_ = "basic";
cite_engine_type_ = ENGINE_TYPE_DEFAULT;
makeDocumentClass();
paragraph_separation = ParagraphIndentSeparation;
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_sans_scale[1] = 100;
fonts_typewriter_scale[0] = 100;
fonts_typewriter_scale[1] = 100;
- inputenc = "auto";
+ inputenc = "utf8";
lang_package = "default";
graphics_driver = "default";
default_output_format = "default";
columns = 1;
listings_params = string();
pagestyle = "default";
+ tablestyle = "default";
suppress_date = false;
justification = true;
// no color is the default (white)
output_sync = false;
use_refstyle = true;
use_minted = false;
+ use_lineno = false;
// map current author
author_map_[pimpl_->authorlist.get(0).bufferId()] = 0;
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;
sides = sidestranslator().find(psides);
} else if (token == "\\paperpagestyle") {
lex >> pagestyle;
+ } else if (token == "\\tablestyle") {
+ lex >> tablestyle;
} else if (token == "\\bullet") {
readBullets(lex);
} else if (token == "\\bulletLaTeX") {
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 >> use_refstyle;
} else if (token == "\\use_minted") {
lex >> use_minted;
+ } else if (token == "\\use_lineno") {
+ lex >> use_lineno;
+ } else if (token == "\\lineno_options") {
+ lex.eatLine();
+ lineno_opts = trim(lex.getString());
} else {
lyxerr << "BufferParams::readToken(): Unknown token: " <<
token << endl;
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\\justification " << convert<string>(justification)
<< "\n\\use_refstyle " << use_refstyle
<< "\n\\use_minted " << use_minted
+ << "\n\\use_lineno " << use_lineno
<< '\n';
+
+ if (!lineno_opts.empty())
+ os << "\\lineno_options " << lineno_opts << '\n';
+
if (isbackgroundcolor == true)
os << "\\backgroundcolor " << lyx::X11hexname(backgroundcolor) << '\n';
if (isfontcolor == true)
<< "\n\\dynamic_quotes " << dynamic_quotes
<< "\n\\papercolumns " << columns
<< "\n\\papersides " << sides
- << "\n\\paperpagestyle " << pagestyle << '\n';
+ << "\n\\paperpagestyle " << pagestyle
+ << "\n\\tablestyle " << tablestyle << '\n';
if (!listings_params.empty())
os << "\\listings_params \"" <<
InsetListingsParams(listings_params).encodedString() << "\"\n";
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())
language_options << ',';
language_options << language->babel();
}
- if (global && !features.needBabelLangOptions()
- && !language_options.str().empty())
+ if (global && !language_options.str().empty())
clsoptions << language_options.str() << ',';
}
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 && inputenc != "utf8x"
+ && (encoding().package() == Encoding::CJK || features.mustProvide("CJK"))) {
+ if (inputenc == "utf8-cjk" || inputenc == "utf8")
+ 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())
<< from_ascii(fonts_default_family) << "}\n";
// set font encoding
- // XeTeX and LuaTeX (with OS fonts) do not need fontenc
+ // non-TeX fonts use font encoding TU (set by fontspec)
if (!useNonTeXFonts && !features.isProvided("fontenc")
&& main_font_encoding() != "default") {
// get main font encodings
vector<string> fontencs = font_encodings();
// get font encodings of secondary languages
+ // FIXME: some languages (hebrew, ...) assume a standard font encoding as last
+ // option (for text in other languages).
features.getFontEncodings(fontencs);
if (!fontencs.empty()) {
os << "\\usepackage["
}
}
+ // Load textcomp and pmboxdraw before (lua)inputenc (#11454)
+ if (features.mustProvide("textcomp"))
+ os << "\\usepackage{textcomp}\n";
+ if (features.mustProvide("pmboxdraw"))
+ os << "\\usepackage{pmboxdraw}\n";
+
// handle inputenc etc.
- writeEncodingPreamble(os, features);
+ // (In documents containing text in Thai language,
+ // we must load inputenc after babel, see lib/languages).
+ if (!contains(features.getBabelPostsettings(), from_ascii("thai.ldf")))
+ writeEncodingPreamble(os, features);
// includeonly
if (!features.runparams().includeall && !included_children_.empty()) {
os << features.getBabelPresettings();
// FIXME UNICODE
os << from_utf8(babelCall(language_options.str(),
- features.needBabelLangOptions())) + '\n';
+ !lyxrc.language_global_options)) + '\n';
os << features.getBabelPostsettings();
}
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"))
// hyperref loads this automatically
os << "\\usepackage{nameref}\n";
+ if (use_lineno){
+ os << "\\usepackage";
+ if (!lineno_opts.empty())
+ os << "[" << lineno_opts << "]";
+ os << "{lineno}\n";
+ os << "\\linenumbers\n";
+ }
+
// bibtopic needs to be loaded after hyperref.
// the dot provides the aux file naming which LyX can detect.
if (features.mustProvide("bibtopic"))
<< "\\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")
os << features.getBabelPresettings();
// FIXME UNICODE
os << from_utf8(babelCall(language_options.str(),
- features.needBabelLangOptions())) + '\n';
+ !lyxrc.language_global_options)) + '\n';
os << features.getBabelPostsettings();
}
+ // In documents containing text in Thai language,
+ // we must load inputenc after babel (see lib/languages).
+ if (contains(features.getBabelPostsettings(), from_ascii("thai.ldf")))
+ writeEncodingPreamble(os, features);
+
if (features.isRequired("bicaption"))
os << "\\usepackage{bicaption}\n";
if (!listings_params.empty()
|| features.mustProvide("listings")
|| features.mustProvide("minted")) {
- if (features.mustProvide("listings"))
- os << "\\usepackage{listings}\n";
- else
+ if (use_minted)
os << "\\usepackage{minted}\n";
- }
- if (!listings_params.empty()) {
- if (features.mustProvide("listings"))
- os << "\\lstset{";
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";
}
// esint and the other packages that provide special glyphs
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.
+ // The `xunicode` package officially only supports XeTeX,
+ // but also works with LuaTeX. We work around its XeTeX test.
if (features.runparams().flavor != OutputParams::XETEX) {
os << "% Pretend to xunicode that we are XeTeX\n"
<< "\\def\\XeTeXpicfile{}\n";
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.isRequired("biblatex-chicago"))
+ && !features.isProvided("biblatex-chicago")
+ && !features.isProvided("biblatex-natbib")
+ && !features.isProvided("natbib-internal")
+ && !features.isProvided("natbib")
+ && !features.isProvided("jurabib")) {
+ // The biblatex-chicago package has a differing interface
+ // it uses a wrapper package and loads styles via fixed options
+ bool const chicago = features.isRequired("biblatex-chicago");
string delim = "";
string opts;
os << "\\usepackage";
if (!biblatex_bibstyle.empty()
- && (biblatex_bibstyle == biblatex_citestyle)) {
+ && (biblatex_bibstyle == biblatex_citestyle)
+ && !chicago) {
opts = "style=" + biblatex_bibstyle;
delim = ",";
- } else {
+ } else if (!chicago) {
if (!biblatex_bibstyle.empty()) {
opts = "bibstyle=" + biblatex_bibstyle;
delim = ",";
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 << "[" << opts << "]";
- os << "{biblatex}\n";
+ if (chicago)
+ os << "{biblatex-chicago}\n";
+ else
+ os << "{biblatex}\n";
}
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,
use_minted);
sides = tclass.sides();
columns = tclass.columns();
pagestyle = tclass.pagestyle();
+ tablestyle = tclass.tablestyle();
use_default_options = true;
// Only if class has a ToC hierarchy
if (tclass.hasTocLevels()) {
return sides == tclass.sides()
&& columns == tclass.columns()
&& pagestyle == tclass.pagestyle()
+ && tablestyle == tclass.tablestyle()
&& use_default_options
&& secnumdepth == tclass.secnumdepth()
&& tocdepth == tclass.tocdepth();
}
-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)
if (useNonTeXFonts) {
excludes.insert("latex");
excludes.insert("pdflatex");
- }
- FormatList result =
- theConverters().getReachable(backs[0], only_viewable, true, excludes);
+ } else if (inputenc != "ascii" && inputenc != "utf8"
+ && inputenc != "utf8x" && inputenc != "utf8-plain")
+ // XeTeX with TeX fonts requires input encoding ascii or utf8
+ // (https://www.tug.org/pipermail/xetex/2010-April/016452.html).
+ excludes.insert("xetex");
+ FormatList result = 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,
- false, excludes);
+ false, excludes);
result.insert(result.end(), r.begin(), r.end());
}
sort(result.begin(), result.end(), Format::formatSorter);
v.push_back("pdflatex");
v.push_back("latex");
}
- v.push_back("xetex");
+ if (useNonTeXFonts || inputenc == "ascii" || inputenc == "utf8"
+ || inputenc == "utf8x" || inputenc == "utf8-plain")
+ v.push_back("xetex");
v.push_back("luatex");
v.push_back("dviluatex");
}
if (find(backs.begin(), backs.end(), dformat) == backs.end()) {
// Get shortest path to format
Graph::EdgePath path;
- for (auto const & bit : backs) {
- Graph::EdgePath p = theConverters().getPath(bit, dformat);
+ for (auto const & bvar : backs) {
+ Graph::EdgePath p = theConverters().getPath(bvar, dformat);
if (!p.empty() && (path.empty() || p.size() < path.size())) {
path = p;
}
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);
}
}
}
// other languages are used (lang_opts is then empty)
if (lang_opts.empty())
return string();
- // either a specific language (AsBabelOptions setting in
- // lib/languages) or the prefs require the languages to
+ // The prefs may require the languages to
// be submitted to babel itself (not the class).
if (langoptions)
return "\\usepackage[" + lang_opts + "]{babel}";
void BufferParams::writeEncodingPreamble(otexstream & os,
LaTeXFeatures & features) const
{
- // XeTeX/LuaTeX: (see also #9740)
- // With Unicode fonts we use utf8-plain without encoding package.
- // With TeX fonts, we cannot use utf8-plain, but "inputenc" fails.
- // XeTeX must use ASCII encoding (see Buffer.cpp),
- // for LuaTeX, we load "luainputenc" (see below).
- if (useNonTeXFonts || features.runparams().flavor == OutputParams::XETEX)
+ // With no-TeX fonts we use utf8-plain without encoding package.
+ if (useNonTeXFonts)
return;
- if (inputenc == "auto") {
+ if (inputenc == "auto-legacy") {
string const doc_encoding =
language->encoding()->latexName();
Encoding::Package const package =
// Create list of inputenc options:
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
+ if (features.runparams().flavor != OutputParams::LUATEX
+ && features.runparams().flavor != OutputParams::DVILUATEX)
// list all input encodings used in the document
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
+ // The "japanese" babel-language requires the pLaTeX engine
+ // which conflicts with "inputenc".
+ // See http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129680.html
if ((!encoding_set.empty() || package == Encoding::inputenc)
&& !features.isRequired("japanese")
&& !features.isProvided("inputenc")) {
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") {
+ } else if (inputenc != "auto-legacy-plain") {
switch (encoding().package()) {
case Encoding::none:
+ case Encoding::CJK:
case Encoding::japanese:
+ if (encoding().iconvName() != "UTF-8"
+ && !features.runparams().isFullUnicode())
+ // don't default to [utf8]{inputenc} with TeXLive >= 18
+ os << "\\ifdefined\\UseRawInputEncoding\n"
+ << " \\UseRawInputEncoding\\fi\n";
break;
case Encoding::inputenc:
// do not load inputenc if japanese is used
if (features.isRequired("japanese")
|| features.isProvided("inputenc"))
break;
+ if (features.runparams().flavor == OutputParams::XETEX)
+ os << xetex_pre_inputenc;
os << "\\usepackage[" << from_ascii(encoding().latexName());
if (features.runparams().flavor == OutputParams::LUATEX
|| features.runparams().flavor == OutputParams::DVILUATEX)
os << "]{luainputenc}\n";
else
os << "]{inputenc}\n";
+ if (features.runparams().flavor == OutputParams::XETEX)
+ os << xetex_post_inputenc;
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";
}
}
+ if (inputenc == "auto-legacy-plain" || features.isRequired("japanese")) {
+ // don't default to [utf8]{inputenc} with TeXLive >= 18
+ os << "\\ifdefined\\UseRawInputEncoding\n";
+ os << " \\UseRawInputEncoding\\fi\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
- // to ASCII in Buffer::makeLaTeXFile (for export)
- // and Buffer::writeLaTeXSource (for preview).
if (useNonTeXFonts)
return *(encodings.fromLyXName("utf8-plain"));
- if (inputenc == "auto" || inputenc == "default")
+ if (inputenc == "auto-legacy" || inputenc == "auto-legacy-plain")
return *language->encoding();
+ if (inputenc == "utf8" && language->lang() == "japanese")
+ return *(encodings.fromLyXName("utf8-platex"));
Encoding const * const enc = encodings.fromLyXName(inputenc);
if (enc)
return *enc;
}
-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);
+}
+
+
+void BufferParams::setBibFileEncoding(string const & file, string const & enc)
+{
+ bib_encodings[file] = enc;
+}
+
+
+string const BufferParams::bibFileEncoding(string const & file) const
+{
+ if (bib_encodings.find(file) == bib_encodings.end())
+ return string();
+ return bib_encodings.find(file)->second;
+}
+
+
+
} // namespace lyx