#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"
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";
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;
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;
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;
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';
<< "\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
&& 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";
}
}
}
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) {
+ // 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) {
}
docstring const i18npreamble =
- features.getTClassI18nPreamble(use_babel, use_polyglossia);
+ features.getTClassI18nPreamble(use_babel, use_polyglossia,
+ use_minted);
if (!i18npreamble.empty())
os << i18npreamble + '\n';
}
-string const BufferParams::font_encoding() const
+string const BufferParams::main_font_encoding() const
{
return font_encodings().empty() ? "default" : font_encodings().back();
}
}
// 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");
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();
}