#include "Lexer.h"
#include "LyXRC.h"
#include "TextClass.h"
+#include "TexRow.h"
+#include "texstream.h"
#include "insets/InsetLayout.h"
"{\\leavevmode\\,$\\triangleleft$\\,\\allowbreak}\n"
"{\\leavevmode\\,$\\triangleright$\\,\\allowbreak}}");
+// ZERO WIDTH SPACE (ZWSP) is actually not a space character
+// but marks a line break opportunity. Several commands provide a
+// line break opportunity. They differ in side-effects:
+// \allowbreak prevents hyphenation after hyphen or dash + ZWSP
+// \linebreak[<n>] takes an optional argument denoting "urgency".
+// The \LyXZeroWidthSpace wrapper allows customization in the preamble.
+static docstring const lyxZWSP_def = from_ascii(
+ "\\newcommand*\\LyXZeroWidthSpace{\\hspace{0pt}}");
+
// for quotes without babel. This does not give perfect results, but
// anybody serious about non-english quotes should use babel (JMarc).
" {\\usefont{U}{lasy}{m}{n}\\char'51}%\n"
"}");
+static docstring const textquotedbl_def = from_ascii(
+ "\\DeclareTextSymbolDefault{\\textquotedbl}{T1}");
+
+static docstring const textquotedblp_xetex_def = from_ascii(
+ "\\providecommand\\textquotedblplain{%\n"
+ " \\bgroup\\addfontfeatures{Mapping=}\\char34\\egroup}");
+
+static docstring const textquotedblp_luatex_def = from_ascii(
+ "\\providecommand\\textquotedblplain{%\n"
+ " \\bgroup\\addfontfeatures{RawFeature=-tlig}\\char34\\egroup}");
+
+static docstring const textquotesinglep_xetex_def = from_ascii(
+ "\\providecommand\\textquotesingleplain{%\n"
+ " \\bgroup\\addfontfeatures{Mapping=}\\char39\\egroup}");
+
+static docstring const textquotesinglep_luatex_def = from_ascii(
+ "\\providecommand\\textquotesingleplain{%\n"
+ " \\bgroup\\addfontfeatures{RawFeature=-tlig}\\char39\\egroup}");
+
static docstring const paragraphleftindent_def = from_ascii(
"\\newenvironment{LyXParagraphLeftIndent}[1]%\n"
"{\n"
"}\n"
"{\\end{list}}\n");
+static docstring const floatingfootnote_def = from_ascii(
+ "%% Special footnote code from the package 'stblftnt.sty'\n"
+ "%% Author: Robin Fairbairns -- Last revised Dec 13 1996\n"
+ "\\let\\SF@@footnote\\footnote\n"
+ "\\def\\footnote{\\ifx\\protect\\@typeset@protect\n"
+ " \\expandafter\\SF@@footnote\n"
+ " \\else\n"
+ " \\expandafter\\SF@gobble@opt\n"
+ " \\fi\n"
+ "}\n"
+ "\\expandafter\\def\\csname SF@gobble@opt \\endcsname{\\@ifnextchar[%]\n"
+ " \\SF@gobble@twobracket\n"
+ " \\@gobble\n"
+ "}\n"
+ "\\edef\\SF@gobble@opt{\\noexpand\\protect\n"
+ " \\expandafter\\noexpand\\csname SF@gobble@opt \\endcsname}\n"
+ "\\def\\SF@gobble@twobracket[#1]#2{}\n");
+
static docstring const binom_def = from_ascii(
"%% Binom macro for standard LaTeX users\n"
"\\newcommand{\\binom}[2]{{#1 \\choose #2}}\n");
static docstring const changetracking_xcolor_ulem_def = from_ascii(
"%% Change tracking with ulem\n"
"\\DeclareRobustCommand{\\lyxadded}[3]{{\\color{lyxadded}{}#3}}\n"
- "\\DeclareRobustCommand{\\lyxdeleted}[3]{{\\color{lyxdeleted}\\sout{#3}}}\n");
+ "\\DeclareRobustCommand{\\lyxdeleted}[3]{{\\color{lyxdeleted}\\lyxsout{#3}}}\n"
+ "\\DeclareRobustCommand{\\lyxsout}[1]{\\ifx\\\\#1\\else\\sout{#1}\\fi}\n");
static docstring const changetracking_xcolor_ulem_hyperref_def = from_ascii(
"%% Change tracking with ulem\n"
"\\DeclareRobustCommand{\\lyxadded}[3]{{\\texorpdfstring{\\color{lyxadded}{}}{}#3}}\n"
- "\\DeclareRobustCommand{\\lyxdeleted}[3]{{\\texorpdfstring{\\color{lyxdeleted}\\sout{#3}}{}}}\n");
+ "\\DeclareRobustCommand{\\lyxdeleted}[3]{{\\texorpdfstring{\\color{lyxdeleted}\\lyxsout{#3}}{}}}\n"
+ "\\DeclareRobustCommand{\\lyxsout}[1]{\\ifx\\\\#1\\else\\sout{#1}\\fi}\n");
+
+static docstring const changetracking_tikz_math_sout_def = from_ascii(
+ "%% Strike out display math with tikz\n"
+ "\\usepackage{tikz}\n"
+ "\\usetikzlibrary{calc}\n"
+ "\\newcommand{\\lyxmathsout}[1]{%\n"
+ " \\tikz[baseline=(math.base)]{\n"
+ " \\node[inner sep=0pt,outer sep=0pt](math){#1};\n"
+ " \\draw($(math.south west)+(2em,.5em)$)--($(math.north east)-(2em,.5em)$);\n"
+ " }\n"
+ "}\n");
static docstring const changetracking_none_def = from_ascii(
"\\newcommand{\\lyxadded}[3]{#3}\n"
static docstring const textgreek_def = from_ascii(
"\\DeclareRobustCommand{\\greektext}{%\n"
" \\fontencoding{LGR}\\selectfont\\def\\encodingdefault{LGR}}\n"
- "\\DeclareRobustCommand{\\textgreek}[1]{\\leavevmode{\\greektext #1}}\n"
- "\\ProvideTextCommand{\\~}{LGR}[1]{\\char126#1}\n");
+ "\\DeclareRobustCommand{\\textgreek}[1]{\\leavevmode{\\greektext #1}}\n");
static docstring const textcyr_T2A_def = from_ascii(
"\\InputIfFileExists{t2aenc.def}{}{%\n"
static docstring const textcyr_def = from_ascii(
"\\DeclareRobustCommand{\\cyrtext}{%\n"
" \\fontencoding{T2A}\\selectfont\\def\\encodingdefault{T2A}}\n"
- "\\DeclareRobustCommand{\\textcyr}[1]{\\leavevmode{\\cyrtext #1}}\n");
+ "\\DeclareRobustCommand{\\textcyrillic}[1]{\\leavevmode{\\cyrtext #1}}\n");
static docstring const lyxmathsym_def = from_ascii(
"\\newcommand{\\lyxmathsym}[1]{\\ifmmode\\begingroup\\def\\b@ld{bold}\n"
"\\pdfpageheight\\paperheight\n"
"\\pdfpagewidth\\paperwidth\n");
+static docstring const papersizepdflua_def = from_ascii(
+ "% Backwards compatibility for LuaTeX < 0.90\n"
+ "\\@ifundefined{pageheight}{\\let\\pageheight\\pdfpageheight}{}\n"
+ "\\@ifundefined{pagewidth}{\\let\\pagewidth\\pdfpagewidth}{}\n"
+ "\\pageheight\\paperheight\n"
+ "\\pagewidth\\paperwidth\n");
+
static docstring const cedilla_def = from_ascii(
"\\newcommand{\\docedilla}[2]{\\underaccent{#1\\mathchar'30}{#2}}\n"
"\\newcommand{\\cedilla}[1]{\\mathpalette\\docedilla{#1}}\n");
static docstring const textcommaaboveright_def = from_ascii(
"\\ProvideTextCommandDefault{\\textcommaaboveright}[1]{%%\n"
- " \\LyxTextAccent[.5ex]{\\LyxAccentSize\\ `}{#1}}\n");
+ " \\LyxTextAccent[.5ex]{\\LyxAccentSize\\ '}{#1}}\n");
// Baltic languages use a comma-accent instead of a cedilla
static docstring const textbaltic_def = from_ascii(
"\\DeclareTextCompositeCommand{\\c}{T1}{r}{\\textcommabelow{r}}\n"
"\\DeclareTextCompositeCommand{\\c}{T1}{R}{\\textcommabelow{R}}\n");
+// split-level fractions
+static docstring const xfrac_def = from_ascii(
+ "\\usepackage{xfrac}\n");
+static docstring const smallLetterFrac_def = from_ascii(
+ "\\DeclareCollectionInstance{smallLetterFrac}{xfrac}{default}{text}\n"
+ " {phantom=c, scale-factor=1.0, slash-left-kern=-.05em}\n"
+ "\\DeclareCollectionInstance{smallLetterFrac}{xfrac}{lmr}{text}\n"
+ " {slash-symbol-font=ptm, phantom=c, scale-factor=1, slash-left-kern=-.05em}\n"
+ "\\DeclareCollectionInstance{smallLetterFrac}{xfrac}{lmss}{text}\n"
+ " {slash-symbol-font=ptm, phantom=c, scale-factor=1, slash-left-kern=-.05em}\n"
+ "\\DeclareCollectionInstance{smallLetterFrac}{xfrac}{cmr}{text}\n"
+ " {slash-symbol-font=ptm, phantom=c, scale-factor=1, slash-left-kern=-.05em}\n"
+ "\\DeclareCollectionInstance{smallLetterFrac}{xfrac}{cmss}{text}\n"
+ " {slash-symbol-font=ptm, phantom=c, scale-factor=1, slash-left-kern=-.05em}\n"
+ "\\newcommand{\\smallLetterFrac}[2]{%\n"
+ " {\\UseCollection{xfrac}{smallLetterFrac}\\sfrac{#1}{#2}}}\n");
+
static docstring const lyxref_def = from_ascii(
"\\RS@ifundefined{subsecref}\n"
" {\\newref{subsec}{name = \\RSsectxt}}\n"
"}\n"
"\\@mparswitchtrue\n");
+static docstring const lyxmintcaption_def = from_ascii(
+ "\\long\\def\\lyxmintcaption[#1]#2{%\n"
+ " \\ifx#1t\\vskip\\baselineskip\\fi%\n"
+ " \\refstepcounter{listing}\\noindent%\n"
+ " \\addcontentsline{lol}{listing}%\n"
+ " {\\protect\\numberline{\\thelisting}{\\ignorespaces #2}}%\n"
+ " \\setbox\\@tempboxa\\hbox{\\listingscaption~\\thelisting: #2}%\n"
+ " \\ifdim \\wd\\@tempboxa >\\linewidth%\n"
+ " \\parbox[t]{\\linewidth}{\\unhbox\\@tempboxa}\\else%\n"
+ " \\hbox to\\linewidth{\\hfil\\box\\@tempboxa\\hfil}\\fi%\n"
+ " \\ifx#1b\\vskip\\baselineskip\\fi\n"
+ "}\n");
+
/////////////////////////////////////////////////////////////////////
//
LaTeXFeatures::LaTeXFeatures(Buffer const & b, BufferParams const & p,
OutputParams const & r)
- : buffer_(&b), params_(p), runparams_(r), in_float_(false)
+ : buffer_(&b), params_(p), runparams_(r), in_float_(false),
+ in_deleted_inset_(false)
{}
if (local_lp == "none")
return LANG_PACK_NONE;
- /* If "auto" is selected, we load polyglossia if required,
+ /* If "auto" is selected, we load polyglossia with non-TeX fonts,
* else we select babel.
* If babel is selected (either directly or via the "auto"
* mechanism), we really do only require it if we have
* a language that needs it.
*/
bool const polyglossia_required =
- isRequired("polyglossia")
+ params_.useNonTeXFonts
&& isAvailable("polyglossia")
&& !isProvided("babel")
&& this->hasOnlyPolyglossiaLanguages();
}
+void LaTeXFeatures::provide(string const & name)
+{
+ provides_.insert(name);
+}
+
+
void LaTeXFeatures::useLayout(docstring const & layoutname)
{
useLayout(layoutname, 0);
bool LaTeXFeatures::isProvided(string const & name) const
{
+ // Currently, this is only features provided by babel languages
+ // (such as textgreek)
+ if (provides_.find(name) != provides_.end())
+ return true;
+
+ // FIXME: the "textbaltic" definitions are only needed if the context
+ // font encoding of the respective char is not l7x.
+ // We cannot check this here as we have no context information.
+
if (params_.useNonTeXFonts)
return params_.documentClass().provides(name);
- bool const ot1 = (params_.font_encoding() == "default"
- || params_.font_encoding() == "OT1");
- bool const complete = (params_.fonts_sans == "default")
- && (params_.fonts_typewriter == "default");
- bool const nomath = (params_.fonts_math == "default");
+ bool const ot1 = (params_.main_font_encoding() == "default"
+ || params_.main_font_encoding() == "OT1");
+ bool const complete = (params_.fontsSans() == "default"
+ && params_.fontsTypewriter() == "default");
+ bool const nomath = (params_.fontsMath() == "default");
return params_.documentClass().provides(name)
|| theLaTeXFonts().getLaTeXFont(
- from_ascii(params_.fonts_roman)).provides(name, ot1,
+ from_ascii(params_.fontsRoman())).provides(name, ot1,
complete,
nomath)
|| theLaTeXFonts().getLaTeXFont(
- from_ascii(params_.fonts_sans)).provides(name, ot1,
+ from_ascii(params_.fontsSans())).provides(name, ot1,
complete,
nomath)
|| theLaTeXFonts().getLaTeXFont(
- from_ascii(params_.fonts_typewriter)).provides(name, ot1,
+ from_ascii(params_.fontsTypewriter())).provides(name, ot1,
complete,
nomath)
|| theLaTeXFonts().getLaTeXFont(
- from_ascii(params_.fonts_math)).provides(name, ot1,
+ from_ascii(params_.fontsMath())).provides(name, ot1,
complete,
nomath);
- // TODO: "textbaltic" provided, if the font-encoding is "L7x"
- // "textgreek" provided, if a language with font-encoding LGR is used in the document
- // "textcyr" provided, if a language with font-encoding T2A is used in the document
}
}
-void LaTeXFeatures::addPreambleSnippet(string const & preamble)
+namespace {
+
+void addSnippet(std::list<TexString> & list, TexString ts, bool allow_dupes)
+{
+ if (allow_dupes ||
+ // test the absense of duplicates, i.e. elements with same str
+ none_of(list.begin(), list.end(), [&](TexString const & ts2){
+ return ts.str == ts2.str;
+ })
+ )
+ list.push_back(move(ts));
+}
+
+
+TexString getSnippets(std::list<TexString> const & list)
{
- SnippetList::const_iterator begin = preamble_snippets_.begin();
- SnippetList::const_iterator end = preamble_snippets_.end();
- if (find(begin, end, preamble) == end)
- preamble_snippets_.push_back(preamble);
+ otexstringstream snip;
+ for (TexString const & ts : list)
+ snip << TexString(ts) << '\n';
+ return snip.release();
+}
+
+} // namespace
+
+
+void LaTeXFeatures::addPreambleSnippet(TexString ts, bool allow_dupes)
+{
+ addSnippet(preamble_snippets_, move(ts), allow_dupes);
+}
+
+
+void LaTeXFeatures::addPreambleSnippet(docstring const & str, bool allow_dupes)
+{
+ addSnippet(preamble_snippets_, TexString(str), allow_dupes);
}
void LaTeXFeatures::addCSSSnippet(std::string const & snippet)
{
- SnippetList::const_iterator begin = css_snippets_.begin();
- SnippetList::const_iterator end = css_snippets_.end();
- if (find(begin, end, snippet) == end)
- css_snippets_.push_back(snippet);
+ addSnippet(css_snippets_, TexString(from_ascii(snippet)), false);
+}
+
+
+TexString LaTeXFeatures::getPreambleSnippets() const
+{
+ return getSnippets(preamble_snippets_);
+}
+
+
+docstring LaTeXFeatures::getCSSSnippets() const
+{
+ return getSnippets(css_snippets_).str;
}
+
void LaTeXFeatures::useFloat(string const & name, bool subfloat)
{
if (!usedFloats_[name])
UsedLanguages_.insert(lang);
if (!lang->requires().empty())
require(lang->requires());
+ // currently only supported for Babel
+ if (!lang->provides().empty() && useBabel())
+ provide(lang->provides());
// CJK languages do not have a babel name.
// They use the CJK package
if (lang->encoding()->package() == Encoding::CJK)
}
+vector<string> LaTeXFeatures::getPolyglossiaExclusiveLanguages() const
+{
+ vector<string> result;
+ // first the main language
+ if (params_.language->isPolyglossiaExclusive())
+ result.push_back(params_.language->display());
+ // now the secondary languages
+ LanguageList::const_iterator const begin = UsedLanguages_.begin();
+ for (LanguageList::const_iterator cit = begin;
+ cit != UsedLanguages_.end();
+ ++cit) {
+ if ((*cit)->isPolyglossiaExclusive())
+ result.push_back((*cit)->display());
+ }
+ return result;
+}
+
+
+vector<string> LaTeXFeatures::getBabelExclusiveLanguages() const
+{
+ vector<string> result;
+ // first the main language
+ if (params_.language->isBabelExclusive())
+ result.push_back(params_.language->display());
+ // now the secondary languages
+ LanguageList::const_iterator const begin = UsedLanguages_.begin();
+ for (LanguageList::const_iterator cit = begin;
+ cit != UsedLanguages_.end();
+ ++cit) {
+ if ((*cit)->isBabelExclusive())
+ result.push_back((*cit)->display());
+ }
+ return result;
+}
+
+
string LaTeXFeatures::getBabelLanguages() const
{
- ostringstream languages;
+ ostringstream langs;
bool first = true;
LanguageList::const_iterator const begin = UsedLanguages_.begin();
if ((*cit)->babel().empty())
continue;
if (!first)
- languages << ',';
+ langs << ',';
else
first = false;
- languages << (*cit)->babel();
+ langs << (*cit)->babel();
}
- return languages.str();
+ return langs.str();
}
-std::map<std::string, std::string> LaTeXFeatures::getPolyglossiaLanguages() const
+set<string> LaTeXFeatures::getPolyglossiaLanguages() const
{
- std::map<std::string, std::string> languages;
+ set<string> langs;
LanguageList::const_iterator const begin = UsedLanguages_.begin();
for (LanguageList::const_iterator cit = begin;
cit != UsedLanguages_.end();
++cit) {
- languages[(*cit)->polyglossia()] = (*cit)->polyglossiaOpts();
+ // We do not need the variants here
+ langs.insert((*cit)->polyglossia());
}
- return languages;
+ return langs;
}
// This does only find encodings of languages supported by babel, but
// that does not matter since we don't have a language with an
// encoding supported by inputenc but without babel support.
- set<string> encodings;
- LanguageList::const_iterator it = UsedLanguages_.begin();
- LanguageList::const_iterator end = UsedLanguages_.end();
- for (; it != end; ++it)
- if ((*it)->encoding()->latexName() != doc_encoding &&
- ((*it)->encoding()->package() == Encoding::inputenc
- || (*it)->encoding()->package() == Encoding::japanese))
- encodings.insert((*it)->encoding()->latexName());
- return encodings;
+ set<string> encs;
+ for (auto const & lang : UsedLanguages_)
+ if (lang->encoding()->latexName() != doc_encoding &&
+ (lang->encoding()->package() == Encoding::inputenc
+ || lang->encoding()->package() == Encoding::japanese))
+ encs.insert(lang->encoding()->latexName());
+ return encs;
}
-void LaTeXFeatures::getFontEncodings(vector<string> & encodings) const
+void LaTeXFeatures::getFontEncodings(vector<string> & encs, bool const onlylangs) const
{
- // these must be loaded if glyphs of this script
- // are used (notwithstanding the language)
- if (mustProvide("textgreek"))
- encodings.insert(encodings.begin(), "LGR");
- if (mustProvide("textcyr"))
- encodings.insert(encodings.begin(), "T2A");
+ if (!onlylangs) {
+ // these must be loaded if glyphs of this script are used
+ // unless a language providing them is used in the document
+ if (mustProvide("textgreek")
+ && find(encs.begin(), encs.end(), "LGR") == encs.end())
+ encs.insert(encs.begin(), "LGR");
+ if (mustProvide("textcyrillic")
+ && find(encs.begin(), encs.end(), "T2A") == encs.end())
+ encs.insert(encs.begin(), "T2A");
+ }
- LanguageList::const_iterator it = UsedLanguages_.begin();
- LanguageList::const_iterator end = UsedLanguages_.end();
- for (; it != end; ++it)
- if (!(*it)->fontenc().empty()
- && ascii_lowercase((*it)->fontenc()) != "none") {
- vector<string> extraencs = getVectorFromString((*it)->fontenc());
- vector<string>::const_iterator fit = extraencs.begin();
- for (; fit != extraencs.end(); ++fit) {
- if (find(encodings.begin(), encodings.end(), *fit) == encodings.end())
- encodings.insert(encodings.begin(), *fit);
+ for (auto const & lang : UsedLanguages_)
+ if (!lang->fontenc().empty()
+ && ascii_lowercase(lang->fontenc()) != "none") {
+ vector<string> extraencs = getVectorFromString(lang->fontenc());
+ for (auto const & extra : extraencs) {
+ if (find(encs.begin(), encs.end(), extra) == encs.end())
+ encs.insert(encs.begin(), extra);
}
}
}
// note that the package order here will be the same in the LaTeX-output
"array",
"verbatim",
+ "cprotect",
"longtable",
"rotating",
"latexsym",
"pdfcomment",
"fixme",
"todonotes",
- "forest"
+ "forest",
+ "varwidth",
+ "footnote",
+ "tablefootnote",
+ "afterpage",
};
char const * bibliofeatures[] = {
"authordate1-4",
"babelbib",
"bibgerm",
+ "chapterbib",
"chicago",
"chscite",
"harvard",
int const nb_simplefeatures = sizeof(simplefeatures) / sizeof(char const *);
-}
+} // namespace
string const LaTeXFeatures::getColorOptions() const
// The rest of these packages are somewhat more complicated
// than those above.
+ // [pdf]lscape is used to rotate longtables
+ if (mustProvide("lscape")) {
+ if (runparams_.flavor == OutputParams::LATEX
+ || runparams_.flavor == OutputParams::DVILUATEX)
+ packages << "\\usepackage{lscape}\n";
+ else
+ packages << "\\usepackage{pdflscape}\n";
+ }
+
// The tipa package and its extensions (tipx, tone) must not
// be loaded with non-TeX fonts, since fontspec includes the
// respective macros
packages << "\\usepackage{tipa}\n";
if (mustProvide("tipx") && !params_.useNonTeXFonts)
packages << "\\usepackage{tipx}\n";
+ if (mustProvide("extraipa") && !params_.useNonTeXFonts)
+ packages << "\\usepackage{extraipa}\n";
if (mustProvide("tone") && !params_.useNonTeXFonts)
packages << "\\usepackage{tone}\n";
// if fontspec or newtxmath is used, AMS packages have to be loaded
// before fontspec (in BufferParams)
string const amsPackages = loadAMSPackages();
- bool const ot1 = (params_.font_encoding() == "default" || params_.font_encoding() == "OT1");
+ bool const ot1 = (params_.main_font_encoding() == "default"
+ || params_.main_font_encoding() == "OT1");
bool const use_newtxmath =
- theLaTeXFonts().getLaTeXFont(from_ascii(params_.fonts_math)).getUsedPackage(
+ theLaTeXFonts().getLaTeXFont(from_ascii(params_.fontsMath())).getUsedPackage(
ot1, false, false) == "newtxmath";
if (!params_.useNonTeXFonts && !use_newtxmath && !amsPackages.empty())
// Some classes load natbib themselves, but still allow (or even require)
// plain numeric citations (ReVTeX is such a case, see bug 5182).
// This special case is indicated by the "natbib-internal" key.
- if (mustProvide("natbib") && !isProvided("natbib-internal")) {
+ if (mustProvide("natbib")
+ && !isProvided("natbib-internal")
+ && !isProvided("biblatex")
+ && !isProvided("biblatex-natbib")
+ && !isProvided("jurabib")) {
packages << "\\usepackage[";
if (params_.citeEngineType() == ENGINE_TYPE_NUMERICAL)
packages << "numbers";
else
packages << "authoryear";
+ if (!params_.biblio_opts.empty())
+ packages << ',' << params_.biblio_opts;
packages << "]{natbib}\n";
}
}
// jurabib -- we need version 0.6 at least.
- if (mustProvide("jurabib"))
- packages << "\\usepackage{jurabib}[2004/01/25]\n";
+ if (mustProvide("jurabib")
+ && !isProvided("natbib-internal")
+ && !isProvided("natbib")
+ && !isProvided("biblatex")
+ && !isProvided("biblatex-natbib")) {
+ packages << "\\usepackage";
+ if (!params_.biblio_opts.empty())
+ packages << '[' << params_.biblio_opts << ']';
+ packages << "{jurabib}[2004/01/25]\n";
+ }
// opcit -- we pass custombst as we output \bibliographystyle ourselves
if (mustProvide("opcit")) {
if (mustProvide("footmisc"))
packages << "\\PassOptionsToPackage{stable}{footmisc}\n";
- return packages.str();
-}
-
-
-string LaTeXFeatures::getPreambleSnippets() const
-{
- ostringstream snip;
- SnippetList::const_iterator pit = preamble_snippets_.begin();
- SnippetList::const_iterator pend = preamble_snippets_.end();
- for (; pit != pend; ++pit)
- snip << *pit << '\n';
- return snip.str();
-}
-
+ if (mustProvide("microtype")){
+ packages << "\\usepackage{microtype}\n";
+ }
-std::string LaTeXFeatures::getCSSSnippets() const
-{
- ostringstream snip;
- SnippetList::const_iterator pit = css_snippets_.begin();
- SnippetList::const_iterator pend = css_snippets_.end();
- for (; pit != pend; ++pit)
- snip << *pit << '\n';
- return snip.str();
+ return packages.str();
}
-docstring const LaTeXFeatures::getMacros() const
+TexString LaTeXFeatures::getMacros() const
{
- odocstringstream macros;
+ otexstringstream macros;
if (!preamble_snippets_.empty()) {
macros << '\n';
- macros << from_utf8(getPreambleSnippets());
+ macros << getPreambleSnippets();
}
+ if (mustProvide("xetexdashbreakstate"))
+ macros << "\\XeTeXdashbreakstate 0" << '\n';
+
if (mustProvide("papersize")) {
- if (runparams_.flavor == OutputParams::LATEX)
+ if (runparams_.flavor == OutputParams::LATEX
+ || runparams_.flavor == OutputParams::DVILUATEX)
macros << papersizedvi_def << '\n';
+ else if (runparams_.flavor == OutputParams::LUATEX)
+ macros << papersizepdflua_def << '\n';
else
macros << papersizepdf_def << '\n';
}
if (mustProvide("lyxarrow"))
macros << lyxarrow_def << '\n';
+ if (mustProvide("lyxzerowidthspace"))
+ macros << lyxZWSP_def << '\n';
+
if (!usePolyglossia() && mustProvide("textgreek")) {
- // ensure LGR font encoding is defined also if fontenc is not loaded by LyX
- if (params_.font_encoding() == "default")
+ // ensure LGR font encoding is defined also if fontenc is not loaded by LyX
+ if (params_.main_font_encoding() == "default")
macros << textgreek_LGR_def;
- // Avoid a LaTeX error if times fonts are used and the grtimes
- // package is installed but actual fonts are not (bug 6469).
- if (params_.fonts_roman == "times")
- macros << subst(textgreek_def,
- from_ascii("\\greektext #1"),
- from_ascii("%\n \\IfFileExists"
- "{grtm10.tfm}{}{\\fontfamily"
- "{cmr}}\\greektext #1"))
- << '\n';
- else
- macros << textgreek_def << '\n';
+ macros << textgreek_def << '\n';
}
- if (!usePolyglossia() && mustProvide("textcyr"))
- // ensure T2A font encoding is set up also if fontenc is not loaded by LyX
- if (params_.font_encoding() == "default")
+ if (!usePolyglossia() && mustProvide("textcyrillic")) {
+ // ensure T2A font encoding is set up also if fontenc is not loaded by LyX
+ if (params_.main_font_encoding() == "default")
macros << textcyr_T2A_def;
macros << textcyr_def << '\n';
+ }
- // non-standard text accents:
+ // non-standard text accents:
if (mustProvide("textcommaabove") || mustProvide("textcommaaboveright") ||
mustProvide("textcommabelow") || mustProvide("textbaltic"))
macros << lyxaccent_def;
if (mustProvide("textbaltic"))
macros << textbaltic_def << '\n';
+ // split-level fractions
+ if (mustProvide("xfrac") || mustProvide("smallLetterFrac"))
+ macros << xfrac_def << '\n';
+
+ if (mustProvide("smallLetterFrac"))
+ macros << smallLetterFrac_def << '\n';
+
if (mustProvide("lyxmathsym"))
macros << lyxmathsym_def << '\n';
macros << guillemotleft_def << '\n';
if (mustProvide("guillemotright"))
macros << guillemotright_def << '\n';
+ if (mustProvide("textquotedbl"))
+ macros << textquotedbl_def << '\n';
+ if (mustProvide("textquotesinglep")) {
+ if (runparams_.flavor == OutputParams::XETEX)
+ macros << textquotesinglep_xetex_def << '\n';
+ else
+ macros << textquotesinglep_luatex_def << '\n';
+ }
+ if (mustProvide("textquotedblp")) {
+ if (runparams_.flavor == OutputParams::XETEX)
+ macros << textquotedblp_xetex_def << '\n';
+ else
+ macros << textquotedblp_luatex_def << '\n';
+ }
// Math mode
if (mustProvide("binom") && !isRequired("amsmath"))
// other
if (mustProvide("ParagraphLeftIndent"))
macros << paragraphleftindent_def;
+ if (mustProvide("NeedLyXFootnoteCode"))
+ macros << floatingfootnote_def;
// some problems with tex->html converters
if (mustProvide("NeedTabularnewline"))
macros << changetracking_dvipost_def;
if (mustProvide("ct-xcolor-ulem")) {
- streamsize const prec = macros.precision(2);
+ streamsize const prec = macros.os().precision(2);
RGBColor cadd = rgbFromHexName(lcolor.getX11Name(Color_addedtext));
macros << "\\providecolor{lyxadded}{rgb}{"
macros << "\\providecolor{lyxdeleted}{rgb}{"
<< cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
- macros.precision(prec);
+ macros.os().precision(prec);
if (isRequired("hyperref"))
macros << changetracking_xcolor_ulem_hyperref_def;
macros << changetracking_xcolor_ulem_def;
}
+ if (mustProvide("ct-tikz-math-sout"))
+ macros << changetracking_tikz_math_sout_def;
+
if (mustProvide("ct-none"))
macros << changetracking_none_def;
if (mustProvide("rtloutputdblcol"))
macros << rtloutputdblcol_def;
- return macros.str();
+ if (mustProvide("lyxmintcaption"))
+ macros << lyxmintcaption_def;
+
+ return macros.release();
}
-string const LaTeXFeatures::getBabelPresettings() const
+docstring const LaTeXFeatures::getBabelPresettings() const
{
- ostringstream tmp;
+ odocstringstream tmp;
- LanguageList::const_iterator it = UsedLanguages_.begin();
- LanguageList::const_iterator end = UsedLanguages_.end();
- for (; it != end; ++it)
- if (!(*it)->babel_presettings().empty())
- tmp << (*it)->babel_presettings() << '\n';
+ for (Language const * lang : UsedLanguages_)
+ if (!lang->babel_presettings().empty())
+ tmp << lang->babel_presettings() << '\n';
if (!params_.language->babel_presettings().empty())
tmp << params_.language->babel_presettings() << '\n';
}
-string const LaTeXFeatures::getBabelPostsettings() const
+docstring const LaTeXFeatures::getBabelPostsettings() const
{
- ostringstream tmp;
+ odocstringstream tmp;
- LanguageList::const_iterator it = UsedLanguages_.begin();
- LanguageList::const_iterator end = UsedLanguages_.end();
- for (; it != end; ++it)
- if (!(*it)->babel_postsettings().empty())
- tmp << (*it)->babel_postsettings() << '\n';
+ for (Language const * lang : UsedLanguages_)
+ if (!lang->babel_postsettings().empty())
+ tmp << lang->babel_postsettings() << '\n';
if (!params_.language->babel_postsettings().empty())
tmp << params_.language->babel_postsettings() << '\n';
list<docstring>::const_iterator cit = usedLayouts_.begin();
list<docstring>::const_iterator end = usedLayouts_.end();
for (; cit != end; ++cit)
- tcpreamble << tclass[*cit].preamble();
+ // For InPreamble layouts, we output the preamble stuff earlier
+ // (before the layouts). See Paragraph::Private::validate.
+ if (!tclass[*cit].inpreamble)
+ tcpreamble << tclass[*cit].preamble();
cit = usedInsetLayouts_.begin();
end = usedInsetLayouts_.end();
return from_utf8(preamble);
}
-}
+} // namespace
-docstring const LaTeXFeatures::getTClassI18nPreamble(bool use_babel, bool use_polyglossia) const
+docstring const LaTeXFeatures::getTClassI18nPreamble(bool use_babel,
+ bool use_polyglossia, bool use_minted) const
{
DocumentClass const & tclass = params_.documentClass();
// collect preamble snippets in a set to prevent multiple identical
// need to force a fixed width encoding for
// \lstlistlistingname and \lstlistingname (bug 9382).
// This needs to be consistent with InsetListings::latex().
- bool const need_fixedwidth = !runparams_.isFullUnicode() &&
- it->second.fixedwidthpreambleencoding();
+ bool const need_fixedwidth = !use_minted &&
+ !runparams_.isFullUnicode() &&
+ it->second.fixedwidthpreambleencoding();
// language dependent commands (once per document)
snippets.insert(i18npreamble(it->second.langpreamble(),
buffer().language(),
{
lyxerr << "LyX needs the following commands when LaTeXing:"
<< "\n***** Packages:" << getPackages()
- << "\n***** Macros:" << to_utf8(getMacros())
+ << "\n***** Macros:" << to_utf8(getMacros().str)
<< "\n***** Textclass stuff:" << to_utf8(getTClassPreamble())
<< "\n***** done." << endl;
}
}
-void LaTeXFeatures::getFloatDefinitions(odocstream & os) const
+void LaTeXFeatures::getFloatDefinitions(otexstream & os) const
{
FloatList const & floats = params_.documentClass().floats();
}
+void LaTeXFeatures::expandMultiples()
+{
+ for (Features::iterator it = features_.begin(); it != features_.end();) {
+ if (contains(*it, ',')) {
+ vector<string> const multiples = getVectorFromString(*it, ",");
+ vector<string>::const_iterator const end = multiples.end();
+ vector<string>::const_iterator itm = multiples.begin();
+ // Do nothing if any multiple is already required
+ for (; itm != end; ++itm) {
+ if (!isRequired(*itm))
+ require(*itm);
+ }
+ features_.erase(it);
+ it = features_.begin();
+ } else
+ ++it;
+ }
+}
+
+
} // namespace lyx