#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_;
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";
use_geometry = false;
biblio_style = "plain";
use_bibtopic = false;
+ multibib = string();
use_indices = false;
save_transient_properties = true;
track_changes = false;
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;
}
+bool BufferParams::useBibtopic() const
+{
+ if (useBiblatex())
+ return false;
+ return (use_bibtopic || (!multibib.empty() && multibib != "child"));
+}
+
+
AuthorList & BufferParams::authors()
{
return pimpl_->authorlist;
}
-HSpace const & BufferParams::getIndentation() const
+Length const & BufferParams::getMathIndent() const
+{
+ return pimpl_->mathindent;
+}
+
+
+void BufferParams::setMathIndent(Length const & indent)
+{
+ pimpl_->mathindent = indent;
+}
+
+
+Length const & BufferParams::getParIndent() const
{
- return pimpl_->indentation;
+ return pimpl_->parindent;
}
-void BufferParams::setIndentation(HSpace const & indent)
+void BufferParams::setParIndent(Length const & indent)
{
- pimpl_->indentation = 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;
biblio_style = lex.getString();
} else if (token == "\\biblio_options") {
lex.eatLine();
- biblio_opts = lex.getString();
+ biblio_opts = trim(lex.getString());
} else if (token == "\\biblatex_bibstyle") {
lex.eatLine();
- biblatex_bibstyle = lex.getString();
+ biblatex_bibstyle = trim(lex.getString());
} else if (token == "\\biblatex_citestyle") {
lex.eatLine();
- biblatex_citestyle = lex.getString();
+ biblatex_citestyle = trim(lex.getString());
} else if (token == "\\use_bibtopic") {
lex >> use_bibtopic;
+ } else if (token == "\\multibib") {
+ lex >> multibib;
} else if (token == "\\use_indices") {
lex >> use_indices;
} else if (token == "\\tracking_changes") {
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 << "\n\\biblatex_bibstyle " << biblatex_bibstyle;
if (!biblatex_citestyle.empty())
os << "\n\\biblatex_citestyle " << biblatex_citestyle;
+ if (!multibib.empty())
+ os << "\n\\multibib " << multibib;
os << "\n\\use_bibtopic " << convert<string>(use_bibtopic)
<< "\n\\use_indices " << convert<string>(use_indices)
<< "\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")
// if we use fontspec or newtxmath, we have to load the AMS packages here
string const ams = features.loadAMSPackages();
- bool const ot1 = (font_encoding() == "default" || font_encoding() == "OT1");
+ bool const ot1 = (main_font_encoding() == "default" || main_font_encoding() == "OT1");
bool const use_newtxmath =
theLaTeXFonts().getLaTeXFont(from_ascii(fontsMath())).getUsedPackage(
ot1, false, false) == "newtxmath";
// set font encoding
// XeTeX and LuaTeX (with OS fonts) do not need fontenc
if (!useNonTeXFonts && !features.isProvided("fontenc")
- && font_encoding() != "default") {
+ && main_font_encoding() != "default") {
// get main font encodings
vector<string> fontencs = font_encodings();
// get font encodings of secondary languages
} 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
IndicesList::const_iterator iit = indiceslist().begin();
IndicesList::const_iterator iend = indiceslist().end();
for (; iit != iend; ++iit) {
- pair<docstring, docstring> indexname_latex =
- features.runparams().encoding->latexString(iit->index(),
- features.runparams().dryrun);
- if (!indexname_latex.second.empty()) {
- // issue a warning about omitted characters
- // FIXME: should be passed to the error dialog
- frontend::Alert::warning(_("Uncodable characters"),
- bformat(_("The following characters that are used in an index name are not\n"
- "representable in the current encoding and therefore have been omitted:\n%1$s."),
- indexname_latex.second));
- }
- os << "\\newindex[";
- os << indexname_latex.first;
- os << "]{";
+ os << "\\newindex{";
os << escape(iit->shortcut());
os << "}\n";
}
// 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()
+ || features.mustProvide("listings")
+ || features.mustProvide("minted")) {
+ if (features.mustProvide("listings"))
+ os << "\\usepackage{listings}\n";
+ else
+ os << "\\usepackage{minted}\n";
+ }
if (!listings_params.empty()) {
- os << "\\lstset{";
+ if (features.mustProvide("listings"))
+ os << "\\lstset{";
+ else
+ os << "\\setminted{";
// do not test validity because listings_params is
// supposed to be valid
string par =
os << "}\n";
}
- // xunicode needs to be loaded at least after amsmath, amssymb,
+ // xunicode only needs to be loaded if tipa is used
+ // (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
- // The package only supports XeTeX currently.
- if (features.runparams().flavor == OutputParams::XETEX
- && 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 << "% Pretend to xunicode that we are XeTeX\n"
+ << "\\def\\XeTeXpicfile{}\n";
+ }
os << "\\usepackage{xunicode}\n";
+ }
// Polyglossia must be loaded last ...
if (use_polyglossia) {
delim = ",";
}
}
+ if (!multibib.empty() && multibib != "child") {
+ opts += delim + "refsection=" + multibib;
+ delim = ",";
+ }
if (bibtexCommand() == "bibtex8"
|| prefixIs(bibtexCommand(), "bibtex8 ")) {
opts += delim + "backend=bibtex8";
}
docstring const i18npreamble =
- features.getTClassI18nPreamble(use_babel, use_polyglossia);
+ features.getTClassI18nPreamble(use_babel, use_polyglossia,
+ use_minted);
if (!i18npreamble.empty())
os << i18npreamble + '\n';
{
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::font_encoding() const
+string const BufferParams::main_font_encoding() const
{
return font_encodings().empty() ? "default" : font_encodings().back();
}
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);
}
}
// Tex Fonts
- bool const ot1 = (font_encoding() == "default" || font_encoding() == "OT1");
+ bool const ot1 = (main_font_encoding() == "default" || main_font_encoding() == "OT1");
bool const dryrun = features.runparams().dryrun;
bool const complete = (fontsSans() == "default" && fontsTypewriter() == "default");
bool const nomath = (fontsMath() == "default");
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
string const & BufferParams::defaultBiblioStyle() const
{
- map<string, string> bs = documentClass().defaultBiblioStyle();
- return bs[theCiteEnginesList.getTypeAsString(citeEngineType())];
+ map<string, string> const & bs = documentClass().defaultBiblioStyle();
+ auto cit = bs.find(theCiteEnginesList.getTypeAsString(citeEngineType()));
+ if (cit != bs.end())
+ return cit->second;
+ else
+ return empty_string();
}
// Return document-specific setting if available
if (bibtex_command != "default")
return bibtex_command;
- // For Japanese, return the specific program
- else if (encoding().package() == Encoding::japanese)
- return lyxrc.jbibtex_command;
- // Else return the processor set in prefs
+
+ // If we have "default" in document settings, consult the prefs
+ // 1. Japanese (uses a specific processor)
+ if (encoding().package() == Encoding::japanese) {
+ if (lyxrc.jbibtex_command != "automatic")
+ // Return the specified program, if "automatic" is not set
+ return lyxrc.jbibtex_command;
+ else if (!useBiblatex()) {
+ // With classic BibTeX, return pbibtex, jbibtex, bibtex
+ if (lyxrc.jbibtex_alternatives.find("pbibtex") != lyxrc.jbibtex_alternatives.end())
+ return "pbibtex";
+ if (lyxrc.jbibtex_alternatives.find("jbibtex") != lyxrc.jbibtex_alternatives.end())
+ return "jbibtex";
+ return "bibtex";
+ }
+ }
+ // 2. All other languages
else if (lyxrc.bibtex_command != "automatic")
+ // Return the specified program, if "automatic" is not set
return lyxrc.bibtex_command;
- // Automatic means: find the most suitable for the current cite framework
+
+ // 3. Automatic: find the most suitable for the current cite framework
if (useBiblatex()) {
- // For biblatex, we prefer biber and fall back to bibtex8 and, as last resort, bibtex
+ // For Biblatex, we prefer biber (also for Japanese)
+ // and fall back to bibtex8 and, as last resort, bibtex
if (lyxrc.bibtex_alternatives.find("biber") != lyxrc.bibtex_alternatives.end())
return "biber";
else if (lyxrc.bibtex_alternatives.find("bibtex8") != lyxrc.bibtex_alternatives.end())