src/LaTeXFeatures.cpp

   1 /**
   2  * \file LaTeXFeatures.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author José Matos
   7  * \author Lars Gullik Bjønnes
   8  * \author Jean-Marc Lasgouttes
   9  * \author Jürgen Vigna
  10  * \author André Pönitz
  11  *
  12  * Full author contact details are available in file CREDITS.
  13  */
  14
  15 #include <config.h>
  16
  17 #include "LaTeXFeatures.h"
  18
  19 #include "Buffer.h"
  20 #include "BufferParams.h"
  21 #include "ColorSet.h"
  22 #include "Converter.h"
  23 #include "Encoding.h"
  24 #include "Floating.h"
  25 #include "FloatList.h"
  26 #include "Language.h"
  27 #include "LaTeXFonts.h"
  28 #include "LaTeXPackages.h"
  29 #include "Layout.h"
  30 #include "LyXRC.h"
  31 #include "OutputParams.h"
  32 #include "TextClass.h"
  33 #include "TexRow.h"
  34 #include "texstream.h"
  35
  36 #include "insets/InsetLayout.h"
  37
  38 #include "support/debug.h"
  39 #include "support/docstream.h"
  40 #include "support/docstring.h"
  41 #include "support/filetools.h"
  42 #include "support/lstrings.h"
  43
  44 #include <algorithm>
  45 #include <regex>
  46
  47
  48 using namespace std;
  49 using namespace lyx::support;
  50
  51
  52 namespace lyx {
  53
  54 /////////////////////////////////////////////////////////////////////
  55 //
  56 // Strings
  57 //
  58 /////////////////////////////////////////////////////////////////////
  59
  60 //\NeedsTeXFormat{LaTeX2e}
  61 //\ProvidesPackage{lyx}[1996/01/11 LLE v0.2 (LyX LaTeX Extensions)]
  62 //\message{LyX LaTeX Extensions (LLE v0.2) of 11-Jan-1996.}
  63
  64 static docstring const lyx_def = from_ascii(
  65         "{%\n  L\\kern-.1667em\\lower.25em\\hbox{Y}\\kern-.125emX\\@}");
  66
  67 static docstring const noun_def = from_ascii(
  68         "\\newcommand{\\noun}[1]{\\textsc{#1}}");
  69
  70 static docstring const lyxarrow_def = from_ascii(
  71         "\\DeclareRobustCommand*{\\lyxarrow}{%\n"
  72         "\\@ifstar\n"
  73         "{\\leavevmode\\,$\\triangleleft$\\,\\allowbreak}\n"
  74         "{\\leavevmode\\,$\\triangleright$\\,\\allowbreak}}");
  75
  76 static docstring const aastex_case_def = from_ascii(
  77                 "\\providecommand\\case[2]{\\mbox{$\\frac{#1}{#2}$}}%");
  78 // Copied from https://github.com/AASJournals/AASTeX60/blob/master/cls/aastex63.cls#L1645
  79 // Adapted to providecommand for compatibility reasons.
  80
  81 // ZERO WIDTH SPACE (ZWSP) is actually not a space character
  82 // but marks a line break opportunity. Several commands provide a
  83 // line break opportunity. They differ in side-effects:
  84 // \allowbreak prevents hyphenation after hyphen or dash + ZWSP
  85 // \linebreak[<n>] takes an optional argument denoting "urgency".
  86 // The \LyXZeroWidthSpace wrapper allows customization in the preamble.
  87 static docstring const lyxZWSP_def = from_ascii(
  88         "\\newcommand*\\LyXZeroWidthSpace{\\hspace{0pt}}");
  89
  90 // for quotes without babel. This does not give perfect results, but
  91 // anybody serious about non-english quotes should use babel (JMarc).
  92
  93 static docstring const quotedblbase_def = from_ascii(
  94         "\\ProvideTextCommandDefault{\\quotedblbase}{%\n"
  95         "  \\raisebox{-1.4ex}[1ex][.5ex]{\\textquotedblright}%\n"
  96         "  \\penalty10000\\hskip0em\\relax%\n"
  97         "}");
  98
  99 static docstring const quotesinglbase_def = from_ascii(
 100         "\\ProvideTextCommandDefault{\\quotesinglbase}{%\n"
 101         "  \\raisebox{-1.4ex}[1ex][.5ex]{\\textquoteright}%\n"
 102         "  \\penalty10000\\hskip0em\\relax%\n"
 103         "}");
 104
 105 static docstring const guillemotleft_def = from_ascii(
 106         "\\ProvideTextCommandDefault{\\guillemotleft}{%\n"
 107         "  {\\usefont{U}{lasy}{m}{n}\\char'50\\kern-.15em\\char'50}%\n"
 108         "\\penalty10000\\hskip0pt\\relax%\n"
 109         "}");
 110
 111 static docstring const guillemotright_def = from_ascii(
 112         "\\ProvideTextCommandDefault{\\guillemotright}{%\n"
 113         "  \\penalty10000\\hskip0pt%\n"
 114         "  {\\usefont{U}{lasy}{m}{n}\\char'51\\kern-.15em\\char'51}%\n"
 115         "}");
 116
 117 static docstring const guilsinglleft_def = from_ascii(
 118         "\\ProvideTextCommandDefault{\\guilsinglleft}{%\n"
 119         "  {\\usefont{U}{lasy}{m}{n}\\char'50}%\n"
 120         "  \\penalty10000\\hskip0pt\\relax%\n"
 121         "}");
 122
 123 static docstring const guilsinglright_def = from_ascii(
 124         "\\ProvideTextCommandDefault{\\guilsinglright}{%\n"
 125         "  \\penalty10000\\hskip0pt%\n"
 126         "  {\\usefont{U}{lasy}{m}{n}\\char'51}%\n"
 127         "}");
 128
 129 static docstring const textquotedbl_def = from_ascii(
 130         "\\DeclareTextSymbolDefault{\\textquotedbl}{T1}");
 131
 132 static docstring const textquotedblp_xetex_def = from_ascii(
 133         "\\providecommand\\textquotedblplain{%\n"
 134         "  \\bgroup\\addfontfeatures{Mapping=}\\char34\\egroup}");
 135
 136 static docstring const textquotedblp_luatex_def = from_ascii(
 137         "\\providecommand\\textquotedblplain{%\n"
 138         "  \\bgroup\\addfontfeatures{RawFeature=-tlig}\\char34\\egroup}");
 139
 140 static docstring const textquotesinglep_xetex_def = from_ascii(
 141         "\\providecommand\\textquotesingleplain{%\n"
 142         "  \\bgroup\\addfontfeatures{Mapping=}\\char39\\egroup}");
 143
 144 static docstring const textquotesinglep_luatex_def = from_ascii(
 145         "\\providecommand\\textquotesingleplain{%\n"
 146         "  \\bgroup\\addfontfeatures{RawFeature=-tlig}\\char39\\egroup}");
 147
 148 static docstring const paragraphleftindent_def = from_ascii(
 149         "\\newenvironment{LyXParagraphLeftIndent}[1]%\n"
 150         "{\n"
 151         "  \\begin{list}{}{%\n"
 152         "    \\setlength{\\topsep}{0pt}%\n"
 153         "    \\addtolength{\\leftmargin}{#1}\n"
 154 // ho hum, yet more things commented out with no hint as to why they
 155 // weren't just removed
 156 //      "%%    \\addtolength{\\leftmargin}{#1\\textwidth}\n"
 157 //      "%%    \\setlength{\\textwidth}{#2\\textwidth}\n"
 158 //      "%%    \\setlength\\listparindent\\parindent%\n"
 159 //      "%%    \\setlength\\itemindent\\parindent%\n"
 160         "    \\setlength{\\parsep}{0pt plus 1pt}%\n"
 161         "  }\n"
 162         "  \\item[]\n"
 163         "}\n"
 164         "{\\end{list}}\n");
 165
 166 static docstring const floatingfootnote_def = from_ascii(
 167         "%% Special footnote code from the package 'stblftnt.sty'\n"
 168         "%% Author: Robin Fairbairns -- Last revised Dec 13 1996\n"
 169         "\\let\\SF@@footnote\\footnote\n"
 170         "\\def\\footnote{\\ifx\\protect\\@typeset@protect\n"
 171         "    \\expandafter\\SF@@footnote\n"
 172         "  \\else\n"
 173         "    \\expandafter\\SF@gobble@opt\n"
 174         "  \\fi\n"
 175         "}\n"
 176         "\\expandafter\\def\\csname SF@gobble@opt \\endcsname{\\@ifnextchar[%]\n"
 177         "  \\SF@gobble@twobracket\n"
 178         "  \\@gobble\n"
 179         "}\n"
 180         "\\edef\\SF@gobble@opt{\\noexpand\\protect\n"
 181         "  \\expandafter\\noexpand\\csname SF@gobble@opt \\endcsname}\n"
 182         "\\def\\SF@gobble@twobracket[#1]#2{}\n");
 183
 184 static docstring const binom_def = from_ascii(
 185         "%% Binom macro for standard LaTeX users\n"
 186         "\\newcommand{\\binom}[2]{{#1 \\choose #2}}\n");
 187
 188 static docstring const mathcircumflex_def = from_ascii(
 189         "%% For printing a cirumflex inside a formula\n"
 190         "\\newcommand{\\mathcircumflex}[0]{\\mbox{\\^{}}}\n");
 191
 192 static docstring const tabularnewline_def = from_ascii(
 193         "%% Because html converters don't know tabularnewline\n"
 194         "\\providecommand{\\tabularnewline}{\\\\}\n");
 195
 196 static docstring const cellvarwidth_def = from_ascii(
 197         "%% Variable width box for table cells\n"
 198         "\\newenvironment{cellvarwidth}[1][t]\n"
 199         "    {\\begin{varwidth}[#1]{\\linewidth}}\n"
 200         "    {\\@finalstrut\\@arstrutbox\\end{varwidth}}\n");
 201
 202 // We want to omit the file extension for includegraphics, but this does not
 203 // work when the filename contains other dots.
 204 // Idea from http://www.tex.ac.uk/cgi-bin/texfaq2html?label=unkgrfextn
 205 static docstring const lyxdot_def = from_ascii(
 206         "%% A simple dot to overcome graphicx limitations\n"
 207         "\\newcommand{\\lyxdot}{.}\n");
 208
 209 static docstring const changetracking_xcolor_ulem_base_def = from_ascii(
 210         "%% Change tracking with ulem and xcolor: base macros\n"
 211         "\\DeclareRobustCommand{\\mklyxadded}[1]{\\bgroup\\color{lyxadded}{}#1\\egroup}\n"
 212         "\\DeclareRobustCommand{\\mklyxdeleted}[1]{\\bgroup\\color{lyxdeleted}\\mklyxsout{#1}\\egroup}\n"
 213         "\\DeclareRobustCommand{\\mklyxsout}[1]{\\ifx\\\\#1\\else\\sout{#1}\\fi}\n");
 214
 215 static docstring const changetracking_xcolor_ulem_def = from_ascii(
 216         "%% Change tracking with ulem and xcolor: ct markup\n"
 217         "\\DeclareRobustCommand{\\lyxadded}[4][]{\\mklyxadded{#4}}\n"
 218         "\\DeclareRobustCommand{\\lyxdeleted}[4][]{\\mklyxdeleted{#4}}\n");
 219
 220 static docstring const changetracking_xcolor_ulem_cb_def = from_ascii(
 221         "%% Change tracking with ulem, xcolor and changebars: ct markup\n"
 222         "\\DeclareRobustCommand{\\lyxadded}[4][]{%\n"
 223         "    \\protect\\cbstart\\mklyxadded{#4}%\n"
 224         "    \\protect\\cbend%\n"
 225         "}\n"
 226         "\\DeclareRobustCommand{\\lyxdeleted}[4][]{%\n"
 227         "    \\protect\\cbstart\\mklyxdeleted{#4}%\n"
 228         "    \\protect\\cbend%\n"
 229         "}\n");
 230
 231 static docstring const changetracking_xcolor_ulem_hyperref_def = from_ascii(
 232         "%% Change tracking with ulem, xcolor, and hyperref: ct markup\n"
 233         "\\DeclareRobustCommand{\\lyxadded}[4][]{\\texorpdfstring{\\mklyxadded{#4}}{#4}}\n"
 234         "\\DeclareRobustCommand{\\lyxdeleted}[4][]{\\texorpdfstring{\\mklyxdeleted{#4}}{}}\n");
 235
 236 static docstring const changetracking_xcolor_ulem_hyperref_cb_def = from_ascii(
 237         "%% Change tracking with ulem, xcolor, hyperref and changebars: ct markup\n"
 238         "\\DeclareRobustCommand{\\lyxadded}[4][]{%\n"
 239         "    \\texorpdfstring{\\protect\\cbstart\\mklyxadded{#4}%\n"
 240         "    \\protect\\cbend}{#4}%\n"
 241         "}\n"
 242         "\\DeclareRobustCommand{\\lyxdeleted}[4][]{%\n"
 243         "    \\texorpdfstring{\\protect\\cbstart\\mklyxdeleted{#4}%\n"
 244         "    \\protect\\cbend}{}%\n"
 245         "}\n");
 246
 247 static docstring const changetracking_tikz_object_sout_def = from_ascii(
 248         "%% Strike out display math and text objects with tikz\n"
 249         "\\usetikzlibrary{calc}\n"
 250         "\\newcommand{\\lyxobjectsout}[1]{%\n"
 251         "  \\bgroup%\n"
 252         "  \\color{lyxdeleted}%\n"
 253         "  \\tikz{\n"
 254         "    \\node[inner sep=0pt,outer sep=0pt](lyxdelobj){#1};\n"
 255         "    \\draw($(lyxdelobj.south west)+(2em,.5em)$)--($(lyxdelobj.north east)-(2em,.5em)$);\n"
 256         "  }\n"
 257         "  \\egroup%\n"
 258         "}\n");
 259
 260 static docstring const changetracking_xcolor_ulem_object_def = from_ascii(
 261         "%% Change tracking with ulem and xcolor: ct markup for complex objects\n"
 262         "\\DeclareRobustCommand{\\lyxobjdeleted}[4][]{\\lyxobjectsout{#4}}\n"
 263         "\\DeclareRobustCommand{\\lyxdisplayobjdeleted}[4][]{%\n"
 264         "  \\ifx#4\\empty\\else%\n"
 265         "     \\leavevmode\\\\%\n"
 266         "     \\lyxobjectsout{\\parbox{\\linewidth}{#4}}%\n"
 267         "  \\fi%\n"
 268         "}\n"
 269         "\\DeclareRobustCommand{\\lyxudisplayobjdeleted}[4][]{%\n"
 270         "  \\ifx#4\\empty\\else%\n"
 271         "     \\leavevmode\\\\%\n"
 272         "     \\raisebox{-\\belowdisplayshortskip}{%\n"
 273         "                \\lyxobjectsout{\\parbox[b]{\\linewidth}{#4}}}%\n"
 274         "     \\leavevmode\\\\%\n"
 275         "  \\fi%\n"
 276         "}\n");
 277
 278 static docstring const changetracking_xcolor_ulem_cb_object_def = from_ascii(
 279         "%% Change tracking with ulem, xcolor and changebars:ct markup for complex objects\n"
 280         "\\DeclareRobustCommand{\\lyxobjdeleted}[4][]{%\n"
 281         "    \\protect\\cbstart\\lyxobjectsout{#4}%\n"
 282         "    \\protect\\cbend%\n"
 283         "}\n"
 284         "\\DeclareRobustCommand{\\lyxdisplayobjdeleted}[4][]{%\n"
 285         "  \\ifx#4\\empty\\else%\n"
 286         "    \\leavevmode\\\\%\n"
 287         "    \\protect\\cbstart%\n"
 288         "    \\lyxobjectsout{\\parbox{\\linewidth}{#4}}%\n"
 289         "    \\protect\\cbend%\n"
 290         "  \\fi%\n"
 291         "}\n"
 292         "\\DeclareRobustCommand{\\lyxudisplayobjdeleted}[4][]{%\n"
 293         "  \\ifx#4\\empty\\else%\n"
 294         "    \\leavevmode\\\\%\n"
 295         "    \\raisebox{-\\belowdisplayshortskip}{%\n"
 296         "               \\protect\\cbstart%\n"
 297         "               \\lyxobjectsout{\\parbox[b]{\\linewidth}{#4}}}%\n"
 298         "               \\protect\\cbend%\n"
 299         "     \\leavevmode\\\\%\n"
 300         "  \\fi%\n"
 301         "}\n");
 302
 303 static docstring const changetracking_xcolor_ulem_hyperref_object_def = from_ascii(
 304         "%% Change tracking with ulem, xcolor, and hyperref: ct markup for complex objects\n"
 305         "\\DeclareRobustCommand{\\lyxobjdeleted}[4][]{\\texorpdfstring{\\lyxobjectsout{#4}}{}}\n"
 306         "\\DeclareRobustCommand{\\lyxdisplayobjdeleted}[4][]{%\n"
 307         "  \\ifx#4\\empty\\else%\n"
 308         "     \\texorpdfstring{\\leavevmode\\\\\\lyxobjectsout{\\parbox{\\linewidth}{#4}}}{}%\n"
 309         "  \\fi%\n"
 310         "}\n"
 311         "\\DeclareRobustCommand{\\lyxudisplayobjdeleted}[4][]{%\n"
 312         "  \\ifx#4\\empty\\else%\n"
 313         "     \\texorpdfstring{\\leavevmode\\\\\\raisebox{-\\belowdisplayshortskip}{%\n"
 314         "                \\lyxobjectsout{\\parbox[b]{\\linewidth}{#4}}}}{}%\n"
 315         "     \\leavevmode\\\\%\n"
 316         "  \\fi%\n"
 317         "}\n");
 318
 319 static docstring const changetracking_xcolor_ulem_hyperref_cb_object_def = from_ascii(
 320         "%% Change tracking with ulem, xcolor, hyperref and changebars:\n"
 321         "%% ct markup for complex objects\n"
 322         "\\DeclareRobustCommand{\\lyxobjdeleted}[4][]{%\n"
 323         "    \\texorpdfstring{\\protect\\cbstart\\lyxobjectsout{#4}%\n"
 324         "    \\protect\\cbend}{}%\n"
 325         "}\n"
 326         "\\DeclareRobustCommand{\\lyxdisplayobjdeleted}[4][]{%\n"
 327         "  \\ifx#4\\empty\\else%\n"
 328         "     \\texorpdfstring{\\leavevmode\\\\\\protect\\cbstart%\n"
 329         "        \\lyxobjectsout{\\parbox{\\linewidth}{#4}}%\n"
 330         "        \\protect\\cbend%\n"
 331         "      }{}%\n"
 332         "  \\fi%\n"
 333         "}\n"
 334         "\\DeclareRobustCommand{\\lyxudisplayobjdeleted}[4][]{%\n"
 335         "  \\ifx#4\\empty\\else%\n"
 336         "     \\texorpdfstring{\\leavevmode\\\\\\protect\\cbstart%\n"
 337         "        \\raisebox{-\\belowdisplayshortskip}{%\n"
 338         "                   \\lyxobjectsout{\\parbox[b]{\\linewidth}{#4}}%\n"
 339         "        }%\n"
 340         "      \\leavevmode\\\\%\n"
 341         "     }{}%\n"
 342         "  \\fi%\n"
 343         "}\n");
 344
 345 static docstring const changetracking_none_def = from_ascii(
 346         "%% Change tracking: Disable markup in output\n"
 347         "\\newcommand{\\lyxadded}[3]{#3}\n"
 348         "\\newcommand{\\lyxdeleted}[3]{}\n"
 349         "\\newcommand{\\lyxobjdeleted}[3]{}\n"
 350         "\\newcommand{\\lyxdisplayobjdeleted}[3]{}\n"
 351         "\\newcommand{\\lyxudisplayobjdeleted}[3]{}\n");
 352
 353 static docstring const textgreek_LGR_def = from_ascii(
 354         "\\DeclareFontEncoding{LGR}{}{}\n");
 355 static docstring const textgreek_def = from_ascii(
 356         "\\DeclareRobustCommand{\\greektext}{%\n"
 357         "  \\fontencoding{LGR}\\selectfont\\def\\encodingdefault{LGR}}\n"
 358         "\\DeclareRobustCommand{\\textgreek}[1]{\\leavevmode{\\greektext #1}}\n");
 359
 360 static docstring const textcyr_T2A_def = from_ascii(
 361         "\\InputIfFileExists{t2aenc.def}{}{%\n"
 362         "  \\errmessage{File `t2aenc.def' not found: Cyrillic script not supported}}\n");
 363 static docstring const textcyr_def = from_ascii(
 364         "\\DeclareRobustCommand{\\cyrtext}{%\n"
 365         "  \\fontencoding{T2A}\\selectfont\\def\\encodingdefault{T2A}}\n"
 366         "\\DeclareRobustCommand{\\textcyrillic}[1]{\\leavevmode{\\cyrtext #1}}\n");
 367
 368 static docstring const lyxmathsym_def = from_ascii(
 369         "\\newcommand{\\lyxmathsym}[1]{\\ifmmode\\begingroup\\def\\b@ld{bold}\n"
 370         "  \\text{\\ifx\\math@version\\b@ld\\bfseries\\fi#1}\\endgroup\\else#1\\fi}\n");
 371
 372 static docstring const papersizedvi_def = from_ascii(
 373         "\\special{papersize=\\the\\paperwidth,\\the\\paperheight}\n");
 374
 375 static docstring const papersizepdf_def = from_ascii(
 376         "\\pdfpageheight\\paperheight\n"
 377         "\\pdfpagewidth\\paperwidth\n");
 378
 379 static docstring const papersizepdflua_def = from_ascii(
 380         "% Backwards compatibility for LuaTeX < 0.90\n"
 381         "\\@ifundefined{pageheight}{\\let\\pageheight\\pdfpageheight}{}\n"
 382         "\\@ifundefined{pagewidth}{\\let\\pagewidth\\pdfpagewidth}{}\n"
 383         "\\pageheight\\paperheight\n"
 384         "\\pagewidth\\paperwidth\n");
 385
 386 static docstring const cedilla_def = from_ascii(
 387         "\\newcommand{\\docedilla}[2]{\\underaccent{#1\\mathchar'30}{#2}}\n"
 388         "\\newcommand{\\cedilla}[1]{\\mathpalette\\docedilla{#1}}\n");
 389
 390 static docstring const subring_def = from_ascii(
 391         "\\newcommand{\\dosubring}[2]{\\underaccent{#1\\mathchar'27}{#2}}\n"
 392         "\\newcommand{\\subring}[1]{\\mathpalette\\dosubring{#1}}\n");
 393
 394 static docstring const subdot_def = from_ascii(
 395         "\\newcommand{\\dosubdot}[2]{\\underaccent{#1.}{#2}}\n"
 396         "\\newcommand{\\subdot}[1]{\\mathpalette\\dosubdot{#1}}\n");
 397
 398 static docstring const subhat_def = from_ascii(
 399         "\\newcommand{\\dosubhat}[2]{\\underaccent{#1\\mathchar'136}{#2}}\n"
 400         "\\newcommand{\\subhat}[1]{\\mathpalette\\dosubhat{#1}}\n");
 401
 402 static docstring const subtilde_def = from_ascii(
 403         "\\newcommand{\\dosubtilde}[2]{\\underaccent{#1\\mathchar'176}{#2}}\n"
 404         "\\newcommand{\\subtilde}[1]{\\mathpalette\\dosubtilde{#1}}\n");
 405
 406 static docstring const dacute_def = from_ascii(
 407         "\\DeclareMathAccent{\\dacute}{\\mathalpha}{operators}{'175}\n");
 408
 409 static docstring const tipasymb_def = from_ascii(
 410         "\\DeclareFontEncoding{T3}{}{}\n"
 411         "\\DeclareSymbolFont{tipasymb}{T3}{cmr}{m}{n}\n");
 412
 413 static docstring const dgrave_def = from_ascii(
 414         "\\DeclareMathAccent{\\dgrave}{\\mathord}{tipasymb}{'15}\n");
 415
 416 static docstring const rcap_def = from_ascii(
 417         "\\DeclareMathAccent{\\rcap}{\\mathord}{tipasymb}{'20}\n");
 418
 419 static docstring const ogonek_def = from_ascii(
 420         "\\newcommand{\\doogonek}[2]{\\setbox0=\\hbox{$#1#2$}\\underaccent{#1\\mkern-6mu\n"
 421         "  \\ifx#2O\\hskip0.5\\wd0\\else\\ifx#2U\\hskip0.5\\wd0\\else\\hskip\\wd0\\fi\\fi\n"
 422         "  \\ifx#2o\\mkern-2mu\\else\\ifx#2e\\mkern-1mu\\fi\\fi\n"
 423         "  \\mathchar\"0\\hexnumber@\\symtipasymb0C}{#2}}\n"
 424         "\\newcommand{\\ogonek}[1]{\\mathpalette\\doogonek{#1}}\n");
 425
 426 static docstring const lyxaccent_def = from_ascii(
 427         "%% custom text accent \\LyxTextAccent[<rise value (length)>]{<accent>}{<base>}\n"
 428         "\\newcommand*{\\LyxTextAccent}[3][0ex]{%\n"
 429         "  \\hmode@bgroup\\ooalign{\\null#3\\crcr\\hidewidth\n"
 430         "  \\raise#1\\hbox{#2}\\hidewidth}\\egroup}\n"
 431         "%% select a font size smaller than the current font size:\n"
 432         "\\newcommand{\\LyxAccentSize}[1][\\sf@size]{%\n"
 433         "  \\check@mathfonts\\fontsize#1\\z@\\math@fontsfalse\\selectfont\n"
 434         "}\n");
 435
 436 static docstring const textcommabelow_def = from_ascii(
 437         "\\ProvideTextCommandDefault{\\textcommabelow}[1]{%%\n"
 438         "  \\LyxTextAccent[-.31ex]{\\LyxAccentSize,}{#1}}\n");
 439
 440 static docstring const textcommaabove_def = from_ascii(
 441         "\\ProvideTextCommandDefault{\\textcommaabove}[1]{%%\n"
 442         "  \\LyxTextAccent[.5ex]{\\LyxAccentSize`}{#1}}\n");
 443
 444 static docstring const textcommaaboveright_def = from_ascii(
 445         "\\ProvideTextCommandDefault{\\textcommaaboveright}[1]{%%\n"
 446         "  \\LyxTextAccent[.5ex]{\\LyxAccentSize\\ '}{#1}}\n");
 447
 448 // Baltic languages use a comma-accent instead of a cedilla
 449 static docstring const textbaltic_def = from_ascii(
 450         "%% use comma accent instead of cedilla for these characters:\n"
 451         "\\DeclareTextCompositeCommand{\\c}{T1}{g}{\\textcommaabove{g}}\n"
 452         "\\DeclareTextCompositeCommand{\\c}{T1}{G}{\\textcommabelow{G}}\n"
 453         "\\DeclareTextCompositeCommand{\\c}{T1}{k}{\\textcommabelow{k}}\n"
 454         "\\DeclareTextCompositeCommand{\\c}{T1}{K}{\\textcommabelow{K}}\n"
 455         "\\DeclareTextCompositeCommand{\\c}{T1}{l}{\\textcommabelow{l}}\n"
 456         "\\DeclareTextCompositeCommand{\\c}{T1}{L}{\\textcommabelow{L}}\n"
 457         "\\DeclareTextCompositeCommand{\\c}{T1}{n}{\\textcommabelow{n}}\n"
 458         "\\DeclareTextCompositeCommand{\\c}{T1}{N}{\\textcommabelow{N}}\n"
 459         "\\DeclareTextCompositeCommand{\\c}{T1}{r}{\\textcommabelow{r}}\n"
 460         "\\DeclareTextCompositeCommand{\\c}{T1}{R}{\\textcommabelow{R}}\n");
 461
 462 // Use cyrillic fonts to provide letter schwa in text (see #11062)
 463 static docstring const textschwa_def = from_ascii(
 464         "%% letter schwa missing in Latin fonts, use Cyrillic schwa\n"
 465         "\\DeclareTextSymbolDefault{\\CYRSCHWA}{T2A}\n"
 466         "\\DeclareTextSymbolDefault{\\cyrschwa}{T2A}\n"
 467         "\\ProvideTextCommandDefault{\\textSchwa}{\\CYRSCHWA}\n"
 468         "\\ProvideTextCommandDefault{\\textschwa}{\\cyrschwa}\n");
 469
 470 // split-level fractions
 471 static docstring const xfrac_def = from_ascii(
 472            "\\usepackage{xfrac}\n");
 473
 474 static docstring const smallLetterFrac_def = from_ascii(
 475         "\\DeclareCollectionInstance{smallLetterFrac}{xfrac}{default}{text}\n"
 476         "  {phantom=c, scale-factor=1.0, slash-left-kern=-.05em}\n"
 477         "\\DeclareCollectionInstance{smallLetterFrac}{xfrac}{lmr}{text}\n"
 478         "  {slash-symbol-font=ptm, phantom=c, scale-factor=1, slash-left-kern=-.05em}\n"
 479         "\\DeclareCollectionInstance{smallLetterFrac}{xfrac}{lmss}{text}\n"
 480         "  {slash-symbol-font=ptm, phantom=c, scale-factor=1, slash-left-kern=-.05em}\n"
 481         "\\DeclareCollectionInstance{smallLetterFrac}{xfrac}{cmr}{text}\n"
 482         "  {slash-symbol-font=ptm, phantom=c, scale-factor=1, slash-left-kern=-.05em}\n"
 483         "\\DeclareCollectionInstance{smallLetterFrac}{xfrac}{cmss}{text}\n"
 484         "  {slash-symbol-font=ptm, phantom=c, scale-factor=1, slash-left-kern=-.05em}\n"
 485         "\\newcommand{\\smallLetterFrac}[2]{%\n"
 486         "  {\\UseCollection{xfrac}{smallLetterFrac}\\sfrac{#1}{#2}}}\n");
 487
 488 static docstring const lyxref_def = from_ascii(
 489         "\\RS@ifundefined{subsecref}\n"
 490         "  {\\newref{subsec}{name = \\RSsectxt}}\n"
 491         "  {}\n"
 492         "\\RS@ifundefined{thmref}\n"
 493         "  {\\def\\RSthmtxt{theorem~}\\newref{thm}{name = \\RSthmtxt}}\n"
 494         "  {}\n"
 495         "\\RS@ifundefined{lemref}\n"
 496         "  {\\def\\RSlemtxt{lemma~}\\newref{lem}{name = \\RSlemtxt}}\n"
 497         "  {}\n");
 498
 499 // Make sure the columns are also outputed as rtl
 500 static docstring const rtloutputdblcol_def = from_ascii(
 501         "\\def\\@outputdblcol{%\n"
 502         "  \\if@firstcolumn\n"
 503         "    \\global \\@firstcolumnfalse\n"
 504         "    \\global \\setbox\\@leftcolumn \\box\\@outputbox\n"
 505         "  \\else\n"
 506         "    \\global \\@firstcolumntrue\n"
 507         "    \\setbox\\@outputbox \\vbox {%\n"
 508         "      \\hb@xt@\\textwidth {%\n"
 509         "      \\kern\\textwidth \\kern-\\columnwidth %**\n"
 510         "      \\hb@xt@\\columnwidth {%\n"
 511         "         \\box\\@leftcolumn \\hss}%\n"
 512         "      \\kern-\\textwidth %**\n"
 513         "      \\hfil\n"
 514         "      {\\normalcolor\\vrule \\@width\\columnseprule}%\n"
 515         "      \\hfil\n"
 516         "      \\kern-\\textwidth  %**\n"
 517         "      \\hb@xt@\\columnwidth {%\n"
 518         "         \\box\\@outputbox \\hss}%\n"
 519         "      \\kern-\\columnwidth \\kern\\textwidth %**\n"
 520         "    }%\n"
 521         "  }%\n"
 522         "  \\@combinedblfloats\n"
 523         "  \\@outputpage\n"
 524         "  \\begingroup\n"
 525         "  \\@dblfloatplacement\n"
 526         "  \\@startdblcolumn\n"
 527         "  \\@whilesw\\if@fcolmade \\fi\n"
 528         "  {\\@outputpage\n"
 529         "    \\@startdblcolumn}%\n"
 530         "  \\endgroup\n"
 531         "  \\fi\n"
 532         "}\n"
 533         "\\@mparswitchtrue\n");
 534
 535 static docstring const lyxmintcaption_def = from_ascii(
 536         "\\long\\def\\lyxmintcaption[#1]#2{%\n"
 537         "  \\ifx#1t\\vskip\\baselineskip\\fi%\n"
 538         "  \\refstepcounter{listing}\\noindent%\n"
 539         "  \\addcontentsline{lol}{listing}%\n"
 540         "  {\\protect\\numberline{\\thelisting}{\\ignorespaces #2}}%\n"
 541         "  \\setbox\\@tempboxa\\hbox{\\listingscaption~\\thelisting: #2}%\n"
 542         "  \\ifdim \\wd\\@tempboxa >\\linewidth%\n"
 543         "  \\parbox[t]{\\linewidth}{\\unhbox\\@tempboxa}\\else%\n"
 544         "  \\hbox to\\linewidth{\\hfil\\box\\@tempboxa\\hfil}\\fi%\n"
 545         "  \\ifx#1b\\vskip\\baselineskip\\fi\n"
 546         "}\n");
 547
 548
 549 docstring const lyxgreyedoutDef(bool const rtl, bool const ct, bool const lua, bool const babel)
 550 {
 551         odocstringstream ods;
 552
 553         if (rtl) {
 554                 ods << "%% The greyedout annotation environment (with RTL support)\n"
 555                     << "\\NewEnviron{lyxgreyedout}{%\n";
 556                 if (lua && !babel)
 557                         // luabidi uses this switch
 558                         ods << "  \\if@RTL%\n";
 559                 else
 560                         ods << "  \\if@rl%\n";
 561                 ods << "    \\everypar{%\n";
 562                 if (lua)
 563                         ods << "      \\pardir TRT \\textdir TRT\\normalfont\\normalsize\\textcolor{note_fontcolor}\\ignorespaces%\n";
 564                 else
 565                         ods << "      \\normalfont\\normalsize\\textcolor{note_fontcolor}\\beginL\\ignorespaces%\n";
 566                 ods << "    }%\n";
 567                 if (ct)
 568                         ods << "    \\colorlet{lyxadded}{lyxadded!30}\\colorlet{lyxdeleted}{lyxdeleted!30}%\n";
 569                 if (lua)
 570                         ods << "    \\BODY\\everypar{\\ignorespacesafterend}%\n";
 571                 else
 572                         ods << "    \\BODY\\everypar{\\ignorespacesafterend\\endL}%\n";
 573                 ods << "  \\else%\n";
 574                 if (ct)
 575                         ods << "    \\colorlet{lyxadded}{lyxadded!30}\\colorlet{lyxdeleted}{lyxdeleted!30}%\n";
 576                 ods << "    \\normalfont\\normalsize\\textcolor{note_fontcolor}\\bgroup\\ignorespaces%\n"
 577                     << "    \\BODY\\ignorespacesafterend\\egroup%\n"
 578                     << "  \\fi%\n"
 579                     << "}\n";
 580         } else {
 581                 ods << "%% The greyedout annotation environment\n"
 582                     << "\\newenvironment{lyxgreyedout}\n"
 583                     << "{";
 584                 if (ct)
 585                         ods << "\\colorlet{lyxadded}{lyxadded!30}\\colorlet{lyxdeleted}{lyxdeleted!30}%\n ";
 586                 ods << "\\normalfont\\normalsize\\textcolor{note_fontcolor}\\bgroup\\ignorespaces}\n"
 587                     << "{\\ignorespacesafterend\\egroup}\n";
 588         }
 589
 590         return ods.str();
 591 }
 592
 593
 594
 595 /////////////////////////////////////////////////////////////////////
 596 //
 597 // LyXHTML strings
 598 //
 599 /////////////////////////////////////////////////////////////////////
 600
 601 static docstring const lyxnoun_style = from_ascii(
 602         "dfn.lyxnoun {\n"
 603         "  font-variant: small-caps;\n"
 604         "}\n");
 605
 606
 607 // this is how it normally renders, but it might not always do so.
 608 static docstring const lyxstrikeout_style = from_ascii(
 609         "del.strikeout {\n"
 610         "  text-decoration: line-through;\n"
 611         "}\n");
 612
 613
 614 /////////////////////////////////////////////////////////////////////
 615 //
 616 // LaTeXFeatures
 617 //
 618 /////////////////////////////////////////////////////////////////////
 619
 620
 621 LaTeXFeatures::LaTeXFeatures(Buffer const & b, BufferParams const & p,
 622                                                          OutputParams const & r)
 623         : buffer_(&b), params_(p), runparams_(r), in_float_(false),
 624           in_deleted_inset_(false)
 625 {}
 626
 627
 628 LaTeXFeatures::LangPackage LaTeXFeatures::langPackage() const
 629 {
 630         string const local_lp = bufferParams().lang_package;
 631
 632         // Locally, custom is just stored as a string
 633         // in bufferParams().lang_package.
 634         if (local_lp != "auto"
 635             && local_lp != "babel"
 636             && local_lp != "default"
 637             && local_lp != "none")
 638                  return LANG_PACK_CUSTOM;
 639
 640         if (local_lp == "none")
 641                 return LANG_PACK_NONE;
 642
 643         /* If "auto" is selected, we load polyglossia with non-TeX fonts,
 644          * else we select babel.
 645          * If babel is selected (either directly or via the "auto"
 646          * mechanism), we really do only require it if we have
 647          * a language that needs it.
 648          */
 649         bool const polyglossia_required =
 650                 params_.useNonTeXFonts
 651                 && isAvailable("polyglossia")
 652                 && !isProvided("babel")
 653                 && this->hasOnlyPolyglossiaLanguages();
 654         bool const babel_required =
 655                 !bufferParams().language->babel().empty()
 656                 || !this->getBabelLanguages().empty();
 657
 658         if (local_lp == "auto") {
 659                 // polyglossia requirement has priority over babel
 660                 if (polyglossia_required)
 661                         return LANG_PACK_POLYGLOSSIA;
 662                 else if (babel_required)
 663                         return LANG_PACK_BABEL;
 664         }
 665
 666         if (local_lp == "babel") {
 667                 if (babel_required)
 668                         return LANG_PACK_BABEL;
 669         }
 670
 671         if (local_lp == "default") {
 672                 switch (lyxrc.language_package_selection) {
 673                 case LyXRC::LP_AUTO:
 674                         // polyglossia requirement has priority over babel
 675                         if (polyglossia_required)
 676                                 return LANG_PACK_POLYGLOSSIA;
 677                         else if (babel_required)
 678                                 return LANG_PACK_BABEL;
 679                         break;
 680                 case LyXRC::LP_BABEL:
 681                         if (babel_required)
 682                                 return LANG_PACK_BABEL;
 683                         break;
 684                 case LyXRC::LP_CUSTOM:
 685                         return LANG_PACK_CUSTOM;
 686                 case LyXRC::LP_NONE:
 687                         return LANG_PACK_NONE;
 688                 }
 689         }
 690
 691         return LANG_PACK_NONE;
 692 }
 693
 694
 695 void LaTeXFeatures::require(string const & name)
 696 {
 697         features_.insert(name);
 698 }
 699
 700
 701 void LaTeXFeatures::require(set<string> const & names)
 702 {
 703         features_.insert(names.begin(), names.end());
 704 }
 705
 706
 707 void LaTeXFeatures::provide(string const & name)
 708 {
 709         provides_.insert(name);
 710 }
 711
 712
 713 void LaTeXFeatures::useLayout(docstring const & layoutname)
 714 {
 715         useLayout(layoutname, 0);
 716 }
 717
 718
 719 void LaTeXFeatures::useLayout(docstring const & layoutname, int level)
 720 {
 721         // Some code to avoid loops in dependency definition
 722         const int maxlevel = 30;
 723         if (level > maxlevel) {
 724                 lyxerr << "LaTeXFeatures::useLayout: maximum level of "
 725                        << "recursion attained by layout "
 726                        << to_utf8(layoutname) << endl;
 727                 return;
 728         }
 729
 730         DocumentClass const & tclass = params_.documentClass();
 731         if (tclass.hasLayout(layoutname)) {
 732                 // Is this layout already in usedLayouts?
 733                 if (find(usedLayouts_.begin(), usedLayouts_.end(), layoutname)
 734                     != usedLayouts_.end())
 735                         return;
 736
 737                 Layout const & layout = tclass[layoutname];
 738                 require(layout.required());
 739
 740                 if (!layout.depends_on().empty()) {
 741                         useLayout(layout.depends_on(), level + 1);
 742                 }
 743                 usedLayouts_.push_back(layoutname);
 744         } else {
 745                 lyxerr << "LaTeXFeatures::useLayout: layout `"
 746                        << to_utf8(layoutname) << "' does not exist in this class"
 747                        << endl;
 748         }
 749 }
 750
 751
 752 void LaTeXFeatures::useInsetLayout(InsetLayout const & lay)
 753 {
 754         docstring const & lname = lay.name();
 755         DocumentClass const & tclass = params_.documentClass();
 756
 757         // this is a default inset layout, nothing useful here
 758         if (!tclass.hasInsetLayout(lname))
 759                 return;
 760         // Is this layout already in usedInsetLayouts?
 761         if (find(usedInsetLayouts_.begin(), usedInsetLayouts_.end(), lname)
 762                         != usedInsetLayouts_.end())
 763                 return;
 764
 765         require(lay.required());
 766         usedInsetLayouts_.push_back(lname);
 767 }
 768
 769
 770 bool LaTeXFeatures::isRequired(string const & name) const
 771 {
 772         return features_.find(name) != features_.end();
 773 }
 774
 775
 776 bool LaTeXFeatures::isProvided(string const & name) const
 777 {
 778         // Currently, this is only features provided by babel languages
 779         // (such as textgreek)
 780         if (provides_.find(name) != provides_.end())
 781                 return true;
 782
 783         if (params_.useNonTeXFonts)
 784                 return params_.documentClass().provides(name);
 785
 786         bool const ot1 = (runparams().main_fontenc == "default"
 787                 || runparams().main_fontenc == "OT1");
 788         bool const complete = (params_.fontsSans() == "default"
 789                 && params_.fontsTypewriter() == "default");
 790         bool const nomath = (params_.fontsMath() == "default");
 791         return params_.documentClass().provides(name)
 792                 || theLaTeXFonts().getLaTeXFont(
 793                         from_ascii(params_.fontsRoman())).provides(name, ot1,
 794                                                                   complete,
 795                                                                   nomath)
 796                 || theLaTeXFonts().getLaTeXFont(
 797                         from_ascii(params_.fontsSans())).provides(name, ot1,
 798                                                                  complete,
 799                                                                  nomath)
 800                 || theLaTeXFonts().getLaTeXFont(
 801                         from_ascii(params_.fontsTypewriter())).provides(name, ot1,
 802                                                                        complete,
 803                                                                        nomath)
 804                 || theLaTeXFonts().getLaTeXFont(
 805                         from_ascii(params_.fontsMath())).provides(name, ot1,
 806                                                                        complete,
 807                                                                        nomath);
 808 }
 809
 810
 811 bool LaTeXFeatures::mustProvide(string const & name) const
 812 {
 813         return isRequired(name) && !isProvided(name);
 814 }
 815
 816
 817 bool LaTeXFeatures::isAvailable(string const & name)
 818 {
 819         string::size_type const i = name.find("->");
 820         if (i != string::npos) {
 821                 string const from = name.substr(0,i);
 822                 string const to = name.substr(i+2);
 823                 //LYXERR0("from=[" << from << "] to=[" << to << "]");
 824                 return theConverters().isReachable(from, to);
 825         }
 826         return LaTeXPackages::isAvailable(name);
 827 }
 828
 829
 830 bool LaTeXFeatures::isAvailableAtLeastFrom(string const & name, int const y, int const m, int const d)
 831 {
 832         return LaTeXPackages::isAvailableAtLeastFrom(name, y, m, d);
 833 }
 834
 835
 836 namespace {
 837
 838 void addSnippet(std::list<TexString> & list, TexString ts, bool allow_dupes)
 839 {
 840         if (allow_dupes ||
 841             // test the absense of duplicates, i.e. elements with same str
 842             none_of(list.begin(), list.end(), [&](TexString const & ts2){
 843                             return ts.str == ts2.str;
 844                     })
 845             )
 846                 list.push_back(std::move(ts));
 847 }
 848
 849
 850 TexString getSnippets(std::list<TexString> const & list)
 851 {
 852         otexstringstream snip;
 853         for (TexString const & ts : list)
 854                 snip << TexString(ts) << '\n';
 855         return snip.release();
 856 }
 857
 858 } // namespace
 859
 860
 861 void LaTeXFeatures::addPreambleSnippet(TexString snippet, bool allow_dupes)
 862 {
 863         addSnippet(preamble_snippets_, std::move(snippet), allow_dupes);
 864 }
 865
 866
 867 void LaTeXFeatures::addPreambleSnippet(docstring const & snippet, bool allow_dupes)
 868 {
 869         addSnippet(preamble_snippets_, TexString(snippet), allow_dupes);
 870 }
 871
 872
 873 void LaTeXFeatures::addCSSSnippet(std::string const & snippet)
 874 {
 875         addSnippet(css_snippets_, TexString(from_ascii(snippet)), false);
 876 }
 877
 878
 879 TexString LaTeXFeatures::getPreambleSnippets() const
 880 {
 881         return getSnippets(preamble_snippets_);
 882 }
 883
 884
 885 docstring LaTeXFeatures::getCSSSnippets() const
 886 {
 887         return getSnippets(css_snippets_).str;
 888 }
 889
 890
 891
 892 void LaTeXFeatures::useFloat(string const & name, bool subfloat)
 893 {
 894         if (!usedFloats_[name])
 895                 usedFloats_[name] = subfloat;
 896         if (subfloat)
 897                 require("subfig");
 898         // We only need float.sty if we use non builtin floats, or if we
 899         // use the "H" modifier. This includes modified table and
 900         // figure floats. (Lgb)
 901         Floating const & fl = params_.documentClass().floats().getType(name);
 902         if (!fl.floattype().empty()) {
 903                 if (fl.usesFloatPkg())
 904                         require("float");
 905                 if (!fl.required().empty()) {
 906                         vector<string> reqs = getVectorFromString(fl.required());
 907                         for (auto const & req : reqs)
 908                                 require(req);
 909                 }
 910         }
 911 }
 912
 913
 914 void LaTeXFeatures::useLanguage(Language const * lang)
 915 {
 916         if (!lang->babel().empty() || !lang->polyglossia().empty())
 917                 UsedLanguages_.insert(lang);
 918         if (!lang->required().empty())
 919                 require(lang->required());
 920         // currently only supported for Babel
 921         if (!lang->provides().empty() && useBabel())
 922                 provide(lang->provides());
 923         // CJK languages do not have a babel name.
 924         // They use the CJK package
 925         if (lang->encoding()->package() == Encoding::CJK)
 926                 require("CJK");
 927         // japanese babel language is special (tied to the pLaTeX engine).
 928         if (lang->encoding()->package() == Encoding::japanese)
 929                 require("japanese");
 930 }
 931
 932
 933 void LaTeXFeatures::includeFile(docstring const & key, string const & name)
 934 {
 935         IncludedFiles_[key] = name;
 936 }
 937
 938
 939 bool LaTeXFeatures::hasLanguages() const
 940 {
 941         return !UsedLanguages_.empty();
 942 }
 943
 944
 945 bool LaTeXFeatures::hasOnlyPolyglossiaLanguages() const
 946 {
 947         // first the main language
 948         if (params_.language->polyglossia().empty())
 949                 return false;
 950         // now the secondary languages
 951         for (auto const & lang : UsedLanguages_)
 952         {
 953                 if (lang->polyglossia().empty())
 954                         return false;
 955         }
 956         return true;
 957 }
 958
 959
 960 bool LaTeXFeatures::hasPolyglossiaExclusiveLanguages() const
 961 {
 962         // first the main language
 963         if (params_.language->isPolyglossiaExclusive())
 964                 return true;
 965         // now the secondary languages
 966         for (auto const & lang : UsedLanguages_)
 967         {
 968                 if (lang->isPolyglossiaExclusive())
 969                         return true;
 970         }
 971         return false;
 972 }
 973
 974
 975 vector<string> LaTeXFeatures::getPolyglossiaExclusiveLanguages() const
 976 {
 977         vector<string> result;
 978         // first the main language
 979         if (params_.language->isPolyglossiaExclusive())
 980                 result.push_back(params_.language->display());
 981         // now the secondary languages
 982         for (auto const & lang : UsedLanguages_)
 983         {
 984                 if (lang->isPolyglossiaExclusive())
 985                         result.push_back(lang->display());
 986         }
 987         return result;
 988 }
 989
 990
 991 vector<string> LaTeXFeatures::getBabelExclusiveLanguages() const
 992 {
 993         vector<string> result;
 994         // first the main language
 995         if (params_.language->isBabelExclusive())
 996                 result.push_back(params_.language->display());
 997         // now the secondary languages
 998         for (auto const & lang : UsedLanguages_)
 999         {
1000                 if (lang->isBabelExclusive())
1001                         result.push_back(lang->display());
1002         }
1003         return result;
1004 }
1005
1006
1007 string LaTeXFeatures::getBabelLanguages() const
1008 {
1009         vector<string> blangs;
1010         for (auto const & lang : UsedLanguages_) {
1011                 if (!lang->babel().empty())
1012                         blangs.push_back(lang->babel());
1013         }
1014
1015         // Sort alphabetically to assure consistent order
1016         // (the order itself does not matter apart from
1017         // some exceptions, e.g. hebrew must come after
1018         // arabic and farsi)
1019         sort(blangs.begin(), blangs.end());
1020
1021         return getStringFromVector(blangs);
1022 }
1023
1024
1025 set<string> LaTeXFeatures::getPolyglossiaLanguages() const
1026 {
1027         set<string> langs;
1028
1029         for (auto const & lang : UsedLanguages_)
1030                 // We do not need the variants here
1031                 langs.insert(lang->polyglossia());
1032         return langs;
1033 }
1034
1035
1036 string LaTeXFeatures::getActiveChars() const
1037 {
1038         string res;
1039         // first the main language
1040         res += params_.language->activeChars();
1041         // now the secondary languages
1042         for (auto const & lang : UsedLanguages_)
1043                 res += (lang->activeChars());
1044         return res;
1045 }
1046
1047
1048 set<string> LaTeXFeatures::getEncodingSet(string const & doc_encoding) const
1049 {
1050         // This does only find encodings of languages supported by babel, but
1051         // that does not matter since we don't have a language with an
1052         // encoding supported by inputenc but without babel support.
1053         set<string> encs;
1054         for (auto const & lang : UsedLanguages_)
1055                 if (lang->encoding()->latexName() != doc_encoding &&
1056                     lang->encoding()->package() == Encoding::inputenc)
1057                         encs.insert(lang->encoding()->latexName());
1058         return encs;
1059 }
1060
1061
1062 void LaTeXFeatures::getFontEncodings(vector<string> & encs, bool const onlylangs) const
1063 {
1064         if (!onlylangs) {
1065                 // these must be loaded if glyphs of this script are used
1066                 // unless a language providing them is used in the document
1067                 if (mustProvide("textgreek")
1068                     && find(encs.begin(), encs.end(), "LGR") == encs.end())
1069                         encs.insert(encs.begin(), "LGR");
1070                 if ((mustProvide("textcyrillic") || mustProvide("textschwa"))
1071                     && find(encs.begin(), encs.end(), "T2A") == encs.end())
1072                         encs.insert(encs.begin(), "T2A");
1073         }
1074
1075         for (auto const & lang : UsedLanguages_)
1076         {
1077                 vector<string> extraencs =
1078                         getVectorFromString(lang->fontenc(buffer().masterParams()));
1079                 for (auto const & extra : extraencs) {
1080                         if (extra != "none" && find(encs.begin(), encs.end(), extra) == encs.end())
1081                                 encs.insert(encs.begin(), extra);
1082                 }
1083         }
1084 }
1085
1086
1087 bool LaTeXFeatures::hasRTLLanguage() const
1088 {
1089         if (params_.language->rightToLeft())
1090                 return true;
1091         for (auto const & lang : UsedLanguages_)
1092                 if (lang->rightToLeft())
1093                         return true;
1094         return false;
1095 }
1096
1097
1098 namespace {
1099
1100 char const * simplefeatures[] = {
1101 // note that the package order here will be the same in the LaTeX-output
1102         "array",
1103         "verbatim",
1104         "cprotect",
1105         "longtable",
1106         "latexsym",
1107         "pifont",
1108         // subfig is handled in BufferParams.cpp
1109         "varioref",
1110         "prettyref",
1111         "refstyle",
1112         /*For a successful cooperation of the `wrapfig' package with the
1113           `float' package you should load the `wrapfig' package *after*
1114           the `float' package. See the caption package documentation
1115           for explanation.*/
1116         "float",
1117         "wrapfig",
1118         "booktabs",
1119         "fancybox",
1120         "calc",
1121         "units",
1122         "framed",
1123         "soul",
1124         "dingbat",
1125         "bbding",
1126         "ifsym",
1127         "txfonts",
1128         "pxfonts",
1129         "mathdesign",
1130         "mathrsfs",
1131         "mathabx",
1132         "mathtools",
1133         // "cancel",
1134         "ascii",
1135         "url",
1136         "csquotes",
1137         "enumitem",
1138         "endnotes",
1139         "enotez",
1140         "hhline",
1141         "ifthen",
1142         // listings is handled in BufferParams.cpp
1143         "bm",
1144         "pdfpages",
1145         "amscd",
1146         "slashed",
1147         "multicol",
1148         "multirow",
1149         "tfrupee",
1150         "shapepar",
1151         "rsphrase",
1152         "hpstatement",
1153         "algorithm2e",
1154         "sectionbox",
1155         "tcolorbox",
1156         "pdfcomment",
1157         "fixme",
1158         "todonotes",
1159         "forest",
1160         "varwidth",
1161         "afterpage",
1162         "tabularx",
1163         "tikz",
1164         "xltabular",
1165         "chessboard",
1166         "xskak",
1167         "pict2e",
1168         "drs",
1169         "environ",
1170         "dsfont",
1171         "hepparticles",
1172         "hepnames"
1173 };
1174
1175 char const * bibliofeatures[] = {
1176         // Known bibliography packages (will be loaded before natbib)
1177         "achicago",
1178         "apacite",
1179         "apalike",
1180         "astron",
1181         "authordate1-4",
1182         "babelbib",
1183         "bibgerm",
1184         "chapterbib",
1185         "chicago",
1186         "chscite",
1187         "harvard",
1188         "mslapa",
1189         "named"
1190 };
1191
1192 } // namespace
1193
1194
1195 string const LaTeXFeatures::getColorOptions() const
1196 {
1197         ostringstream colors;
1198
1199         // Handling the color packages separately is needed to be able to load them
1200         // before babel when hyperref is loaded with the colorlinks option
1201         // for more info see Bufferparams.cpp
1202
1203         // [x]color.sty
1204         if (mustProvide("color") || mustProvide("xcolor")) {
1205                 string const package =
1206                         (mustProvide("xcolor") ? "xcolor" : "color");
1207                 if (params_.graphics_driver == "default"
1208                         || params_.graphics_driver == "none")
1209                         colors << "\\usepackage{" << package << "}\n";
1210                 else
1211                         colors << "\\usepackage["
1212                                  << params_.graphics_driver
1213                                  << "]{" << package << "}\n";
1214         }
1215
1216         // pdfcolmk must be loaded after color
1217         if (mustProvide("pdfcolmk"))
1218                 colors << "\\usepackage{pdfcolmk}\n";
1219
1220         // the following 3 color commands must be set after color
1221         // is loaded and before pdfpages, therefore add the command
1222         // here define the set color
1223         if (mustProvide("pagecolor")) {
1224                 colors << "\\definecolor{page_backgroundcolor}{rgb}{";
1225                 colors << outputLaTeXColor(params_.backgroundcolor) << "}\n";
1226                 // set the page color
1227                 colors << "\\pagecolor{page_backgroundcolor}\n";
1228         }
1229
1230         if (mustProvide("fontcolor")) {
1231                 colors << "\\definecolor{document_fontcolor}{rgb}{";
1232                 colors << outputLaTeXColor(params_.fontcolor) << "}\n";
1233                 // set the color
1234                 colors << "\\color{document_fontcolor}\n";
1235         }
1236
1237         if (mustProvide("lyxgreyedout")) {
1238                 colors << "\\definecolor{note_fontcolor}{rgb}{";
1239                 colors << outputLaTeXColor(params_.notefontcolor) << "}\n";
1240                 // the color will be set together with the definition of
1241                 // the lyxgreyedout environment (see lyxgreyedout_def)
1242         }
1243
1244         // color for shaded boxes
1245         if (isRequired("framed") && mustProvide("color")) {
1246                 colors << "\\definecolor{shadecolor}{rgb}{";
1247                 colors << outputLaTeXColor(params_.boxbgcolor) << "}\n";
1248                 // this color is automatically used by the LaTeX-package "framed"
1249         }
1250
1251         return colors.str();
1252 }
1253
1254
1255 string const LaTeXFeatures::getPackageOptions() const
1256 {
1257         ostringstream packageopts;
1258         // Output all the package option stuff we have been asked to do.
1259         for (auto const & p : params_.documentClass().packageOptions())
1260                 if (mustProvide(p.first))
1261                         packageopts << "\\PassOptionsToPackage{" << p.second << "}"
1262                                  << "{" << p.first << "}\n";
1263         return packageopts.str();
1264 }
1265
1266
1267 string const LaTeXFeatures::getPackages() const
1268 {
1269         ostringstream packages;
1270
1271         // FIXME: currently, we can only load packages and macros known
1272         // to LyX.
1273         // However, with the Require tag of layouts/custom insets,
1274         // also unknown packages can be requested. They are silently
1275         // swallowed now. We should change this eventually.
1276
1277         //  These are all the 'simple' includes.  i.e
1278         //  packages which we just \usepackage{package}
1279         for (char const * feature : simplefeatures) {
1280                 if (mustProvide(feature))
1281                         packages << "\\usepackage{" << feature << "}\n";
1282         }
1283
1284         // The rest of these packages are somewhat more complicated
1285         // than those above.
1286
1287         if (mustProvide("changebar")) {
1288                 packages << "\\usepackage";
1289                 if (runparams_.flavor == Flavor::LaTeX
1290                     || runparams_.flavor == Flavor::DviLuaTeX)
1291                         packages << "[dvips]";
1292                 packages << "{changebar}\n";
1293         }
1294
1295         if (mustProvide("footnote")) {
1296                 if (isRequired("hyperref"))
1297                         packages << "\\usepackage{footnotehyper}\n";
1298                 else
1299                         packages << "\\usepackage{footnote}\n";
1300         }
1301
1302         // [pdf]lscape is used to rotate longtables
1303         if (mustProvide("lscape")) {
1304                 if (runparams_.flavor == Flavor::LaTeX
1305                     || runparams_.flavor == Flavor::DviLuaTeX)
1306                         packages << "\\usepackage{lscape}\n";
1307                 else
1308                         packages << "\\usepackage{pdflscape}\n";
1309         }
1310
1311         // The tipa package and its extensions (tipx, tone) must not
1312         // be loaded with non-TeX fonts, since fontspec includes the
1313         // respective macros
1314         if (mustProvide("tipa") && !params_.useNonTeXFonts)
1315                 packages << "\\usepackage{tipa}\n";
1316         if (mustProvide("tipx") && !params_.useNonTeXFonts)
1317                 packages << "\\usepackage{tipx}\n";
1318         if (mustProvide("extraipa") && !params_.useNonTeXFonts)
1319                 packages << "\\usepackage{extraipa}\n";
1320         if (mustProvide("tone") && !params_.useNonTeXFonts)
1321                 packages << "\\usepackage{tone}\n";
1322
1323         // if fontspec or newtxmath is used, AMS packages have to be loaded
1324         // before fontspec (in BufferParams)
1325         string const amsPackages = loadAMSPackages();
1326         bool const ot1 = (runparams().main_fontenc == "default"
1327                           || runparams().main_fontenc == "OT1");
1328         bool const use_newtxmath =
1329                 theLaTeXFonts().getLaTeXFont(from_ascii(params_.fontsMath())).getUsedPackage(
1330                         ot1, false, false) == "newtxmath";
1331
1332         if (!params_.useNonTeXFonts && !use_newtxmath && !amsPackages.empty())
1333                 packages << amsPackages;
1334
1335         if (mustProvide("cancel") &&
1336             params_.use_package("cancel") != BufferParams::package_off)
1337                 packages << "\\usepackage{cancel}\n";
1338
1339         // marvosym and bbding both define the \Cross macro
1340         if (mustProvide("marvosym")) {
1341             if (mustProvide("bbding"))
1342                 packages << "\\let\\Cross\\relax\n";
1343             packages << "\\usepackage{marvosym}\n";
1344         }
1345
1346         // accents must be loaded after amsmath
1347         if (mustProvide("accents") &&
1348             params_.use_package("accents") != BufferParams::package_off)
1349                 packages << "\\usepackage{accents}\n";
1350
1351         // mathdots must be loaded after amsmath
1352         if (mustProvide("mathdots") &&
1353                 params_.use_package("mathdots") != BufferParams::package_off)
1354                 packages << "\\usepackage{mathdots}\n";
1355
1356         // yhmath must be loaded after amsmath
1357         if (mustProvide("yhmath") &&
1358             params_.use_package("yhmath") != BufferParams::package_off)
1359                 packages << "\\usepackage{yhmath}\n";
1360
1361         // stmaryrd must be loaded after amsmath
1362         if (mustProvide("stmaryrd") &&
1363             params_.use_package("stmaryrd") != BufferParams::package_off)
1364                 packages << "\\usepackage{stmaryrd}\n";
1365
1366         if (mustProvide("stackrel") &&
1367             params_.use_package("stackrel") != BufferParams::package_off)
1368                 packages << "\\usepackage{stackrel}\n";
1369
1370         if (mustProvide("undertilde") &&
1371                 params_.use_package("undertilde") != BufferParams::package_off)
1372                 packages << "\\usepackage{undertilde}\n";
1373
1374         // [x]color and pdfcolmk are handled in getColorOptions() above
1375
1376         // makeidx.sty
1377         if (isRequired("makeidx") || isRequired("splitidx")) {
1378                 if (!isProvided("makeidx") && !isRequired("splitidx"))
1379                         packages << "\\usepackage{makeidx}\n";
1380                 if (mustProvide("splitidx"))
1381                         packages << "\\usepackage{splitidx}\n";
1382                 packages << "\\makeindex\n";
1383         }
1384
1385         // graphicx.sty
1386         if (mustProvide("graphicx") && params_.graphics_driver != "none") {
1387                 if (params_.graphics_driver == "default")
1388                         packages << "\\usepackage{graphicx}\n";
1389                 else
1390                         packages << "\\usepackage["
1391                                  << params_.graphics_driver
1392                                  << "]{graphicx}\n";
1393         }
1394
1395         // These must be loaded after graphicx, since they try
1396         // to load graphicx without options
1397         if (mustProvide("rotating"))
1398                 packages << "\\usepackage{rotating}\n";
1399         if (mustProvide("rotfloat"))
1400                 packages << "\\usepackage{rotfloat}\n";
1401         // and this must be loaded after rotating
1402         if (mustProvide("tablefootnote"))
1403                 packages << "\\usepackage{tablefootnote}\n";
1404
1405         // lyxskak.sty --- newer chess support based on skak.sty
1406         if (mustProvide("chess"))
1407                 packages << "\\usepackage[ps,mover]{lyxskak}\n";
1408
1409         // setspace.sty
1410         if (mustProvide("setspace") && !isProvided("SetSpace"))
1411                 packages << "\\usepackage{setspace}\n";
1412
1413         // we need to assure that mhchem is loaded before esint and every other
1414         // package that redefines command of amsmath because mhchem loads amlatex
1415         // (this info is from the author of mhchem from June 2013)
1416         if (mustProvide("mhchem") &&
1417             params_.use_package("mhchem") != BufferParams::package_off)
1418                 packages << "\\PassOptionsToPackage{version=3}{mhchem}\n"
1419                             "\\usepackage{mhchem}\n";
1420
1421         // wasysym is a simple feature, but it must be after amsmath if both
1422         // are used
1423         // wasysym redefines some integrals (e.g. iint) from amsmath. That
1424         // leads to inconsistent integrals. We only load this package if
1425         // the document does not contain integrals (then isRequired("esint")
1426         // is false) or if esint is used, since esint redefines all relevant
1427         // integral symbols from wasysym and amsmath.
1428         // See http://www.lyx.org/trac/ticket/1942
1429         if (mustProvide("wasysym") &&
1430             params_.use_package("wasysym") != BufferParams::package_off &&
1431             (params_.use_package("esint") != BufferParams::package_off || !isRequired("esint")))
1432                 packages << "\\usepackage{wasysym}\n";
1433
1434         // esint must be after amsmath (and packages requiring amsmath, like mhchem)
1435         // and wasysym, since it will redeclare inconsistent integral symbols
1436         if (mustProvide("esint") &&
1437             params_.use_package("esint") != BufferParams::package_off)
1438                 packages << "\\usepackage{esint}\n";
1439
1440         // Known bibliography packages (simple \usepackage{package})
1441         for (char const * feature : bibliofeatures) {
1442                 if (mustProvide(feature))
1443                         packages << "\\usepackage{" << feature << "}\n";
1444         }
1445
1446         // Compatibility between achicago and natbib
1447         if (mustProvide("achicago") && mustProvide("natbib"))
1448                 packages << "\\let\\achicagobib\\thebibliography\n";
1449
1450         // natbib.sty
1451         // Some classes load natbib themselves, but still allow (or even require)
1452         // plain numeric citations (ReVTeX is such a case, see bug 5182).
1453         // This special case is indicated by the "natbib-internal" key.
1454         if (mustProvide("natbib")
1455             && !isProvided("natbib-internal")
1456             && !isProvided("biblatex")
1457             && !isProvided("biblatex-natbib")
1458             && !isProvided("jurabib")) {
1459                 packages << "\\usepackage[";
1460                 if (params_.citeEngineType() == ENGINE_TYPE_NUMERICAL)
1461                         packages << "numbers";
1462                 else
1463                         packages << "authoryear";
1464                 if (!params_.biblio_opts.empty())
1465                         packages << ',' << params_.biblio_opts;
1466                 packages << "]{natbib}\n";
1467         }
1468
1469         // Compatibility between achicago and natbib
1470         if (mustProvide("achicago") && mustProvide("natbib")) {
1471                 packages << "\\let\\thebibliography\\achicagobib\n";
1472                 packages << "\\let\\SCcite\\astroncite\n";
1473                 packages << "\\let\\UnexpandableProtect\\protect\n";
1474         }
1475
1476         // jurabib -- we need version 0.6 at least.
1477         if (mustProvide("jurabib")
1478             && !isProvided("natbib-internal")
1479             && !isProvided("natbib")
1480             && !isProvided("biblatex")
1481             && !isProvided("biblatex-natbib")) {
1482                 packages << "\\usepackage";
1483                 if (!params_.biblio_opts.empty())
1484                         packages << '[' << params_.biblio_opts << ']';
1485                 packages << "{jurabib}[2004/01/25]\n";
1486         }
1487
1488         // opcit -- we pass custombst as we output \bibliographystyle ourselves
1489         if (mustProvide("opcit")) {
1490                 if (isRequired("hyperref"))
1491                         packages << "\\usepackage[custombst,hyperref]{opcit}\n";
1492                 else
1493                         packages << "\\usepackage[custombst]{opcit}\n";
1494         }
1495
1496         // xargs -- we need version 1.09 at least
1497         if (mustProvide("xargs"))
1498                 packages << "\\usepackage{xargs}[2008/03/08]\n";
1499
1500         if (mustProvide("xy"))
1501                 packages << "\\usepackage[all]{xy}\n";
1502
1503         if (mustProvide("feyn"))
1504                 packages << "\\usepackage{feyn}\n"; //Diagram
1505
1506         if (mustProvide("ulem"))
1507                 packages << "\\PassOptionsToPackage{normalem}{ulem}\n"
1508                             "\\usepackage{ulem}\n";
1509
1510         if (mustProvide("nomencl")) {
1511                 // Make it work with the new and old version of the package,
1512                 // but don't use the compatibility option since it is
1513                 // incompatible to other packages.
1514                 packages << "\\usepackage{nomencl}\n"
1515                             "% the following is useful when we have the old nomencl.sty package\n"
1516                             "\\providecommand{\\printnomenclature}{\\printglossary}\n"
1517                             "\\providecommand{\\makenomenclature}{\\makeglossary}\n"
1518                             "\\makenomenclature\n";
1519         }
1520
1521         // fixltx2e provides subscript
1522         if (mustProvide("subscript") && !isRequired("fixltx2e")
1523             && !isAvailableAtLeastFrom("LaTeX", 2005, 12))
1524                 packages << "\\usepackage{subscript}\n";
1525
1526         // footmisc must be loaded after setspace
1527         // Set options here, load the package after the user preamble to
1528         // avoid problems with manual loaded footmisc.
1529         if (mustProvide("footmisc"))
1530                 packages << "\\PassOptionsToPackage{stable}{footmisc}\n";
1531
1532         if (mustProvide("microtype")){
1533                 packages << "\\usepackage{microtype}\n";
1534         }
1535
1536         return packages.str();
1537 }
1538
1539
1540 TexString LaTeXFeatures::getMacros() const
1541 {
1542         otexstringstream macros;
1543
1544         if (!preamble_snippets_.empty()) {
1545                 macros << '\n';
1546                 macros << getPreambleSnippets();
1547         }
1548
1549         if (mustProvide("xetexdashbreakstate"))
1550                 macros << "\\XeTeXdashbreakstate 0" << '\n';
1551
1552         if (mustProvide("papersize")) {
1553                 if (runparams_.flavor == Flavor::LaTeX
1554                     || runparams_.flavor == Flavor::DviLuaTeX)
1555                         macros << papersizedvi_def << '\n';
1556                 else if  (runparams_.flavor == Flavor::LuaTeX)
1557                         macros << papersizepdflua_def << '\n';
1558                 else
1559                         macros << papersizepdf_def << '\n';
1560         }
1561
1562         if (mustProvide("LyX")) {
1563                 macros << "\\providecommand{\\LyX}";
1564                 // open conditional wrappers
1565                 if (runparams_.use_polyglossia && hasRTLLanguage())
1566                         macros << "{\\@ensure@LTR";
1567                 if (isRequired("hyperref"))
1568                         macros << "{\\texorpdfstring";
1569                 if (useBabel())
1570                         macros << "{\\ensureascii";
1571                 // main definition
1572                 macros << lyx_def;
1573                 // close conditional wrappers
1574                 if (useBabel())
1575                         macros << '}';
1576                 if (isRequired("hyperref"))
1577                         macros << "{LyX}}";
1578                 if (runparams_.use_polyglossia && hasRTLLanguage())
1579                         macros << '}';
1580                 macros << '\n';
1581         }
1582
1583         if (mustProvide("noun"))
1584                 macros << noun_def << '\n';
1585
1586         if (mustProvide("lyxarrow"))
1587                 macros << lyxarrow_def << '\n';
1588
1589         if (mustProvide("aastex_case"))
1590                 macros << aastex_case_def << '\n';
1591
1592         if (mustProvide("lyxzerowidthspace"))
1593                 macros << lyxZWSP_def << '\n';
1594
1595         if (!usePolyglossia() && mustProvide("textgreek")) {
1596                 // ensure LGR font encoding is defined also if fontenc is not loaded by LyX
1597                 if (runparams().main_fontenc == "default")
1598                         macros << textgreek_LGR_def;
1599                 macros << textgreek_def << '\n';
1600         }
1601
1602         if (!usePolyglossia() && mustProvide("textcyrillic")) {
1603                 // ensure T2A font encoding is set up also if fontenc is not loaded by LyX
1604                 if (runparams().main_fontenc == "default")
1605                         macros << textcyr_T2A_def;
1606                 macros << textcyr_def << '\n';
1607         }
1608
1609         // non-standard text accents:
1610         if (mustProvide("textcommaabove") || mustProvide("textcommaaboveright") ||
1611             mustProvide("textcommabelow") || mustProvide("textbaltic"))
1612                 macros << lyxaccent_def;
1613
1614         if (mustProvide("textcommabelow") || mustProvide("textbaltic"))
1615                 macros << textcommabelow_def << '\n';
1616
1617         if (mustProvide("textcommaabove") || mustProvide("textbaltic"))
1618                 macros << textcommaabove_def << '\n';
1619
1620         if (mustProvide("textcommaaboveright"))
1621                 macros << textcommaaboveright_def << '\n';
1622
1623         if (mustProvide("textbaltic"))
1624                 macros << textbaltic_def << '\n';
1625
1626         if (mustProvide("textschwa"))
1627                 macros << textschwa_def << '\n';
1628
1629         // split-level fractions
1630         if (mustProvide("xfrac") || mustProvide("smallLetterFrac"))
1631                 macros << xfrac_def << '\n';
1632
1633         if (mustProvide("smallLetterFrac"))
1634                 macros << smallLetterFrac_def << '\n';
1635
1636         if (mustProvide("lyxmathsym"))
1637                 macros << lyxmathsym_def << '\n';
1638
1639         if (mustProvide("cedilla"))
1640                 macros << cedilla_def << '\n';
1641
1642         if (mustProvide("subring"))
1643                 macros << subring_def << '\n';
1644
1645         if (mustProvide("subdot"))
1646                 macros << subdot_def << '\n';
1647
1648         if (mustProvide("subhat"))
1649                 macros << subhat_def << '\n';
1650
1651         if (mustProvide("subtilde"))
1652                 macros << subtilde_def << '\n';
1653
1654         if (mustProvide("dacute"))
1655                 macros << dacute_def << '\n';
1656
1657         if (mustProvide("tipasymb"))
1658                 macros << tipasymb_def << '\n';
1659
1660         if (mustProvide("dgrave"))
1661                 macros << dgrave_def << '\n';
1662
1663         if (mustProvide("rcap"))
1664                 macros << rcap_def << '\n';
1665
1666         if (mustProvide("ogonek"))
1667                 macros << ogonek_def << '\n';
1668
1669         // quotes.
1670         if (mustProvide("quotesinglbase"))
1671                 macros << quotesinglbase_def << '\n';
1672         if (mustProvide("quotedblbase"))
1673                 macros << quotedblbase_def << '\n';
1674         if (mustProvide("guilsinglleft"))
1675                 macros << guilsinglleft_def << '\n';
1676         if (mustProvide("guilsinglright"))
1677                 macros << guilsinglright_def << '\n';
1678         if (mustProvide("guillemotleft"))
1679                 macros << guillemotleft_def << '\n';
1680         if (mustProvide("guillemotright"))
1681                 macros << guillemotright_def << '\n';
1682         if (mustProvide("textquotedbl"))
1683                 macros << textquotedbl_def << '\n';
1684         if (mustProvide("textquotesinglep")) {
1685                 if (runparams_.flavor == Flavor::XeTeX)
1686                         macros << textquotesinglep_xetex_def << '\n';
1687                 else
1688                         macros << textquotesinglep_luatex_def << '\n';
1689         }
1690         if (mustProvide("textquotedblp")) {
1691                 if (runparams_.flavor == Flavor::XeTeX)
1692                         macros << textquotedblp_xetex_def << '\n';
1693                 else
1694                         macros << textquotedblp_luatex_def << '\n';
1695         }
1696
1697         // Math mode
1698         if (mustProvide("binom") && !isRequired("amsmath"))
1699                 macros << binom_def << '\n';
1700         if (mustProvide("mathcircumflex"))
1701                 macros << mathcircumflex_def << '\n';
1702
1703         // other
1704         if (mustProvide("ParagraphLeftIndent"))
1705                 macros << paragraphleftindent_def;
1706         if (mustProvide("NeedLyXFootnoteCode"))
1707                 macros << floatingfootnote_def;
1708
1709         // some problems with tex->html converters
1710         if (mustProvide("NeedTabularnewline"))
1711                 macros << tabularnewline_def;
1712
1713         if (mustProvide("cellvarwidth"))
1714                 macros << cellvarwidth_def;
1715
1716         // greyed-out environment (note inset)
1717         // the color is specified in the routine
1718         // getColorOptions() to avoid LaTeX-package clashes
1719         if (mustProvide("lyxgreyedout"))
1720                 // We need different version for RTL (#8647), with change tracking (#12025)
1721                 // and for some specific engine/language package combinations
1722                 macros << lyxgreyedoutDef(hasRTLLanguage(), mustProvide("ct-xcolor-ulem"),
1723                                           (runparams_.flavor == Flavor::LuaTeX), useBabel());
1724
1725         if (mustProvide("lyxdot"))
1726                 macros << lyxdot_def << '\n';
1727
1728         // floats
1729         getFloatDefinitions(macros);
1730
1731         if (mustProvide("refstyle"))
1732                 macros << lyxref_def << '\n';
1733
1734         // change tracking
1735         if (mustProvide("ct-xcolor-ulem")) {
1736                 streamsize const prec = macros.os().precision(2);
1737
1738                 RGBColor cadd = rgbFromHexName(lcolor.getX11HexName(Color_addedtext_output));
1739                 macros << "\\providecolor{lyxadded}{rgb}{"
1740                        << cadd.r / 255.0 << ',' << cadd.g / 255.0 << ',' << cadd.b / 255.0 << "}\n";
1741
1742                 RGBColor cdel = rgbFromHexName(lcolor.getX11HexName(Color_deletedtext_output));
1743                 macros << "\\providecolor{lyxdeleted}{rgb}{"
1744                        << cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
1745
1746                 macros.os().precision(prec);
1747
1748                 macros << changetracking_xcolor_ulem_base_def;
1749
1750                 if (isRequired("changebar")) {
1751                         if (isRequired("hyperref"))
1752                                 macros << changetracking_xcolor_ulem_hyperref_cb_def;
1753                         else
1754                                 macros << changetracking_xcolor_ulem_cb_def;
1755                 } else {
1756                         if (isRequired("hyperref"))
1757                                 macros << changetracking_xcolor_ulem_hyperref_def;
1758                         else
1759                                 macros << changetracking_xcolor_ulem_def;
1760                 }
1761         }
1762
1763         if (mustProvide("ct-tikz-object-sout")) {
1764                 if (!mustProvide("ct-xcolor-ulem")) {
1765                         streamsize const prec = macros.os().precision(2);
1766
1767                         RGBColor cadd = rgbFromHexName(lcolor.getX11HexName(Color_addedtext_output));
1768                         macros << "\\providecolor{lyxadded}{rgb}{"
1769                                << cadd.r / 255.0 << ',' << cadd.g / 255.0 << ',' << cadd.b / 255.0 << "}\n";
1770
1771                         RGBColor cdel = rgbFromHexName(lcolor.getX11HexName(Color_deletedtext_output));
1772                         macros << "\\providecolor{lyxdeleted}{rgb}{"
1773                                << cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
1774
1775                         macros.os().precision(prec);
1776                 }
1777
1778                 macros << changetracking_tikz_object_sout_def;
1779
1780                 if (isRequired("changebar")) {
1781                         if (isRequired("hyperref"))
1782                                 macros << changetracking_xcolor_ulem_hyperref_cb_object_def;
1783                         else
1784                                 macros << changetracking_xcolor_ulem_cb_object_def;
1785                 } else {
1786                         if (isRequired("hyperref"))
1787                                 macros << changetracking_xcolor_ulem_hyperref_object_def;
1788                         else
1789                                 macros << changetracking_xcolor_ulem_object_def;
1790                 }
1791         }
1792
1793         if (mustProvide("ct-none"))
1794                 macros << changetracking_none_def;
1795
1796         if (mustProvide("rtloutputdblcol"))
1797                 macros << rtloutputdblcol_def;
1798
1799         if (mustProvide("lyxmintcaption"))
1800                 macros << lyxmintcaption_def;
1801
1802         return macros.release();
1803 }
1804
1805
1806 docstring const LaTeXFeatures::getBabelPresettings() const
1807 {
1808         odocstringstream tmp;
1809
1810         for (auto const & lang : UsedLanguages_)
1811                 if (!lang->babel_presettings().empty())
1812                         tmp << lang->babel_presettings() << '\n';
1813         if (!params_.language->babel_presettings().empty())
1814                 tmp << params_.language->babel_presettings() << '\n';
1815
1816         if (!contains(tmp.str(), '@'))
1817                 return tmp.str();
1818
1819         return "\\makeatletter\n" + tmp.str() + "\\makeatother\n";
1820 }
1821
1822
1823 docstring const LaTeXFeatures::getBabelPostsettings() const
1824 {
1825         odocstringstream tmp;
1826
1827         for (auto const & lang : UsedLanguages_)
1828                 if (!lang->babel_postsettings().empty())
1829                         tmp << lang->babel_postsettings() << '\n';
1830         if (!params_.language->babel_postsettings().empty())
1831                 tmp << params_.language->babel_postsettings() << '\n';
1832
1833         if (!contains(tmp.str(), '@'))
1834                 return tmp.str();
1835
1836         return "\\makeatletter\n" + tmp.str() + "\\makeatother\n";
1837 }
1838
1839
1840 string const LaTeXFeatures::loadAMSPackages() const
1841 {
1842         ostringstream tmp;
1843
1844         if (mustProvide("amsmath")
1845             && params_.use_package("amsmath") != BufferParams::package_off) {
1846                 tmp << "\\usepackage{amsmath}\n";
1847         } else {
1848                 // amsbsy and amstext are already provided by amsmath
1849                 if (mustProvide("amsbsy"))
1850                         tmp << "\\usepackage{amsbsy}\n";
1851                 if (mustProvide("amstext"))
1852                         tmp << "\\usepackage{amstext}\n";
1853         }
1854
1855         if (mustProvide("amsthm"))
1856                 tmp << "\\usepackage{amsthm}\n";
1857
1858         if (mustProvide("amssymb")
1859             && params_.use_package("amssymb") != BufferParams::package_off)
1860                 tmp << "\\usepackage{amssymb}\n";
1861
1862         return tmp.str();
1863 }
1864
1865
1866 docstring const LaTeXFeatures::getTClassPreamble() const
1867 {
1868         // the text class specific preamble
1869         DocumentClass const & tclass = params_.documentClass();
1870         odocstringstream tcpreamble;
1871
1872         tcpreamble << tclass.preamble();
1873
1874         list<docstring>::const_iterator cit = usedLayouts_.begin();
1875         list<docstring>::const_iterator end = usedLayouts_.end();
1876         for (; cit != end; ++cit)
1877                 // For InPreamble layouts, we output the preamble stuff earlier
1878                 // (before the layouts). See Paragraph::Private::validate.
1879                 if (!tclass[*cit].inpreamble)
1880                         tcpreamble << tclass[*cit].preamble();
1881
1882         cit = usedInsetLayouts_.begin();
1883         end = usedInsetLayouts_.end();
1884         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1885         for (; cit != end; ++cit) {
1886                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1887                 if (it == ils.end())
1888                         continue;
1889                 tcpreamble << it->second.preamble();
1890         }
1891
1892         return tcpreamble.str();
1893 }
1894
1895
1896 docstring const LaTeXFeatures::getTClassHTMLPreamble() const
1897 {
1898         DocumentClass const & tclass = params_.documentClass();
1899         odocstringstream tcpreamble;
1900
1901         tcpreamble << tclass.htmlpreamble();
1902
1903         list<docstring>::const_iterator cit = usedLayouts_.begin();
1904         list<docstring>::const_iterator end = usedLayouts_.end();
1905         for (; cit != end; ++cit)
1906                 tcpreamble << tclass[*cit].htmlpreamble();
1907
1908         cit = usedInsetLayouts_.begin();
1909         end = usedInsetLayouts_.end();
1910         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1911         for (; cit != end; ++cit) {
1912                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1913                 if (it == ils.end())
1914                         continue;
1915                 tcpreamble << it->second.htmlpreamble();
1916         }
1917
1918         return tcpreamble.str();
1919 }
1920
1921
1922 docstring const LaTeXFeatures::getTClassHTMLStyles() const
1923 {
1924         DocumentClass const & tclass = params_.documentClass();
1925         odocstringstream tcpreamble;
1926
1927         if (mustProvide("noun"))
1928                 tcpreamble << lyxnoun_style;
1929         // this isn't exact, but it won't hurt that much if it
1930         // wasn't for this.
1931         if (mustProvide("ulem"))
1932                 tcpreamble << lyxstrikeout_style;
1933
1934         tcpreamble << tclass.htmlstyles();
1935
1936         for (auto const & c : usedLayouts_)
1937                 tcpreamble << tclass[c].htmlstyle();
1938
1939         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1940         for (auto const & c : usedInsetLayouts_) {
1941                 TextClass::InsetLayouts::const_iterator it = ils.find(c);
1942                 if (it == ils.end())
1943                         continue;
1944                 tcpreamble << it->second.htmlstyle();
1945         }
1946
1947         return tcpreamble.str();
1948 }
1949
1950
1951 namespace {
1952
1953 docstring const getFloatI18nPreamble(docstring const & type,
1954                         docstring const & name, Language const * lang,
1955                         Encoding const & enc, bool const polyglossia)
1956 {
1957         // Check whether name can be encoded in the buffer encoding
1958         bool encodable = true;
1959         for (char_type c : name) {
1960                 if (!enc.encodable(c)) {
1961                         encodable = false;
1962                         break;
1963                 }
1964         }
1965
1966         docstring const language = polyglossia ? from_ascii(lang->polyglossia())
1967                                                : from_ascii(lang->babel());
1968         docstring const langenc = from_ascii(lang->encoding()->iconvName());
1969         docstring const texenc = from_ascii(lang->encoding()->latexName());
1970         docstring const bufenc = from_ascii(enc.iconvName());
1971         docstring const s1 = docstring(1, 0xF0000);
1972         docstring const s2 = docstring(1, 0xF0001);
1973         docstring const translated = encodable ? name
1974                 : from_ascii("\\inputencoding{") + texenc + from_ascii("}")
1975                         + s1 + langenc + s2 + name + s1 + bufenc + s2;
1976
1977         odocstringstream os;
1978         os << "\\addto\\captions" << language
1979            << "{\\renewcommand{\\" << type << "name}{" << translated << "}}\n";
1980         return os.str();
1981 }
1982
1983
1984 docstring const i18npreamble(docstring const & templ, Language const * lang,
1985                              Encoding const & enc, bool const polyglossia,
1986                              bool const need_fixedwidth)
1987 {
1988         if (templ.empty())
1989                 return templ;
1990
1991         string preamble = polyglossia ?
1992                 subst(to_utf8(templ), "$$lang", lang->polyglossia()) :
1993                 subst(to_utf8(templ), "$$lang", lang->babel());
1994
1995         string const langenc = lang->encoding()->iconvName();
1996         string const texenc = lang->encoding()->latexName();
1997         string const bufenc = enc.iconvName();
1998         Encoding const * testenc(&enc);
1999         bool lang_fallback = false;
2000         bool ascii_fallback = false;
2001         if (need_fixedwidth && !enc.hasFixedWidth()) {
2002                 if (lang->encoding()->hasFixedWidth()) {
2003                         testenc = lang->encoding();
2004                         lang_fallback = true;
2005                 } else {
2006                         // We need a fixed width encoding, but both the buffer
2007                         // encoding and the language encoding are variable
2008                         // width. As a last fallback, try to convert to pure
2009                         // ASCII using the LaTeX commands defined in unicodesymbols.
2010                         testenc = encodings.fromLyXName("ascii");
2011                         if (!testenc)
2012                                 return docstring();
2013                         ascii_fallback = true;
2014                 }
2015         }
2016         // First and second character of plane 15 (Private Use Area)
2017         string const s1 = "\xf3\xb0\x80\x80"; // U+F0000
2018         string const s2 = "\xf3\xb0\x80\x81"; // U+F0001
2019         // FIXME UNICODE
2020         // lyx::regex is not unicode-safe.
2021         // Should use QRegExp or (boost::u32regex, but that requires ICU)
2022         static regex const reg("_\\(([^\\)]+)\\)");
2023         smatch sub;
2024         while (regex_search(preamble, sub, reg)) {
2025                 string const key = sub.str(1);
2026                 docstring const name = lang->translateLayout(key);
2027                 // Check whether name can be encoded in the buffer encoding
2028                 bool encodable = true;
2029                 for (size_t i = 0; i < name.size() && encodable; ++i)
2030                         if (!testenc->encodable(name[i]))
2031                                 encodable = false;
2032                 string translated;
2033                 if (encodable && !lang_fallback)
2034                         translated = to_utf8(name);
2035                 else if (ascii_fallback)
2036                         translated = to_ascii(testenc->latexString(name).first);
2037                 else
2038                         translated = "\\inputencoding{" + texenc + "}"
2039                                 + s1 + langenc + s2 + to_utf8(name)
2040                                 + s1 + bufenc + s2;
2041                 preamble = subst(preamble, sub.str(), translated);
2042         }
2043         return from_utf8(preamble);
2044 }
2045
2046 } // namespace
2047
2048
2049 docstring const LaTeXFeatures::getTClassI18nPreamble(bool use_babel,
2050                                 bool use_polyglossia, bool use_minted) const
2051 {
2052         DocumentClass const & tclass = params_.documentClass();
2053         // collect preamble snippets in a set to prevent multiple identical
2054         // commands (would happen if e.g. both theorem and theorem* are used)
2055         set<docstring> snippets;
2056         typedef LanguageList::const_iterator lang_it;
2057         lang_it const lbeg = UsedLanguages_.begin();
2058         lang_it const lend =  UsedLanguages_.end();
2059         list<docstring>::const_iterator cit = usedLayouts_.begin();
2060         list<docstring>::const_iterator end = usedLayouts_.end();
2061         for (; cit != end; ++cit) {
2062                 // language dependent commands (once per document)
2063                 snippets.insert(i18npreamble(tclass[*cit].langpreamble(),
2064                                                 buffer().language(),
2065                                                 buffer().params().encoding(),
2066                                                 use_polyglossia, false));
2067                 // commands for language changing (for multilanguage documents)
2068                 if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
2069                         snippets.insert(i18npreamble(
2070                                                 tclass[*cit].babelpreamble(),
2071                                                 buffer().language(),
2072                                                 buffer().params().encoding(),
2073                                                 use_polyglossia, false));
2074                         for (lang_it lit = lbeg; lit != lend; ++lit)
2075                                 snippets.insert(i18npreamble(
2076                                                 tclass[*cit].babelpreamble(),
2077                                                 *lit,
2078                                                 buffer().params().encoding(),
2079                                                 use_polyglossia, false));
2080                 }
2081         }
2082         if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
2083                 FloatList const & floats = params_.documentClass().floats();
2084                 UsedFloats::const_iterator fit = usedFloats_.begin();
2085                 UsedFloats::const_iterator fend = usedFloats_.end();
2086                 for (; fit != fend; ++fit) {
2087                         Floating const & fl = floats.getType(fit->first);
2088                         // we assume builtin floats are translated
2089                         if (fl.isPredefined())
2090                                 continue;
2091                         docstring const type = from_ascii(fl.floattype());
2092                         docstring const flname = from_utf8(fl.name());
2093                         docstring name = buffer().language()->translateLayout(fl.name());
2094                         // only request translation if we have a real translation
2095                         // (that differs from the source)
2096                         if (flname != name)
2097                                 snippets.insert(getFloatI18nPreamble(
2098                                                 type, name, buffer().language(),
2099                                                 buffer().params().encoding(),
2100                                                 use_polyglossia));
2101                         for (lang_it lit = lbeg; lit != lend; ++lit) {
2102                                 string const code = (*lit)->code();
2103                                 name = (*lit)->translateLayout(fl.name());
2104                                 // we assume we have a suitable translation if
2105                                 // either the language is English (we need to
2106                                 // translate into English if English is a secondary
2107                                 // language) or if translateIfPossible returns
2108                                 // something different to the English source.
2109                                 bool const have_translation =
2110                                         (flname != name || contains(code, "en"));
2111                                 if (have_translation)
2112                                         snippets.insert(getFloatI18nPreamble(
2113                                                 type, name, *lit,
2114                                                 buffer().params().encoding(),
2115                                                 use_polyglossia));
2116                         }
2117                 }
2118         }
2119
2120         cit = usedInsetLayouts_.begin();
2121         end = usedInsetLayouts_.end();
2122         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
2123         for (; cit != end; ++cit) {
2124                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
2125                 if (it == ils.end())
2126                         continue;
2127                 // The listings package does not work with variable width
2128                 // encodings, only with fixed width encodings. Therefore we
2129                 // need to force a fixed width encoding for
2130                 // \lstlistlistingname and \lstlistingname (bug 9382).
2131                 // This needs to be consistent with InsetListings::latex()
2132                 // rsp. InsetListings::forcedEncoding().
2133                 bool const need_fixedwidth = !use_minted &&
2134                                         !runparams_.isFullUnicode() &&
2135                                         buffer().params().encoding().package() != Encoding::japanese &&
2136                                         it->second.fixedwidthpreambleencoding();
2137                 // language dependent commands (once per document)
2138                 snippets.insert(i18npreamble(it->second.langpreamble(),
2139                                                 buffer().language(),
2140                                                 buffer().params().encoding(),
2141                                                 use_polyglossia, need_fixedwidth));
2142                 // commands for language changing (for multilanguage documents)
2143                 if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
2144                         snippets.insert(i18npreamble(
2145                                                 it->second.babelpreamble(),
2146                                                 buffer().language(),
2147                                                 buffer().params().encoding(),
2148                                                 use_polyglossia, need_fixedwidth));
2149                         for (lang_it lit = lbeg; lit != lend; ++lit)
2150                                 snippets.insert(i18npreamble(
2151                                                 it->second.babelpreamble(),
2152                                                 *lit,
2153                                                 buffer().params().encoding(),
2154                                                 use_polyglossia, need_fixedwidth));
2155                 }
2156         }
2157
2158         odocstringstream tcpreamble;
2159         set<docstring>::const_iterator const send = snippets.end();
2160         set<docstring>::const_iterator it = snippets.begin();
2161         for (; it != send; ++it)
2162                 tcpreamble << *it;
2163         return tcpreamble.str();
2164 }
2165
2166
2167 void LaTeXFeatures::showStruct() const
2168 {
2169         lyxerr << "LyX needs the following commands when LaTeXing:"
2170                << "\n***** Packages:" << getPackages()
2171                << "\n***** Macros:" << to_utf8(getMacros().str)
2172                << "\n***** Textclass stuff:" << to_utf8(getTClassPreamble())
2173                << "\n***** done." << endl;
2174 }
2175
2176
2177 Buffer const & LaTeXFeatures::buffer() const
2178 {
2179         return *buffer_;
2180 }
2181
2182
2183 void LaTeXFeatures::setBuffer(Buffer const & buffer)
2184 {
2185         buffer_ = &buffer;
2186 }
2187
2188
2189 BufferParams const & LaTeXFeatures::bufferParams() const
2190 {
2191         return params_;
2192 }
2193
2194
2195 void LaTeXFeatures::getFloatDefinitions(otexstream & os) const
2196 {
2197         FloatList const & floats = params_.documentClass().floats();
2198
2199         // Here we will output the code to create the needed float styles.
2200         // We will try to do this as minimal as possible.
2201         // \floatstyle{ruled}
2202         // \newfloat{algorithm}{htbp}{loa}
2203         // \providecommand{\algorithmname}{Algorithm}
2204         // \floatname{algorithm}{\protect\algorithmname}
2205         for (auto const & cit : usedFloats_) {
2206                 Floating const & fl = floats.getType(cit.first);
2207
2208                 // For builtin floats we do nothing.
2209                 if (fl.isPredefined())
2210                         continue;
2211
2212                 // We have to special case "table" and "figure"
2213                 if (fl.floattype() == "tabular" || fl.floattype() == "figure") {
2214                         // Output code to modify "table" or "figure"
2215                         // but only if builtin == false
2216                         // and that have to be true at this point in the
2217                         // function.
2218                         docstring const type = from_ascii(fl.floattype());
2219                         docstring const placement = from_ascii(fl.placement());
2220                         docstring const style = from_ascii(fl.style());
2221                         if (!style.empty()) {
2222                                 os << "\\floatstyle{" << style << "}\n"
2223                                    << "\\restylefloat{" << type << "}\n";
2224                         }
2225                         if (!placement.empty()) {
2226                                 os << "\\floatplacement{" << type << "}{"
2227                                    << placement << "}\n";
2228                         }
2229                 } else {
2230                         // The other non builtin floats.
2231
2232                         docstring const type = from_ascii(fl.floattype());
2233                         docstring const placement = from_ascii(fl.placement());
2234                         docstring const ext = from_ascii(fl.ext());
2235                         docstring const within = from_ascii(fl.within());
2236                         docstring const style = from_ascii(fl.style());
2237                         docstring const name =
2238                                 buffer().language()->translateLayout(fl.name());
2239                         os << "\\floatstyle{" << style << "}\n"
2240                            << "\\newfloat{" << type << "}{" << placement
2241                            << "}{" << ext << '}';
2242                         if (!within.empty())
2243                                 os << '[' << within << ']';
2244                         os << '\n'
2245                            << "\\providecommand{\\" << type << "name}{"
2246                            << name << "}\n"
2247                            << "\\floatname{" << type << "}{\\protect\\"
2248                            << type << "name}\n";
2249
2250                         // What missing here is to code to minimalize the code
2251                         // output so that the same floatstyle will not be
2252                         // used several times, when the same style is still in
2253                         // effect. (Lgb)
2254                 }
2255                 if (cit.second)
2256                         // The subfig package is loaded later
2257                         os << "\n\\AtBeginDocument{\\newsubfloat{" << from_ascii(fl.floattype()) << "}}\n";
2258         }
2259 }
2260
2261
2262 void LaTeXFeatures::resolveAlternatives()
2263 {
2264         for (Features::iterator it = features_.begin(); it != features_.end();) {
2265                 if (contains(*it, '|')) {
2266                         vector<string> const alternatives = getVectorFromString(*it, "|");
2267                         vector<string>::const_iterator const end = alternatives.end();
2268                         vector<string>::const_iterator ita = alternatives.begin();
2269                         // Is any alternative already required? => use that
2270                         for (; ita != end; ++ita) {
2271                                 if (isRequired(*ita))
2272                                         break;
2273                         }
2274                         // Is any alternative available? => use the first one
2275                         // (bug 9498)
2276                         if (ita == end) {
2277                                 for (ita = alternatives.begin(); ita != end; ++ita) {
2278                                         if (isAvailable(*ita)) {
2279                                                 require(*ita);
2280                                                 break;
2281                                         }
2282                                 }
2283                         }
2284                         // This will not work, but not requiring something
2285                         // would be more confusing
2286                         if (ita == end)
2287                                 require(alternatives.front());
2288                         features_.erase(it);
2289                         it = features_.begin();
2290                 } else
2291                         ++it;
2292         }
2293 }
2294
2295
2296 void LaTeXFeatures::expandMultiples()
2297 {
2298         for (Features::iterator it = features_.begin(); it != features_.end();) {
2299                 if (contains(*it, ',')) {
2300                         // Do nothing if any multiple is already required
2301                         for (string const & pkg : getVectorFromString(*it, ",")) {
2302                                 if (!isRequired(pkg))
2303                                         require(pkg);
2304                         }
2305                         features_.erase(it);
2306                         it = features_.begin();
2307                 } else
2308                         ++it;
2309         }
2310 }
2311
2312
2313 } // namespace lyx