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         // Babel languages with activated colon (such as French) break
1288         // with prettyref. Work around that.
1289         if (!runparams_.isFullUnicode() && useBabel()
1290             && mustProvide("prettyref") && contains(getActiveChars(), ':')) {
1291                 packages << "% Make prettyref compatible with babel active colon\n"
1292                          << "\\def\\prettyref#1{\\expandafter\\@prettyref\\detokenize{#1:}}\n";
1293         }
1294
1295         if (mustProvide("changebar")) {
1296                 packages << "\\usepackage";
1297                 if (runparams_.flavor == Flavor::LaTeX
1298                     || runparams_.flavor == Flavor::DviLuaTeX)
1299                         packages << "[dvips]";
1300                 packages << "{changebar}\n";
1301         }
1302
1303         if (mustProvide("footnote")) {
1304                 if (isRequired("hyperref"))
1305                         packages << "\\usepackage{footnotehyper}\n";
1306                 else
1307                         packages << "\\usepackage{footnote}\n";
1308         }
1309
1310         // [pdf]lscape is used to rotate longtables
1311         if (mustProvide("lscape")) {
1312                 if (runparams_.flavor == Flavor::LaTeX
1313                     || runparams_.flavor == Flavor::DviLuaTeX)
1314                         packages << "\\usepackage{lscape}\n";
1315                 else
1316                         packages << "\\usepackage{pdflscape}\n";
1317         }
1318
1319         // The tipa package and its extensions (tipx, tone) must not
1320         // be loaded with non-TeX fonts, since fontspec includes the
1321         // respective macros
1322         if (mustProvide("tipa") && !params_.useNonTeXFonts)
1323                 packages << "\\usepackage{tipa}\n";
1324         if (mustProvide("tipx") && !params_.useNonTeXFonts)
1325                 packages << "\\usepackage{tipx}\n";
1326         if (mustProvide("extraipa") && !params_.useNonTeXFonts)
1327                 packages << "\\usepackage{extraipa}\n";
1328         if (mustProvide("tone") && !params_.useNonTeXFonts)
1329                 packages << "\\usepackage{tone}\n";
1330
1331         // if fontspec or newtxmath is used, AMS packages have to be loaded
1332         // before fontspec (in BufferParams)
1333         string const amsPackages = loadAMSPackages();
1334         bool const ot1 = (runparams().main_fontenc == "default"
1335                           || runparams().main_fontenc == "OT1");
1336         bool const use_newtxmath =
1337                 theLaTeXFonts().getLaTeXFont(from_ascii(params_.fontsMath())).getUsedPackage(
1338                         ot1, false, false) == "newtxmath";
1339
1340         if (!params_.useNonTeXFonts && !use_newtxmath && !amsPackages.empty())
1341                 packages << amsPackages;
1342
1343         if (mustProvide("cancel") &&
1344             params_.use_package("cancel") != BufferParams::package_off)
1345                 packages << "\\usepackage{cancel}\n";
1346
1347         // marvosym and bbding both define the \Cross macro
1348         if (mustProvide("marvosym")) {
1349             if (mustProvide("bbding"))
1350                 packages << "\\let\\Cross\\relax\n";
1351             packages << "\\usepackage{marvosym}\n";
1352         }
1353
1354         // accents must be loaded after amsmath
1355         if (mustProvide("accents") &&
1356             params_.use_package("accents") != BufferParams::package_off)
1357                 packages << "\\usepackage{accents}\n";
1358
1359         // mathdots must be loaded after amsmath
1360         if (mustProvide("mathdots") &&
1361                 params_.use_package("mathdots") != BufferParams::package_off)
1362                 packages << "\\usepackage{mathdots}\n";
1363
1364         // yhmath must be loaded after amsmath
1365         if (mustProvide("yhmath") &&
1366             params_.use_package("yhmath") != BufferParams::package_off)
1367                 packages << "\\usepackage{yhmath}\n";
1368
1369         // stmaryrd must be loaded after amsmath
1370         if (mustProvide("stmaryrd") &&
1371             params_.use_package("stmaryrd") != BufferParams::package_off)
1372                 packages << "\\usepackage{stmaryrd}\n";
1373
1374         if (mustProvide("stackrel") &&
1375             params_.use_package("stackrel") != BufferParams::package_off)
1376                 packages << "\\usepackage{stackrel}\n";
1377
1378         if (mustProvide("undertilde") &&
1379                 params_.use_package("undertilde") != BufferParams::package_off)
1380                 packages << "\\usepackage{undertilde}\n";
1381
1382         // [x]color and pdfcolmk are handled in getColorOptions() above
1383
1384         // makeidx.sty
1385         if (isRequired("makeidx") || isRequired("splitidx")) {
1386                 if (!isProvided("makeidx") && !isRequired("splitidx"))
1387                         packages << "\\usepackage{makeidx}\n";
1388                 if (mustProvide("splitidx"))
1389                         packages << "\\usepackage{splitidx}\n";
1390                 packages << "\\makeindex\n";
1391         }
1392
1393         // graphicx.sty
1394         if (mustProvide("graphicx") && params_.graphics_driver != "none") {
1395                 if (params_.graphics_driver == "default")
1396                         packages << "\\usepackage{graphicx}\n";
1397                 else
1398                         packages << "\\usepackage["
1399                                  << params_.graphics_driver
1400                                  << "]{graphicx}\n";
1401         }
1402
1403         // These must be loaded after graphicx, since they try
1404         // to load graphicx without options
1405         if (mustProvide("rotating"))
1406                 packages << "\\usepackage{rotating}\n";
1407         if (mustProvide("rotfloat"))
1408                 packages << "\\usepackage{rotfloat}\n";
1409         // and this must be loaded after rotating
1410         if (mustProvide("tablefootnote"))
1411                 packages << "\\usepackage{tablefootnote}\n";
1412
1413         // lyxskak.sty --- newer chess support based on skak.sty
1414         if (mustProvide("chess"))
1415                 packages << "\\usepackage[ps,mover]{lyxskak}\n";
1416
1417         // setspace.sty
1418         if (mustProvide("setspace") && !isProvided("SetSpace"))
1419                 packages << "\\usepackage{setspace}\n";
1420
1421         // we need to assure that mhchem is loaded before esint and every other
1422         // package that redefines command of amsmath because mhchem loads amlatex
1423         // (this info is from the author of mhchem from June 2013)
1424         if (mustProvide("mhchem") &&
1425             params_.use_package("mhchem") != BufferParams::package_off)
1426                 packages << "\\PassOptionsToPackage{version=3}{mhchem}\n"
1427                             "\\usepackage{mhchem}\n";
1428
1429         // wasysym is a simple feature, but it must be after amsmath if both
1430         // are used
1431         // wasysym redefines some integrals (e.g. iint) from amsmath. That
1432         // leads to inconsistent integrals. We only load this package if
1433         // the document does not contain integrals (then isRequired("esint")
1434         // is false) or if esint is used, since esint redefines all relevant
1435         // integral symbols from wasysym and amsmath.
1436         // See http://www.lyx.org/trac/ticket/1942
1437         if (mustProvide("wasysym") &&
1438             params_.use_package("wasysym") != BufferParams::package_off &&
1439             (params_.use_package("esint") != BufferParams::package_off || !isRequired("esint")))
1440                 packages << "\\usepackage{wasysym}\n";
1441
1442         // esint must be after amsmath (and packages requiring amsmath, like mhchem)
1443         // and wasysym, since it will redeclare inconsistent integral symbols
1444         if (mustProvide("esint") &&
1445             params_.use_package("esint") != BufferParams::package_off)
1446                 packages << "\\usepackage{esint}\n";
1447
1448         // Known bibliography packages (simple \usepackage{package})
1449         for (char const * feature : bibliofeatures) {
1450                 if (mustProvide(feature))
1451                         packages << "\\usepackage{" << feature << "}\n";
1452         }
1453
1454         // Compatibility between achicago and natbib
1455         if (mustProvide("achicago") && mustProvide("natbib"))
1456                 packages << "\\let\\achicagobib\\thebibliography\n";
1457
1458         // natbib.sty
1459         // Some classes load natbib themselves, but still allow (or even require)
1460         // plain numeric citations (ReVTeX is such a case, see bug 5182).
1461         // This special case is indicated by the "natbib-internal" key.
1462         if (mustProvide("natbib")
1463             && !isProvided("natbib-internal")
1464             && !isProvided("biblatex")
1465             && !isProvided("biblatex-natbib")
1466             && !isProvided("jurabib")) {
1467                 packages << "\\usepackage[";
1468                 if (params_.citeEngineType() == ENGINE_TYPE_NUMERICAL)
1469                         packages << "numbers";
1470                 else
1471                         packages << "authoryear";
1472                 if (!params_.biblio_opts.empty())
1473                         packages << ',' << params_.biblio_opts;
1474                 packages << "]{natbib}\n";
1475         }
1476
1477         // Compatibility between achicago and natbib
1478         if (mustProvide("achicago") && mustProvide("natbib")) {
1479                 packages << "\\let\\thebibliography\\achicagobib\n";
1480                 packages << "\\let\\SCcite\\astroncite\n";
1481                 packages << "\\let\\UnexpandableProtect\\protect\n";
1482         }
1483
1484         // jurabib -- we need version 0.6 at least.
1485         if (mustProvide("jurabib")
1486             && !isProvided("natbib-internal")
1487             && !isProvided("natbib")
1488             && !isProvided("biblatex")
1489             && !isProvided("biblatex-natbib")) {
1490                 packages << "\\usepackage";
1491                 if (!params_.biblio_opts.empty())
1492                         packages << '[' << params_.biblio_opts << ']';
1493                 packages << "{jurabib}[2004/01/25]\n";
1494         }
1495
1496         // opcit -- we pass custombst as we output \bibliographystyle ourselves
1497         if (mustProvide("opcit")) {
1498                 if (isRequired("hyperref"))
1499                         packages << "\\usepackage[custombst,hyperref]{opcit}\n";
1500                 else
1501                         packages << "\\usepackage[custombst]{opcit}\n";
1502         }
1503
1504         // xargs -- we need version 1.09 at least
1505         if (mustProvide("xargs"))
1506                 packages << "\\usepackage{xargs}[2008/03/08]\n";
1507
1508         if (mustProvide("xy"))
1509                 packages << "\\usepackage[all]{xy}\n";
1510
1511         if (mustProvide("feyn"))
1512                 packages << "\\usepackage{feyn}\n"; //Diagram
1513
1514         if (mustProvide("ulem"))
1515                 packages << "\\PassOptionsToPackage{normalem}{ulem}\n"
1516                             "\\usepackage{ulem}\n";
1517
1518         if (mustProvide("nomencl")) {
1519                 // Make it work with the new and old version of the package,
1520                 // but don't use the compatibility option since it is
1521                 // incompatible to other packages.
1522                 packages << "\\usepackage{nomencl}\n"
1523                             "% the following is useful when we have the old nomencl.sty package\n"
1524                             "\\providecommand{\\printnomenclature}{\\printglossary}\n"
1525                             "\\providecommand{\\makenomenclature}{\\makeglossary}\n"
1526                             "\\makenomenclature\n";
1527         }
1528
1529         // fixltx2e provides subscript
1530         if (mustProvide("subscript") && !isRequired("fixltx2e")
1531             && !isAvailableAtLeastFrom("LaTeX", 2005, 12))
1532                 packages << "\\usepackage{subscript}\n";
1533
1534         // footmisc must be loaded after setspace
1535         // Set options here, load the package after the user preamble to
1536         // avoid problems with manual loaded footmisc.
1537         if (mustProvide("footmisc"))
1538                 packages << "\\PassOptionsToPackage{stable}{footmisc}\n";
1539
1540         if (mustProvide("microtype")){
1541                 packages << "\\usepackage{microtype}\n";
1542         }
1543
1544         return packages.str();
1545 }
1546
1547
1548 TexString LaTeXFeatures::getMacros() const
1549 {
1550         otexstringstream macros;
1551
1552         if (!preamble_snippets_.empty()) {
1553                 macros << '\n';
1554                 macros << getPreambleSnippets();
1555         }
1556
1557         if (mustProvide("xetexdashbreakstate"))
1558                 macros << "\\XeTeXdashbreakstate 0" << '\n';
1559
1560         if (mustProvide("papersize")) {
1561                 if (runparams_.flavor == Flavor::LaTeX
1562                     || runparams_.flavor == Flavor::DviLuaTeX)
1563                         macros << papersizedvi_def << '\n';
1564                 else if  (runparams_.flavor == Flavor::LuaTeX)
1565                         macros << papersizepdflua_def << '\n';
1566                 else
1567                         macros << papersizepdf_def << '\n';
1568         }
1569
1570         if (mustProvide("LyX")) {
1571                 macros << "\\providecommand{\\LyX}";
1572                 // open conditional wrappers
1573                 if (runparams_.use_polyglossia && hasRTLLanguage())
1574                         macros << "{\\@ensure@LTR";
1575                 if (isRequired("hyperref"))
1576                         macros << "{\\texorpdfstring";
1577                 if (useBabel())
1578                         macros << "{\\ensureascii";
1579                 // main definition
1580                 macros << lyx_def;
1581                 // close conditional wrappers
1582                 if (useBabel())
1583                         macros << '}';
1584                 if (isRequired("hyperref"))
1585                         macros << "{LyX}}";
1586                 if (runparams_.use_polyglossia && hasRTLLanguage())
1587                         macros << '}';
1588                 macros << '\n';
1589         }
1590
1591         if (mustProvide("noun"))
1592                 macros << noun_def << '\n';
1593
1594         if (mustProvide("lyxarrow"))
1595                 macros << lyxarrow_def << '\n';
1596
1597         if (mustProvide("aastex_case"))
1598                 macros << aastex_case_def << '\n';
1599
1600         if (mustProvide("lyxzerowidthspace"))
1601                 macros << lyxZWSP_def << '\n';
1602
1603         if (!usePolyglossia() && mustProvide("textgreek")) {
1604                 // ensure LGR font encoding is defined also if fontenc is not loaded by LyX
1605                 if (runparams().main_fontenc == "default")
1606                         macros << textgreek_LGR_def;
1607                 macros << textgreek_def << '\n';
1608         }
1609
1610         if (!usePolyglossia() && mustProvide("textcyrillic")) {
1611                 // ensure T2A font encoding is set up also if fontenc is not loaded by LyX
1612                 if (runparams().main_fontenc == "default")
1613                         macros << textcyr_T2A_def;
1614                 macros << textcyr_def << '\n';
1615         }
1616
1617         // non-standard text accents:
1618         if (mustProvide("textcommaabove") || mustProvide("textcommaaboveright") ||
1619             mustProvide("textcommabelow") || mustProvide("textbaltic"))
1620                 macros << lyxaccent_def;
1621
1622         if (mustProvide("textcommabelow") || mustProvide("textbaltic"))
1623                 macros << textcommabelow_def << '\n';
1624
1625         if (mustProvide("textcommaabove") || mustProvide("textbaltic"))
1626                 macros << textcommaabove_def << '\n';
1627
1628         if (mustProvide("textcommaaboveright"))
1629                 macros << textcommaaboveright_def << '\n';
1630
1631         if (mustProvide("textbaltic"))
1632                 macros << textbaltic_def << '\n';
1633
1634         if (mustProvide("textschwa"))
1635                 macros << textschwa_def << '\n';
1636
1637         // split-level fractions
1638         if (mustProvide("xfrac") || mustProvide("smallLetterFrac"))
1639                 macros << xfrac_def << '\n';
1640
1641         if (mustProvide("smallLetterFrac"))
1642                 macros << smallLetterFrac_def << '\n';
1643
1644         if (mustProvide("lyxmathsym"))
1645                 macros << lyxmathsym_def << '\n';
1646
1647         if (mustProvide("cedilla"))
1648                 macros << cedilla_def << '\n';
1649
1650         if (mustProvide("subring"))
1651                 macros << subring_def << '\n';
1652
1653         if (mustProvide("subdot"))
1654                 macros << subdot_def << '\n';
1655
1656         if (mustProvide("subhat"))
1657                 macros << subhat_def << '\n';
1658
1659         if (mustProvide("subtilde"))
1660                 macros << subtilde_def << '\n';
1661
1662         if (mustProvide("dacute"))
1663                 macros << dacute_def << '\n';
1664
1665         if (mustProvide("tipasymb"))
1666                 macros << tipasymb_def << '\n';
1667
1668         if (mustProvide("dgrave"))
1669                 macros << dgrave_def << '\n';
1670
1671         if (mustProvide("rcap"))
1672                 macros << rcap_def << '\n';
1673
1674         if (mustProvide("ogonek"))
1675                 macros << ogonek_def << '\n';
1676
1677         // quotes.
1678         if (mustProvide("quotesinglbase"))
1679                 macros << quotesinglbase_def << '\n';
1680         if (mustProvide("quotedblbase"))
1681                 macros << quotedblbase_def << '\n';
1682         if (mustProvide("guilsinglleft"))
1683                 macros << guilsinglleft_def << '\n';
1684         if (mustProvide("guilsinglright"))
1685                 macros << guilsinglright_def << '\n';
1686         if (mustProvide("guillemotleft"))
1687                 macros << guillemotleft_def << '\n';
1688         if (mustProvide("guillemotright"))
1689                 macros << guillemotright_def << '\n';
1690         if (mustProvide("textquotedbl"))
1691                 macros << textquotedbl_def << '\n';
1692         if (mustProvide("textquotesinglep")) {
1693                 if (runparams_.flavor == Flavor::XeTeX)
1694                         macros << textquotesinglep_xetex_def << '\n';
1695                 else
1696                         macros << textquotesinglep_luatex_def << '\n';
1697         }
1698         if (mustProvide("textquotedblp")) {
1699                 if (runparams_.flavor == Flavor::XeTeX)
1700                         macros << textquotedblp_xetex_def << '\n';
1701                 else
1702                         macros << textquotedblp_luatex_def << '\n';
1703         }
1704
1705         // Math mode
1706         if (mustProvide("binom") && !isRequired("amsmath"))
1707                 macros << binom_def << '\n';
1708         if (mustProvide("mathcircumflex"))
1709                 macros << mathcircumflex_def << '\n';
1710
1711         // other
1712         if (mustProvide("ParagraphLeftIndent"))
1713                 macros << paragraphleftindent_def;
1714         if (mustProvide("NeedLyXFootnoteCode"))
1715                 macros << floatingfootnote_def;
1716
1717         // some problems with tex->html converters
1718         if (mustProvide("NeedTabularnewline"))
1719                 macros << tabularnewline_def;
1720
1721         if (mustProvide("cellvarwidth"))
1722                 macros << cellvarwidth_def;
1723
1724         // greyed-out environment (note inset)
1725         // the color is specified in the routine
1726         // getColorOptions() to avoid LaTeX-package clashes
1727         if (mustProvide("lyxgreyedout"))
1728                 // We need different version for RTL (#8647), with change tracking (#12025)
1729                 // and for some specific engine/language package combinations
1730                 macros << lyxgreyedoutDef(hasRTLLanguage(), mustProvide("ct-xcolor-ulem"),
1731                                           (runparams_.flavor == Flavor::LuaTeX), useBabel());
1732
1733         if (mustProvide("lyxdot"))
1734                 macros << lyxdot_def << '\n';
1735
1736         // floats
1737         getFloatDefinitions(macros);
1738
1739         if (mustProvide("refstyle"))
1740                 macros << lyxref_def << '\n';
1741
1742         // change tracking
1743         if (mustProvide("ct-xcolor-ulem")) {
1744                 streamsize const prec = macros.os().precision(2);
1745
1746                 RGBColor cadd = rgbFromHexName(lcolor.getX11HexName(Color_addedtext_output));
1747                 macros << "\\providecolor{lyxadded}{rgb}{"
1748                        << cadd.r / 255.0 << ',' << cadd.g / 255.0 << ',' << cadd.b / 255.0 << "}\n";
1749
1750                 RGBColor cdel = rgbFromHexName(lcolor.getX11HexName(Color_deletedtext_output));
1751                 macros << "\\providecolor{lyxdeleted}{rgb}{"
1752                        << cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
1753
1754                 macros.os().precision(prec);
1755
1756                 macros << changetracking_xcolor_ulem_base_def;
1757
1758                 if (isRequired("changebar")) {
1759                         if (isRequired("hyperref"))
1760                                 macros << changetracking_xcolor_ulem_hyperref_cb_def;
1761                         else
1762                                 macros << changetracking_xcolor_ulem_cb_def;
1763                 } else {
1764                         if (isRequired("hyperref"))
1765                                 macros << changetracking_xcolor_ulem_hyperref_def;
1766                         else
1767                                 macros << changetracking_xcolor_ulem_def;
1768                 }
1769         }
1770
1771         if (mustProvide("ct-tikz-object-sout")) {
1772                 if (!mustProvide("ct-xcolor-ulem")) {
1773                         streamsize const prec = macros.os().precision(2);
1774
1775                         RGBColor cadd = rgbFromHexName(lcolor.getX11HexName(Color_addedtext_output));
1776                         macros << "\\providecolor{lyxadded}{rgb}{"
1777                                << cadd.r / 255.0 << ',' << cadd.g / 255.0 << ',' << cadd.b / 255.0 << "}\n";
1778
1779                         RGBColor cdel = rgbFromHexName(lcolor.getX11HexName(Color_deletedtext_output));
1780                         macros << "\\providecolor{lyxdeleted}{rgb}{"
1781                                << cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
1782
1783                         macros.os().precision(prec);
1784                 }
1785
1786                 macros << changetracking_tikz_object_sout_def;
1787
1788                 if (isRequired("changebar")) {
1789                         if (isRequired("hyperref"))
1790                                 macros << changetracking_xcolor_ulem_hyperref_cb_object_def;
1791                         else
1792                                 macros << changetracking_xcolor_ulem_cb_object_def;
1793                 } else {
1794                         if (isRequired("hyperref"))
1795                                 macros << changetracking_xcolor_ulem_hyperref_object_def;
1796                         else
1797                                 macros << changetracking_xcolor_ulem_object_def;
1798                 }
1799         }
1800
1801         if (mustProvide("ct-none"))
1802                 macros << changetracking_none_def;
1803
1804         if (mustProvide("rtloutputdblcol"))
1805                 macros << rtloutputdblcol_def;
1806
1807         if (mustProvide("lyxmintcaption"))
1808                 macros << lyxmintcaption_def;
1809
1810         return macros.release();
1811 }
1812
1813
1814 docstring const LaTeXFeatures::getBabelPresettings() const
1815 {
1816         odocstringstream tmp;
1817
1818         for (auto const & lang : UsedLanguages_)
1819                 if (!lang->babel_presettings().empty())
1820                         tmp << lang->babel_presettings() << '\n';
1821         if (!params_.language->babel_presettings().empty())
1822                 tmp << params_.language->babel_presettings() << '\n';
1823
1824         if (!contains(tmp.str(), '@'))
1825                 return tmp.str();
1826
1827         return "\\makeatletter\n" + tmp.str() + "\\makeatother\n";
1828 }
1829
1830
1831 docstring const LaTeXFeatures::getBabelPostsettings() const
1832 {
1833         odocstringstream tmp;
1834
1835         for (auto const & lang : UsedLanguages_)
1836                 if (!lang->babel_postsettings().empty())
1837                         tmp << lang->babel_postsettings() << '\n';
1838         if (!params_.language->babel_postsettings().empty())
1839                 tmp << params_.language->babel_postsettings() << '\n';
1840
1841         if (!contains(tmp.str(), '@'))
1842                 return tmp.str();
1843
1844         return "\\makeatletter\n" + tmp.str() + "\\makeatother\n";
1845 }
1846
1847
1848 string const LaTeXFeatures::loadAMSPackages() const
1849 {
1850         ostringstream tmp;
1851
1852         if (mustProvide("amsmath")
1853             && params_.use_package("amsmath") != BufferParams::package_off) {
1854                 tmp << "\\usepackage{amsmath}\n";
1855         } else {
1856                 // amsbsy and amstext are already provided by amsmath
1857                 if (mustProvide("amsbsy"))
1858                         tmp << "\\usepackage{amsbsy}\n";
1859                 if (mustProvide("amstext"))
1860                         tmp << "\\usepackage{amstext}\n";
1861         }
1862
1863         if (mustProvide("amsthm"))
1864                 tmp << "\\usepackage{amsthm}\n";
1865
1866         if (mustProvide("amssymb")
1867             && params_.use_package("amssymb") != BufferParams::package_off)
1868                 tmp << "\\usepackage{amssymb}\n";
1869
1870         return tmp.str();
1871 }
1872
1873
1874 docstring const LaTeXFeatures::getTClassPreamble() const
1875 {
1876         // the text class specific preamble
1877         DocumentClass const & tclass = params_.documentClass();
1878         odocstringstream tcpreamble;
1879
1880         tcpreamble << tclass.preamble();
1881
1882         list<docstring>::const_iterator cit = usedLayouts_.begin();
1883         list<docstring>::const_iterator end = usedLayouts_.end();
1884         for (; cit != end; ++cit)
1885                 // For InPreamble layouts, we output the preamble stuff earlier
1886                 // (before the layouts). See Paragraph::Private::validate.
1887                 if (!tclass[*cit].inpreamble)
1888                         tcpreamble << tclass[*cit].preamble();
1889
1890         cit = usedInsetLayouts_.begin();
1891         end = usedInsetLayouts_.end();
1892         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1893         for (; cit != end; ++cit) {
1894                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1895                 if (it == ils.end())
1896                         continue;
1897                 tcpreamble << it->second.preamble();
1898         }
1899
1900         return tcpreamble.str();
1901 }
1902
1903
1904 docstring const LaTeXFeatures::getTClassHTMLPreamble() const
1905 {
1906         DocumentClass const & tclass = params_.documentClass();
1907         odocstringstream tcpreamble;
1908
1909         tcpreamble << tclass.htmlpreamble();
1910
1911         list<docstring>::const_iterator cit = usedLayouts_.begin();
1912         list<docstring>::const_iterator end = usedLayouts_.end();
1913         for (; cit != end; ++cit)
1914                 tcpreamble << tclass[*cit].htmlpreamble();
1915
1916         cit = usedInsetLayouts_.begin();
1917         end = usedInsetLayouts_.end();
1918         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1919         for (; cit != end; ++cit) {
1920                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1921                 if (it == ils.end())
1922                         continue;
1923                 tcpreamble << it->second.htmlpreamble();
1924         }
1925
1926         return tcpreamble.str();
1927 }
1928
1929
1930 docstring const LaTeXFeatures::getTClassHTMLStyles() const
1931 {
1932         DocumentClass const & tclass = params_.documentClass();
1933         odocstringstream tcpreamble;
1934
1935         if (mustProvide("noun"))
1936                 tcpreamble << lyxnoun_style;
1937         // this isn't exact, but it won't hurt that much if it
1938         // wasn't for this.
1939         if (mustProvide("ulem"))
1940                 tcpreamble << lyxstrikeout_style;
1941
1942         tcpreamble << tclass.htmlstyles();
1943
1944         for (auto const & c : usedLayouts_)
1945                 tcpreamble << tclass[c].htmlstyle();
1946
1947         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1948         for (auto const & c : usedInsetLayouts_) {
1949                 TextClass::InsetLayouts::const_iterator it = ils.find(c);
1950                 if (it == ils.end())
1951                         continue;
1952                 tcpreamble << it->second.htmlstyle();
1953         }
1954
1955         return tcpreamble.str();
1956 }
1957
1958
1959 namespace {
1960
1961 docstring const getFloatI18nPreamble(docstring const & type,
1962                         docstring const & name, Language const * lang,
1963                         Encoding const & enc, bool const polyglossia)
1964 {
1965         // Check whether name can be encoded in the buffer encoding
1966         bool encodable = true;
1967         for (char_type c : name) {
1968                 if (!enc.encodable(c)) {
1969                         encodable = false;
1970                         break;
1971                 }
1972         }
1973
1974         docstring const language = polyglossia ? from_ascii(lang->polyglossia())
1975                                                : from_ascii(lang->babel());
1976         docstring const langenc = from_ascii(lang->encoding()->iconvName());
1977         docstring const texenc = from_ascii(lang->encoding()->latexName());
1978         docstring const bufenc = from_ascii(enc.iconvName());
1979         docstring const s1 = docstring(1, 0xF0000);
1980         docstring const s2 = docstring(1, 0xF0001);
1981         docstring const translated = encodable ? name
1982                 : from_ascii("\\inputencoding{") + texenc + from_ascii("}")
1983                         + s1 + langenc + s2 + name + s1 + bufenc + s2;
1984
1985         odocstringstream os;
1986         os << "\\addto\\captions" << language
1987            << "{\\renewcommand{\\" << type << "name}{" << translated << "}}\n";
1988         return os.str();
1989 }
1990
1991
1992 docstring const i18npreamble(docstring const & templ, Language const * lang,
1993                              Encoding const & enc, bool const polyglossia,
1994                              bool const need_fixedwidth)
1995 {
1996         if (templ.empty())
1997                 return templ;
1998
1999         string preamble = polyglossia ?
2000                 subst(to_utf8(templ), "$$lang", lang->polyglossia()) :
2001                 subst(to_utf8(templ), "$$lang", lang->babel());
2002
2003         string const langenc = lang->encoding()->iconvName();
2004         string const texenc = lang->encoding()->latexName();
2005         string const bufenc = enc.iconvName();
2006         Encoding const * testenc(&enc);
2007         bool lang_fallback = false;
2008         bool ascii_fallback = false;
2009         if (need_fixedwidth && !enc.hasFixedWidth()) {
2010                 if (lang->encoding()->hasFixedWidth()) {
2011                         testenc = lang->encoding();
2012                         lang_fallback = true;
2013                 } else {
2014                         // We need a fixed width encoding, but both the buffer
2015                         // encoding and the language encoding are variable
2016                         // width. As a last fallback, try to convert to pure
2017                         // ASCII using the LaTeX commands defined in unicodesymbols.
2018                         testenc = encodings.fromLyXName("ascii");
2019                         if (!testenc)
2020                                 return docstring();
2021                         ascii_fallback = true;
2022                 }
2023         }
2024         // First and second character of plane 15 (Private Use Area)
2025         string const s1 = "\xf3\xb0\x80\x80"; // U+F0000
2026         string const s2 = "\xf3\xb0\x80\x81"; // U+F0001
2027         // FIXME UNICODE
2028         // lyx::regex is not unicode-safe.
2029         // Should use QRegExp or (boost::u32regex, but that requires ICU)
2030         static regex const reg("_\\(([^\\)]+)\\)");
2031         smatch sub;
2032         while (regex_search(preamble, sub, reg)) {
2033                 string const key = sub.str(1);
2034                 docstring const name = lang->translateLayout(key);
2035                 // Check whether name can be encoded in the buffer encoding
2036                 bool encodable = true;
2037                 for (size_t i = 0; i < name.size() && encodable; ++i)
2038                         if (!testenc->encodable(name[i]))
2039                                 encodable = false;
2040                 string translated;
2041                 if (encodable && !lang_fallback)
2042                         translated = to_utf8(name);
2043                 else if (ascii_fallback)
2044                         translated = to_ascii(testenc->latexString(name).first);
2045                 else
2046                         translated = "\\inputencoding{" + texenc + "}"
2047                                 + s1 + langenc + s2 + to_utf8(name)
2048                                 + s1 + bufenc + s2;
2049                 preamble = subst(preamble, sub.str(), translated);
2050         }
2051         return from_utf8(preamble);
2052 }
2053
2054 } // namespace
2055
2056
2057 docstring const LaTeXFeatures::getTClassI18nPreamble(bool use_babel,
2058                                 bool use_polyglossia, bool use_minted) const
2059 {
2060         DocumentClass const & tclass = params_.documentClass();
2061         // collect preamble snippets in a set to prevent multiple identical
2062         // commands (would happen if e.g. both theorem and theorem* are used)
2063         set<docstring> snippets;
2064         typedef LanguageList::const_iterator lang_it;
2065         lang_it const lbeg = UsedLanguages_.begin();
2066         lang_it const lend =  UsedLanguages_.end();
2067         list<docstring>::const_iterator cit = usedLayouts_.begin();
2068         list<docstring>::const_iterator end = usedLayouts_.end();
2069         for (; cit != end; ++cit) {
2070                 // language dependent commands (once per document)
2071                 snippets.insert(i18npreamble(tclass[*cit].langpreamble(),
2072                                                 buffer().language(),
2073                                                 buffer().params().encoding(),
2074                                                 use_polyglossia, false));
2075                 // commands for language changing (for multilanguage documents)
2076                 if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
2077                         snippets.insert(i18npreamble(
2078                                                 tclass[*cit].babelpreamble(),
2079                                                 buffer().language(),
2080                                                 buffer().params().encoding(),
2081                                                 use_polyglossia, false));
2082                         for (lang_it lit = lbeg; lit != lend; ++lit)
2083                                 snippets.insert(i18npreamble(
2084                                                 tclass[*cit].babelpreamble(),
2085                                                 *lit,
2086                                                 buffer().params().encoding(),
2087                                                 use_polyglossia, false));
2088                 }
2089         }
2090         if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
2091                 FloatList const & floats = params_.documentClass().floats();
2092                 UsedFloats::const_iterator fit = usedFloats_.begin();
2093                 UsedFloats::const_iterator fend = usedFloats_.end();
2094                 for (; fit != fend; ++fit) {
2095                         Floating const & fl = floats.getType(fit->first);
2096                         // we assume builtin floats are translated
2097                         if (fl.isPredefined())
2098                                 continue;
2099                         docstring const type = from_ascii(fl.floattype());
2100                         docstring const flname = from_utf8(fl.name());
2101                         docstring name = buffer().language()->translateLayout(fl.name());
2102                         // only request translation if we have a real translation
2103                         // (that differs from the source)
2104                         if (flname != name)
2105                                 snippets.insert(getFloatI18nPreamble(
2106                                                 type, name, buffer().language(),
2107                                                 buffer().params().encoding(),
2108                                                 use_polyglossia));
2109                         for (lang_it lit = lbeg; lit != lend; ++lit) {
2110                                 string const code = (*lit)->code();
2111                                 name = (*lit)->translateLayout(fl.name());
2112                                 // we assume we have a suitable translation if
2113                                 // either the language is English (we need to
2114                                 // translate into English if English is a secondary
2115                                 // language) or if translateIfPossible returns
2116                                 // something different to the English source.
2117                                 bool const have_translation =
2118                                         (flname != name || contains(code, "en"));
2119                                 if (have_translation)
2120                                         snippets.insert(getFloatI18nPreamble(
2121                                                 type, name, *lit,
2122                                                 buffer().params().encoding(),
2123                                                 use_polyglossia));
2124                         }
2125                 }
2126         }
2127
2128         cit = usedInsetLayouts_.begin();
2129         end = usedInsetLayouts_.end();
2130         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
2131         for (; cit != end; ++cit) {
2132                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
2133                 if (it == ils.end())
2134                         continue;
2135                 // The listings package does not work with variable width
2136                 // encodings, only with fixed width encodings. Therefore we
2137                 // need to force a fixed width encoding for
2138                 // \lstlistlistingname and \lstlistingname (bug 9382).
2139                 // This needs to be consistent with InsetListings::latex()
2140                 // rsp. InsetListings::forcedEncoding().
2141                 bool const need_fixedwidth = !use_minted &&
2142                                         !runparams_.isFullUnicode() &&
2143                                         buffer().params().encoding().package() != Encoding::japanese &&
2144                                         it->second.fixedwidthpreambleencoding();
2145                 // language dependent commands (once per document)
2146                 snippets.insert(i18npreamble(it->second.langpreamble(),
2147                                                 buffer().language(),
2148                                                 buffer().params().encoding(),
2149                                                 use_polyglossia, need_fixedwidth));
2150                 // commands for language changing (for multilanguage documents)
2151                 if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
2152                         snippets.insert(i18npreamble(
2153                                                 it->second.babelpreamble(),
2154                                                 buffer().language(),
2155                                                 buffer().params().encoding(),
2156                                                 use_polyglossia, need_fixedwidth));
2157                         for (lang_it lit = lbeg; lit != lend; ++lit)
2158                                 snippets.insert(i18npreamble(
2159                                                 it->second.babelpreamble(),
2160                                                 *lit,
2161                                                 buffer().params().encoding(),
2162                                                 use_polyglossia, need_fixedwidth));
2163                 }
2164         }
2165
2166         odocstringstream tcpreamble;
2167         set<docstring>::const_iterator const send = snippets.end();
2168         set<docstring>::const_iterator it = snippets.begin();
2169         for (; it != send; ++it)
2170                 tcpreamble << *it;
2171         return tcpreamble.str();
2172 }
2173
2174
2175 void LaTeXFeatures::showStruct() const
2176 {
2177         lyxerr << "LyX needs the following commands when LaTeXing:"
2178                << "\n***** Packages:" << getPackages()
2179                << "\n***** Macros:" << to_utf8(getMacros().str)
2180                << "\n***** Textclass stuff:" << to_utf8(getTClassPreamble())
2181                << "\n***** done." << endl;
2182 }
2183
2184
2185 Buffer const & LaTeXFeatures::buffer() const
2186 {
2187         return *buffer_;
2188 }
2189
2190
2191 void LaTeXFeatures::setBuffer(Buffer const & buffer)
2192 {
2193         buffer_ = &buffer;
2194 }
2195
2196
2197 BufferParams const & LaTeXFeatures::bufferParams() const
2198 {
2199         return params_;
2200 }
2201
2202
2203 void LaTeXFeatures::getFloatDefinitions(otexstream & os) const
2204 {
2205         FloatList const & floats = params_.documentClass().floats();
2206
2207         // Here we will output the code to create the needed float styles.
2208         // We will try to do this as minimal as possible.
2209         // \floatstyle{ruled}
2210         // \newfloat{algorithm}{htbp}{loa}
2211         // \providecommand{\algorithmname}{Algorithm}
2212         // \floatname{algorithm}{\protect\algorithmname}
2213         for (auto const & cit : usedFloats_) {
2214                 Floating const & fl = floats.getType(cit.first);
2215
2216                 // For builtin floats we do nothing.
2217                 if (fl.isPredefined())
2218                         continue;
2219
2220                 // We have to special case "table" and "figure"
2221                 if (fl.floattype() == "tabular" || fl.floattype() == "figure") {
2222                         // Output code to modify "table" or "figure"
2223                         // but only if builtin == false
2224                         // and that have to be true at this point in the
2225                         // function.
2226                         docstring const type = from_ascii(fl.floattype());
2227                         docstring const placement = from_ascii(fl.placement());
2228                         docstring const style = from_ascii(fl.style());
2229                         if (!style.empty()) {
2230                                 os << "\\floatstyle{" << style << "}\n"
2231                                    << "\\restylefloat{" << type << "}\n";
2232                         }
2233                         if (!placement.empty()) {
2234                                 os << "\\floatplacement{" << type << "}{"
2235                                    << placement << "}\n";
2236                         }
2237                 } else {
2238                         // The other non builtin floats.
2239
2240                         docstring const type = from_ascii(fl.floattype());
2241                         docstring const placement = from_ascii(fl.placement());
2242                         docstring const ext = from_ascii(fl.ext());
2243                         docstring const within = from_ascii(fl.within());
2244                         docstring const style = from_ascii(fl.style());
2245                         docstring const name =
2246                                 buffer().language()->translateLayout(fl.name());
2247                         os << "\\floatstyle{" << style << "}\n"
2248                            << "\\newfloat{" << type << "}{" << placement
2249                            << "}{" << ext << '}';
2250                         if (!within.empty())
2251                                 os << '[' << within << ']';
2252                         os << '\n'
2253                            << "\\providecommand{\\" << type << "name}{"
2254                            << name << "}\n"
2255                            << "\\floatname{" << type << "}{\\protect\\"
2256                            << type << "name}\n";
2257
2258                         // What missing here is to code to minimalize the code
2259                         // output so that the same floatstyle will not be
2260                         // used several times, when the same style is still in
2261                         // effect. (Lgb)
2262                 }
2263                 if (cit.second)
2264                         // The subfig package is loaded later
2265                         os << "\n\\AtBeginDocument{\\newsubfloat{" << from_ascii(fl.floattype()) << "}}\n";
2266         }
2267 }
2268
2269
2270 void LaTeXFeatures::resolveAlternatives()
2271 {
2272         for (Features::iterator it = features_.begin(); it != features_.end();) {
2273                 if (contains(*it, '|')) {
2274                         vector<string> const alternatives = getVectorFromString(*it, "|");
2275                         vector<string>::const_iterator const end = alternatives.end();
2276                         vector<string>::const_iterator ita = alternatives.begin();
2277                         // Is any alternative already required? => use that
2278                         for (; ita != end; ++ita) {
2279                                 if (isRequired(*ita))
2280                                         break;
2281                         }
2282                         // Is any alternative available? => use the first one
2283                         // (bug 9498)
2284                         if (ita == end) {
2285                                 for (ita = alternatives.begin(); ita != end; ++ita) {
2286                                         if (isAvailable(*ita)) {
2287                                                 require(*ita);
2288                                                 break;
2289                                         }
2290                                 }
2291                         }
2292                         // This will not work, but not requiring something
2293                         // would be more confusing
2294                         if (ita == end)
2295                                 require(alternatives.front());
2296                         features_.erase(it);
2297                         it = features_.begin();
2298                 } else
2299                         ++it;
2300         }
2301 }
2302
2303
2304 void LaTeXFeatures::expandMultiples()
2305 {
2306         for (Features::iterator it = features_.begin(); it != features_.end();) {
2307                 if (contains(*it, ',')) {
2308                         // Do nothing if any multiple is already required
2309                         for (string const & pkg : getVectorFromString(*it, ",")) {
2310                                 if (!isRequired(pkg))
2311                                         require(pkg);
2312                         }
2313                         features_.erase(it);
2314                         it = features_.begin();
2315                 } else
2316                         ++it;
2317         }
2318 }
2319
2320
2321 } // namespace lyx